@agent-native/core 0.81.3 → 0.83.0

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2043
-- template files: 4804
+- template files: 4820

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.83.0
+
+### Minor Changes
+
+- 1a8d939: Add dynamic command menu results and an opt-in contenteditable Cmd+K shortcut path for editor-backed apps.
+
+## 0.82.0
+
+### Minor Changes
+
+- fe9fd99: Add optional `resumable` capability to `FileUploadProvider` for streaming uploads. Providers that implement `startSession`, `relayChunk`, and `completeSession` can receive video chunks during recording instead of waiting for a fully assembled file after stop. The Builder.io provider implements this via the GCS resumable upload protocol. Also exports `ResumableUploadSession` and `ResumableChunkResult` types.
+
 ## 0.81.3
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.81.3",
+  "version": "0.83.0",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/client/CommandMenu.tsx

@@ -261,6 +261,8 @@ export interface CommandMenuProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
   children: ReactNode;
+  /** Render app-specific dynamic results from the current search value. */
+  renderResults?: (search: string) => ReactNode;
   /** Placeholder text for the search input */
   placeholder?: string;
   /** Text shown when no results match (before showing agent fallback) */
@@ -291,6 +293,7 @@ export function CommandMenu({
   open,
   onOpenChange,
   children,
+  renderResults,
   placeholder = "Type a command or ask AI...",
   emptyText: _emptyText = "No commands found.",
   showAgentFallback = true,
@@ -325,8 +328,15 @@ export function CommandMenu({
     setTimeout(() => setChangelogOpen(true), 50);
   }, [onOpenChange, markChangelogSeen]);
 
-  // Focus input when opening
+  // Focus input when opening; clear search while closed so reopen never renders
+  // dynamic results for the previous query.
   useEffect(() => {
+    if (!open) {
+      setSearch("");
+      setSelectedIndex(0);
+      return;
+    }
+
     if (open) {
       setSearch("");
       setSelectedIndex(0);
@@ -497,6 +507,8 @@ export function CommandMenu({
       React.isValidElement(child) &&
       (child.type === CommandGroup || child.type === CommandDocsGroup),
   );
+  const dynamicResults = open ? renderResults?.(search) : null;
+  const hasDynamicResults = Boolean(dynamicResults);
 
   return (
     <>
@@ -528,6 +540,7 @@ export function CommandMenu({
 
               {/* Command list */}
               <div className="max-h-[300px] overflow-y-auto overflow-x-hidden">
+                {dynamicResults}
                 {hasResults && filteredChildren}
 
                 {/* What's new — built-in changelog entry */}
@@ -567,7 +580,9 @@ export function CommandMenu({
                 {/* Ask AI — always visible at the bottom */}
                 {showAgentFallback && (
                   <>
-                    {(hasResults || showChangelogRow) && <CommandSeparator />}
+                    {(hasResults || showChangelogRow || hasDynamicResults) && (
+                      <CommandSeparator />
+                    )}
                     <div className="p-1">
                       <div
                         className="relative flex cursor-pointer select-none items-center gap-2 rounded-sm px-2 py-2 text-sm outline-none"
@@ -658,16 +673,21 @@ CommandMenu.Separator = CommandSeparator;
 /**
  * Hook to handle Cmd+K (or Ctrl+K) to open the command menu
  */
-export function useCommandMenuShortcut(onOpen: () => void) {
+export function useCommandMenuShortcut(
+  onOpen: () => void,
+  options: { allowContentEditable?: boolean } = {},
+) {
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
-      if ((e.metaKey || e.ctrlKey) && e.key === "k") {
-        // Don't trigger if user is typing in an input/textarea
-        const target = e.target as HTMLElement;
+      if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === "k") {
+        // Don't trigger if user is typing in a native form control.
+        const target = e.target instanceof HTMLElement ? e.target : null;
+        const isContentEditable = target?.isContentEditable;
         if (
-          target.tagName === "INPUT" ||
-          target.tagName === "TEXTAREA" ||
-          target.isContentEditable
+          target?.tagName === "INPUT" ||
+          target?.tagName === "TEXTAREA" ||
+          target?.tagName === "SELECT" ||
+          (!options.allowContentEditable && isContentEditable)
         ) {
           return;
         }
@@ -675,9 +695,11 @@ export function useCommandMenuShortcut(onOpen: () => void) {
         onOpen();
       }
     };
-    document.addEventListener("keydown", handleKeyDown);
-    return () => document.removeEventListener("keydown", handleKeyDown);
-  }, [onOpen]);
+    const useCapture = Boolean(options.allowContentEditable);
+    document.addEventListener("keydown", handleKeyDown, useCapture);
+    return () =>
+      document.removeEventListener("keydown", handleKeyDown, useCapture);
+  }, [onOpen, options.allowContentEditable]);
 }
 
 export type {

package/corpus/core/src/file-upload/builder.ts

@@ -2,6 +2,8 @@ import type {
   FileUploadProvider,
   FileUploadInput,
   FileUploadResult,
+  ResumableUploadSession,
+  ResumableChunkResult,
 } from "./types.js";
 
 const DEFAULT_BUILDER_APP_HOST = "https://builder.io";
@@ -46,8 +48,6 @@ async function uploadLargeFileViaSignedUrl(
   bareMimeType: string,
   bytes: Uint8Array,
 ): Promise<FileUploadResult> {
-  const host = builderUploadHost();
-  const authHeader = { Authorization: `Bearer ${privateKey}` };
   const name = input.filename ?? "upload";
   const mb = (bytes.byteLength / (1024 * 1024)).toFixed(1);
 
@@ -57,32 +57,12 @@ async function uploadLargeFileViaSignedUrl(
 
   // Step 1 — request a signed URL.
   console.log(`[builder-upload] step 1: requesting signed URL`);
-  const step1Res = await fetchWithTimeout(
-    new URL("/api/v1/upload/signed-url", host).toString(),
-    {
-      method: "POST",
-      headers: { ...authHeader, "Content-Type": "application/json" },
-      body: JSON.stringify({
-        fileName: name,
-        contentType: bareMimeType,
-        size: bytes.byteLength,
-      }),
-    },
+  const { uploadUrl, assetId, requiredHeaders } = await requestBuilderSignedUrl(
+    privateKey,
+    name,
+    bareMimeType,
+    bytes.byteLength,
   );
-  await assertOk(step1Res, "Builder.io signed-URL request failed");
-
-  const step1Json = (await step1Res.json()) as {
-    uploadUrl?: string;
-    assetId?: string;
-    expiresAt?: string;
-    requiredHeaders?: Record<string, string>;
-  };
-  const { uploadUrl, assetId, requiredHeaders } = step1Json;
-  if (!uploadUrl || !assetId || !requiredHeaders) {
-    throw new Error(
-      `Builder.io signed-URL response missing required fields: ${JSON.stringify(Object.keys(step1Json))}`,
-    );
-  }
   console.log(`[builder-upload] step 1 ok: assetId=${assetId}`);
 
   // Step 2 — PUT bytes directly to GCS. Only requiredHeaders; no Authorization
@@ -102,21 +82,80 @@ async function uploadLargeFileViaSignedUrl(
   console.log(
     `[builder-upload] step 3: registering asset - ${assetId}, ${input.filename}`,
   );
-  const step3Res = await fetchWithTimeout(
+  const { url, id } = await completeBuilderUpload(
+    privateKey,
+    assetId,
+    input.filename,
+  );
+  console.log(`[builder-upload] done [${assetId}]: ${url}`);
+  return { url, id, provider: "builder" };
+}
+
+async function requestBuilderSignedUrl(
+  privateKey: string,
+  filename: string,
+  mimeType: string,
+  size: number,
+  resumable = false,
+): Promise<{
+  uploadUrl: string;
+  assetId: string;
+  requiredHeaders: Record<string, string>;
+}> {
+  const host = builderUploadHost();
+  const url = new URL("/api/v1/upload/signed-url", host);
+  const res = await fetchWithTimeout(url.toString(), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${privateKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      fileName: filename,
+      contentType: mimeType,
+      size,
+      resumable,
+    }),
+  });
+  await assertOk(res, "Builder.io signed-URL request failed");
+  const json = (await res.json()) as {
+    uploadUrl?: string;
+    assetId?: string;
+    requiredHeaders?: Record<string, string>;
+  };
+  if (!json.uploadUrl || !json.assetId || !json.requiredHeaders) {
+    throw new Error(
+      `Builder.io signed-URL response missing required fields: ${JSON.stringify(Object.keys(json))}`,
+    );
+  }
+  return {
+    uploadUrl: json.uploadUrl,
+    assetId: json.assetId,
+    requiredHeaders: json.requiredHeaders,
+  };
+}
+
+async function completeBuilderUpload(
+  privateKey: string,
+  assetId: string,
+  filename: string | undefined,
+): Promise<{ url: string; id?: string }> {
+  const host = builderUploadHost();
+  const res = await fetchWithTimeout(
     new URL("/api/v1/upload/complete", host).toString(),
     {
       method: "POST",
-      headers: { ...authHeader, "Content-Type": "application/json" },
-      body: JSON.stringify({ assetId, name: input.filename }),
+      headers: {
+        Authorization: `Bearer ${privateKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ assetId, name: filename }),
     },
   );
-  await assertOk(step3Res, "Builder.io upload complete failed");
-
-  const { url, id } = (await step3Res.json()) as { url?: string; id?: string };
-  if (!url) throw new Error("Builder.io upload/complete returned no URL");
-
-  console.log(`[builder-upload] done [${assetId}]: ${url}`);
-  return { url, id, provider: "builder" };
+  await assertOk(res, "Builder.io upload complete failed");
+  const json = (await res.json()) as { url?: string; id?: string };
+  if (!json.url) throw new Error("Builder.io upload/complete returned no URL");
+  return { url: json.url, id: json.id };
 }
 
 // Retry transient 5xx once with backoff. Builder.io's upload service
@@ -221,4 +260,127 @@ export const builderFileUploadProvider: FileUploadProvider = {
     console.log(`[builder-upload] done: ${json.url}`);
     return { url: json.url, id: json.id, provider: "builder" };
   },
+
+  resumable: {
+    async startSession(filename, mimeType, maxBytes) {
+      const { resolveBuilderPrivateKey } =
+        await import("../server/credential-provider.js");
+      const privateKey = await resolveBuilderPrivateKey();
+      if (!privateKey) throw new Error("BUILDER_PRIVATE_KEY is not set");
+
+      console.log(
+        `[builder-resumable] starting session: ${filename} ${mimeType} ${maxBytes} bytes`,
+      );
+      const { uploadUrl, assetId, requiredHeaders } =
+        await requestBuilderSignedUrl(
+          privateKey,
+          filename,
+          mimeType,
+          maxBytes,
+          true,
+        );
+      console.log(`[builder-resumable] session step 1 ok: assetId=${assetId}`);
+
+      const initHeaders: Record<string, string> = {
+        "Content-Type": mimeType,
+        "x-goog-resumable": "start",
+      };
+      const contentLengthRange =
+        requiredHeaders?.["x-goog-content-length-range"];
+      if (contentLengthRange)
+        initHeaders["x-goog-content-length-range"] = contentLengthRange;
+
+      console.log(`[builder-resumable] session step 2: initiating GCS session`);
+      const initRes = await fetchWithTimeout(uploadUrl, {
+        method: "POST",
+        headers: initHeaders,
+        body: new Uint8Array(0),
+      });
+      if (!initRes.ok) {
+        const body = await initRes.text().catch(() => "");
+        throw new Error(
+          `GCS resumable session initiation failed (${initRes.status}): ${body}`,
+        );
+      }
+      const sessionUri = initRes.headers.get("location");
+      if (!sessionUri)
+        throw new Error(
+          "GCS did not return a Location header for the resumable session",
+        );
+
+      console.log(`[builder-resumable] session ready: assetId=${assetId}`);
+      return {
+        sessionId: sessionUri,
+        meta: { assetId, filename, mimeType },
+      } satisfies ResumableUploadSession;
+    },
+
+    async relayChunk(session, contentRange, bytes, options) {
+      const sessionUri = session.sessionId;
+      const MAX_ATTEMPTS = 4;
+      const RETRYABLE = new Set([408, 429, 500, 502, 503, 504]);
+      const delayMs = (attempt: number) =>
+        Math.min(2000, 300 * 2 ** (attempt - 1));
+
+      let lastError: unknown = null;
+      for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+          const headers: Record<string, string> = {
+            "Content-Range": contentRange,
+          };
+          if (options?.mimeType) headers["Content-Type"] = options.mimeType;
+          const res = await fetch(sessionUri, {
+            method: "PUT",
+            headers,
+            body: bytes as unknown as BodyInit,
+          });
+          if (res.status === 308 || res.ok)
+            return {
+              ok: true,
+              status: res.status,
+            } satisfies ResumableChunkResult;
+          if (RETRYABLE.has(res.status) && attempt < MAX_ATTEMPTS) {
+            await res.text().catch(() => "");
+            console.warn(
+              `[builder-resumable] transient ${res.status} on attempt ${attempt}, retrying`,
+            );
+            await new Promise((r) => setTimeout(r, delayMs(attempt)));
+            continue;
+          }
+          return {
+            ok: false,
+            status: res.status,
+          } satisfies ResumableChunkResult;
+        } catch (err) {
+          lastError = err;
+          if (attempt >= MAX_ATTEMPTS) break;
+          console.warn(
+            `[builder-resumable] network error on attempt ${attempt}:`,
+            err instanceof Error ? err.message : String(err),
+          );
+          await new Promise((r) => setTimeout(r, delayMs(attempt)));
+        }
+      }
+      throw lastError instanceof Error
+        ? lastError
+        : new Error("GCS PUT failed after retries");
+    },
+
+    async completeSession(session, filename) {
+      const { resolveBuilderPrivateKey } =
+        await import("../server/credential-provider.js");
+      const privateKey = await resolveBuilderPrivateKey();
+      if (!privateKey) throw new Error("BUILDER_PRIVATE_KEY is not set");
+
+      const assetId = session.meta.assetId as string;
+      console.log(`[builder-resumable] completing upload: assetId=${assetId}`);
+      const { url } = await completeBuilderUpload(
+        privateKey,
+        assetId,
+        filename,
+      );
+      console.log(`[builder-resumable] upload complete: ${url}`);
+      return url;
+    },
+  },
 };

package/corpus/core/src/file-upload/index.ts

@@ -2,6 +2,8 @@ export type {
   FileUploadInput,
   FileUploadProvider,
   FileUploadResult,
+  ResumableUploadSession,
+  ResumableChunkResult,
 } from "./types.js";
 export {
   registerFileUploadProvider,

package/corpus/core/src/file-upload/types.ts

@@ -27,6 +27,22 @@ export interface FileUploadResult {
   provider: string;
 }
 
+/** Opaque session handle returned by {@link FileUploadProvider.resumable.startSession}.
+ * `sessionId` is provider-specific (GCS Location URI, S3 UploadId, etc.).
+ * `meta` holds any provider state needed for subsequent relay and complete calls. */
+export interface ResumableUploadSession {
+  sessionId: string;
+  meta: Record<string, unknown>;
+}
+
+export interface ResumableChunkResult {
+  ok: boolean;
+  status: number;
+  /** Providers that need per-chunk state (e.g. S3 ETags) return updated meta
+   * here; the chunk route merges it back into the stored session. */
+  updatedMeta?: Record<string, unknown>;
+}
+
 export interface FileUploadProvider {
   /** Unique id, e.g. "builder", "s3". */
   id: string;
@@ -41,4 +57,26 @@ export interface FileUploadProvider {
   isConfiguredForRequest?: () => Promise<boolean>;
   /** Upload a file and return a URL. Throw on failure. */
   upload: (input: FileUploadInput) => Promise<FileUploadResult>;
+  /**
+   * Optional resumable/streaming upload capability.
+   * When present, create-recording will initialise a session and stream chunks
+   * during recording instead of assembling the full blob after stop().
+   */
+  resumable?: {
+    startSession(
+      filename: string,
+      mimeType: string,
+      maxBytes: number,
+    ): Promise<ResumableUploadSession>;
+    relayChunk(
+      session: ResumableUploadSession,
+      contentRange: string,
+      bytes: Uint8Array,
+      options?: { mimeType?: string },
+    ): Promise<ResumableChunkResult>;
+    completeSession(
+      session: ResumableUploadSession,
+      filename: string,
+    ): Promise<string>;
+  };
 }

package/corpus/templates/analytics/actions/hubspot-deals.ts

@@ -264,6 +264,12 @@ function hasStructuredFilters(filters: ReturnType<typeof buildFilterSummary>) {
 function buildGuidance(options: {
   query: string | undefined;
   structuredFilters: boolean;
+  truncated: boolean;
+  hasMore: boolean;
+  total: number;
+  returned: number;
+  offset: number;
+  limit: number;
 }) {
   const guidance: string[] = [];
 
@@ -285,6 +291,15 @@ function buildGuidance(options: {
     );
   }
 
+  if (options.truncated) {
+    const more = options.hasMore
+      ? `Fetch the next page with offset ${options.offset + options.returned}.`
+      : "This is the last page of the cohort.";
+    guidance.push(
+      `Returned ${options.returned} of ${options.total} matching deals (limit ${options.limit}, offset ${options.offset}). This is a partial slice — do NOT treat it as the full cohort. Use total for counts/aggregates. ${more} Narrow the filters or, for exhaustive cohort analysis, use provider-api-request with provider = hubspot and stageAs.`,
+    );
+  }
+
   return guidance.join(" ");
 }
 
@@ -293,7 +308,7 @@ export default defineAction({
   // reusable across continuation retries (no re-fetch on resume).
   readOnly: true,
   description:
-    "Get HubSpot deals with normalized stage, pipeline, owner, forecast, and NBM fields. This is a bounded deal analytics shortcut, not the full HubSpot capability surface. Use query for a specific customer/deal/account deep dive. For cohorts like products field = Publish, closed-won, pipeline = New Business, or close date in a range, use the structured product, pipeline, closedStatus, closedDateFrom, and closedDateTo filters instead of query when the answer is the deal list itself. If the cohort feeds a cross-source join, transcript/message/ticket search, exhaustive absence check, or downstream code/corpus workflow, prefer provider-api-catalog/provider-api-request with provider = hubspot and stageAs so the cohort is available as a staged dataset. For non-deal CRM records use hubspot-records; for arbitrary HubSpot endpoints, filters, associations, batch APIs, or payloads use provider-api-catalog/provider-api-docs/provider-api-request with provider = hubspot.",
+    "Get HubSpot deals with normalized stage, pipeline, owner, forecast, and NBM fields. This is a bounded deal analytics shortcut, not the full HubSpot capability surface. Use query for a specific customer/deal/account deep dive. For cohorts like products field = Publish, closed-won, pipeline = New Business, or close date in a range, use the structured product, pipeline, closedStatus, closedDateFrom, and closedDateTo filters instead of query when the answer is the deal list itself. If the cohort feeds a cross-source join, transcript/message/ticket search, exhaustive absence check, or downstream code/corpus workflow, prefer provider-api-catalog/provider-api-request with provider = hubspot and stageAs so the cohort is available as a staged dataset. Both paths are bounded: at most limit deals are returned (default 25, max 100). The structured-filter path returns total as the true matched count and a truncated flag; page with offset (or narrow filters) instead of expecting the whole cohort in one call, since a full enriched cohort can be several MB and overruns extension and context budgets. For non-deal CRM records use hubspot-records; for arbitrary HubSpot endpoints, filters, associations, batch APIs, or payloads use provider-api-catalog/provider-api-docs/provider-api-request with provider = hubspot.",
   schema: z.object({
     properties: StringListSchema.describe(
       "Optional comma-separated extra HubSpot deal property names to include.",
@@ -344,7 +359,17 @@ export default defineAction({
       .min(1)
       .max(100)
       .default(25)
-      .describe("Maximum records to return when query is provided."),
+      .describe(
+        "Maximum deals to return. Applies to BOTH full-text query results and structured-filter cohorts. The structured-filter path returns at most this many enriched deals (use total for the true matched count and offset to page).",
+      ),
+    offset: z.coerce
+      .number()
+      .int()
+      .min(0)
+      .default(0)
+      .describe(
+        "Number of structured-filter results to skip before returning limit deals. Use for paging through a large cohort; ignored when query is provided.",
+      ),
     after: z
       .string()
       .optional()
@@ -362,6 +387,7 @@ export default defineAction({
     closedDateTo,
     query,
     limit = 25,
+    offset = 0,
     after,
   }) => {
     const trimmedQuery = query?.trim();
@@ -414,7 +440,7 @@ export default defineAction({
       closedDateTo: closedDateTo?.trim(),
     });
     const structuredFilters = hasStructuredFilters(filters);
-    const deals = rawDeals
+    const matchedDeals = rawDeals
       .filter((d) => visibleIds.has(String(d.properties.pipeline)))
       .map((deal) => enrichDeal(deal, lookups, owners))
       .filter((deal) => {
@@ -435,18 +461,52 @@ export default defineAction({
         return matchesDateRange(deal, fromMs, toMs);
       });
 
+    // The full-text query path is already bounded by HubSpot's own `limit`.
+    // EVERY non-query call (with or without structured filters) scans the whole
+    // visible deal set, so bound the returned cohort here. This is deliberately
+    // NOT gated on `structuredFilters`: the unfiltered `hubspot-deals({})` call
+    // is the LARGEST payload of all (every visible deal), so it must be bounded
+    // too — a full enriched cohort can be multiple MB, which overruns the
+    // extension iframe bridge and the agent context. We
+    // keep `total` as the true matched count and signal partial slices via
+    // `truncated` so callers never mistake a page for the full cohort.
+    // `truncated` means "this response is only part of the cohort" (returned <
+    // total) and stays true on the LAST page of a paginated read too; pagination
+    // (is there a next page) is reported separately via `hasMore` / `nextOffset`.
+    const matchedTotal = matchedDeals.length;
+    const deals = trimmedQuery
+      ? matchedDeals
+      : matchedDeals.slice(offset, offset + limit);
+    const truncated = !trimmedQuery && deals.length < matchedTotal;
+    const hasMore = !trimmedQuery && offset + deals.length < matchedTotal;
+
     return {
       deals,
       stageLabels: lookups.stageLabels,
       pipelineLabels: lookups.pipelineLabels,
-      total: deals.length,
+      total: matchedTotal,
       count: deals.length,
       query: trimmedQuery || null,
       filters,
       nextAfter: Array.isArray(dealResult) ? null : dealResult.nextAfter,
+      ...(trimmedQuery
+        ? {}
+        : {
+            limit,
+            offset,
+            truncated,
+            hasMore,
+            nextOffset: hasMore ? offset + deals.length : null,
+          }),
       guidance: buildGuidance({
         query: trimmedQuery,
         structuredFilters,
+        truncated,
+        hasMore,
+        total: matchedTotal,
+        returned: deals.length,
+        offset,
+        limit,
       }),
       ...(Array.isArray(dealResult)
         ? {}

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,
     };
   },
 });