@goscribe/server 1.3.4 → 1.5.0

package/src/services/content/podcast.service.ts

@@ -0,0 +1,777 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { v4 as uuidv4 } from 'uuid';
+import { BaseService } from '../base.service.js';
+import { ArtifactType } from '../../lib/constants.js';
+import { ai } from '../../lib/ai/index.js';
+import { generateSignedUrl, deleteFromSupabase } from '../../lib/storage.js';
+import PusherService from '../../lib/pusher.js';
+import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+
+export const speakerSchema = z.object({
+  id: z.string(),
+  role: z.enum(['host', 'guest', 'expert']),
+  name: z.string().optional(),
+});
+
+export const podcastInputSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  userPrompt: z.string(),
+  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),
+});
+
+export type PodcastInput = z.infer<typeof podcastInputSchema>;
+
+export const podcastMetadataSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  totalDuration: z.number(),
+  speakers: z.array(speakerSchema),
+  summary: z.object({
+    executiveSummary: z.string(),
+    learningObjectives: z.array(z.string()),
+    keyConcepts: z.array(z.string()),
+    followUpActions: z.array(z.string()),
+    targetAudience: z.string(),
+    prerequisites: z.array(z.string()),
+    tags: z.array(z.string()),
+  }),
+  generatedAt: z.string(),
+});
+
+export class PodcastService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  async listEpisodes(userId: string, workspaceId: string) {
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: workspaceId, ownerId: userId },
+    });
+    if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const artifacts = await this.db.artifact.findMany({
+      where: { workspaceId, type: ArtifactType.PODCAST_EPISODE },
+      include: {
+        versions: { orderBy: { version: 'desc' }, take: 1 },
+        podcastSegments: { orderBy: { order: 'asc' } },
+      },
+      orderBy: { updatedAt: 'desc' },
+    });
+
+    this.logger.debug(`Found ${artifacts.length} podcast artifacts`);
+    artifacts.forEach((artifact, i) => {
+      this.logger.debug(
+        `  Podcast ${i + 1}: "${artifact.title}" - ${artifact.podcastSegments.length} segments`,
+      );
+    });
+
+    const episodesWithUrls = await Promise.all(
+      artifacts.map(async (artifact) => {
+        const latestVersion = artifact.versions[0];
+        let objectUrl = null;
+        if (artifact.imageObjectKey) {
+          objectUrl = await generateSignedUrl(artifact.imageObjectKey, 24);
+        }
+
+        const segmentsWithUrls = await Promise.all(
+          artifact.podcastSegments.map(async (segment) => {
+            if (segment.objectKey) {
+              try {
+                const signedUrl = await generateSignedUrl(segment.objectKey, 24);
+                return {
+                  id: segment.id,
+                  title: segment.title,
+                  audioUrl: signedUrl,
+                  objectKey: segment.objectKey,
+                  startTime: segment.startTime,
+                  duration: segment.duration,
+                  order: segment.order,
+                };
+              } catch (error) {
+                this.logger.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,
+            };
+          }),
+        );
+
+        let metadata = null;
+        if (latestVersion) {
+          try {
+            this.logger.debug(JSON.stringify(latestVersion.data));
+            metadata = podcastMetadataSchema.parse(latestVersion.data);
+          } catch (error) {
+            this.logger.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,
+          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;
+  }
+
+  async getEpisode(userId: string, episodeId: string) {
+    const episode = await this.db.artifact.findFirst({
+      where: {
+        id: episodeId,
+        type: ArtifactType.PODCAST_EPISODE,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include: {
+        versions: { orderBy: { version: 'desc' }, take: 1 },
+        podcastSegments: { orderBy: { order: 'asc' } },
+      },
+    });
+
+    this.logger.debug(JSON.stringify(episode));
+
+    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' });
+
+    this.logger.debug(JSON.stringify(latestVersion));
+    try {
+      podcastMetadataSchema.parse(latestVersion.data);
+    } catch (error) {
+      this.logger.error('Failed to parse podcast metadata:', error);
+    }
+    const metadata = podcastMetadataSchema.parse(latestVersion.data);
+
+    const imageUrl = episode.imageObjectKey
+      ? await generateSignedUrl(episode.imageObjectKey, 24)
+      : null;
+
+    const segmentsWithUrls = await Promise.all(
+      episode.podcastSegments.map(async (segment) => {
+        if (segment.objectKey) {
+          try {
+            const signedUrl = await generateSignedUrl(segment.objectKey, 24);
+            return {
+              id: segment.id,
+              title: segment.title,
+              content: segment.content,
+              audioUrl: signedUrl,
+              objectKey: segment.objectKey,
+              startTime: segment.startTime,
+              duration: segment.duration,
+              keyPoints: segment.keyPoints,
+              order: segment.order,
+            };
+          } catch (error) {
+            this.logger.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+            return {
+              id: segment.id,
+              title: segment.title,
+              content: segment.content,
+              audioUrl: null,
+              objectKey: segment.objectKey,
+              startTime: segment.startTime,
+              duration: segment.duration,
+              keyPoints: segment.keyPoints,
+              order: segment.order,
+            };
+          }
+        }
+        return {
+          id: segment.id,
+          title: segment.title,
+          content: segment.content,
+          audioUrl: null,
+          objectKey: segment.objectKey,
+          startTime: segment.startTime,
+          duration: segment.duration,
+          keyPoints: segment.keyPoints,
+          order: segment.order,
+        };
+      }),
+    );
+
+    return {
+      id: episode.id,
+      title: metadata.title,
+      description: metadata.description,
+      metadata,
+      imageUrl,
+      segments: segmentsWithUrls,
+      content: latestVersion.content,
+      createdAt: episode.createdAt,
+      updatedAt: episode.updatedAt,
+    };
+  }
+
+  async generateEpisode(
+    userId: string,
+    input: { workspaceId: string; podcastData: PodcastInput },
+  ) {
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: input.workspaceId, ownerId: userId },
+    });
+    if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    await PusherService.emitTaskComplete(input.workspaceId, 'podcast_generation_start', {
+      title: input.podcastData.title,
+    });
+
+    const BEGIN_PODCAST_GENERATION_MESSAGE = 'Structuring podcast contents...';
+
+    const newArtifact = await this.db.artifact.create({
+      data: {
+        title: '----',
+        type: ArtifactType.PODCAST_EPISODE,
+        generating: true,
+        generatingMetadata: { message: BEGIN_PODCAST_GENERATION_MESSAGE },
+        workspace: { connect: { id: input.workspaceId } },
+      },
+    });
+
+    await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+      message: BEGIN_PODCAST_GENERATION_MESSAGE,
+    });
+
+    try {
+      const structureResult = await ai.backend.generatePodcastStructure(
+        input.workspaceId,
+        userId,
+        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 generate podcast structure',
+        });
+      }
+
+      const structure = structureResult.structure;
+
+      await this.db.artifact.update({
+        where: { id: newArtifact.id },
+        data: { title: structure.episodeTitle },
+      });
+
+      const segments: Array<{
+        id: string;
+        title: string;
+        content: string;
+        objectKey: string;
+        startTime: number;
+        duration: number;
+        keyPoints: string[];
+        order: number;
+      }> = [];
+      const failedSegments: Array<{ index: number; title: string; error: string }> = [];
+      let totalDuration = 0;
+      let fullTranscript = '';
+
+      await this.db.artifact.update({
+        where: { id: newArtifact.id },
+        data: { generatingMetadata: { message: `Generating podcast image...` } },
+      });
+
+      await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+        message: `Generating podcast image...`,
+      });
+
+      const podcastImage = await ai.backend.generatePodcastImage(
+        input.workspaceId,
+        userId,
+        structure.segments.map((segment: any) => segment.content).join('\n\n'),
+      );
+
+      await this.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 {
+          await this.db.artifact.update({
+            where: { id: newArtifact.id },
+            data: {
+              generatingMetadata: {
+                message: `Generating audio for "${segment.title}" (${i + 1} of ${structure.segments.length})...`,
+              },
+            },
+          });
+
+          await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+            message: `Generating audio for segment ${i + 1} of ${structure.segments.length}...`,
+          });
+
+          const audioResult = await ai.backend.generatePodcastAudioFromText(
+            input.workspaceId,
+            userId,
+            newArtifact.id,
+            i,
+            segment.content,
+            input.podcastData.speakers,
+            segment.voiceId,
+          );
+
+          if (!audioResult.success) {
+            throw new Error('Failed to generate audio for segment');
+          }
+
+          segments.push({
+            id: uuidv4(),
+            title: segment.title,
+            content: segment.content,
+            objectKey: audioResult.objectKey,
+            startTime: totalDuration,
+            duration: audioResult.duration,
+            keyPoints: segment.keyPoints || [],
+            order: segment.order || i + 1,
+          });
+
+          totalDuration += audioResult.duration;
+          fullTranscript += `\n\n## ${segment.title}\n\n${segment.content}`;
+        } catch (audioError) {
+          const errorMessage = audioError instanceof Error ? audioError.message : 'Unknown error';
+          this.logger.error(`❌ Error generating audio for segment ${i + 1}:`, {
+            title: segment.title,
+            error: errorMessage,
+            stack: audioError instanceof Error ? audioError.stack : undefined,
+          });
+
+          failedSegments.push({
+            index: i + 1,
+            title: segment.title || `Segment ${i + 1}`,
+            error: errorMessage,
+          });
+
+          await PusherService.emitTaskComplete(input.workspaceId, 'podcast_segment_error', {
+            segmentIndex: i + 1,
+            segmentTitle: segment.title || `Segment ${i + 1}`,
+            error: errorMessage,
+            successfulSegments: segments.length,
+            failedSegments: failedSegments.length,
+          });
+        }
+      }
+
+      if (segments.length === 0) {
+        this.logger.error('No segments were successfully generated');
+        await PusherService.emitError(
+          input.workspaceId,
+          `Failed to generate any segments. ${failedSegments.length} segment(s) failed.`,
+          'podcast',
+        );
+
+        await notifyArtifactFailed(this.db, {
+          userId,
+          workspaceId: input.workspaceId,
+          artifactType: ArtifactType.PODCAST_EPISODE,
+          artifactId: newArtifact.id,
+          title: input.podcastData.title,
+          message: `Failed to generate any audio segments. All ${failedSegments.length} attempts failed.`,
+        }).catch(() => {});
+
+        await this.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 this.db.artifact.update({
+        where: { id: newArtifact.id },
+        data: { generatingMetadata: { message: `Preparing podcast summary...` } },
+      });
+
+      await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+        message: `Preparing podcast summary...`,
+      });
+
+      const summaryPrompt = `Create a comprehensive podcast episode summary including:
+        - Executive summary
+        - Learning objectives
+        - Key concepts covered
+        - Recommended follow-up actions
+        - Target audience
+        - Prerequisites (if any)
+
+        Format as JSON:
+        {
+          "executiveSummary": "Brief overview of the episode",
+          "learningObjectives": ["objective1", "objective2"],
+          "keyConcepts": ["concept1", "concept2"],
+          "followUpActions": ["action1", "action2"],
+          "targetAudience": "Description of target audience",
+          "prerequisites": ["prerequisite1", "prerequisite2"],
+          "tags": ["tag1", "tag2", "tag3"]
+        }
+
+        Podcast Title: ${structure.episodeTitle}
+        Segments: ${JSON.stringify(segments.map((s) => ({ title: s.title, keyPoints: s.keyPoints })))}`;
+
+      const summaryResponse = await ai.llm.complete([{ role: 'user', content: summaryPrompt }]);
+      const summaryContent: string = summaryResponse.choices[0].message.content || '';
+
+      let episodeSummary;
+      try {
+        const jsonMatch = summaryContent.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+          throw new Error('No JSON found in summary response');
+        }
+        episodeSummary = JSON.parse(jsonMatch[0]);
+      } catch (parseError) {
+        this.logger.error('Failed to parse summary response:', summaryContent);
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_summary_error', {
+          error: 'Failed to parse summary response',
+        });
+        episodeSummary = {
+          executiveSummary: 'AI-generated podcast episode',
+          learningObjectives: [],
+          keyConcepts: [],
+          followUpActions: [],
+          targetAudience: 'General audience',
+          prerequisites: [],
+          tags: [],
+        };
+      }
+
+      await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+        message: `Podcast summary generated.`,
+      });
+
+      const episodeTitle = structure.episodeTitle || input.podcastData.title;
+
+      await this.db.artifact.update({
+        where: { id: newArtifact.id },
+        data: {
+          workspaceId: input.workspaceId,
+          type: ArtifactType.PODCAST_EPISODE,
+          title: episodeTitle,
+          description: input.podcastData.description,
+          createdById: userId,
+        },
+      });
+
+      await this.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,
+        summary: episodeSummary,
+        speakers: input.podcastData.speakers,
+        generatedAt: new Date().toISOString(),
+      };
+
+      await this.db.artifactVersion.create({
+        data: {
+          artifactId: newArtifact.id,
+          version: 1,
+          content: fullTranscript.trim(),
+          data: metadata,
+          createdById: userId,
+        },
+      });
+
+      await this.db.artifact.update({
+        where: { id: newArtifact.id },
+        data: { generating: false },
+      });
+
+      await PusherService.emitPodcastComplete(input.workspaceId, newArtifact);
+      await notifyArtifactReady(this.db, {
+        userId,
+        workspaceId: input.workspaceId,
+        artifactId: newArtifact.id,
+        artifactType: ArtifactType.PODCAST_EPISODE,
+        title: metadata.title,
+      }).catch(() => {});
+
+      return {
+        id: newArtifact.id,
+        title: metadata.title,
+        description: metadata.description,
+        metadata,
+        content: fullTranscript.trim(),
+      };
+    } catch (error) {
+      this.logger.error('Error generating podcast episode:', error);
+
+      await notifyArtifactFailed(this.db, {
+        userId,
+        workspaceId: input.workspaceId,
+        artifactType: ArtifactType.PODCAST_EPISODE,
+        artifactId: newArtifact.id,
+        title: input.podcastData.title,
+        message: error instanceof Error ? error.message : 'Podcast generation failed.',
+      }).catch(() => {});
+
+      await this.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'}`,
+      });
+    }
+  }
+
+  async deleteSegment(segmentId: string) {
+    return this.db.podcastSegment.delete({ where: { id: segmentId } });
+  }
+
+  async getEpisodeSchema(userId: string, episodeId: string) {
+    const episode = await this.db.artifact.findFirst({
+      where: {
+        id: episodeId,
+        type: ArtifactType.PODCAST_EPISODE,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include: {
+        versions: { orderBy: { version: 'desc' }, take: 1 },
+        podcastSegments: { orderBy: { order: 'asc' } },
+      },
+    });
+
+    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);
+
+    return {
+      segments: episode.podcastSegments.map((s) => ({
+        id: s.id,
+        title: s.title,
+        startTime: s.startTime,
+        duration: s.duration,
+        keyPoints: s.keyPoints,
+        order: s.order,
+      })),
+      summary: metadata.summary,
+      metadata: {
+        title: metadata.title,
+        description: metadata.description,
+        totalDuration: metadata.totalDuration,
+        speakers: metadata.speakers,
+      },
+    };
+  }
+
+  async updateEpisode(
+    userId: string,
+    input: { episodeId: string; title?: string; description?: string },
+  ) {
+    const episode = await this.db.artifact.findFirst({
+      where: {
+        id: input.episodeId,
+        type: ArtifactType.PODCAST_EPISODE,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include: {
+        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);
+
+    if (input.title) metadata.title = input.title;
+    if (input.description) metadata.description = input.description;
+
+    const nextVersion = (latestVersion.version || 0) + 1;
+    await this.db.artifactVersion.create({
+      data: {
+        artifactId: input.episodeId,
+        version: nextVersion,
+        content: latestVersion.content,
+        data: metadata,
+        createdById: userId,
+      },
+    });
+
+    return this.db.artifact.update({
+      where: { id: input.episodeId },
+      data: {
+        title: input.title ?? episode.title,
+        description: input.description ?? episode.description,
+        updatedAt: new Date(),
+      },
+    });
+  }
+
+  async deleteEpisode(userId: string, episodeId: string) {
+    const episode = await this.db.artifact.findFirst({
+      where: {
+        id: episodeId,
+        type: ArtifactType.PODCAST_EPISODE,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include: {
+        versions: { orderBy: { version: 'desc' }, take: 1 },
+      },
+    });
+
+    if (!episode) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    try {
+      await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_deletion_start', {
+        episodeId,
+        episodeTitle: episode.title || 'Untitled Episode',
+      });
+
+      const segments = await this.db.podcastSegment.findMany({
+        where: { artifactId: episodeId },
+      });
+
+      for (const segment of segments) {
+        if (segment.objectKey) {
+          try {
+            await deleteFromSupabase(segment.objectKey);
+          } catch (error) {
+            this.logger.error(`Failed to delete audio file ${segment.objectKey}:`, error);
+          }
+        }
+      }
+
+      await this.db.podcastSegment.deleteMany({ where: { artifactId: episodeId } });
+      await this.db.artifactVersion.deleteMany({ where: { artifactId: episodeId } });
+      await this.db.artifact.delete({ where: { id: episodeId } });
+
+      await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_deletion_complete', {
+        episodeId,
+        episodeTitle: episode.title || 'Untitled Episode',
+      });
+
+      return true;
+    } catch (error) {
+      this.logger.error('Error deleting episode:', error);
+      await PusherService.emitError(
+        episode.workspaceId,
+        `Failed to delete episode: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        'podcast',
+      );
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to delete episode',
+      });
+    }
+  }
+
+  async getSegment(userId: string, segmentId: string) {
+    const segment = await this.db.podcastSegment.findFirst({
+      where: {
+        id: segmentId,
+        artifact: { workspace: workspaceAccessWhere(userId) },
+      },
+      include: { artifact: true },
+    });
+
+    if (!segment) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    let audioUrl = null;
+    if (segment.objectKey) {
+      try {
+        audioUrl = await generateSignedUrl(segment.objectKey, 24);
+      } catch (error) {
+        this.logger.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,
+    };
+  }
+
+  getAvailableVoices() {
+    return [
+      { id: 'alloy', name: 'Alloy', description: 'Neutral, balanced voice' },
+      { id: 'echo', name: 'Echo', description: 'Clear, professional voice' },
+      { id: 'fable', name: 'Fable', description: 'Warm, storytelling voice' },
+      { id: 'onyx', name: 'Onyx', description: 'Deep, authoritative voice' },
+      { id: 'nova', name: 'Nova', description: 'Friendly, conversational voice' },
+      { id: 'shimmer', name: 'Shimmer', description: 'Bright, energetic voice' },
+    ];
+  }
+}