@goscribe/server 1.0.11 → 1.1.1

package/dist/routers/podcast.js

@@ -3,8 +3,9 @@ import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
 import { v4 as uuidv4 } from 'uuid';
 import inference from '../lib/inference.js';
-import { uploadToGCS, generateSignedUrl, deleteFromGCS } from '../lib/storage.js';
+import { generateSignedUrl, deleteFromSupabase } from '../lib/storage.js';
 import PusherService from '../lib/pusher.js';
+import { aiSessionService } from '../lib/ai-session.js';
 // Prisma enum values mapped manually to avoid type import issues in ESM
 const ArtifactType = {
     PODCAST_EPISODE: 'PODCAST_EPISODE',
@@ -21,27 +22,31 @@ const podcastSegmentSchema = z.object({
     keyPoints: z.array(z.string()),
     order: z.number().int(),
     audioUrl: z.string().optional(),
-    objectKey: z.string().optional(), // Google Cloud Storage object key
+    objectKey: z.string().optional(), // Supabase Storage object key
+});
+// Speaker schema
+const speakerSchema = z.object({
+    id: z.string(),
+    role: z.enum(['host', 'guest', 'expert']),
+    name: z.string().optional(),
 });
 // Podcast creation input schema
 const podcastInputSchema = z.object({
     title: z.string(),
     description: z.string().optional(),
     userPrompt: z.string(),
-    voice: z.enum(['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']).default('nova'),
+    speakers: z.array(speakerSchema).min(1).default([{ id: 'pNInz6obpgDQGcFmaJgB', role: 'host' }]),
     speed: z.number().min(0.25).max(4.0).default(1.0),
     generateIntro: z.boolean().default(true),
     generateOutro: z.boolean().default(true),
     segmentByTopics: z.boolean().default(true),
 });
-// Podcast metadata schema for version data
+// Podcast metadata schema for version data (segments stored separately in database)
 const podcastMetadataSchema = z.object({
     title: z.string(),
     description: z.string().optional(),
     totalDuration: z.number(),
-    voice: z.string(),
-    speed: z.number(),
-    segments: z.array(podcastSegmentSchema),
+    speakers: z.array(speakerSchema),
     summary: z.object({
         executiveSummary: z.string(),
         learningObjectives: z.array(z.string()),
@@ -61,6 +66,7 @@ export const podcast = router({
         const workspace = await ctx.db.workspace.findFirst({
             where: { id: input.workspaceId, ownerId: ctx.session.user.id },
         });
+        // Check if workspace exists
         if (!workspace)
             throw new TRPCError({ code: 'NOT_FOUND' });
         const artifacts = await ctx.db.artifact.findMany({
@@ -73,99 +79,88 @@ export const podcast = router({
                     orderBy: { version: 'desc' },
                     take: 1, // Get only the latest version
                 },
+                podcastSegments: {
+                    orderBy: { order: 'asc' },
+                },
             },
             orderBy: { updatedAt: 'desc' },
         });
-        // Transform to include metadata from the latest version with fresh signed URLs
+        console.log(`📻 Found ${artifacts.length} podcast artifacts`);
+        artifacts.forEach((artifact, i) => {
+            console.log(`  Podcast ${i + 1}: "${artifact.title}" - ${artifact.podcastSegments.length} segments`);
+        });
+        // Transform to include segments with fresh signed URLs
         const episodesWithUrls = await Promise.all(artifacts.map(async (artifact) => {
             const latestVersion = artifact.versions[0];
-            if (!latestVersion) {
-                // Return a consistent structure even when no version exists
-                return {
-                    id: artifact.id,
-                    title: artifact.title || 'Untitled Episode',
-                    description: artifact.description || null,
-                    metadata: null,
-                    segments: [],
-                    createdAt: artifact.createdAt,
-                    updatedAt: artifact.updatedAt,
-                    workspaceId: artifact.workspaceId,
-                    type: artifact.type,
-                    createdById: artifact.createdById,
-                    isArchived: artifact.isArchived,
-                };
+            let objectUrl = null;
+            if (artifact.imageObjectKey) {
+                objectUrl = await generateSignedUrl(artifact.imageObjectKey, 24);
             }
-            try {
-                const metadata = podcastMetadataSchema.parse(latestVersion.data);
-                // Generate fresh signed URLs for all segments
-                const segmentsWithUrls = await Promise.all(metadata.segments.map(async (segment) => {
-                    if (segment.objectKey) {
-                        try {
-                            const signedUrl = await generateSignedUrl(segment.objectKey, 24); // 24 hours
-                            return {
-                                id: segment.id,
-                                title: segment.title,
-                                audioUrl: signedUrl,
-                                objectKey: segment.objectKey,
-                                startTime: segment.startTime,
-                                duration: segment.duration,
-                                order: segment.order,
-                            };
-                        }
-                        catch (error) {
-                            console.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
-                            return {
-                                id: segment.id,
-                                title: segment.title,
-                                audioUrl: null,
-                                objectKey: segment.objectKey,
-                                startTime: segment.startTime,
-                                duration: segment.duration,
-                                order: segment.order,
-                            };
-                        }
+            // Generate fresh signed URLs for all segments
+            const segmentsWithUrls = await Promise.all(artifact.podcastSegments.map(async (segment) => {
+                if (segment.objectKey) {
+                    try {
+                        const signedUrl = await generateSignedUrl(segment.objectKey, 24); // 24 hours
+                        return {
+                            id: segment.id,
+                            title: segment.title,
+                            audioUrl: signedUrl,
+                            objectKey: segment.objectKey,
+                            startTime: segment.startTime,
+                            duration: segment.duration,
+                            order: segment.order,
+                        };
                     }
-                    return {
-                        id: segment.id,
-                        title: segment.title,
-                        audioUrl: null,
-                        objectKey: segment.objectKey,
-                        startTime: segment.startTime,
-                        duration: segment.duration,
-                        order: segment.order,
-                    };
-                }));
-                return {
-                    id: artifact.id,
-                    title: metadata.title, // Use title from version metadata
-                    description: metadata.description, // Use description from version metadata
-                    metadata: metadata,
-                    segments: segmentsWithUrls,
-                    createdAt: artifact.createdAt,
-                    updatedAt: artifact.updatedAt,
-                    workspaceId: artifact.workspaceId,
-                    type: artifact.type,
-                    createdById: artifact.createdById,
-                    isArchived: artifact.isArchived,
-                };
-            }
-            catch (error) {
-                console.error('Failed to parse podcast metadata:', error);
-                // Return a consistent structure even when metadata parsing fails
+                    catch (error) {
+                        console.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+                        return {
+                            id: segment.id,
+                            title: segment.title,
+                            audioUrl: null,
+                            objectKey: segment.objectKey,
+                            startTime: segment.startTime,
+                            duration: segment.duration,
+                            order: segment.order,
+                        };
+                    }
+                }
                 return {
-                    id: artifact.id,
-                    title: artifact.title || 'Untitled Episode',
-                    description: artifact.description || null,
-                    metadata: null,
-                    segments: [],
-                    createdAt: artifact.createdAt,
-                    updatedAt: artifact.updatedAt,
-                    workspaceId: artifact.workspaceId,
-                    type: artifact.type,
-                    createdById: artifact.createdById,
-                    isArchived: artifact.isArchived,
+                    id: segment.id,
+                    title: segment.title,
+                    audioUrl: null,
+                    objectKey: segment.objectKey,
+                    startTime: segment.startTime,
+                    duration: segment.duration,
+                    order: segment.order,
                 };
+            }));
+            // Parse metadata from latest version if available
+            let metadata = null;
+            if (latestVersion) {
+                try {
+                    console.log(latestVersion.data);
+                    metadata = podcastMetadataSchema.parse(latestVersion.data);
+                }
+                catch (error) {
+                    console.error('Failed to parse podcast metadata:', error);
+                }
             }
+            return {
+                id: artifact.id,
+                title: metadata?.title || artifact.title || 'Untitled Episode',
+                description: metadata?.description || artifact.description || null,
+                metadata: metadata,
+                imageUrl: objectUrl,
+                segments: segmentsWithUrls,
+                createdAt: artifact.createdAt,
+                updatedAt: artifact.updatedAt,
+                workspaceId: artifact.workspaceId,
+                generating: artifact.generating,
+                generatingMetadata: artifact.generatingMetadata,
+                type: artifact.type,
+                createdById: artifact.createdById,
+                isArchived: artifact.isArchived,
+            };
         }));
         return episodesWithUrls;
     }),
@@ -184,6 +179,9 @@ export const podcast = router({
                     orderBy: { version: 'desc' },
                     take: 1,
                 },
+                podcastSegments: {
+                    orderBy: { order: 'asc' },
+                },
             },
         });
         console.log(episode);
@@ -193,9 +191,16 @@ export const podcast = router({
         if (!latestVersion)
             throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
         console.log(latestVersion);
+        try {
+            const metadata = podcastMetadataSchema.parse(latestVersion.data);
+        }
+        catch (error) {
+            console.error('Failed to parse podcast metadata:', error);
+        }
         const metadata = podcastMetadataSchema.parse(latestVersion.data);
+        const imageUrl = episode.imageObjectKey ? await generateSignedUrl(episode.imageObjectKey, 24) : null;
         // Generate fresh signed URLs for all segments
-        const segmentsWithUrls = await Promise.all(metadata.segments.map(async (segment) => {
+        const segmentsWithUrls = await Promise.all(episode.podcastSegments.map(async (segment) => {
             if (segment.objectKey) {
                 try {
                     const signedUrl = await generateSignedUrl(segment.objectKey, 24); // 24 hours
@@ -243,6 +248,7 @@ export const podcast = router({
             title: metadata.title, // Use title from version metadata
             description: metadata.description, // Use description from version metadata
             metadata,
+            imageUrl: imageUrl,
             segments: segmentsWithUrls,
             content: latestVersion.content, // transcript
             createdAt: episode.createdAt,
@@ -261,170 +267,163 @@ export const podcast = router({
         });
         if (!workspace)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        try {
-            // Emit podcast generation start notification
-            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_generation_start', {
-                title: input.podcastData.title
-            });
-            const studyGuide = await ctx.db.artifact.findFirst({
-                where: {
-                    workspaceId: input.workspaceId,
-                    type: ArtifactType.STUDY_GUIDE,
-                },
-                include: {
-                    versions: {
-                        orderBy: { version: 'desc' },
-                        take: 1,
-                    },
+        // Emit podcast generation start notification
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_generation_start', {
+            title: input.podcastData.title
+        });
+        const BEGIN_PODCAST_GENERATION_MESSAGE = 'Structuring podcast contents...';
+        const newArtifact = await ctx.db.artifact.create({
+            data: {
+                title: '----',
+                type: ArtifactType.PODCAST_EPISODE,
+                generating: true,
+                generatingMetadata: {
+                    message: BEGIN_PODCAST_GENERATION_MESSAGE,
                 },
-            });
-            const latestVersion = studyGuide?.versions[0];
-            const studyGuideContent = latestVersion?.content || '';
-            // Step 1: Structure the content into segments using inference API
-            const structurePrompt = `You are a podcast content structuring assistant. Given a user prompt, create a complete podcast episode with engaging content and logical segments.
-        
-        Based on the user's prompt (and any existing study guide context for this workspace), generate a podcast episode that:
-        - Addresses the user's request or topic
-        - Is educational, informative, and engaging
-        - Has natural, conversational language
-        - Flows logically from one segment to the next
-        
-        Create segments that are:
-        - 2-5 minutes each when spoken
-        - Focused on specific topics or concepts
-        - Include key takeaways for each segment
-        - Use natural, conversational language suitable for audio
-
-        ${input.podcastData.generateIntro ? 'Include an engaging introduction segment that hooks the listener.' : ''}
-        ${input.podcastData.generateOutro ? 'Include a conclusion/outro segment that summarizes key points.' : ''}
-
-        Format your response as JSON:
-        {
-          "episodeTitle": "Enhanced title for the podcast",
-          "totalEstimatedDuration": "estimated duration in minutes",
-          "segments": [
-            {
-              "title": "Segment title",
-              "content": "Natural, conversational script for this segment",
-              "keyPoints": ["key point 1", "key point 2"],
-              "estimatedDuration": "duration in minutes",
-              "order": 1
-            }
-          ]
-        }
-
-        Title: ${input.podcastData.title}
-        Description: ${input.podcastData.description || 'No description provided'}
-        Users notes: 
-        User Prompt: ${input.podcastData.userPrompt}
-        
-        If there is a study guide artifact in this workspace, incorporate its key points and structure to improve coherence. Use it only as supportive context, do not copy verbatim.`;
-            const structureResponse = await inference(structurePrompt, 'podcast_structure');
-            const structureData = await structureResponse.json();
-            const structureContent = structureData.response || '';
-            let structuredContent;
-            try {
-                // Extract JSON from the response
-                const jsonMatch = structureContent.match(/\{[\s\S]*\}/);
-                if (!jsonMatch) {
-                    throw new Error('No JSON found in response');
+                workspace: {
+                    connect: {
+                        id: input.workspaceId,
+                    }
                 }
-                structuredContent = JSON.parse(jsonMatch[0]);
             }
-            catch (parseError) {
-                console.error('Failed to parse structure response:', structureContent);
-                await PusherService.emitError(input.workspaceId, 'Failed to structure podcast content', 'podcast');
+        });
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+            message: BEGIN_PODCAST_GENERATION_MESSAGE,
+        });
+        try {
+            const structureResult = await aiSessionService.generatePodcastStructure(input.workspaceId, ctx.session.user.id, input.podcastData.title, input.podcastData.description || '', input.podcastData.userPrompt, input.podcastData.speakers);
+            if (!structureResult.success || !structureResult.structure) {
                 throw new TRPCError({
                     code: 'INTERNAL_SERVER_ERROR',
-                    message: 'Failed to structure podcast content'
+                    message: 'Failed to generate podcast structure'
                 });
             }
-            // Emit structure completion notification
-            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_structure_complete', {
-                segmentsCount: structuredContent.segments?.length || 0
+            const structure = structureResult.structure;
+            await ctx.db.artifact.update({
+                where: {
+                    id: newArtifact.id,
+                },
+                data: {
+                    title: structure.episodeTitle,
+                }
             });
             // Step 2: Generate audio for each segment
             const segments = [];
+            const failedSegments = [];
             let totalDuration = 0;
             let fullTranscript = '';
-            // Emit audio generation start notification
-            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_audio_generation_start', {
-                totalSegments: structuredContent.segments?.length || 0
+            await ctx.db.artifact.update({
+                where: {
+                    id: newArtifact.id,
+                },
+                data: {
+                    generatingMetadata: {
+                        message: `Generating podcast image...`,
+                    },
+                }
+            });
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+                message: `Generating podcast image...`,
             });
-            for (const [index, segment] of structuredContent.segments.entries()) {
+            const podcastImage = await aiSessionService.generatePodcastImage(input.workspaceId, ctx.session.user.id, structure.segments.map((segment) => segment.content).join('\n\n'));
+            await ctx.db.artifact.update({
+                where: {
+                    id: newArtifact.id,
+                },
+                data: {
+                    imageObjectKey: podcastImage,
+                }
+            });
+            for (let i = 0; i < structure.segments.length; i++) {
+                const segment = structure.segments[i];
                 try {
                     // Emit segment generation progress
-                    await PusherService.emitTaskComplete(input.workspaceId, 'podcast_segment_progress', {
-                        currentSegment: index + 1,
-                        totalSegments: structuredContent.segments.length,
-                        segmentTitle: segment.title || `Segment ${index + 1}`
-                    });
-                    // Generate speech for this segment using Murf TTS
-                    const mp3Response = await fetch('https://api.murf.ai/v1/speech/generate', {
-                        method: 'POST',
-                        headers: {
-                            'api-key': process.env.MURF_TTS_KEY || '',
-                            'Content-Type': 'application/json',
-                            'Accept': 'application/json',
+                    // await PusherService.emitTaskComplete(input.workspaceId, 'podcast_segment_progress', { 
+                    //   currentSegment: i + 1,
+                    //   totalSegments: structure.segments.length,
+                    //   segmentTitle: segment.title || `Segment ${i + 1}`,
+                    //   successfulSegments: segments.length,
+                    //   failedSegments: failedSegments.length,
+                    // });
+                    await ctx.db.artifact.update({
+                        where: {
+                            id: newArtifact.id,
                         },
-                        body: JSON.stringify({
-                            text: segment.content,
-                            voiceId: 'en-US-natalie',
-                        }),
+                        data: {
+                            generatingMetadata: {
+                                message: `Generating audio for "${segment.title}" (${i + 1} of ${structure.segments.length})...`,
+                            },
+                        }
                     });
-                    if (!mp3Response.ok) {
-                        throw new Error(`Murf TTS error: ${mp3Response.status} ${mp3Response.statusText}`);
-                    }
-                    // Parse the response to get the audio URL
-                    const mp3Data = await mp3Response.json();
-                    // Check for different possible response structures
-                    const audioUrl = mp3Data.audioFile || mp3Data.audioUrl || mp3Data.url || mp3Data.downloadUrl;
-                    if (!audioUrl) {
-                        console.error('No audio URL found in Murf response. Available fields:', Object.keys(mp3Data));
-                        throw new Error('No audio URL in Murf response');
-                    }
-                    // Download the actual audio file from the URL
-                    const audioResponse = await fetch(audioUrl);
-                    if (!audioResponse.ok) {
-                        throw new Error(`Failed to download audio: ${audioResponse.status} ${audioResponse.statusText}`);
+                    await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+                        message: `Generating audio for segment ${i + 1} of ${structure.segments.length}...`,
+                    });
+                    // Generate audio using new API
+                    const audioResult = await aiSessionService.generatePodcastAudioFromText(input.workspaceId, ctx.session.user.id, newArtifact.id, i, segment.content, input.podcastData.speakers, segment.voiceId);
+                    if (!audioResult.success) {
+                        throw new Error('Failed to generate audio for segment');
                     }
-                    // Upload to Google Cloud Storage
-                    const audioBuffer = Buffer.from(await audioResponse.arrayBuffer());
-                    const fileName = `segment_${index + 1}.mp3`;
-                    const uploadResult = await uploadToGCS(audioBuffer, fileName, 'audio/mpeg', false); // Keep private
-                    // Estimate duration (roughly 150 words per minute for TTS)
-                    const wordCount = segment.content.split(' ').length;
-                    const estimatedDuration = Math.ceil((wordCount / 150) * 60); // in seconds
                     segments.push({
                         id: uuidv4(),
                         title: segment.title,
                         content: segment.content,
-                        objectKey: uploadResult.objectKey, // Store object key for future operations
+                        objectKey: audioResult.objectKey,
                         startTime: totalDuration,
-                        duration: estimatedDuration,
+                        duration: audioResult.duration,
                         keyPoints: segment.keyPoints || [],
-                        order: segment.order || index + 1,
+                        order: segment.order || i + 1,
                     });
-                    totalDuration += estimatedDuration;
+                    totalDuration += audioResult.duration;
                     fullTranscript += `\n\n## ${segment.title}\n\n${segment.content}`;
                 }
                 catch (audioError) {
-                    console.error(`Error generating audio for segment ${index + 1}:`, audioError);
+                    const errorMessage = audioError instanceof Error ? audioError.message : 'Unknown error';
+                    console.error(`❌ Error generating audio for segment ${i + 1}:`, {
+                        title: segment.title,
+                        error: errorMessage,
+                        stack: audioError instanceof Error ? audioError.stack : undefined,
+                    });
+                    // Track failed segment
+                    failedSegments.push({
+                        index: i + 1,
+                        title: segment.title || `Segment ${i + 1}`,
+                        error: errorMessage,
+                    });
                     await PusherService.emitTaskComplete(input.workspaceId, 'podcast_segment_error', {
-                        segmentIndex: index + 1,
-                        error: audioError instanceof Error ? audioError.message : 'Unknown error'
+                        segmentIndex: i + 1,
+                        segmentTitle: segment.title || `Segment ${i + 1}`,
+                        error: errorMessage,
+                        successfulSegments: segments.length,
+                        failedSegments: failedSegments.length,
                     });
                     // Continue with other segments even if one fails
                 }
             }
-            // Emit audio generation completion notification
-            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_audio_generation_complete', {
-                totalSegments: segments.length,
-                totalDuration: totalDuration
+            // Check if any segments were successfully generated
+            if (segments.length === 0) {
+                console.error('No segments were successfully generated');
+                await PusherService.emitError(input.workspaceId, `Failed to generate any segments. ${failedSegments.length} segment(s) failed.`, 'podcast');
+                // Cleanup the artifact
+                await ctx.db.artifact.delete({
+                    where: { id: newArtifact.id },
+                });
+                throw new TRPCError({
+                    code: 'INTERNAL_SERVER_ERROR',
+                    message: `Failed to generate any audio segments. All ${failedSegments.length} attempts failed.`
+                });
+            }
+            await ctx.db.artifact.update({
+                where: {
+                    id: newArtifact.id,
+                },
+                data: {
+                    generatingMetadata: {
+                        message: `Preparing podcast summary...`,
+                    },
+                }
             });
-            // Step 2.5: Prepare segment audio array for frontend joining
-            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_audio_preparation_complete', {
-                totalSegments: segments.length
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+                message: `Preparing podcast summary...`,
             });
             // Step 3: Generate episode summary using inference API
             const summaryPrompt = `Create a comprehensive podcast episode summary including:
@@ -446,11 +445,10 @@ export const podcast = router({
           "tags": ["tag1", "tag2", "tag3"]
         }
 
-        Podcast Title: ${structuredContent.episodeTitle}
+        Podcast Title: ${structure.episodeTitle}
         Segments: ${JSON.stringify(segments.map(s => ({ title: s.title, keyPoints: s.keyPoints })))}`;
-            const summaryResponse = await inference(summaryPrompt, 'podcast_summary');
-            const summaryData = await summaryResponse.json();
-            const summaryContent = summaryData.response || '';
+            const summaryResponse = await inference(summaryPrompt);
+            const summaryContent = summaryResponse.choices[0].message.content || '';
             let episodeSummary;
             try {
                 // Extract JSON from the response
@@ -476,12 +474,15 @@ export const podcast = router({
                 };
             }
             // Emit summary generation completion notification
-            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_summary_complete', {
-                summaryGenerated: true
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+                message: `Podcast summary generated.`,
             });
             // Step 4: Create artifact and initial version
-            const episodeTitle = structuredContent.episodeTitle || input.podcastData.title;
-            const artifact = await ctx.db.artifact.create({
+            const episodeTitle = structure.episodeTitle || input.podcastData.title;
+            await ctx.db.artifact.update({
+                where: {
+                    id: newArtifact.id,
+                },
                 data: {
                     workspaceId: input.workspaceId,
                     type: ArtifactType.PODCAST_EPISODE,
@@ -490,30 +491,51 @@ export const podcast = router({
                     createdById: ctx.session.user.id,
                 },
             });
-            // Create initial version with complete metadata
+            const createdSegments = await ctx.db.podcastSegment.createMany({
+                data: segments.map(segment => ({
+                    artifactId: newArtifact.id,
+                    title: segment.title,
+                    content: segment.content,
+                    startTime: segment.startTime,
+                    duration: segment.duration,
+                    order: segment.order,
+                    objectKey: segment.objectKey,
+                    keyPoints: segment.keyPoints,
+                    meta: {
+                        speed: input.podcastData.speed,
+                        speakers: input.podcastData.speakers,
+                    },
+                })),
+            });
             const metadata = {
                 title: episodeTitle,
                 description: input.podcastData.description,
                 totalDuration: totalDuration,
-                voice: input.podcastData.voice,
-                speed: input.podcastData.speed,
-                segments: segments, // Array of segments with audio URLs for frontend joining
                 summary: episodeSummary,
+                speakers: input.podcastData.speakers,
                 generatedAt: new Date().toISOString(),
             };
             await ctx.db.artifactVersion.create({
                 data: {
-                    artifactId: artifact.id,
+                    artifactId: newArtifact.id,
                     version: 1,
                     content: fullTranscript.trim(), // Full transcript as markdown
                     data: metadata,
                     createdById: ctx.session.user.id,
                 },
             });
+            await ctx.db.artifact.update({
+                where: {
+                    id: newArtifact.id,
+                },
+                data: {
+                    generating: false,
+                },
+            });
             // Emit podcast generation completion notification
-            await PusherService.emitPodcastComplete(input.workspaceId, artifact);
+            await PusherService.emitPodcastComplete(input.workspaceId, {});
             return {
-                id: artifact.id,
+                id: newArtifact.id,
                 title: metadata.title,
                 description: metadata.description,
                 metadata,
@@ -522,6 +544,11 @@ export const podcast = router({
         }
         catch (error) {
             console.error('Error generating podcast episode:', error);
+            await ctx.db.artifact.delete({
+                where: {
+                    id: newArtifact.id,
+                },
+            });
             await PusherService.emitError(input.workspaceId, `Failed to generate podcast episode: ${error instanceof Error ? error.message : 'Unknown error'}`, 'podcast');
             throw new TRPCError({
                 code: 'INTERNAL_SERVER_ERROR',
@@ -529,148 +556,11 @@ export const podcast = router({
             });
         }
     }),
-    // Regenerate a specific segment
-    regenerateSegment: authedProcedure
-        .input(z.object({
-        episodeId: z.string(),
-        segmentId: z.string(),
-        newContent: z.string().optional(),
-        voice: z.enum(['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']).optional(),
-        speed: z.number().min(0.25).max(4.0).optional(),
-    }))
+    deleteSegment: authedProcedure
+        .input(z.object({ segmentId: z.string() }))
         .mutation(async ({ ctx, input }) => {
-        const episode = await ctx.db.artifact.findFirst({
-            where: {
-                id: input.episodeId,
-                type: ArtifactType.PODCAST_EPISODE,
-                workspace: { ownerId: ctx.session.user.id }
-            },
-            include: {
-                workspace: true,
-                versions: {
-                    orderBy: { version: 'desc' },
-                    take: 1,
-                },
-            },
-        });
-        if (!episode)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        const latestVersion = episode.versions[0];
-        if (!latestVersion)
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
-        const metadata = podcastMetadataSchema.parse(latestVersion.data);
-        const segment = metadata.segments.find(s => s.id === input.segmentId);
-        if (!segment)
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Segment not found' });
-        try {
-            // Emit segment regeneration start notification
-            await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_segment_regeneration_start', {
-                segmentId: input.segmentId,
-                segmentTitle: segment.title || 'Untitled Segment'
-            });
-            // Use new content or existing content
-            const contentToSpeak = input.newContent || segment.content;
-            const voice = input.voice || metadata.voice || 'nova';
-            const speed = input.speed || metadata.speed || 1.0;
-            // Generate new audio using Murf TTS
-            const mp3Response = await fetch('https://api.murf.ai/v1/speech/generate', {
-                method: 'POST',
-                headers: {
-                    'api-key': process.env.MURF_TTS_KEY || '',
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json',
-                },
-                body: JSON.stringify({
-                    text: contentToSpeak,
-                    voiceId: 'en-US-natalie',
-                }),
-            });
-            if (!mp3Response.ok) {
-                throw new Error(`Murf TTS error: ${mp3Response.status} ${mp3Response.statusText}`);
-            }
-            // Parse the response to get the audio URL
-            const mp3Data = await mp3Response.json();
-            // Check for different possible response structures
-            const audioUrl = mp3Data.audioFile || mp3Data.audioUrl || mp3Data.url || mp3Data.downloadUrl;
-            if (!audioUrl) {
-                console.error('No audio URL found in Murf response. Available fields:', Object.keys(mp3Data));
-                throw new Error('No audio URL in Murf response');
-            }
-            // Download the actual audio file from the URL
-            const audioResponse = await fetch(audioUrl);
-            if (!audioResponse.ok) {
-                throw new Error(`Failed to download audio: ${audioResponse.status} ${audioResponse.statusText}`);
-            }
-            // Upload to Google Cloud Storage
-            const audioBuffer = Buffer.from(await audioResponse.arrayBuffer());
-            const fileName = `segment_${segment.order}_${Date.now()}.mp3`;
-            const uploadResult = await uploadToGCS(audioBuffer, fileName, 'audio/mpeg', false); // Keep private
-            // Update segment data
-            segment.content = contentToSpeak;
-            segment.objectKey = uploadResult.objectKey; // Store object key
-            // Recalculate duration
-            const wordCount = contentToSpeak.split(' ').length;
-            segment.duration = Math.ceil((wordCount / 150) * 60);
-            // Recalculate start times for subsequent segments
-            let currentTime = 0;
-            for (const seg of metadata.segments) {
-                if (seg.order < segment.order) {
-                    currentTime += seg.duration;
-                }
-                else if (seg.order === segment.order) {
-                    seg.startTime = currentTime;
-                    currentTime += seg.duration;
-                }
-                else {
-                    seg.startTime = currentTime;
-                    currentTime += seg.duration;
-                }
-            }
-            // Update total duration
-            metadata.totalDuration = currentTime;
-            // Rebuild transcript
-            const fullTranscript = metadata.segments
-                .sort((a, b) => a.order - b.order)
-                .map(s => `\n\n## ${s.title}\n\n${s.content}`)
-                .join('');
-            // Step: Update segment audio (no need to regenerate full episode)
-            await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_segment_audio_updated', {
-                segmentId: input.segmentId,
-                totalSegments: metadata.segments.length
-            });
-            // Create new version
-            const nextVersion = (latestVersion.version || 0) + 1;
-            await ctx.db.artifactVersion.create({
-                data: {
-                    artifactId: input.episodeId,
-                    version: nextVersion,
-                    content: fullTranscript.trim(),
-                    data: metadata,
-                    createdById: ctx.session.user.id,
-                },
-            });
-            // Emit segment regeneration completion notification
-            await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_segment_regeneration_complete', {
-                segmentId: input.segmentId,
-                segmentTitle: segment.title || 'Untitled Segment',
-                duration: segment.duration
-            });
-            return {
-                segmentId: input.segmentId,
-                audioUrl: segment.audioUrl,
-                duration: segment.duration,
-                content: segment.content,
-                totalDuration: metadata.totalDuration,
-            };
-        }
-        catch (error) {
-            console.error('Error regenerating segment:', error);
-            await PusherService.emitError(episode.workspaceId, `Failed to regenerate segment: ${error instanceof Error ? error.message : 'Unknown error'}`, 'podcast');
-            throw new TRPCError({
-                code: 'INTERNAL_SERVER_ERROR',
-                message: `Failed to regenerate segment: ${error instanceof Error ? error.message : 'Unknown error'}`
-            });
-        }
+        const segment = await ctx.db.podcastSegment.delete({ where: { id: input.segmentId } });
+        return segment;
     }),
     // Get episode schema/structure for navigation
     getEpisodeSchema: authedProcedure
@@ -687,6 +577,9 @@ export const podcast = router({
                     orderBy: { version: 'desc' },
                     take: 1,
                 },
+                podcastSegments: {
+                    orderBy: { order: 'asc' },
+                },
             },
         });
         if (!episode)
@@ -696,7 +589,7 @@ export const podcast = router({
             throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
         const metadata = podcastMetadataSchema.parse(latestVersion.data);
         return {
-            segments: metadata.segments.map(s => ({
+            segments: episode.podcastSegments.map(s => ({
                 id: s.id,
                 title: s.title,
                 startTime: s.startTime,
@@ -709,8 +602,7 @@ export const podcast = router({
                 title: metadata.title,
                 description: metadata.description,
                 totalDuration: metadata.totalDuration,
-                voice: metadata.voice,
-                speed: metadata.speed,
+                speakers: metadata.speakers,
             },
         };
     }),
@@ -792,22 +684,25 @@ export const podcast = router({
                 episodeId: input.episodeId,
                 episodeTitle: episode.title || 'Untitled Episode'
             });
-            // Parse episode data to get audio file paths
-            const latestVersion = episode.versions[0];
-            if (latestVersion) {
-                const metadata = podcastMetadataSchema.parse(latestVersion.data);
-                // Delete audio files from Google Cloud Storage
-                for (const segment of metadata.segments || []) {
-                    if (segment.objectKey) {
-                        try {
-                            await deleteFromGCS(segment.objectKey);
-                        }
-                        catch (error) {
-                            console.error(`Failed to delete audio file ${segment.objectKey}:`, error);
-                        }
+            // Get segments to delete audio files
+            const segments = await ctx.db.podcastSegment.findMany({
+                where: { artifactId: input.episodeId },
+            });
+            // Delete audio files from Supabase Storage
+            for (const segment of segments) {
+                if (segment.objectKey) {
+                    try {
+                        await deleteFromSupabase(segment.objectKey);
+                    }
+                    catch (error) {
+                        console.error(`Failed to delete audio file ${segment.objectKey}:`, error);
                     }
                 }
             }
+            // Delete associated segments
+            await ctx.db.podcastSegment.deleteMany({
+                where: { artifactId: input.episodeId },
+            });
             // Delete associated versions
             await ctx.db.artifactVersion.deleteMany({
                 where: { artifactId: input.episodeId },
@@ -832,6 +727,48 @@ export const podcast = router({
             });
         }
     }),
+    // Get a specific segment with signed URL
+    getSegment: authedProcedure
+        .input(z.object({ segmentId: z.string() }))
+        .query(async ({ ctx, input }) => {
+        const segment = await ctx.db.podcastSegment.findFirst({
+            where: {
+                id: input.segmentId,
+                artifact: {
+                    workspace: { ownerId: ctx.session.user.id }
+                }
+            },
+            include: {
+                artifact: true,
+            },
+        });
+        if (!segment)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        // Generate fresh signed URL
+        let audioUrl = null;
+        if (segment.objectKey) {
+            try {
+                audioUrl = await generateSignedUrl(segment.objectKey, 24); // 24 hours
+            }
+            catch (error) {
+                console.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+            }
+        }
+        return {
+            id: segment.id,
+            title: segment.title,
+            content: segment.content,
+            startTime: segment.startTime,
+            duration: segment.duration,
+            order: segment.order,
+            keyPoints: segment.keyPoints,
+            audioUrl,
+            objectKey: segment.objectKey,
+            meta: segment.meta,
+            createdAt: segment.createdAt,
+            updatedAt: segment.updatedAt,
+        };
+    }),
     // Get available voices for TTS
     getAvailableVoices: authedProcedure
         .query(async () => {