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"
    });
}

// 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;
}