voice-router-dev 0.3.2 → 0.3.4

package/dist/index.js

@@ -42,18 +42,18 @@ __export(src_exports, {
   BaseAdapter: () => BaseAdapter,
   BaseWebhookHandler: () => BaseWebhookHandler,
   DeepgramAdapter: () => DeepgramAdapter,
-  DeepgramEncoding: () => ListenV1EncodingParameter,
+  DeepgramEncoding: () => DeepgramEncoding,
   DeepgramModel: () => DeepgramModel,
-  DeepgramRedact: () => ListenV1RedactParameterOneOfItem,
-  DeepgramTopicMode: () => SharedCustomTopicModeParameter,
+  DeepgramRedact: () => DeepgramRedact,
+  DeepgramTopicMode: () => DeepgramTopicMode,
   DeepgramWebhookHandler: () => DeepgramWebhookHandler,
   GladiaAdapter: () => GladiaAdapter,
-  GladiaBitDepth: () => StreamingSupportedBitDepthEnum,
-  GladiaEncoding: () => StreamingSupportedEncodingEnum,
-  GladiaLanguage: () => TranscriptionLanguageCodeEnum,
-  GladiaModel: () => StreamingSupportedModels,
-  GladiaSampleRate: () => StreamingSupportedSampleRateEnum,
-  GladiaTranslationLanguage: () => TranslationLanguageCodeEnum,
+  GladiaBitDepth: () => GladiaBitDepth,
+  GladiaEncoding: () => GladiaEncoding,
+  GladiaLanguage: () => GladiaLanguage,
+  GladiaModel: () => GladiaModel,
+  GladiaSampleRate: () => GladiaSampleRate,
+  GladiaTranslationLanguage: () => GladiaTranslationLanguage,
   GladiaTypes: () => schema_exports,
   GladiaWebhookHandler: () => GladiaWebhookHandler,
   ListenV1EncodingParameter: () => ListenV1EncodingParameter,
@@ -244,8 +244,20 @@ var VoiceRouter = class {
     return adapter.deleteTranscript(transcriptId);
   }
   /**
-   * List recent transcriptions
-   * Not all providers support this operation
+   * List recent transcriptions with filtering
+   *
+   * Supports date/time filtering, status filtering, and pagination.
+   * Not all providers support this operation.
+   *
+   * @example Filter by date range
+   * ```typescript
+   * const { transcripts } = await router.listTranscripts('assemblyai', {
+   *   afterDate: '2026-01-01',
+   *   beforeDate: '2026-01-31',
+   *   status: 'completed',
+   *   limit: 50
+   * })
+   * ```
    */
   async listTranscripts(provider, options) {
     const adapter = this.getAdapter(provider);
@@ -547,7 +559,40 @@ var TranslationLanguageCodeEnum = {
   zh: "zh"
 };
 
+// src/generated/assemblyai/schema/transcriptStatus.ts
+var TranscriptStatus = {
+  queued: "queued",
+  processing: "processing",
+  completed: "completed",
+  error: "error"
+};
+
+// src/generated/gladia/schema/transcriptionControllerListV2StatusItem.ts
+var TranscriptionControllerListV2StatusItem = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/azure/schema/status.ts
+var Status = {
+  NotStarted: "NotStarted",
+  Running: "Running",
+  Succeeded: "Succeeded",
+  Failed: "Failed"
+};
+
+// src/generated/deepgram/schema/manageV1FilterStatusParameter.ts
+var ManageV1FilterStatusParameter = {
+  succeeded: "succeeded",
+  failed: "failed"
+};
+
 // src/constants.ts
+var DeepgramEncoding = ListenV1EncodingParameter;
+var DeepgramRedact = ListenV1RedactParameterOneOfItem;
+var DeepgramTopicMode = SharedCustomTopicModeParameter;
 var DeepgramModel = {
   // Nova 3 models (latest)
   "nova-3": "nova-3",
@@ -584,6 +629,12 @@ var DeepgramModel = {
   voicemail: "voicemail",
   video: "video"
 };
+var GladiaEncoding = StreamingSupportedEncodingEnum;
+var GladiaSampleRate = StreamingSupportedSampleRateEnum;
+var GladiaBitDepth = StreamingSupportedBitDepthEnum;
+var GladiaModel = StreamingSupportedModels;
+var GladiaLanguage = TranscriptionLanguageCodeEnum;
+var GladiaTranslationLanguage = TranslationLanguageCodeEnum;
 var AssemblyAIEncoding = {
   /** PCM signed 16-bit little-endian (recommended) */
   pcmS16le: "pcm_s16le",
@@ -1551,14 +1602,6 @@ var TranscriptionControllerListV2KindItem = {
   live: "live"
 };
 
-// src/generated/gladia/schema/transcriptionControllerListV2StatusItem.ts
-var TranscriptionControllerListV2StatusItem = {
-  queued: "queued",
-  processing: "processing",
-  done: "done",
-  error: "error"
-};
-
 // src/generated/gladia/schema/transcriptMessageType.ts
 var TranscriptMessageType = {
   transcript: "transcript"
@@ -1843,6 +1886,18 @@ var preRecordedControllerGetPreRecordedJobV2 = (id, options) => {
 var preRecordedControllerDeletePreRecordedJobV2 = (id, options) => {
   return import_axios.default.delete(`/v2/pre-recorded/${id}`, options);
 };
+var preRecordedControllerGetAudioV2 = (id, options) => {
+  return import_axios.default.get(`/v2/pre-recorded/${id}/file`, {
+    responseType: "blob",
+    ...options
+  });
+};
+var transcriptionControllerListV2 = (params, options) => {
+  return import_axios.default.get("/v2/transcription", {
+    ...options,
+    params: { ...params, ...options?.params }
+  });
+};
 var streamingControllerInitStreamingSessionV2 = (streamingRequest, params, options) => {
   return import_axios.default.post("/v2/live", streamingRequest, {
     ...options,
@@ -1852,6 +1907,12 @@ var streamingControllerInitStreamingSessionV2 = (streamingRequest, params, optio
 var streamingControllerDeleteStreamingJobV2 = (id, options) => {
   return import_axios.default.delete(`/v2/live/${id}`, options);
 };
+var streamingControllerGetAudioV2 = (id, options) => {
+  return import_axios.default.get(`/v2/live/${id}/file`, {
+    responseType: "blob",
+    ...options
+  });
+};
 
 // src/adapters/gladia-adapter.ts
 var GladiaAdapter = class extends BaseAdapter {
@@ -1867,8 +1928,12 @@ var GladiaAdapter = class extends BaseAdapter {
       summarization: true,
       sentimentAnalysis: true,
       entityDetection: true,
-      piiRedaction: false
+      piiRedaction: false,
       // Gladia doesn't have PII redaction in their API
+      listTranscripts: true,
+      deleteTranscript: true,
+      getAudioFile: true
+      // Gladia stores and allows downloading original audio files
     };
     this.baseUrl = "https://api.gladia.io";
   }
@@ -2083,6 +2148,10 @@ var GladiaAdapter = class extends BaseAdapter {
         utterances: this.extractUtterances(transcription),
         summary: result?.summarization?.results || void 0,
         metadata: {
+          sourceAudioUrl: response.file?.source ?? void 0,
+          audioFileAvailable: this.capabilities.getAudioFile ?? false,
+          filename: response.file?.filename ?? void 0,
+          audioDuration: response.file?.audio_duration ?? void 0,
           requestParams: response.request_params
         },
         createdAt: response.created_at,
@@ -2201,6 +2270,204 @@ var GladiaAdapter = class extends BaseAdapter {
       throw error;
     }
   }
+  /**
+   * Download the original audio file from a transcription
+   *
+   * Gladia stores the audio files used for transcription and allows downloading them.
+   * This works for both pre-recorded and streaming (live) transcriptions.
+   *
+   * @param transcriptId - The ID of the transcript/job
+   * @param jobType - Type of job: 'pre-recorded' or 'streaming' (defaults to 'pre-recorded')
+   * @returns Promise with the audio file as a Blob, or error
+   *
+   * @example Download audio from a pre-recorded transcription
+   * ```typescript
+   * const result = await adapter.getAudioFile('abc123');
+   * if (result.success && result.data) {
+   *   // Save to file (Node.js)
+   *   const buffer = Buffer.from(await result.data.arrayBuffer());
+   *   fs.writeFileSync('audio.mp3', buffer);
+   *
+   *   // Or create download URL (browser)
+   *   const url = URL.createObjectURL(result.data);
+   * }
+   * ```
+   *
+   * @example Download audio from a live/streaming session
+   * ```typescript
+   * const result = await adapter.getAudioFile('stream-456', 'streaming');
+   * if (result.success) {
+   *   console.log('Audio file size:', result.data?.size);
+   * }
+   * ```
+   *
+   * @see https://docs.gladia.io/
+   */
+  async getAudioFile(transcriptId, jobType = "pre-recorded") {
+    this.validateConfig();
+    try {
+      let response;
+      if (jobType === "streaming") {
+        response = await streamingControllerGetAudioV2(transcriptId, this.getAxiosConfig());
+      } else {
+        response = await preRecordedControllerGetAudioV2(transcriptId, this.getAxiosConfig());
+      }
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      if (err.response?.status === 404) {
+        return {
+          success: false,
+          error: {
+            code: "NOT_FOUND",
+            message: `Audio file not found for transcript ${transcriptId}`
+          }
+        };
+      }
+      return {
+        success: false,
+        error: {
+          code: "DOWNLOAD_ERROR",
+          message: err.message || "Failed to download audio file"
+        }
+      };
+    }
+  }
+  /**
+   * List recent transcriptions with filtering
+   *
+   * Retrieves a list of transcription jobs (both pre-recorded and streaming)
+   * with optional filtering by status, date, and custom metadata.
+   *
+   * @param options - Filtering and pagination options
+   * @param options.limit - Maximum number of transcripts to return
+   * @param options.offset - Pagination offset (skip N results)
+   * @param options.status - Filter by status (queued, processing, done, error)
+   * @param options.date - Filter by exact date (ISO format YYYY-MM-DD)
+   * @param options.beforeDate - Filter for transcripts before this date
+   * @param options.afterDate - Filter for transcripts after this date
+   * @param options.gladia - Full Gladia-specific options (custom_metadata, kind, etc.)
+   * @returns List of transcripts with pagination info
+   *
+   * @example List recent transcripts
+   * ```typescript
+   * const { transcripts, hasMore } = await adapter.listTranscripts({
+   *   limit: 50,
+   *   status: 'done'
+   * })
+   * ```
+   *
+   * @example Filter by date range
+   * ```typescript
+   * const { transcripts } = await adapter.listTranscripts({
+   *   afterDate: '2026-01-01',
+   *   beforeDate: '2026-01-31',
+   *   limit: 100
+   * })
+   * ```
+   *
+   * @example Filter by custom metadata
+   * ```typescript
+   * const { transcripts } = await adapter.listTranscripts({
+   *   gladia: {
+   *     custom_metadata: { project: 'my-project' }
+   *   }
+   * })
+   * ```
+   *
+   * @see https://docs.gladia.io/
+   */
+  async listTranscripts(options) {
+    this.validateConfig();
+    try {
+      const params = {
+        ...options?.gladia
+      };
+      if (options?.limit) {
+        params.limit = options.limit;
+      }
+      if (options?.offset) {
+        params.offset = options.offset;
+      }
+      if (options?.status) {
+        const statusMap = {
+          queued: TranscriptionControllerListV2StatusItem.queued,
+          processing: TranscriptionControllerListV2StatusItem.processing,
+          completed: TranscriptionControllerListV2StatusItem.done,
+          // Gladia uses 'done' not 'completed'
+          done: TranscriptionControllerListV2StatusItem.done,
+          error: TranscriptionControllerListV2StatusItem.error
+        };
+        const mappedStatus = statusMap[options.status.toLowerCase()];
+        if (mappedStatus) {
+          params.status = [mappedStatus];
+        }
+      }
+      if (options?.date) {
+        params.date = options.date;
+      }
+      if (options?.beforeDate) {
+        params.before_date = options.beforeDate;
+      }
+      if (options?.afterDate) {
+        params.after_date = options.afterDate;
+      }
+      const response = await transcriptionControllerListV2(params, this.getAxiosConfig());
+      const transcripts = response.data.items.map(
+        (item) => this.normalizeListItem(item)
+      );
+      return {
+        transcripts,
+        hasMore: response.data.next !== null
+      };
+    } catch (error) {
+      return {
+        transcripts: [this.createErrorResponse(error)],
+        hasMore: false
+      };
+    }
+  }
+  /**
+   * Normalize a transcript list item to unified format
+   */
+  normalizeListItem(item) {
+    const preRecorded = item;
+    const streaming = item;
+    const isLive = "kind" in item && item.kind === "live";
+    const id = preRecorded.id || streaming.id;
+    const status = normalizeStatus(preRecorded.status || streaming.status, "gladia");
+    const text = preRecorded.result?.transcription?.full_transcript || "";
+    const file = preRecorded.file;
+    return {
+      success: status !== "error",
+      provider: this.name,
+      data: {
+        id,
+        text,
+        status,
+        duration: file?.audio_duration ?? void 0,
+        metadata: {
+          sourceAudioUrl: file?.source ?? void 0,
+          audioFileAvailable: this.capabilities.getAudioFile ?? false,
+          filename: file?.filename ?? void 0,
+          audioDuration: file?.audio_duration ?? void 0,
+          numberOfChannels: file?.number_of_channels ?? void 0,
+          createdAt: preRecorded.created_at || streaming.created_at,
+          completedAt: preRecorded.completed_at || streaming.completed_at || void 0,
+          kind: isLive ? "live" : "pre-recorded",
+          customMetadata: preRecorded.custom_metadata || streaming.custom_metadata
+        }
+      },
+      error: preRecorded.error_code || streaming.error_code ? {
+        code: (preRecorded.error_code || streaming.error_code)?.toString() || "ERROR",
+        message: "Transcription failed"
+      } : void 0,
+      raw: item
+    };
+  }
   /**
    * Stream audio for real-time transcription
    *
@@ -3081,18 +3348,16 @@ var TranscriptReadyStatus = {
   error: "error"
 };
 
-// src/generated/assemblyai/schema/transcriptStatus.ts
-var TranscriptStatus = {
-  queued: "queued",
-  processing: "processing",
-  completed: "completed",
-  error: "error"
-};
-
 // src/generated/assemblyai/api/assemblyAIAPI.ts
 var createTranscript = (transcriptParams, options) => {
   return import_axios2.default.post("/v2/transcript", transcriptParams, options);
 };
+var listTranscripts = (params, options) => {
+  return import_axios2.default.get("/v2/transcript", {
+    ...options,
+    params: { ...params, ...options?.params }
+  });
+};
 var getTranscript = (transcriptId, options) => {
   return import_axios2.default.get(`/v2/transcript/${transcriptId}`, options);
 };
@@ -3114,7 +3379,9 @@ var AssemblyAIAdapter = class extends BaseAdapter {
       summarization: true,
       sentimentAnalysis: true,
       entityDetection: true,
-      piiRedaction: true
+      piiRedaction: true,
+      listTranscripts: true,
+      deleteTranscript: true
     };
     this.baseUrl = "https://api.assemblyai.com";
     // Generated functions already include /v2 path
@@ -3265,6 +3532,106 @@ var AssemblyAIAdapter = class extends BaseAdapter {
       throw error;
     }
   }
+  /**
+   * List recent transcriptions with filtering
+   *
+   * Retrieves a list of transcripts with optional filtering by status and date.
+   * Transcripts are sorted from newest to oldest and can be retrieved for the
+   * last 90 days of usage.
+   *
+   * @param options - Filtering and pagination options
+   * @param options.limit - Maximum number of transcripts (max 200)
+   * @param options.status - Filter by status (queued, processing, completed, error)
+   * @param options.date - Filter by exact date (ISO format YYYY-MM-DD)
+   * @param options.assemblyai - Full AssemblyAI-specific options (before_id, after_id, etc.)
+   * @returns List of transcripts with pagination info
+   *
+   * @example List recent transcripts
+   * ```typescript
+   * const { transcripts, hasMore } = await adapter.listTranscripts({
+   *   limit: 50,
+   *   status: 'completed'
+   * })
+   * ```
+   *
+   * @example Filter by date
+   * ```typescript
+   * const { transcripts } = await adapter.listTranscripts({
+   *   date: '2026-01-07',
+   *   limit: 100
+   * })
+   * ```
+   *
+   * @example Use cursor pagination
+   * ```typescript
+   * const { transcripts } = await adapter.listTranscripts({
+   *   assemblyai: {
+   *     after_id: 'abc123',  // Get transcripts after this ID
+   *     limit: 50
+   *   }
+   * })
+   * ```
+   *
+   * @see https://www.assemblyai.com/docs/api-reference/transcripts/list
+   */
+  async listTranscripts(options) {
+    this.validateConfig();
+    try {
+      const params = {
+        ...options?.assemblyai
+      };
+      if (options?.limit) {
+        params.limit = options.limit;
+      }
+      if (options?.status) {
+        params.status = options.status;
+      }
+      if (options?.date) {
+        params.created_on = options.date;
+      }
+      const response = await listTranscripts(params, this.getAxiosConfig());
+      const transcripts = response.data.transcripts.map(
+        (item) => this.normalizeListItem(item)
+      );
+      return {
+        transcripts,
+        hasMore: response.data.page_details.next_url !== null
+      };
+    } catch (error) {
+      return {
+        transcripts: [this.createErrorResponse(error)],
+        hasMore: false
+      };
+    }
+  }
+  /**
+   * Normalize a transcript list item to unified format
+   */
+  normalizeListItem(item) {
+    return {
+      success: item.status !== "error",
+      provider: this.name,
+      data: {
+        id: item.id,
+        text: "",
+        // List items don't include full text
+        status: item.status,
+        // Note: audio_duration is NOT available in TranscriptListItem (only in full Transcript)
+        metadata: {
+          sourceAudioUrl: item.audio_url,
+          audioFileAvailable: this.capabilities.getAudioFile ?? false,
+          createdAt: item.created,
+          completedAt: item.completed || void 0,
+          resourceUrl: item.resource_url
+        }
+      },
+      error: item.error ? {
+        code: "TRANSCRIPTION_ERROR",
+        message: item.error
+      } : void 0,
+      raw: item
+    };
+  }
   /**
    * Build AssemblyAI transcription request from unified options
    */
@@ -3372,7 +3739,8 @@ var AssemblyAIAdapter = class extends BaseAdapter {
         utterances: this.extractUtterances(response),
         summary: response.summary || void 0,
         metadata: {
-          audioUrl: response.audio_url
+          sourceAudioUrl: response.audio_url,
+          audioFileAvailable: this.capabilities.getAudioFile ?? false
         }
       },
       // Extended data - fully typed from OpenAPI specs
@@ -3817,6 +4185,16 @@ function createAssemblyAIAdapter(config) {
 // src/adapters/deepgram-adapter.ts
 var import_axios3 = __toESM(require("axios"));
 var import_ws3 = __toESM(require("ws"));
+
+// src/generated/deepgram/schema/manageV1FilterEndpointParameter.ts
+var ManageV1FilterEndpointParameter = {
+  listen: "listen",
+  read: "read",
+  speak: "speak",
+  agent: "agent"
+};
+
+// src/adapters/deepgram-adapter.ts
 var DeepgramAdapter = class extends BaseAdapter {
   constructor() {
     super(...arguments);
@@ -3830,13 +4208,17 @@ var DeepgramAdapter = class extends BaseAdapter {
       summarization: true,
       sentimentAnalysis: true,
       entityDetection: true,
-      piiRedaction: true
+      piiRedaction: true,
+      listTranscripts: true,
+      // Via request history API (requires projectId)
+      deleteTranscript: false
     };
     this.baseUrl = "https://api.deepgram.com/v1";
     this.wsBaseUrl = "wss://api.deepgram.com/v1/listen";
   }
   initialize(config) {
     super.initialize(config);
+    this.projectId = config.projectId;
     this.client = import_axios3.default.create({
       baseURL: config.baseUrl || this.baseUrl,
       timeout: config.timeout || 6e4,
@@ -3921,23 +4303,66 @@ var DeepgramAdapter = class extends BaseAdapter {
   /**
    * Get transcription result by ID
    *
-   * Note: Deepgram processes synchronously, so this method is primarily
-   * for retrieving cached results if you've stored the request ID.
-   * The initial transcribe() call already returns complete results.
+   * Retrieves a previous transcription from Deepgram's request history.
    *
-   * @param transcriptId - Request ID from Deepgram
-   * @returns Normalized transcription response
+   * Unlike the list endpoint, getting a single request DOES include the full
+   * transcript response. Requires `projectId` to be set during initialization.
+   *
+   * @param transcriptId - Request ID from a previous transcription
+   * @returns Full transcript response including text, words, and metadata
+   *
+   * @example Get a transcript by request ID
+   * ```typescript
+   * const adapter = new DeepgramAdapter()
+   * adapter.initialize({
+   *   apiKey: process.env.DEEPGRAM_API_KEY,
+   *   projectId: process.env.DEEPGRAM_PROJECT_ID
+   * })
+   *
+   * const result = await adapter.getTranscript('abc123-request-id')
+   * if (result.success) {
+   *   console.log(result.data?.text)
+   *   console.log(result.data?.words)
+   * }
+   * ```
+   *
+   * @see https://developers.deepgram.com/reference/get-request
    */
   async getTranscript(transcriptId) {
     this.validateConfig();
-    return {
-      success: false,
-      provider: this.name,
-      error: {
-        code: "NOT_SUPPORTED",
-        message: "Deepgram returns transcription results immediately. Store the response from transcribe() instead of using getTranscript()."
+    if (!this.projectId) {
+      return {
+        success: false,
+        provider: this.name,
+        error: {
+          code: "MISSING_PROJECT_ID",
+          message: "Deepgram getTranscript requires projectId. Initialize with: { apiKey, projectId }"
+        }
+      };
+    }
+    try {
+      const response = await this.client.get(
+        `/projects/${this.projectId}/requests/${transcriptId}`
+      );
+      const request = response.data.request;
+      if (!request) {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "NOT_FOUND",
+            message: `Request ${transcriptId} not found`
+          }
+        };
       }
-    };
+      const transcriptResponse = request.response;
+      if (!transcriptResponse) {
+        return this.normalizeRequestItem(request);
+      }
+      return this.normalizeResponse(transcriptResponse);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
   }
   /**
    * Build Deepgram transcription parameters from unified options
@@ -4507,6 +4932,133 @@ var DeepgramAdapter = class extends BaseAdapter {
       }
     }
   }
+  /**
+   * List recent transcription requests from Deepgram's request history
+   *
+   * **Important:** Deepgram processes synchronously and doesn't store transcript content.
+   * This method returns request metadata (IDs, timestamps, status) but NOT the actual
+   * transcript text. Use this for auditing, billing analysis, or request tracking.
+   *
+   * Requires `projectId` to be set during initialization.
+   *
+   * @param options - Filtering and pagination options
+   * @param options.limit - Maximum number of requests (default 10, max 1000)
+   * @param options.status - Filter by status: 'succeeded' or 'failed'
+   * @param options.afterDate - Start date (YYYY-MM-DD or ISO 8601)
+   * @param options.beforeDate - End date (YYYY-MM-DD or ISO 8601)
+   * @param options.deepgram - Provider-specific params (page, request_id, etc.)
+   * @returns List of transcription request metadata
+   *
+   * @example List recent transcription requests
+   * ```typescript
+   * const adapter = new DeepgramAdapter()
+   * adapter.initialize({
+   *   apiKey: process.env.DEEPGRAM_API_KEY,
+   *   projectId: process.env.DEEPGRAM_PROJECT_ID
+   * })
+   *
+   * const { transcripts, hasMore } = await adapter.listTranscripts({
+   *   limit: 50,
+   *   status: 'succeeded'
+   * })
+   *
+   * transcripts.forEach(t => {
+   *   console.log(t.data?.id, t.data?.metadata?.createdAt)
+   * })
+   * ```
+   *
+   * @see https://developers.deepgram.com/reference/get-all-requests
+   */
+  async listTranscripts(options) {
+    this.validateConfig();
+    if (!this.projectId) {
+      return {
+        transcripts: [
+          {
+            success: false,
+            provider: this.name,
+            error: {
+              code: "MISSING_PROJECT_ID",
+              message: "Deepgram listTranscripts requires projectId. Initialize with: { apiKey, projectId }"
+            }
+          }
+        ],
+        hasMore: false
+      };
+    }
+    try {
+      const params = {
+        // Filter to only transcription requests (listen endpoint)
+        endpoint: ManageV1FilterEndpointParameter.listen,
+        ...options?.deepgram
+      };
+      if (options?.limit) {
+        params.limit = options.limit;
+      }
+      if (options?.afterDate) {
+        params.start = options.afterDate;
+      }
+      if (options?.beforeDate) {
+        params.end = options.beforeDate;
+      }
+      if (options?.status) {
+        const statusMap = {
+          completed: ManageV1FilterStatusParameter.succeeded,
+          succeeded: ManageV1FilterStatusParameter.succeeded,
+          error: ManageV1FilterStatusParameter.failed,
+          failed: ManageV1FilterStatusParameter.failed
+        };
+        params.status = statusMap[options.status.toLowerCase()];
+      }
+      const response = await this.client.get(
+        `/projects/${this.projectId}/requests`,
+        { params }
+      );
+      const data = response.data;
+      const transcripts = (data.requests || []).map(
+        (item) => this.normalizeRequestItem(item)
+      );
+      return {
+        transcripts,
+        hasMore: (data.page || 1) * (data.limit || 10) < (data.requests?.length || 0)
+      };
+    } catch (error) {
+      return {
+        transcripts: [this.createErrorResponse(error)],
+        hasMore: false
+      };
+    }
+  }
+  /**
+   * Normalize a Deepgram request history item to unified format
+   */
+  normalizeRequestItem(item) {
+    const isSuccess = (item.code || 0) < 400;
+    return {
+      success: isSuccess,
+      provider: this.name,
+      data: {
+        id: item.request_id || "",
+        text: "",
+        // Deepgram doesn't store transcript content in request history
+        status: isSuccess ? "completed" : "error",
+        metadata: {
+          audioFileAvailable: this.capabilities.getAudioFile ?? false,
+          createdAt: item.created,
+          apiPath: item.path,
+          apiKeyId: item.api_key_id,
+          deployment: item.deployment,
+          callbackUrl: item.callback,
+          responseCode: item.code
+        }
+      },
+      error: !isSuccess ? {
+        code: "REQUEST_FAILED",
+        message: `Request failed with status code ${item.code}`
+      } : void 0,
+      raw: item
+    };
+  }
 };
 function createDeepgramAdapter(config) {
   const adapter = new DeepgramAdapter();
@@ -4519,6 +5071,12 @@ var import_axios5 = __toESM(require("axios"));
 
 // src/generated/azure/api/speechServicesAPIV31.ts
 var import_axios4 = __toESM(require("axios"));
+var transcriptionsList = (params, options) => {
+  return import_axios4.default.get("/transcriptions", {
+    ...options,
+    params: { ...params, ...options?.params }
+  });
+};
 var transcriptionsCreate = (transcription, options) => {
   return import_axios4.default.post("/transcriptions", transcription, options);
 };
@@ -4550,7 +5108,9 @@ var AzureSTTAdapter = class extends BaseAdapter {
       summarization: false,
       sentimentAnalysis: false,
       entityDetection: false,
-      piiRedaction: false
+      piiRedaction: false,
+      listTranscripts: true,
+      deleteTranscript: true
     };
     this.baseUrl = "https://eastus.api.cognitive.microsoft.com/speechtotext/v3.1";
   }
@@ -4714,6 +5274,113 @@ var AzureSTTAdapter = class extends BaseAdapter {
       throw error;
     }
   }
+  /**
+   * List recent transcriptions with filtering
+   *
+   * Retrieves a list of transcription jobs for the authenticated subscription.
+   * Azure uses OData filtering for advanced queries.
+   *
+   * @param options - Filtering and pagination options
+   * @param options.limit - Maximum number of transcripts (maps to 'top')
+   * @param options.offset - Pagination offset (maps to 'skip')
+   * @param options.status - Filter by status (uses OData filter)
+   * @returns List of transcripts with pagination info
+   *
+   * @example List recent transcripts
+   * ```typescript
+   * const { transcripts, hasMore } = await adapter.listTranscripts({
+   *   limit: 50
+   * })
+   * ```
+   *
+   * @example Filter by status using OData
+   * ```typescript
+   * const { transcripts } = await adapter.listTranscripts({
+   *   status: 'Succeeded',
+   *   limit: 100
+   * })
+   * ```
+   *
+   * @see https://learn.microsoft.com/azure/cognitive-services/speech-service/batch-transcription
+   */
+  async listTranscripts(options) {
+    this.validateConfig();
+    try {
+      const params = {};
+      if (options?.limit) {
+        params.top = options.limit;
+      }
+      if (options?.offset) {
+        params.skip = options.offset;
+      }
+      if (options?.status) {
+        const azureStatus = this.mapStatusToAzure(options.status);
+        params.filter = `status eq '${azureStatus}'`;
+      }
+      const response = await transcriptionsList(params, this.getAxiosConfig());
+      const transcripts = (response.data.values || []).map(
+        (item) => this.normalizeListItem(item)
+      );
+      return {
+        transcripts,
+        hasMore: response.data["@nextLink"] !== void 0
+      };
+    } catch (error) {
+      return {
+        transcripts: [this.createErrorResponse(error)],
+        hasMore: false
+      };
+    }
+  }
+  /**
+   * Map unified status to Azure status format using generated enum
+   */
+  mapStatusToAzure(status) {
+    const statusMap = {
+      completed: Status.Succeeded,
+      succeeded: Status.Succeeded,
+      processing: Status.Running,
+      running: Status.Running,
+      queued: Status.NotStarted,
+      notstarted: Status.NotStarted,
+      error: Status.Failed,
+      failed: Status.Failed
+    };
+    return statusMap[status.toLowerCase()] || status;
+  }
+  /**
+   * Normalize a transcript list item to unified format
+   */
+  normalizeListItem(item) {
+    const id = item.self?.split("/").pop() || "";
+    const status = this.normalizeStatus(item.status);
+    return {
+      success: status !== "error",
+      provider: this.name,
+      data: {
+        id,
+        text: "",
+        // List items don't include full text
+        status,
+        language: item.locale,
+        // Note: contentUrls is write-only per Azure API docs (not returned in list response)
+        // Note: duration is not available in Transcription list item
+        metadata: {
+          audioFileAvailable: this.capabilities.getAudioFile ?? false,
+          displayName: item.displayName,
+          description: item.description || void 0,
+          createdAt: item.createdDateTime,
+          lastActionAt: item.lastActionDateTime,
+          filesUrl: item.links?.files
+        }
+      },
+      error: status === "error" ? {
+        code: "TRANSCRIPTION_ERROR",
+        message: item.properties?.error?.message || "Transcription failed"
+      } : void 0,
+      raw: item
+    };
+  }
   /**
    * Build Azure-specific transcription properties
    */
@@ -4879,7 +5546,10 @@ var OpenAIWhisperAdapter = class extends BaseAdapter {
       summarization: false,
       sentimentAnalysis: false,
       entityDetection: false,
-      piiRedaction: false
+      piiRedaction: false,
+      listTranscripts: false,
+      // Synchronous API, no stored transcripts
+      deleteTranscript: false
     };
     this.baseUrl = "https://api.openai.com/v1";
   }
@@ -5110,7 +5780,9 @@ var SpeechmaticsAdapter = class extends BaseAdapter {
       summarization: true,
       sentimentAnalysis: true,
       entityDetection: true,
-      piiRedaction: false
+      piiRedaction: false,
+      listTranscripts: true,
+      deleteTranscript: true
     };
     this.baseUrl = "https://asr.api.speechmatics.com/v2";
   }