@agent-native/core-corpus 0.201.0-nightly-20261005153421 → 0.201.0

package/corpus/templates/clips/actions/lib/chunked-transcription.ts

@@ -0,0 +1,151 @@
+import { normalizeProviderTranscript } from "./provider-transcript.js";
+
+const CHUNK_TRANSCRIPTION_CONCURRENCY = 3;
+
+export interface TimedChunk {
+  startMs: number;
+  durationMs: number;
+}
+
+export interface ProviderTranscriptResult {
+  text: string;
+  language?: string | null;
+  segments?: Array<{
+    startMs: number;
+    endMs: number;
+    text: string;
+    speakerLabel?: string;
+  }>;
+}
+
+interface JoinedTranscriptSegment {
+  startMs: number;
+  endMs: number;
+  text: string;
+  speaker?: string;
+}
+
+interface JoinedTranscript {
+  fullText: string;
+  language: string | null;
+  segments: JoinedTranscriptSegment[];
+}
+
+export class ChunkTranscriptionError extends Error {
+  readonly chunkIndex: number;
+  readonly chunkCount: number;
+  readonly cause: unknown;
+
+  constructor(chunkIndex: number, chunkCount: number, cause: unknown) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(
+      `Transcribing part ${chunkIndex + 1} of ${chunkCount} failed: ${reason}`,
+    );
+    this.name = "ChunkTranscriptionError";
+    this.chunkIndex = chunkIndex;
+    this.chunkCount = chunkCount;
+    this.cause = cause;
+  }
+}
+
+/**
+ * Transcribes every chunk, at most `concurrency` at a time, retrying each
+ * chunk once when `isRetryable` accepts its error. Any chunk that still fails
+ * fails the whole run: a transcript missing a part must never be saved as if
+ * it were complete. A single-chunk run rethrows the provider error unchanged.
+ */
+export async function transcribeAudioChunks<C extends TimedChunk>({
+  chunks,
+  transcribe,
+  isRetryable,
+  concurrency = CHUNK_TRANSCRIPTION_CONCURRENCY,
+}: {
+  chunks: C[];
+  transcribe: (chunk: C, index: number) => Promise<ProviderTranscriptResult>;
+  isRetryable: (err: unknown) => boolean;
+  concurrency?: number;
+}): Promise<ProviderTranscriptResult[]> {
+  const results = new Array<ProviderTranscriptResult>(chunks.length);
+  let next = 0;
+  let failure: { index: number; error: unknown } | null = null;
+
+  const transcribeWithRetry = async (index: number) => {
+    try {
+      return await transcribe(chunks[index], index);
+    } catch (err) {
+      if (!isRetryable(err)) throw err;
+      return transcribe(chunks[index], index);
+    }
+  };
+
+  const worker = async () => {
+    while (!failure && next < chunks.length) {
+      const index = next++;
+      try {
+        results[index] = await transcribeWithRetry(index);
+      } catch (error) {
+        failure ??= { index, error };
+      }
+    }
+  };
+
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, chunks.length) }, worker),
+  );
+
+  if (failure) {
+    const { index, error } = failure;
+    if (chunks.length === 1) throw error;
+    throw new ChunkTranscriptionError(index, chunks.length, error);
+  }
+  return results;
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
+/**
+ * Stitches per-chunk results into one transcript on the recording timeline.
+ * Provider timestamps drift past the end of long audio, so each segment is
+ * clamped to its own chunk before the chunk's offset is added.
+ */
+export function joinChunkTranscripts(
+  chunks: TimedChunk[],
+  results: ProviderTranscriptResult[],
+): JoinedTranscript {
+  const texts: string[] = [];
+  const segments: JoinedTranscriptSegment[] = [];
+  let language: string | null = null;
+
+  chunks.forEach((chunk, index) => {
+    const result = results[index];
+    const chunkSegments = (result.segments ?? [])
+      .map((segment) => {
+        const startMs = clamp(segment.startMs, 0, chunk.durationMs);
+        const endMs = clamp(segment.endMs, startMs, chunk.durationMs);
+        const speaker = segment.speakerLabel?.trim();
+        return {
+          startMs: chunk.startMs + startMs,
+          endMs: chunk.startMs + endMs,
+          text: segment.text.trim(),
+          ...(speaker ? { speaker } : {}),
+        };
+      })
+      .filter((segment) => segment.text)
+      .sort((a, b) => a.startMs - b.startMs);
+
+    const normalized = normalizeProviderTranscript(result.text, chunkSegments);
+    if (normalized.fullText) {
+      texts.push(normalized.fullText);
+      language ??= result.language?.trim() || null;
+    }
+    segments.push(...normalized.segments);
+  });
+
+  return {
+    fullText: texts.join("\n\n"),
+    language,
+    segments,
+  };
+}

package/corpus/templates/clips/actions/lib/recording-audio-source.ts

@@ -0,0 +1,191 @@
+import { createWriteStream } from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import type { ReadableStream as NodeReadableStream } from "node:stream/web";
+
+import { readAppState } from "@agent-native/core/application-state";
+import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
+import { MAX_UPLOAD_BYTES } from "@shared/upload-limits.js";
+
+import { isBuilderCdnHost } from "../../server/lib/builder-cdn.js";
+import {
+  AudioOnlyExtractionError,
+  extractAudioOnlyWithFfmpeg,
+  type AudioExtractor,
+  type AudioOnlyTranscriptionMedia,
+} from "./audio-only-transcription.js";
+
+interface RecordingAudioTimeouts {
+  downloadMs: number;
+  extractionMs: number;
+}
+
+type MediaFetcher = (url: string, init: RequestInit) => Promise<Response>;
+
+type RecordingMediaTarget =
+  | { kind: "local-blob" }
+  | { kind: "stream"; url: string; origin: "app" | "builder-cdn" }
+  | { kind: "download"; url: string };
+
+function appOrigin(): string {
+  const port = process.env.NITRO_PORT || process.env.PORT || "3000";
+  return (
+    process.env.PUBLIC_URL ??
+    process.env.NITRO_PUBLIC_URL ??
+    `http://localhost:${port}`
+  );
+}
+
+// Only URLs the server controls may be streamed by ffmpeg directly: ffmpeg
+// follows redirects and resolves hosts without the SSRF guard, so any other
+// URL is downloaded through ssrfSafeFetch instead.
+export function resolveRecordingMediaTarget(
+  videoUrl: string,
+): RecordingMediaTarget {
+  if (
+    videoUrl.startsWith("/api/video/") ||
+    (videoUrl.startsWith("/api/uploads/") && videoUrl.endsWith("/blob"))
+  ) {
+    return { kind: "local-blob" };
+  }
+  if (videoUrl.startsWith("/") && !videoUrl.startsWith("//")) {
+    return { kind: "stream", url: `${appOrigin()}${videoUrl}`, origin: "app" };
+  }
+  let parsed: URL;
+  try {
+    parsed = new URL(videoUrl);
+  } catch {
+    return { kind: "download", url: videoUrl };
+  }
+  if (parsed.protocol === "https:" && isBuilderCdnHost(parsed.hostname)) {
+    return { kind: "stream", url: parsed.toString(), origin: "builder-cdn" };
+  }
+  return { kind: "download", url: videoUrl };
+}
+
+const safeFetch: MediaFetcher = (url, init) =>
+  ssrfSafeFetch(url, init, { maxRedirects: 3 });
+
+function tooLargeError(bytes: number): Error {
+  return new Error(
+    `Recording media is too large to transcribe (${bytes} bytes, max ${MAX_UPLOAD_BYTES}).`,
+  );
+}
+
+async function withTempDir<T>(work: (dir: string) => Promise<T>): Promise<T> {
+  const dir = await mkdtemp(join(tmpdir(), "clips-transcription-source-"));
+  try {
+    return await work(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch((err) => {
+      console.warn(
+        `[clips] failed to remove transcription temp dir ${dir}:`,
+        (err as Error)?.message ?? String(err),
+      );
+    });
+  }
+}
+
+async function downloadToFile(
+  url: string,
+  path: string,
+  fetcher: MediaFetcher,
+  timeoutMs: number,
+): Promise<void> {
+  const res = await fetcher(url, { signal: AbortSignal.timeout(timeoutMs) });
+  if (!res.ok) {
+    // guard:allow-bare-error — invariant: request-transcript records media preparation errors as a failed transcript.
+    throw new Error(
+      `Failed to fetch videoUrl: HTTP ${res.status} ${res.statusText}`,
+    );
+  }
+  const declaredBytes = Number(res.headers.get("content-length") ?? "0");
+  if (declaredBytes > MAX_UPLOAD_BYTES) throw tooLargeError(declaredBytes);
+  // guard:allow-bare-error — invariant: request-transcript catches media preparation errors and records them as a failed transcript.
+  if (!res.body) throw new Error("Failed to fetch videoUrl: empty body");
+
+  let receivedBytes = 0;
+  const limit = new Transform({
+    transform(chunk: Buffer, _encoding, callback) {
+      receivedBytes += chunk.length;
+      if (receivedBytes > MAX_UPLOAD_BYTES) {
+        callback(tooLargeError(receivedBytes));
+        return;
+      }
+      callback(null, chunk);
+    },
+  });
+  await pipeline(
+    Readable.fromWeb(res.body as unknown as NodeReadableStream),
+    limit,
+    createWriteStream(path),
+  );
+}
+
+export async function prepareRecordingTranscriptionAudio({
+  recordingId,
+  videoUrl,
+  timeouts,
+  extractor = extractAudioOnlyWithFfmpeg,
+  fetchers = { app: fetch, safe: safeFetch },
+}: {
+  recordingId: string;
+  videoUrl: string;
+  timeouts: RecordingAudioTimeouts;
+  extractor?: AudioExtractor;
+  fetchers?: { app: MediaFetcher; safe: MediaFetcher };
+}): Promise<AudioOnlyTranscriptionMedia> {
+  const extractFromFile = (write: (path: string) => Promise<void>) =>
+    withTempDir(async (dir) => {
+      const path = join(dir, "input");
+      await write(path);
+      return extractor({
+        source: { kind: "file", path },
+        timeoutMs: timeouts.extractionMs,
+      });
+    });
+  const downloadAndExtract = (url: string, fetcher: MediaFetcher) =>
+    extractFromFile((path) =>
+      downloadToFile(url, path, fetcher, timeouts.downloadMs),
+    );
+
+  const target = resolveRecordingMediaTarget(videoUrl);
+  switch (target.kind) {
+    case "local-blob":
+      return extractFromFile(async (path) => {
+        const stash = await readAppState(`recording-blob-${recordingId}`);
+        const b64 = typeof stash?.data === "string" ? stash.data : null;
+        // guard:allow-bare-error — invariant: request-transcript catches media preparation errors and records them as a failed transcript.
+        if (!b64) throw new Error("recording-blob app-state missing");
+        await writeFile(path, Buffer.from(b64, "base64"));
+      });
+    case "download":
+      return downloadAndExtract(target.url, fetchers.safe);
+    case "stream":
+      try {
+        return await extractor({
+          source: { kind: "url", url: target.url },
+          timeoutMs: timeouts.downloadMs + timeouts.extractionMs,
+        });
+      } catch (err) {
+        // A stream can fail where a full download succeeds, e.g. a server
+        // without range support for an MP4 whose index sits at the end.
+        if (
+          !(err instanceof AudioOnlyExtractionError) ||
+          err.code !== "EXTRACTION_FAILED"
+        ) {
+          throw err;
+        }
+        console.warn(
+          `[clips] streaming audio extraction failed for ${recordingId}; retrying from a downloaded copy: ${err.message}`,
+        );
+        return downloadAndExtract(
+          target.url,
+          target.origin === "app" ? fetchers.app : fetchers.safe,
+        );
+      }
+  }
+}

package/corpus/templates/clips/actions/request-transcript.ts

@@ -1,10 +1,6 @@
 import { defineAction } from "@agent-native/core/action";
 import type { ActionRunContext } from "@agent-native/core/action";
-import {
-  readAppState,
-  writeAppState,
-} from "@agent-native/core/application-state";
-import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
+import { writeAppState } from "@agent-native/core/application-state";
 import { resolveHasBuilderGatewayCredential } from "@agent-native/core/server";
 import { assertAccess } from "@agent-native/core/sharing";
 import { track } from "@agent-native/core/tracking";
@@ -37,25 +33,28 @@ import { PENDING_TRANSCRIPT_HEARTBEAT_MS } from "../shared/transcript-status.js"
 import {
   AudioOnlyExtractionError,
   assertAudioHasAudibleSignal,
+  audioExtractionTimeoutMs,
   isNoExtractableAudioError,
   isTransientExtractionError,
-  prepareAudioOnlyTranscriptionMedia,
   type AudioOnlyTranscriptionMedia,
 } from "./lib/audio-only-transcription.js";
 import {
   clearBuilderCreditsExhausted,
   noteBuilderCreditsExhausted,
 } from "./lib/builder-credits-state.js";
+import {
+  ChunkTranscriptionError,
+  joinChunkTranscripts,
+  transcribeAudioChunks,
+} from "./lib/chunked-transcription.js";
 import { finalizeEndedMeetingsForRecording } from "./lib/finalize-ended-meetings.js";
 import {
   fetchLoomTranscript,
   loomTranscriptUnavailableMessage,
 } from "./lib/loom-transcript.js";
 import { isLoomRecording } from "./lib/native-media.js";
-import {
-  isLikelyMismatchedTranscriptLanguage,
-  normalizeProviderTranscript,
-} from "./lib/provider-transcript.js";
+import { isLikelyMismatchedTranscriptLanguage } from "./lib/provider-transcript.js";
+import { prepareRecordingTranscriptionAudio } from "./lib/recording-audio-source.js";
 import regenerateSummary from "./regenerate-summary.js";
 import regenerateTitle from "./regenerate-title.js";
 
@@ -158,6 +157,24 @@ export function builderTranscriptionTimeoutMs(
   );
 }
 
+// The stored size may describe the original upload or its compressed copy,
+// depending on whether compression finished, so budget for the larger of it
+// and a duration-based estimate.
+export function estimatedRecordingMediaBytes(
+  videoSizeBytes: number | null | undefined,
+  durationMs: number | null | undefined,
+): number {
+  const sizeBytes =
+    videoSizeBytes && Number.isFinite(videoSizeBytes) && videoSizeBytes > 0
+      ? videoSizeBytes
+      : 0;
+  const durationBytes =
+    durationMs && Number.isFinite(durationMs) && durationMs > 0
+      ? Math.ceil(durationMs / 60_000) * ESTIMATED_VIDEO_BYTES_PER_MINUTE
+      : 0;
+  return Math.max(sizeBytes, durationBytes);
+}
+
 export function recordingMediaFetchTimeoutMs(
   videoSizeBytes: number | null | undefined,
   durationMs: number | null | undefined,
@@ -172,12 +189,10 @@ export function recordingMediaFetchTimeoutMs(
     );
   }
 
-  const estimatedBytes =
-    videoSizeBytes && Number.isFinite(videoSizeBytes) && videoSizeBytes > 0
-      ? videoSizeBytes
-      : durationMs && Number.isFinite(durationMs) && durationMs > 0
-        ? Math.ceil(durationMs / 60_000) * ESTIMATED_VIDEO_BYTES_PER_MINUTE
-        : 0;
+  const estimatedBytes = estimatedRecordingMediaBytes(
+    videoSizeBytes,
+    durationMs,
+  );
   if (!estimatedBytes) return MEDIA_FETCH_MIN_TIMEOUT_MS;
 
   const fiftyMbUnits = Math.ceil(estimatedBytes / (50 * 1024 * 1024));
@@ -301,78 +316,6 @@ function rootCause(err: Error): Error {
   return cause instanceof Error ? rootCause(cause) : err;
 }
 
-function recordingFallbackMimeType(
-  rec: Pick<RecordingMediaRow, "videoFormat">,
-): string {
-  return rec.videoFormat === "mp4" ? "video/mp4" : "video/webm";
-}
-
-function pickSourceMimeType(
-  actual: string | null | undefined,
-  fallback: string,
-): string {
-  const base = (actual ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
-  if (!base || base === "application/octet-stream") return fallback;
-  return actual ?? fallback;
-}
-
-async function loadRecordingMediaBlob({
-  recordingId,
-  videoUrl,
-  fallbackMimeType,
-  timeoutMs,
-}: {
-  recordingId: string;
-  videoUrl: string;
-  fallbackMimeType: string;
-  timeoutMs: number;
-}): Promise<{ blob: Blob; sourceMimeType: string }> {
-  const isLocalBlob =
-    videoUrl.startsWith("/api/video/") ||
-    (videoUrl.startsWith("/api/uploads/") && videoUrl.endsWith("/blob"));
-  if (isLocalBlob) {
-    const stash = await readAppState(`recording-blob-${recordingId}`);
-    const b64 = typeof stash?.data === "string" ? stash.data : null;
-    if (!b64) throw new Error("recording-blob app-state missing");
-    const bytes = Buffer.from(b64, "base64");
-    const mime =
-      typeof stash?.mimeType === "string" ? stash.mimeType : fallbackMimeType;
-    return {
-      blob: new Blob([bytes], { type: mime }),
-      sourceMimeType: pickSourceMimeType(mime, fallbackMimeType),
-    };
-  }
-
-  let resolvedVideoUrl = videoUrl;
-  const isAppRelativeUrl =
-    resolvedVideoUrl.startsWith("/") && !resolvedVideoUrl.startsWith("//");
-  if (isAppRelativeUrl) {
-    const port = process.env.NITRO_PORT || process.env.PORT || "3000";
-    const origin =
-      process.env.PUBLIC_URL ??
-      process.env.NITRO_PUBLIC_URL ??
-      `http://localhost:${port}`;
-    resolvedVideoUrl = `${origin}${resolvedVideoUrl}`;
-  }
-  const vidRes = isAppRelativeUrl
-    ? await fetch(resolvedVideoUrl, { signal: AbortSignal.timeout(timeoutMs) })
-    : await ssrfSafeFetch(
-        resolvedVideoUrl,
-        { signal: AbortSignal.timeout(timeoutMs) },
-        { maxRedirects: 3 },
-      );
-  if (!vidRes.ok) {
-    throw new Error(
-      `Failed to fetch videoUrl: HTTP ${vidRes.status} ${vidRes.statusText}`,
-    );
-  }
-  const blob = await vidRes.blob();
-  return {
-    blob,
-    sourceMimeType: pickSourceMimeType(blob.type, fallbackMimeType),
-  };
-}
-
 function isRecentlyPendingTranscript(transcript: {
   status: string | null;
   updatedAt: string | null;
@@ -1069,8 +1012,8 @@ const requestTranscriptAction = defineAction({
     const now = new Date().toISOString();
 
     let builderError: string | null = null;
+    let builderFailureCode: TranscriptFailureCode = "CLOUD_FAILED";
     let audioMediaPromise: Promise<AudioOnlyTranscriptionMedia> | null = null;
-    let audioSignalPromise: Promise<void> | null = null;
 
     const getAudioMedia = (
       rec: RecordingMediaRow,
@@ -1083,31 +1026,21 @@ const requestTranscriptAction = defineAction({
           transcriptFailureMessage("NO_AUDIO_SAVED"),
         );
       }
-      audioMediaPromise ??= (async () => {
-        const fallbackMimeType = recordingFallbackMimeType(rec);
-        const media = await loadRecordingMediaBlob({
-          recordingId: args.recordingId,
-          videoUrl,
-          fallbackMimeType,
-          timeoutMs: recordingMediaFetchTimeoutMs(
+      audioMediaPromise ??= prepareRecordingTranscriptionAudio({
+        recordingId: args.recordingId,
+        videoUrl,
+        timeouts: {
+          downloadMs: recordingMediaFetchTimeoutMs(
             rec.videoSizeBytes,
             rec.durationMs,
           ),
-        });
-        return prepareAudioOnlyTranscriptionMedia({
-          blob: media.blob,
-          recordingId: args.recordingId,
-          sourceMimeType: media.sourceMimeType,
-        });
-      })();
+          extractionMs: audioExtractionTimeoutMs(
+            estimatedRecordingMediaBytes(rec.videoSizeBytes, rec.durationMs),
+          ),
+        },
+      });
       return audioMediaPromise;
     };
-    const ensureAudioHasSignal = (
-      media: AudioOnlyTranscriptionMedia,
-    ): Promise<void> => {
-      audioSignalPromise ??= assertAudioHasAudibleSignal(media);
-      return audioSignalPromise;
-    };
 
     const [existingNativeTranscript] = await db
       .select({
@@ -1231,13 +1164,14 @@ const requestTranscriptAction = defineAction({
       }
 
       let audioMedia: AudioOnlyTranscriptionMedia;
+      const extractionStartedAt = Date.now();
       try {
         audioMedia = await withPendingTranscriptHeartbeat(
           db,
           args.recordingId,
           async () => {
             const media = await getAudioMedia(rec);
-            await ensureAudioHasSignal(media);
+            assertAudioHasAudibleSignal(media);
             return media;
           },
         );
@@ -1252,35 +1186,39 @@ const requestTranscriptAction = defineAction({
         });
       }
 
+      console.log("[clips] transcription audio prepared", {
+        recordingId: args.recordingId,
+        chunks: audioMedia.chunks.length,
+        audioBytes: audioMedia.chunks.reduce(
+          (total, chunk) => total + chunk.audioBytes.byteLength,
+          0,
+        ),
+        elapsedMs: Date.now() - extractionStartedAt,
+      });
+
       try {
         const startedAt = Date.now();
-        const builderResult = await withPendingTranscriptHeartbeat(
+        const chunkResults = await withPendingTranscriptHeartbeat(
           db,
           args.recordingId,
           () =>
-            transcribeWithBuilderModelFallback({
-              audioBytes: audioMedia.audioBytes,
-              mimeType: audioMedia.mimeType,
-              diarize: true,
-              instructions: SPEECH_ONLY_TRANSCRIPTION_INSTRUCTIONS,
-              timeoutMs: builderTranscriptionTimeoutMs(rec.durationMs),
+            transcribeAudioChunks({
+              chunks: audioMedia.chunks,
+              isRetryable: isTransientTranscriptionError,
+              transcribe: (chunk) =>
+                transcribeWithBuilderModelFallback({
+                  audioBytes: chunk.audioBytes,
+                  mimeType: audioMedia.mimeType,
+                  diarize: true,
+                  instructions: SPEECH_ONLY_TRANSCRIPTION_INSTRUCTIONS,
+                  timeoutMs: builderTranscriptionTimeoutMs(chunk.durationMs),
+                }),
             }),
         );
 
-        const segments = (builderResult.segments ?? [])
-          .map((s) => {
-            const speaker = s.speakerLabel?.trim();
-            return {
-              startMs: s.startMs,
-              endMs: s.endMs,
-              text: s.text.trim(),
-              ...(speaker ? { speaker } : {}),
-            };
-          })
-          .filter((segment) => segment.text);
-        const normalizedTranscript = normalizeProviderTranscript(
-          builderResult.text,
-          segments,
+        const normalizedTranscript = joinChunkTranscripts(
+          audioMedia.chunks,
+          chunkResults,
         );
         const fullText = normalizedTranscript.fullText;
 
@@ -1309,7 +1247,7 @@ const requestTranscriptAction = defineAction({
             ownerEmail,
             status: "ready",
             failureReason: null,
-            language: builderResult.language ?? "en",
+            language: normalizedTranscript.language ?? "en",
             segmentsJson: JSON.stringify(normalizedTranscript.segments),
             fullText,
             now,
@@ -1363,7 +1301,7 @@ const requestTranscriptAction = defineAction({
 
           const elapsedMs = Date.now() - startedAt;
           console.log(
-            `Transcribed recording ${args.recordingId} via builder in ${elapsedMs}ms (${normalizedTranscript.segments.length} segments)`,
+            `Transcribed recording ${args.recordingId} via builder in ${elapsedMs}ms (${audioMedia.chunks.length} parts, ${normalizedTranscript.segments.length} segments)`,
           );
           return {
             recordingId: args.recordingId,
@@ -1375,6 +1313,8 @@ const requestTranscriptAction = defineAction({
       } catch (err) {
         const reason = (err as Error).message;
         const details = serializeError(err);
+        const chunkErr = err instanceof ChunkTranscriptionError ? err : null;
+        if (chunkErr) builderFailureCode = "CHUNK_FAILED";
         if (isBuilderCreditsExhaustedMessage(reason)) {
           await noteBuilderCreditsExhausted({
             source: "transcription",
@@ -1401,6 +1341,12 @@ const requestTranscriptAction = defineAction({
           provider: BUILDER_GEMINI_TRANSCRIPTION_MODEL,
           failureReason: reason,
           details,
+          ...(chunkErr
+            ? {
+                chunkIndex: chunkErr.chunkIndex,
+                chunkCount: chunkErr.chunkCount,
+              }
+            : {}),
         });
       }
     }
@@ -1424,14 +1370,14 @@ const requestTranscriptAction = defineAction({
       ownerEmail,
       status: "failed",
       failureReason: reason,
-      failureCode: builderError ? "CLOUD_FAILED" : "CLOUD_UNCONFIGURED",
+      failureCode: builderError ? builderFailureCode : "CLOUD_UNCONFIGURED",
       now,
       ...(cloudTransient ? { retryCount: cloudNextRetryCount } : {}),
     });
     track(
       "recording_transcription_failed",
       {
-        failure_code: builderError ? "CLOUD_FAILED" : "CLOUD_UNCONFIGURED",
+        failure_code: builderError ? builderFailureCode : "CLOUD_UNCONFIGURED",
         stage: "transcription",
         retryable: cloudTransient,
         output_id: args.recordingId,