@goscribe/server 1.0.11 → 1.1.1

package/src/routers/podcast.ts

@@ -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 { uploadToSupabase, 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 = {
@@ -23,7 +24,14 @@ 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
@@ -31,21 +39,19 @@ 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()),
@@ -66,6 +72,9 @@ 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({
@@ -78,104 +87,96 @@ export const podcast = router({
             orderBy: { version: 'desc' },
             take: 1, // Get only the latest version
           },
+          podcastSegments: {
+            orderBy: { order: 'asc' },
+          },
         },
         orderBy: { updatedAt: 'desc' },
       });
+      
+      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
+
 
-      // Transform to include metadata from the latest version 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,
+                  };
+                } 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: segment.id,
-                  title: segment.title,
-                  audioUrl: null,
-                  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
-            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,
-            };
+          // 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,
+          };
         })
       );
 
@@ -197,6 +198,9 @@ export const podcast = router({
             orderBy: { version: 'desc' },
             take: 1,
           },
+          podcastSegments: {
+            orderBy: { order: 'asc' },
+          },
         },
       });
 
@@ -208,13 +212,19 @@ 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) => {
+        episode.podcastSegments.map(async (segment) => {
           if (segment.objectKey) {
             try {
               const signedUrl = await generateSignedUrl(segment.objectKey, 24); // 24 hours
@@ -263,6 +273,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,
@@ -282,189 +293,215 @@ 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,
+        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,
             },
-          },
+            workspace: {
+              connect: {
+                id: input.workspaceId,
+              }
+            }
+          }
         });
 
-        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
-            }
-          ]
-        }
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', { 
+          message: BEGIN_PODCAST_GENERATION_MESSAGE,
+        });
 
-        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.`;
+      try {
 
-        const structureResponse = await inference(structurePrompt, 'podcast_structure');
-        const structureData = await structureResponse.json();
-        const structureContent = structureData.response || '';
+        const structureResult = await aiSessionService.generatePodcastStructure(
+          input.workspaceId,
+          ctx.session.user.id,
+          input.podcastData.title,
+          input.podcastData.description || '',
+          input.podcastData.userPrompt,
+          input.podcastData.speakers
+        );
 
-        let structuredContent;
-        try {
-          // Extract JSON from the response
-          const jsonMatch = structureContent.match(/\{[\s\S]*\}/);
-          if (!jsonMatch) {
-            throw new Error('No JSON found in response');
-          }
-          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');
+        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: any) => 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();
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', { 
+              message: `Generating audio for segment ${i + 1} of ${structure.segments.length}...`,
+            });
 
-            // 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');
-            }
+            // 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
+            );
 
-            // 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}`);
+            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
           }
         }
+        
+        // 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.` 
+          });
+        }
+
 
-        // Emit audio generation completion notification
-        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_audio_generation_complete', { 
-          totalSegments: segments.length,
-          totalDuration: totalDuration
+        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
@@ -487,12 +524,11 @@ 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: string = summaryResponse.choices[0].message.content || '';
 
         let episodeSummary;
         try {
@@ -519,14 +555,17 @@ 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 episodeTitle = structure.episodeTitle || input.podcastData.title;
         
-        const artifact = await ctx.db.artifact.create({
+        await ctx.db.artifact.update({
+          where: {
+            id: newArtifact.id,
+          },
           data: {
             workspaceId: input.workspaceId,
             type: ArtifactType.PODCAST_EPISODE,
@@ -535,22 +574,36 @@ 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,
@@ -558,11 +611,20 @@ export const podcast = router({
           },
         });
 
+        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,
@@ -570,174 +632,27 @@ 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', 
           message: `Failed to generate podcast episode: ${error instanceof Error ? error.message : 'Unknown error'}` 
         });
       }
-          }),
+    }),
 
-  // 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
@@ -755,6 +670,9 @@ export const podcast = router({
             orderBy: { version: 'desc' },
             take: 1,
           },
+          podcastSegments: {
+            orderBy: { order: 'asc' },
+          },
         },
       });
       
@@ -766,7 +684,7 @@ export const podcast = router({
       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,
@@ -779,8 +697,7 @@ export const podcast = router({
           title: metadata.title,
           description: metadata.description,
           totalDuration: metadata.totalDuration,
-          voice: metadata.voice,
-          speed: metadata.speed,
+          speakers: metadata.speakers,
         },
       };
     }),
@@ -868,23 +785,27 @@ export const podcast = router({
           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 },
@@ -913,6 +834,50 @@ 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 () => {