Media Generation in Live Pages¶

{
    success: true,
    message: "Image/s generated and saved to the 'images' folder",
    images: [
        { name: "generated-image.png", path: "/images" }
    ]
}

// Basic image generation
await pt.generateImage({
    prompt: "A serene mountain landscape at sunset with a lake reflection",
    size: "1536x1024"
});

// With style and negative prompt
await pt.generateImage({
    prompt: "A modern minimalist office interior",
    style: "realistic",
    size: "1024x1024",
    negative_prompt: "people, clutter, mess, dark"
});

// Using reference images for style consistency
await pt.generateImage({
    prompt: "A product photo of a coffee mug",
    reference_images: ["https://example.com/style-reference.jpg"],
    reference_weight: 0.7,
    size: "1024x1024"
});

// Generate multiple variations
await pt.generateImage({
    prompt: "Abstract geometric patterns with vibrant colors",
    size: "1024x1024",
    count: 4
});

// Organize images in folders
await pt.generateImage({
    prompt: "Company logo design with mountain theme",
    size: "1024x1024",
    folder: "logos/concepts"
});

// With custom filename
const result = await pt.generateImage({
    prompt: "Product hero image for homepage",
    name: "hero-banner",
    folder: "marketing"
});
// result.images = [{ name: "hero-banner.png", path: "/marketing" }]

// Specify provider
await pt.generateImage({
    prompt: "Photorealistic landscape",
    provider: "openai",
    size: "1536x1024"
});

// Interactive image generator
async function generateUserImage() {
    const prompt = document.getElementById('promptInput').value;
    const size = document.getElementById('sizeSelect').value;
    const style = document.getElementById('styleSelect').value;

    if (!prompt) {
        alert('Please enter a description');
        return;
    }

    const button = document.getElementById('generateBtn');
    button.disabled = true;
    button.textContent = 'Generating...';

    try {
        await pt.generateImage({
            prompt: prompt,
            style: style,
            size: size
        });

        alert('Image generated successfully! Check the chat for the result.');
    } catch (error) {
        console.error('Image generation failed:', error);
        alert('Failed to generate image. Please try again.');
    } finally {
        button.disabled = false;
        button.textContent = 'Generate Image';
    }
}

// Generate product mockups
async function generateProductMockup(productData) {
    const prompt = `Professional product photo of ${productData.name}, ${productData.description},
                   studio lighting, white background, high quality, commercial photography`;

    return await pt.generateImage({
        prompt: prompt,
        size: "1024x1024",
        negative_prompt: "blurry, low quality, watermark, text, logo",
        folder: `products/${productData.category}`
    });
}

// Batch generate images
async function generateImageSet(prompts) {
    const results = [];

    for (const prompt of prompts) {
        try {
            const result = await pt.generateImage({
                prompt: prompt,
                size: "1024x1024"
            });
            results.push({ success: true, prompt, result });
        } catch (error) {
            results.push({ success: false, prompt, error: error.message });
        }
    }

    const successful = results.filter(r => r.success).length;
    alert(`Generated ${successful} of ${prompts.length} images`);

    return results;
}

{
    speaker: "Speaker Name",
    text: "What the speaker says",
    voice_id: "voice-id",
    description: "Optional speaker description for tone/emotion"
}

{
    success: true,
    message: "Audio file is generated and saved to the 'audio' folder",
    voice: { name: "generated-audio.mp3", path: "/audio" }
}

// Basic text-to-speech
await pt.generateVoice({
    text: "Welcome to PrimeThink. This is a demonstration of our text to speech system.",
    voice: "alloy",
    provider: "openai"
});

// With voice instructions
await pt.generateVoice({
    text: "This is an important security announcement. Please update your password immediately.",
    voice: "onyx",
    instructions: "Speak with authority and urgency, emphasizing 'important' and 'immediately'",
    provider: "openai"
});

// Multi-speaker dialogue
await pt.generateVoice({
    provider: "openai",
    dialogue: [
        {
            speaker: "Host",
            text: "Welcome to today's podcast. We're discussing AI in business.",
            voice_id: "fable",
            description: "enthusiastic and welcoming"
        },
        {
            speaker: "Guest",
            text: "Thanks for having me. It's a fascinating topic.",
            voice_id: "echo",
            description: "professional and knowledgeable"
        },
        {
            speaker: "Host",
            text: "Let's start with the basics. What exactly is machine learning?",
            voice_id: "fable",
            description: "curious and engaged"
        }
    ]
});

// Save to specific folder
await pt.generateVoice({
    text: "Chapter 1: The Beginning. In a distant galaxy...",
    voice: "onyx",
    instructions: "Use a storytelling voice with dramatic pauses",
    folder: "audiobooks/chapter1"
});

// With custom filename
const result = await pt.generateVoice({
    text: "Welcome to our application",
    voice: "alloy",
    name: "welcome-audio"
});
// result.voice = { name: "welcome-audio.mp3", path: "/audio" }

// Interactive voice generator
async function generateNarration() {
    const text = document.getElementById('narrationText').value;
    const voice = document.getElementById('voiceSelect').value;
    const instructions = document.getElementById('instructionsInput').value;

    if (!text) {
        alert('Please enter text to narrate');
        return;
    }

    const button = document.getElementById('generateVoiceBtn');
    button.disabled = true;
    button.textContent = 'Generating...';

    try {
        await pt.generateVoice({
            text: text,
            voice: voice,
            instructions: instructions,
            provider: "openai"
        });

        alert('Audio generated successfully! Check the chat for the audio file.');
    } catch (error) {
        console.error('Voice generation failed:', error);
        alert('Failed to generate audio. Please try again.');
    } finally {
        button.disabled = false;
        button.textContent = 'Generate Voice';
    }
}

// Generate voice for notifications
async function speakNotification(message, priority = 'normal') {
    const voices = {
        low: { voice: 'alloy', instructions: 'calm and neutral' },
        normal: { voice: 'nova', instructions: 'clear and friendly' },
        high: { voice: 'onyx', instructions: 'urgent and serious' }
    };

    const config = voices[priority];

    return await pt.generateVoice({
        text: message,
        voice: config.voice,
        instructions: config.instructions,
        provider: "openai",
        folder: "notifications"
    });
}

// Generate podcast from script
async function generatePodcast(script) {
    const dialogue = script.segments.map(segment => ({
        speaker: segment.speaker,
        text: segment.text,
        voice_id: segment.voice || 'alloy',
        description: segment.emotion || 'neutral'
    }));

    return await pt.generateVoice({
        provider: "openai",
        dialogue: dialogue,
        folder: `podcasts/${script.episode}`
    });
}

// Usage
await generatePodcast({
    episode: "ep01",
    segments: [
        {
            speaker: "Alex",
            text: "Hello and welcome to TechTalk!",
            voice: "nova",
            emotion: "excited and energetic"
        },
        {
            speaker: "Jordan",
            text: "Great to be here. Let's dive into today's topic.",
            voice: "echo",
            emotion: "professional and confident"
        }
    ]
});

// Generate audio guide
async function generateAudioGuide(steps) {
    const text = steps.map((step, index) =>
        `Step ${index + 1}: ${step}`
    ).join('. ');

    return await pt.generateVoice({
        text: text,
        voice: "alloy",
        instructions: "Speak clearly and slowly, pause between steps",
        provider: "openai",
        folder: "guides"
    });
}

{
    success: true,
    message: "Diarized transcript saved to the 'transcripts' folder",
    transcript: "[00:00] Speaker 1: Hello everyone...\n[00:05] Speaker 2: Thanks...",
    documents: [
        { id: 789, uuid: "...", name: "meeting_transcript.md", path: "/transcripts" }
    ]
}

// Basic diarization with auto-detected speakers
const result = await pt.diarizeAudio({
    document_id: 456
});
console.log(result.transcript);

// Specify speaker count for a known 3-person meeting
await pt.diarizeAudio({
    document_id: 456,
    speaker_count: 3
});

// With language and speaker name hints
await pt.diarizeAudio({
    document_id: 456,
    speaker_count: 2,
    extra_instructions: "The audio is in Italian. Speakers are Marco and Giulia."
});

// Save to custom folder with custom filename
await pt.diarizeAudio({
    document_id: 456,
    folder: "meetings/2024-03",
    filename: "team-standup-march-15"
});

// Full workflow: find audio document and diarize
async function transcribeMeeting() {
    const docs = await pt.list('documents');
    const audioDoc = docs.find(d => d.name.endsWith('.m4a'));

    if (!audioDoc) {
        alert('No audio document found');
        return;
    }

    const btn = document.getElementById('transcribeBtn');
    btn.disabled = true;
    btn.textContent = 'Transcribing...';

    try {
        const result = await pt.diarizeAudio({
            document_id: audioDoc.id,
            speaker_count: 2,
            folder: "transcripts/meetings"
        });
        alert(`Transcript saved: ${result.documents[0].name}`);
    } catch (error) {
        alert('Diarization failed: ' + error.message);
    } finally {
        btn.disabled = false;
        btn.textContent = 'Transcribe Meeting';
    }
}

const tokenData = await pt.sttStreamToken();
// Returns: { token: "...", websocket_url: "..." }

let transcribeState = {
    isRecording: false,
    scribe: null        // holds the active Scribe connection
};

async function startTranscribe() {
    try {
        // Wait for SDK to load (module scripts are async)
        if (!window.ElevenLabsScribe) {
            await new Promise(resolve => {
                if (window.ElevenLabsScribe) resolve();
                else window.addEventListener('elevenlabs-sdk-loaded', resolve, { once: true });
            });
        }

        // Get a single-use token from the PrimeThink server
        const tokenData = await pt.sttStreamToken();
        if (!tokenData?.token) throw new Error('Failed to get STT stream token');

        // Connect to ElevenLabs Scribe — SDK handles microphone access
        transcribeState.scribe = await window.ElevenLabsScribe.connect({
            token: tokenData.token,
            languageCode: 'en',           // or 'es', 'fr', etc.
            modelId: 'scribe_v2_realtime',
            microphone: {
                echoCancellation: true,
                noiseSuppression: true,
                autoGainControl: true
            }
        });

        // Track committed (finalized) text separately from partials
        let committedText = '';

        // Partial transcripts — live preview, may change as more audio comes in
        transcribeState.scribe.on('partial_transcript', (data) => {
            if (data.text) {
                let partial = data.text;
                // Scribe sometimes wraps text in quotes — strip them
                if (partial.startsWith('"') && partial.endsWith('"')) partial = partial.slice(1, -1);
                inputEl.value = committedText + (committedText ? ' ' : '') + partial;
            }
        });

        // Committed transcripts — finalized text, won't change
        transcribeState.scribe.on('committed_transcript', (data) => {
            let text = (data.text || '').trim();
            if (!text) return;
            // Strip surrounding quotes (Scribe quirk)
            if (text.startsWith('"') && text.endsWith('"')) text = text.slice(1, -1).trim();
            if (!text) return;
            committedText = (committedText ? committedText + ' ' : '') + text;
            inputEl.value = committedText;
        });

        // Handle errors
        transcribeState.scribe.on('error', (error) => {
            console.error('Scribe error:', error);
            stopTranscribe();
        });

        transcribeState.isRecording = true;

    } catch (err) {
        console.error('Failed to start transcription:', err);
        cleanupTranscribe();
    }
}

async function stopTranscribe() {
    transcribeState.isRecording = false;
    cleanupTranscribe();

    // Optionally auto-send the transcribed text
    if (inputEl.value.trim()) {
        sendMessage();
    }
}

function cleanupTranscribe() {
    if (transcribeState.scribe) {
        transcribeState.scribe.close();
        transcribeState.scribe = null;
    }
}

async function toggleTranscribe() {
    if (transcribeState.isRecording) {
        await stopTranscribe();
    } else {
        await startTranscribe();
    }
}

async function dictateAndProcess() {
    let committedText = '';

    // Start transcription (same setup as above)
    const tokenData = await pt.sttStreamToken();
    transcribeState.scribe = await window.ElevenLabsScribe.connect({
        token: tokenData.token,
        languageCode: 'en',
        modelId: 'scribe_v2_realtime',
        microphone: { echoCancellation: true, noiseSuppression: true, autoGainControl: true }
    });

    transcribeState.scribe.on('committed_transcript', (data) => {
        let text = (data.text || '').trim();
        if (text.startsWith('"') && text.endsWith('"')) text = text.slice(1, -1).trim();
        if (!text) return;
        committedText = (committedText ? committedText + ' ' : '') + text;
        document.getElementById('transcript').textContent = committedText;
    });

    // When user clicks "Done", send transcript to AI for processing
    document.getElementById('done-btn').onclick = async () => {
        transcribeState.scribe.close();
        transcribeState.scribe = null;

        if (!committedText.trim()) return;

        // Use fire-and-forget to process the transcript
        const entity = await pt.add('dictation', {
            status: 'queued',
            transcript: committedText,
            summary: null
        });

        pt.addMessage(`TASK: Summarize this dictated transcript.
ENTITY ID: ${entity.id}

--- TRANSCRIPT ---
${committedText}
--- END ---

ACTUALLY CALL chatdb_edit with these exact parameters:
- entity_id: ${entity.id}
- data: {"status": "complete", "summary": "<your summary>"}
- merge: true
You MUST pass merge: true as a parameter.`);

        startPolling(entity.id);
    };
}

// Generate illustrated story with narration
async function createIllustratedStory(storyData) {
    // Generate illustration
    await pt.generateImage({
        prompt: storyData.sceneDescription,
        style: "digital art, storybook illustration",
        size: "1536x1024",
        folder: `stories/${storyData.title}/images`
    });

    // Generate narration
    await pt.generateVoice({
        text: storyData.narrationText,
        voice: "fable",
        instructions: "warm storytelling voice with expressive emotion",
        folder: `stories/${storyData.title}/audio`
    });

    return {
        success: true,
        message: `Story "${storyData.title}" created with image and audio`
    };
}

// Generate product presentation
async function generateProductPresentation(product) {
    // Generate product image
    await pt.generateImage({
        prompt: `Professional product photo of ${product.name}, ${product.description},
                studio lighting, white background`,
        size: "1024x1024",
        folder: `products/${product.id}/images`
    });

    // Generate product description audio
    const script = `Introducing the ${product.name}. ${product.pitch}.
                   Available now for ${product.price}.`;

    await pt.generateVoice({
        text: script,
        voice: "nova",
        instructions: "enthusiastic marketing voice",
        folder: `products/${product.id}/audio`
    });

    alert('Product presentation generated!');
}

// Create video storyboard with voiceover
async function createStoryboard(scenes) {
    const results = [];

    for (const [index, scene] of scenes.entries()) {
        // Generate scene image
        const imageResult = await pt.generateImage({
            prompt: scene.visualDescription,
            size: "1536x1024",
            folder: `storyboard/scene-${index + 1}`
        });

        // Generate scene narration
        const audioResult = await pt.generateVoice({
            text: scene.narration,
            voice: scene.narratorVoice || "alloy",
            instructions: scene.tone || "neutral",
            folder: `storyboard/scene-${index + 1}`
        });

        results.push({
            scene: index + 1,
            image: imageResult,
            audio: audioResult
        });
    }

    return results;
}

async function safeGenerateMedia(type, options) {
    try {
        if (type === 'image') {
            return await pt.generateImage(options);
        } else if (type === 'voice') {
            return await pt.generateVoice(options);
        }
    } catch (error) {
        console.error(`${type} generation failed:`, error);

        // Show user-friendly error
        const errorMessages = {
            'Rate limit exceeded': 'Too many requests. Please wait a moment and try again.',
            'Invalid prompt': 'Please provide a valid description.',
            'Network error': 'Connection issue. Please check your internet and try again.'
        };

        const message = errorMessages[error.message] ||
                       `Failed to generate ${type}. Please try again.`;

        alert(message);
        return { success: false, error: error.message };
    }
}

// Usage
await safeGenerateMedia('image', {
    prompt: userInput,
    size: "1024x1024"
});

// Batch generation with rate limiting
async function generateImagesWithRateLimit(prompts, delayMs = 2000) {
    const results = [];

    for (const [index, prompt] of prompts.entries()) {
        console.log(`Generating image ${index + 1}/${prompts.length}`);

        const result = await pt.generateImage({ prompt, size: "1024x1024" });
        results.push(result);

        // Wait before next generation (except for last item)
        if (index < prompts.length - 1) {
            await new Promise(resolve => setTimeout(resolve, delayMs));
        }
    }

    return results;
}