@agent-native/core 0.81.2 → 0.82.0

package/corpus/templates/clips/actions/create-recording.ts

@@ -11,6 +11,9 @@
 
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
+import { getActiveFileUploadProviderForRequest } from "@agent-native/core/file-upload";
+import type { UploadMode } from "@shared/recording-core.js";
+import { MAX_UPLOAD_BYTES } from "@shared/upload-limits.js";
 
 import { getDb, schema } from "../server/db/index.js";
 import {
@@ -19,6 +22,7 @@ import {
   requireOrganizationAccess,
   stringifySpaceIds,
 } from "../server/lib/recordings.js";
+import { setResumableSession } from "../server/lib/resumable-session.js";
 import { createRecordingSchema } from "./lib/create-recording-schema.js";
 import { DEFAULT_RECORDING_TITLE } from "./lib/title-source.js";
 
@@ -76,6 +80,45 @@ export default defineAction({
 
     console.log(`Created recording "${title}" (${id})`);
 
+    // Initialize a resumable upload session so chunks are streamed to the
+    // provider during recording (no post-stop assembly). Falls back gracefully
+    // to the SQL chunk path when no provider supports resumable uploads or the
+    // init fails.
+    let uploadMode: UploadMode = "buffered";
+    const uploadProvider = await getActiveFileUploadProviderForRequest();
+    if (args.requestStreaming && uploadProvider?.resumable) {
+      try {
+        const recordingMimeType =
+          args.mimeType?.split(";")[0]?.trim() || "video/webm";
+        const ext = /mp4|quicktime/i.test(recordingMimeType) ? "mp4" : "webm";
+        const filename = `${id}.${ext}`;
+        console.log(
+          `[create-recording] starting resumable session: provider=${uploadProvider.id} mimeType=${recordingMimeType}`,
+        );
+        const session = await uploadProvider.resumable.startSession(
+          filename,
+          recordingMimeType,
+          MAX_UPLOAD_BYTES,
+        );
+        await setResumableSession(id, {
+          providerId: uploadProvider.id,
+          sessionId: session.sessionId,
+          meta: session.meta,
+          bytesUploaded: 0,
+          lastCommittedIndex: -1,
+        });
+        uploadMode = "streaming";
+        console.log(
+          `[create-recording] resumable session ready for ${id}: provider=${uploadProvider.id}`,
+        );
+      } catch (err) {
+        console.warn(
+          `[create-recording] resumable session init failed, falling back to buffered:`,
+          err instanceof Error ? err.message : String(err),
+        );
+      }
+    }
+
     return {
       id,
       organizationId,
@@ -84,6 +127,7 @@ export default defineAction({
       abortUrl: `/api/uploads/${id}/abort`,
       // Frontend substitutes {index}/{total}/{isFinal}
       uploadChunkUrlTemplate: `/api/uploads/${id}/chunk?index={index}&total={total}&isFinal={isFinal}`,
+      uploadMode,
     };
   },
 });

package/corpus/templates/clips/actions/finalize-recording.ts

@@ -15,7 +15,10 @@ import {
   deleteAppState,
 } from "@agent-native/core/application-state";
 import { emit } from "@agent-native/core/event-bus";
-import { uploadFile } from "@agent-native/core/file-upload";
+import {
+  getActiveFileUploadProvider,
+  uploadFile,
+} from "@agent-native/core/file-upload";
 import { captureRouteError } from "@agent-native/core/server";
 import { MAX_UPLOAD_BYTES as MAX_RECORDING_UPLOAD_BYTES } from "@shared/upload-limits.js";
 import { and, eq } from "drizzle-orm";
@@ -32,6 +35,10 @@ import {
   getCurrentOwnerEmail,
   ownerEmailMatches,
 } from "../server/lib/recordings.js";
+import {
+  deleteResumableSession,
+  getResumableSession,
+} from "../server/lib/resumable-session.js";
 import {
   requiresConfiguredVideoStorage,
   STORAGE_SETUP_REQUIRED_REASON,
@@ -96,6 +103,120 @@ const cliBoolean = z.preprocess((value) => {
   return value;
 }, z.boolean());
 
+// Flip recording to 'ready', seed transcript row, fire background transcript,
+// emit clip.created. Used by both the resumable and buffered upload paths.
+async function markRecordingReady(params: {
+  id: string;
+  ownerEmail: string;
+  videoUrl: string;
+  videoSizeBytes: number;
+  videoFormat: "webm" | "mp4";
+  finalDurationMs: number;
+  finalWidth: number;
+  finalHeight: number;
+  finalHasAudio: boolean;
+  finalHasCamera: boolean;
+  existingTitle: string;
+}) {
+  const {
+    id,
+    ownerEmail,
+    videoUrl,
+    videoSizeBytes,
+    videoFormat,
+    finalDurationMs,
+    finalWidth,
+    finalHeight,
+    finalHasAudio,
+    finalHasCamera,
+    existingTitle,
+  } = params;
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  await db
+    .update(schema.recordings)
+    .set({
+      status: "ready",
+      videoUrl,
+      videoFormat,
+      videoSizeBytes,
+      durationMs: finalDurationMs,
+      width: finalWidth,
+      height: finalHeight,
+      hasAudio: finalHasAudio,
+      hasCamera: finalHasCamera,
+      failureReason: null,
+      uploadProgress: 100,
+      updatedAt: now,
+    })
+    .where(
+      and(
+        eq(schema.recordings.id, id),
+        ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+      ),
+    );
+
+  const [existingTranscript] = await db
+    .select({ recordingId: schema.recordingTranscripts.recordingId })
+    .from(schema.recordingTranscripts)
+    .where(eq(schema.recordingTranscripts.recordingId, id));
+  if (!existingTranscript) {
+    await db.insert(schema.recordingTranscripts).values({
+      recordingId: id,
+      ownerEmail,
+      status: "pending",
+      createdAt: now,
+      updatedAt: now,
+    });
+  }
+
+  await writeAppState(`recording-upload-${id}`, {
+    recordingId: id,
+    status: "ready",
+    progress: 100,
+    videoUrl,
+    finishedAt: now,
+  });
+  await writeAppState("refresh-signal", { ts: Date.now() });
+
+  // Kick off transcription in the background — fire-and-forget so the chunk
+  // endpoint gets a quick response. The request context (user email via
+  // AsyncLocalStorage) carries through to async continuations.
+  void Promise.resolve(
+    requestTranscript.run({ recordingId: id, force: true }),
+  ).catch((err: unknown) => {
+    console.error("[finalize] background transcript failed", {
+      id,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  });
+
+  try {
+    emit(
+      "clip.created",
+      {
+        clipId: id,
+        title: existingTitle,
+        createdBy: ownerEmail,
+        duration: finalDurationMs,
+        url: videoUrl,
+      },
+      { owner: ownerEmail },
+    );
+  } catch (err) {
+    console.warn("[finalize] clip.created emit failed:", err);
+  }
+
+  return {
+    id,
+    status: "ready" as const,
+    videoUrl,
+    videoSizeBytes,
+    durationMs: finalDurationMs,
+  };
+}
+
 export default defineAction({
   description:
     "Assemble recorded chunks into a final video blob, upload it to the configured storage provider, update the recording row (videoUrl, durationMs, width/height/hasAudio/hasCamera), flip status to 'ready', and trigger the agent to produce a title, summary, transcript, and chapters in the background.",
@@ -154,6 +275,21 @@ export default defineAction({
         throw new Error(`Recording not found: ${id}`);
       }
 
+      // Idempotency guard: finalize can be re-invoked when a client retries the
+      // final chunk after a lost response. If already 'ready' return the existing
+      // result instead of re-running the complete/assembly path (session and
+      // chunks are gone by then).
+      if (existing.status === "ready" && existing.videoUrl) {
+        debugLog("[finalize] already finalized, returning existing", { id });
+        return {
+          id,
+          status: "ready" as const,
+          videoUrl: existing.videoUrl,
+          videoSizeBytes: existing.videoSizeBytes ?? 0,
+          durationMs: existing.durationMs ?? 0,
+        };
+      }
+
       const uploadStateRaw = await readAppState(`recording-upload-${id}`);
       const uploadState =
         uploadStateRaw && typeof uploadStateRaw === "object"
@@ -190,6 +326,62 @@ export default defineAction({
           ? args.hasCamera
           : (stateBoolean(uploadState, "hasCamera") ?? existing.hasCamera);
 
+      const readyParams = {
+        id,
+        ownerEmail,
+        videoFormat,
+        finalDurationMs,
+        finalWidth,
+        finalHeight,
+        finalHasAudio,
+        finalHasCamera,
+        existingTitle: existing.title,
+      };
+
+      // Resumable path: create-recording initialized a session and chunk.post.ts
+      // forwarded all chunks to the provider. Complete the session to get the CDN URL.
+      const resumableSession = await getResumableSession(id);
+      if (resumableSession) {
+        debugLog("[finalize] resumable session found, completing upload", {
+          id,
+          providerId: resumableSession.providerId,
+        });
+        try {
+          const uploadProvider = getActiveFileUploadProvider();
+          if (!uploadProvider?.resumable) {
+            throw new Error("No resumable upload provider configured");
+          }
+          const videoUrl = await uploadProvider.resumable.completeSession(
+            {
+              sessionId: resumableSession.sessionId,
+              meta: resumableSession.meta,
+            },
+            typeof resumableSession.meta.filename === "string"
+              ? resumableSession.meta.filename
+              : "",
+          );
+          debugLog("[finalize] resumable upload completed", { id, videoUrl });
+          const result = await markRecordingReady({
+            ...readyParams,
+            videoUrl,
+            videoSizeBytes: resumableSession.bytesUploaded,
+          });
+          // Delete only after durable state is written — so a retry before
+          // this point can still find the session and re-enter this path.
+          deleteResumableSession(id).catch((err) =>
+            console.warn("[finalize] failed to delete resumable session:", err),
+          );
+          return result;
+        } catch (err) {
+          console.error("[finalize] resumable complete failed:", err);
+          throw new Error(
+            `Upload completion failed: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+      }
+
+      // Buffered path — assemble chunks from application_state, then upload.
+
       // The recorder stashes compression metadata at
       // `recording-compression-{id}` when its browser-side ffmpeg.wasm
       // pass ran to bring the assembled blob under Builder.io's 100 MB
@@ -514,99 +706,17 @@ export default defineAction({
         }
         throw err;
       }
-      const videoUrl = upload.url;
-
-      // Update the recording row with final metadata and flip to 'ready'.
-      await db
-        .update(schema.recordings)
-        .set({
-          status: "ready",
-          videoUrl,
-          videoFormat,
-          videoSizeBytes: assembled.byteLength,
-          durationMs: finalDurationMs,
-          width: finalWidth,
-          height: finalHeight,
-          hasAudio: finalHasAudio,
-          hasCamera: finalHasCamera,
-          failureReason: null,
-          uploadProgress: 100,
-          updatedAt: new Date().toISOString(),
-        })
-        .where(eq(schema.recordings.id, id));
-
-      // Seed a pending transcript row so the agent background task has a place
-      // to write results.
-      const [existingTranscript] = await db
-        .select({ recordingId: schema.recordingTranscripts.recordingId })
-        .from(schema.recordingTranscripts)
-        .where(eq(schema.recordingTranscripts.recordingId, id));
-      if (!existingTranscript) {
-        await db.insert(schema.recordingTranscripts).values({
-          recordingId: id,
-          ownerEmail,
-          status: "pending",
-          createdAt: new Date().toISOString(),
-          updatedAt: new Date().toISOString(),
-        });
-      }
-
-      await writeAppState(`recording-upload-${id}`, {
-        recordingId: id,
-        status: "ready",
-        progress: 100,
-        videoUrl,
-        finishedAt: new Date().toISOString(),
-      });
-
-      await writeAppState("refresh-signal", { ts: Date.now() });
-
-      // Kick off transcription in the background. Native web/macOS speech rows
-      // are preserved first; cloud transcription only fills gaps/refines when
-      // needed. The chunk endpoint already awaits this finalize call, so we
-      // fire-and-forget — the request context (user email via AsyncLocalStorage)
-      // carries through to async continuations started before this run()
-      // returns. Without this the transcript row stays in `pending` forever and
-      // the UI shows an infinite "Transcribing…" spinner.
-      void Promise.resolve(
-        requestTranscript.run({ recordingId: id, force: true }),
-      ).catch((err: unknown) => {
-        console.error("[finalize] background transcript failed", {
-          id,
-          error: err instanceof Error ? err.message : String(err),
-        });
-      });
-
-      // Emit clip.created event — best-effort, never block the main flow.
-      try {
-        emit(
-          "clip.created",
-          {
-            clipId: id,
-            title: existing.title,
-            createdBy: ownerEmail,
-            duration: finalDurationMs,
-            url: videoUrl,
-          },
-          { owner: ownerEmail },
-        );
-      } catch (err) {
-        console.warn("[finalize] clip.created emit failed:", err);
-      }
 
       debugLog("[finalize] done", {
         id,
-        videoUrl,
+        videoUrl: upload.url,
         bytes: assembled.byteLength,
       });
-
-      return {
-        id,
-        status: "ready" as const,
-        videoUrl,
+      return markRecordingReady({
+        ...readyParams,
+        videoUrl: upload.url,
         videoSizeBytes: assembled.byteLength,
-        durationMs: finalDurationMs,
-      };
+      });
     } finally {
       // Unconditional chunk scratch-space cleanup. Runs on success AND on
       // error — a throw during uploadFile / drizzle update / anything else

package/corpus/templates/clips/actions/lib/create-recording-schema.ts

@@ -64,4 +64,16 @@ export const createRecordingSchema = z.object({
     .enum(["private", "org", "public"])
     .optional()
     .describe("Initial share visibility for the recording"),
+  mimeType: z
+    .string()
+    .optional()
+    .describe(
+      "MIME type the browser will record (e.g. video/webm, video/mp4). Used to initialize the resumable session with the correct content type.",
+    ),
+  requestStreaming: z
+    .boolean()
+    .optional()
+    .describe(
+      "Opt in to the resumable streaming upload path. Only send this when the caller can produce 256 KiB-aligned chunks (GCS requirement). Defaults to false — callers that omit this always get the buffered path.",
+    ),
 });

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -11,6 +11,7 @@ import {
   chunkUploadUrl,
   pickMimeType,
   pickMimeTypeCandidates,
+  type UploadMode,
 } from "@shared/recording-core";
 
 import {
@@ -32,7 +33,7 @@ import {
 
 // Re-exported for existing callers; the canonical impls live in
 // @shared/recording-core and are shared with the Chrome extension recorder.
-export { pickMimeType, pickMimeTypeCandidates };
+export { pickMimeType, pickMimeTypeCandidates, canUseTimeslicedRecorderChunks };
 
 export type RecordingMode = "screen" | "camera" | "screen+camera";
 export type DisplaySurface = "monitor" | "window" | "browser";
@@ -95,6 +96,13 @@ export interface RecorderEngineOptions {
   uploadUrl?: string;
   /** Abort URL. Default `/api/uploads/:id/abort`. */
   abortUrl?: string;
+  /**
+   * Upload strategy returned by create-recording.
+   * `"streaming"` — server has a resumable session; engine flushes aligned
+   * chunks during recording. `"buffered"` — blob assembled after stop() and
+   * uploaded in slices via the SQL chunk path.
+   */
+  uploadMode?: UploadMode;
   /** Fired whenever the state machine transitions. */
   onState?: (state: RecorderState, detail?: Record<string, unknown>) => void;
   /** Fired on each uploaded chunk (for progress UI). */
@@ -183,6 +191,11 @@ interface CompressionUploadMeta {
 }
 
 const DEFAULT_CHUNK_MS = 1000;
+// GCS resumable uploads require every non-final chunk to be a multiple of
+// 256 KiB. MediaRecorder emits arbitrary blob sizes, so on the streaming path
+// we buffer raw blobs and only PUT aligned slices. ~4 MiB per streamed chunk.
+const GCS_CHUNK_ALIGN_BYTES = 256 * 1024;
+const STREAM_CHUNK_BYTES = 15 * GCS_CHUNK_ALIGN_BYTES; // 3.75 MiB
 const CHUNK_UPLOAD_MAX_ATTEMPTS = 3;
 const RETRYABLE_CHUNK_UPLOAD_STATUSES = new Set([
   408, 425, 429, 500, 502, 503, 504,
@@ -430,7 +443,15 @@ export class RecorderEngine {
    * fetch quietly complete and the recording finalise server-side.
    */
   private uploadAbort: AbortController | null = null;
-  private streamChunksDuringRecording = false;
+  private uploadMode: UploadMode = "buffered";
+  /**
+   * Streaming-path buffer. MediaRecorder blobs accumulate here until at least
+   * STREAM_CHUNK_BYTES is available, then a 256 KiB-aligned slice is PUT to API
+   * as a non-final chunk. The unaligned remainder is held and uploaded as the
+   * final chunk on stop().
+   */
+  private pendingStreamBlobs: Blob[] = [];
+  private pendingStreamBytes = 0;
   /**
    * One-shot guards so a camera/mic disconnect warning fires at most once even
    * when a device exposes multiple tracks that each emit `ended`.
@@ -806,10 +827,12 @@ export class RecorderEngine {
     recordingId: string;
     uploadUrl: string;
     abortUrl: string;
+    uploadMode?: UploadMode;
   }): void {
     this.opts.recordingId = target.recordingId;
     this.opts.uploadUrl = target.uploadUrl;
     this.opts.abortUrl = target.abortUrl;
+    this.opts.uploadMode = target.uploadMode ?? "buffered";
   }
 
   // -------------------------------------------------------------------------
@@ -884,7 +907,9 @@ export class RecorderEngine {
     this.totalRecordedBytes = 0;
     this.lastFinalizeMeta = null;
     this.uploadAbort = new AbortController();
-    this.streamChunksDuringRecording = false;
+    this.uploadMode = this.opts.uploadMode ?? "buffered";
+    this.pendingStreamBlobs = [];
+    this.pendingStreamBytes = 0;
     this.cameraDisconnectNotified = false;
     this.micDisconnectNotified = false;
     const useTimeslicedLocalChunks = canUseTimeslicedRecorderChunks(
@@ -901,9 +926,10 @@ export class RecorderEngine {
       // whether this recording needs compression.
       this.localChunks.push(blob);
       this.totalRecordedBytes += blob.size;
-      if (this.streamChunksDuringRecording) {
-        const index = this.chunkIndex++;
-        this.queueChunk(blob, index, /* isFinal */ false);
+      if (this.uploadMode === "streaming") {
+        this.pendingStreamBlobs.push(blob);
+        this.pendingStreamBytes += blob.size;
+        this.flushAlignedStreamChunks();
       }
     });
 
@@ -1071,12 +1097,13 @@ export class RecorderEngine {
     try {
       if (
         COMPRESSION_ENABLED &&
-        this.totalRecordedBytes > COMPRESS_THRESHOLD_BYTES
+        this.totalRecordedBytes > COMPRESS_THRESHOLD_BYTES &&
+        this.opts.uploadMode !== "streaming"
       ) {
         // Compress before the first server upload so large recordings don't
         // stage their uncompressed source in SQL.
         result = await this.compressAndReupload(finalizeMeta);
-      } else if (!this.streamChunksDuringRecording) {
+      } else if (this.uploadMode !== "streaming") {
         this.transition("uploading", { progress: 0 });
         const assembled = new Blob(this.localChunks, { type: this.mimeType });
         result = await this.uploadBlobInSlices(
@@ -1086,26 +1113,28 @@ export class RecorderEngine {
           this.uploadAbort?.signal,
         );
       } else {
-        // Send a 0-byte isFinal sentinel — the actual final-chunk bytes
-        // were already uploaded by the start()-time listener as a
-        // regular (non-final) chunk. Mirroring the auto-stop path so
-        // both branches share one code shape.
+        // Streaming path: all 256 KiB-aligned chunks were queued during
+        // recording. Whatever bytes remain become the
+        // final chunk. If the recording happened to end exactly
+        // on a boundary the remainder is empty, which the server treats as a
+        // close sentinel.
         this.transition("uploading", { progress: 100 });
-        result = await this.uploadChunk(
-          new Blob([], { type: this.mimeType }),
-          this.chunkIndex++,
-          {
-            isFinal: true,
-            total: this.chunkIndex,
-            mimeType: this.mimeType,
-            durationMs,
-            width: dimensions.width,
-            height: dimensions.height,
-            hasAudio,
-            hasCamera,
-            signal: this.uploadAbort?.signal,
-          },
-        );
+        const remainder = new Blob(this.pendingStreamBlobs, {
+          type: this.mimeType,
+        });
+        this.pendingStreamBlobs = [];
+        this.pendingStreamBytes = 0;
+        result = await this.uploadChunk(remainder, this.chunkIndex++, {
+          isFinal: true,
+          total: this.chunkIndex,
+          mimeType: this.mimeType,
+          durationMs,
+          width: dimensions.width,
+          height: dimensions.height,
+          hasAudio,
+          hasCamera,
+          signal: this.uploadAbort?.signal,
+        });
       }
       this.transition("complete");
       completed = true;
@@ -1523,6 +1552,30 @@ export class RecorderEngine {
     }
   }
 
+  /**
+   * Drain the streaming buffer in 256 KiB-aligned chunks.
+   * GCS rejects non-final resumable chunks that are not a multiple of 256 KiB,
+   * so we slice on STREAM_CHUNK_BYTES boundaries and carry the remainder. The
+   * leftover is uploaded as the final chunk on stop().
+   */
+  private flushAlignedStreamChunks(): void {
+    while (this.pendingStreamBytes >= STREAM_CHUNK_BYTES) {
+      const combined = new Blob(this.pendingStreamBlobs, {
+        type: this.mimeType,
+      });
+      const head = combined.slice(0, STREAM_CHUNK_BYTES, this.mimeType);
+      const tail = combined.slice(
+        STREAM_CHUNK_BYTES,
+        combined.size,
+        this.mimeType,
+      );
+      this.pendingStreamBlobs = tail.size > 0 ? [tail] : [];
+      this.pendingStreamBytes = tail.size;
+      const index = this.chunkIndex++;
+      this.queueChunk(head, index, /* isFinal */ false);
+    }
+  }
+
   private queueChunk(blob: Blob, index: number, isFinal: boolean): void {
     this.chunkQueue = this.chunkQueue.then(async () => {
       if (this.uploadFailure) return;
@@ -1660,8 +1713,10 @@ export class RecorderEngine {
           signal: extra.signal,
         });
       } catch (err) {
+        // The final chunk is safe to retry on a network error: finalize is
+        // idempotent server-side (a recording already 'ready' returns its
+        // existing result), so a lost response won't double-finalize.
         if (
-          extra.isFinal ||
           attempt >= CHUNK_UPLOAD_MAX_ATTEMPTS ||
           (err as { name?: string } | null)?.name === "AbortError"
         ) {
@@ -1673,7 +1728,6 @@ export class RecorderEngine {
 
       if (
         !res.ok &&
-        !extra.isFinal &&
         attempt < CHUNK_UPLOAD_MAX_ATTEMPTS &&
         isRetryableChunkUploadStatus(res.status)
       ) {

package/corpus/templates/clips/app/routes/record.tsx

@@ -7,7 +7,11 @@ import {
 } from "@agent-native/core/client";
 import { useLiveTranscription } from "@agent-native/core/client/transcription/use-live-transcription";
 import type { BrowserDiagnosticsData } from "@shared/browser-diagnostics";
-import { chunkUploadUrl } from "@shared/recording-core";
+import {
+  chunkUploadUrl,
+  pickMimeType,
+  type UploadMode,
+} from "@shared/recording-core";
 import {
   IconAlertTriangle,
   IconArrowLeft,
@@ -95,6 +99,7 @@ import { CountdownOverlay } from "@/components/recorder/countdown-overlay";
 import { PreRecordPanel } from "@/components/recorder/pre-record-panel";
 import {
   RecorderEngine,
+  canUseTimeslicedRecorderChunks,
   NO_MIC_DEVICE_ID,
   type DisplaySurface,
   type RecorderFinalizeResult,
@@ -567,6 +572,7 @@ interface PendingRecording {
   id: string;
   uploadChunkUrl: string;
   abortUrl: string;
+  uploadMode?: UploadMode;
 }
 
 function PreRecordPanelSkeleton() {
@@ -1194,6 +1200,8 @@ export default function RecordRoute() {
               visibility: reportContext ? "org" : "public",
               spaceIds: spaceIdFromUrl ? [spaceIdFromUrl] : undefined,
               folderId: folderIdFromUrl ?? undefined,
+              mimeType: pickMimeType() || undefined,
+              requestStreaming: canUseTimeslicedRecorderChunks(pickMimeType()),
             }),
           },
         );
@@ -1213,10 +1221,12 @@ export default function RecordRoute() {
             id: string;
             uploadChunkUrl: string;
             abortUrl: string;
+            uploadMode?: UploadMode;
           };
           id?: string;
           uploadChunkUrl?: string;
           abortUrl?: string;
+          uploadMode?: UploadMode;
         };
         const info = created.result ?? (created as PendingRecording);
         if (!info?.id) {
@@ -1244,6 +1254,7 @@ export default function RecordRoute() {
           recordingId: info.id,
           uploadUrl: uploadChunkUrl,
           abortUrl,
+          uploadMode: info.uploadMode,
         });
         await saveBugReportContextRef.current(info.id);