@agent-native/core 0.101.3 → 0.101.5

package/corpus/core/src/server/action-discovery.ts

@@ -192,6 +192,9 @@ function preserveActionFlags(entry: Record<string, any>): Partial<ActionEntry> {
   if (typeof entry.parallelSafe === "boolean") {
     out.parallelSafe = entry.parallelSafe;
   }
+  if (typeof entry.dedupe === "boolean") {
+    out.dedupe = entry.dedupe;
+  }
   if (typeof entry.toolCallable === "boolean") {
     out.toolCallable = entry.toolCallable;
   }
@@ -716,7 +719,7 @@ export async function mergeCoreSharingActions(
           run: def.run,
           ...(def.http !== undefined ? { http: def.http } : {}),
           // Carry security-relevant flags (toolCallable, publicAgent, link,
-          // mcpApp) plus readOnly/parallelSafe. Without this, the sharing
+          // mcpApp) plus readOnly/parallelSafe/dedupe. Without this, the sharing
           // actions' `toolCallable: false` (audit-H5) is dropped and the
           // tools-iframe bridge 403 in action-routes.ts never fires.
           ...preserveActionFlags(def),

package/corpus/core/src/server/agent-chat/context-tools.ts

@@ -241,6 +241,10 @@ export function createRefreshScreenEntry(): Record<string, ActionEntry> {
       // distinct `screen-refresh` poll event. Don't double-emit a generic
       // `action` event on top of that.
       readOnly: true,
+      // Refetching volatile on-screen state is the entire point of this
+      // tool — an identical repeat call (even with the same scope) is a
+      // legitimate re-refresh, not a redundant read to skip.
+      dedupe: false,
       tool: {
         description:
           "Manually refresh the user's current screen. The framework ALREADY auto-refreshes after any successful mutating action tool call (template actions and any enabled raw DB write tools) — you do NOT need to call this after a normal action. Use it only when (a) you mutated data via a path the framework can't detect (e.g. a direct write to an external system the app mirrors), or (b) you want to pass a `scope` hint so the UI narrows which queries to refetch. The UI re-fetches its queries without a full page reload.",

package/corpus/templates/chat/changelog/2026-07-14-chat-opens-reliably-on-hosted-deployments-instead-of-failing.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-14
+---
+
+Chat opens reliably on hosted deployments instead of failing during startup

package/corpus/templates/clips/app/components/player/media-duration.ts

@@ -0,0 +1,24 @@
+const MEDIARECORDER_DURATION_DRIFT_MS = 3_000;
+
+function finitePositiveMs(value: number): number {
+  return Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
+}
+
+/**
+ * Prefer recorder metadata for normal MediaRecorder timeslice drift, but use
+ * the playable media's duration when the two values clearly describe
+ * different timelines (for example, metadata that accidentally counted a
+ * long pause).
+ */
+export function resolveMediaDurationMs(
+  recordedDurationMs: number,
+  mediaDurationSeconds: number,
+): number {
+  const recordedMs = finitePositiveMs(recordedDurationMs);
+  const mediaMs = finitePositiveMs(mediaDurationSeconds * 1000);
+  if (mediaMs === 0) return recordedMs;
+  if (recordedMs === 0) return mediaMs;
+  return Math.abs(recordedMs - mediaMs) > MEDIARECORDER_DURATION_DRIFT_MS
+    ? mediaMs
+    : recordedMs;
+}

package/corpus/templates/clips/app/components/player/video-player.tsx

@@ -19,6 +19,7 @@ import {
   useState,
 } from "react";
 
+import { resolveMediaDurationMs } from "@/components/player/media-duration";
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -824,22 +825,16 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
       durationProbedRef.current = false;
     }, [activeVideoSrc, durationMs]);
 
-    // The recorder's elapsed-time counter (durationMs prop) is the most
-    // trustworthy length we have. A MediaRecorder WebM's own duration is
-    // cluster-estimated and lands short by up to one timeslice, so we never
-    // let it overwrite a real prop — doing so makes the scrubber jump to a
-    // shorter length than the actual recording on first watch.
-    const hasReliableDurationProp =
-      Number.isFinite(durationMs) && durationMs > 0;
-
+    // Prefer the recorder's elapsed-time counter for ordinary WebM timeslice
+    // drift, but let clearly different playable-media metadata win. This also
+    // repairs playback controls for older clips whose stored duration counted
+    // time spent paused.
     const probeDurationIfNeeded = useCallback(
       (v: HTMLVideoElement) => {
         if (durationProbedRef.current) return;
         if (Number.isFinite(v.duration) && v.duration > 0) {
           durationProbedRef.current = true;
-          if (!hasReliableDurationProp) {
-            setResolvedDurationMs(Math.round(v.duration * 1000));
-          }
+          setResolvedDurationMs(resolveMediaDurationMs(durationMs, v.duration));
           return;
         }
         if (playAttemptPendingRef.current || !v.paused) return;
@@ -855,7 +850,7 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
           // picks up the real duration.
         }
       },
-      [hasReliableDurationProp],
+      [durationMs],
     );
 
     // Resolve the WebM-duration-is-Infinity Chrome quirk: when a video created
@@ -873,11 +868,7 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
 
       const onDurationChange = () => {
         if (Number.isFinite(v.duration) && v.duration > 0) {
-          // Don't downgrade a trustworthy recorder duration to the
-          // cluster-estimated WebM duration; only adopt it as a fallback.
-          if (!hasReliableDurationProp) {
-            setResolvedDurationMs(Math.round(v.duration * 1000));
-          }
+          setResolvedDurationMs(resolveMediaDurationMs(durationMs, v.duration));
           // After we've resolved the real duration, rewind back to 0 so the
           // user isn't sitting at the end of the clip.
           if (durationProbedRef.current && v.currentTime > v.duration) {
@@ -900,7 +891,7 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
         v.removeEventListener("loadedmetadata", onLoadedMetadata);
         v.removeEventListener("durationchange", onDurationChange);
       };
-    }, [activeVideoSrc, hasReliableDurationProp, probeDurationIfNeeded]);
+    }, [activeVideoSrc, durationMs, probeDurationIfNeeded]);
 
     // Reset the thumbnail-capture flag when the source changes (e.g. the
     // player is reused for a different recording via React Router).

package/corpus/templates/clips/changelog/2026-07-14-paused-time-no-longer-counts-toward-chrome-extension-recordi.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-14
+---
+
+Paused time no longer counts toward Chrome extension recording durations.

package/corpus/templates/clips/chrome-extension/src/offscreen.ts

@@ -36,6 +36,13 @@ import {
 import { MAX_UPLOAD_BYTES } from "@shared/upload-limits";
 
 import { waitForReadyRecordingAfterFinalizeError } from "./finalize-recovery";
+import {
+  createRecordingDurationState,
+  pauseRecordingDuration,
+  resumeRecordingDuration,
+  startRecordingDuration,
+  type RecordingDurationState,
+} from "./recording-duration";
 import { captureExtensionError, initExtensionSentry } from "./sentry";
 
 initExtensionSentry("offscreen");
@@ -187,6 +194,7 @@ type ActiveRecording = {
   authToken: string | null;
   mode: CaptureMode;
   startedAtMs: number;
+  duration: RecordingDurationState;
   mimeType: string;
   recorder: MediaRecorder;
   outputStream: MediaStream;
@@ -1218,6 +1226,7 @@ async function begin(message: BeginMessage): Promise<{
     authToken: message.authToken ?? null,
     mode: ready.mode,
     startedAtMs: 0,
+    duration: createRecordingDurationState(),
     mimeType,
     recorder,
     outputStream,
@@ -1350,6 +1359,7 @@ function startRecorderNow(recording: ActiveRecording): void {
     playStartChime();
     recording.recorder.start(2000);
     recording.startedAtMs = Date.now();
+    recording.duration = startRecordingDuration(recording.startedAtMs);
     console.log("[clips-offscreen] recorder.start ok");
     reportStatus(recording.sessionId, "recording", {
       recordingId: recording.recordingId,
@@ -1446,6 +1456,11 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
     recording.resolveStopped({ ok: true, status: "cancelled" });
     return;
   }
+  // Freeze the media duration as soon as MediaRecorder stops. Waiting for
+  // outstanding uploads below must not make the clip appear longer, and time
+  // spent paused is excluded by pauseRecordingDuration().
+  recording.duration = pauseRecordingDuration(recording.duration, Date.now());
+  const durationMs = recording.duration.elapsedMs;
   reportStatus(recording.sessionId, "uploading", {
     recordingId: recording.recordingId,
   });
@@ -1460,7 +1475,6 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
         ? rejected.reason
         : new Error(String(rejected.reason));
     }
-    const durationMs = Math.max(0, Date.now() - recording.startedAtMs);
     // Surface WHY a finalize might fail before the server's cryptic "No chunks
     // found": 0 chunks means the recorder emitted no non-empty data (empty
     // capture / never started), which is a different problem than an auth 401.
@@ -1549,7 +1563,7 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
         recordingId: recording.recordingId,
         chunkCount: recording.chunkIndex,
         mimeType: recording.mimeType,
-        durationMs: Math.max(0, Date.now() - recording.startedAtMs),
+        durationMs,
       },
     });
     // The upload failed — save the buffered recording to disk so it isn't lost.
@@ -1574,7 +1588,13 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
 function pause(message: SimpleMessage): { ok: boolean } {
   const recording = activeRecording;
   if (recording && recording.sessionId === message.sessionId) {
-    if (recording.recorder.state === "recording") recording.recorder.pause();
+    if (recording.recorder.state === "recording") {
+      recording.recorder.pause();
+      recording.duration = pauseRecordingDuration(
+        recording.duration,
+        Date.now(),
+      );
+    }
     reportStatus(recording.sessionId, "paused", {
       recordingId: recording.recordingId,
     });
@@ -1585,7 +1605,13 @@ function pause(message: SimpleMessage): { ok: boolean } {
 function resume(message: SimpleMessage): { ok: boolean } {
   const recording = activeRecording;
   if (recording && recording.sessionId === message.sessionId) {
-    if (recording.recorder.state === "paused") recording.recorder.resume();
+    if (recording.recorder.state === "paused") {
+      recording.recorder.resume();
+      recording.duration = resumeRecordingDuration(
+        recording.duration,
+        Date.now(),
+      );
+    }
     reportStatus(recording.sessionId, "recording", {
       recordingId: recording.recordingId,
     });

package/corpus/templates/clips/chrome-extension/src/recording-duration.ts

@@ -0,0 +1,32 @@
+export type RecordingDurationState = {
+  elapsedMs: number;
+  activeSinceMs: number | null;
+};
+
+export function createRecordingDurationState(): RecordingDurationState {
+  return { elapsedMs: 0, activeSinceMs: null };
+}
+
+export function startRecordingDuration(nowMs: number): RecordingDurationState {
+  return { elapsedMs: 0, activeSinceMs: nowMs };
+}
+
+export function pauseRecordingDuration(
+  state: RecordingDurationState,
+  nowMs: number,
+): RecordingDurationState {
+  if (state.activeSinceMs === null) return state;
+  return {
+    elapsedMs:
+      state.elapsedMs + Math.max(0, Math.round(nowMs - state.activeSinceMs)),
+    activeSinceMs: null,
+  };
+}
+
+export function resumeRecordingDuration(
+  state: RecordingDurationState,
+  nowMs: number,
+): RecordingDurationState {
+  if (state.activeSinceMs !== null) return state;
+  return { ...state, activeSinceMs: nowMs };
+}

package/corpus/templates/slides/actions/_uploaded-files.ts

@@ -4,11 +4,19 @@ import path from "path";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 
 import { tenantUploadDir } from "../server/lib/tenant-files.js";
+import { readUploadedReferenceBlob } from "../server/lib/uploaded-reference-storage.js";
 
-export function resolveUserUploadedFile(filePath: string): string {
+export async function readUserUploadedFile(
+  filePath: string,
+): Promise<{ data: Buffer; filename: string }> {
   const email = getRequestUserEmail();
   if (!email) throw new Error("no authenticated user");
 
+  const privateUpload = await readUploadedReferenceBlob(filePath, email);
+  if (privateUpload) {
+    return privateUpload;
+  }
+
   const allowedDir = tenantUploadDir(email);
   const absPath = path.isAbsolute(filePath)
     ? filePath
@@ -23,5 +31,8 @@ export function resolveUserUploadedFile(filePath: string): string {
   if (!fs.existsSync(resolved)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  return resolved;
+  return {
+    data: await fs.promises.readFile(resolved),
+    filename: path.basename(resolved),
+  };
 }

package/corpus/templates/slides/actions/import-docx.ts

@@ -1,11 +1,9 @@
-import fs from "fs";
-
 import { defineAction } from "@agent-native/core";
 import { z } from "zod";
 
 import { parseDocx } from "../server/handlers/import/docx-parser.js";
 import { convertSectionsToSlides } from "../server/handlers/import/html-converter.js";
-import { resolveUserUploadedFile } from "./_uploaded-files.js";
+import { readUserUploadedFile } from "./_uploaded-files.js";
 
 export default defineAction({
   description:
@@ -16,9 +14,7 @@ export default defineAction({
   schema: z.object({
     filePath: z
       .string()
-      .describe(
-        "Server path to the uploaded DOCX file (e.g. data/uploads/document.docx)",
-      ),
+      .describe("Uploaded DOCX path or opaque hosted upload reference"),
     convertToSlides: z
       .boolean()
       .optional()
@@ -28,9 +24,7 @@ export default defineAction({
       ),
   }),
   run: async ({ filePath, convertToSlides }) => {
-    const absPath = resolveUserUploadedFile(filePath);
-
-    const fileBuffer = await fs.promises.readFile(absPath);
+    const { data: fileBuffer } = await readUserUploadedFile(filePath);
     const doc = await parseDocx(fileBuffer);
 
     const result: Record<string, unknown> = {

package/corpus/templates/slides/actions/import-file.ts

@@ -1,4 +1,3 @@
-import fs from "fs";
 import path from "path";
 
 import { defineAction } from "@agent-native/core";
@@ -15,7 +14,7 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { notifyClients } from "../server/handlers/decks.js";
 import { upsertBuilderProxyDesignSystem } from "../server/lib/builder-design-system-proxy.js";
-import { resolveUserUploadedFile } from "./_uploaded-files.js";
+import { readUserUploadedFile } from "./_uploaded-files.js";
 
 const DEFAULT_MAX_SOURCE_CHARS = 60_000;
 
@@ -30,9 +29,7 @@ export default defineAction({
   schema: z.object({
     filePath: z
       .string()
-      .describe(
-        "Server path to the uploaded file (e.g. data/uploads/file.pptx)",
-      ),
+      .describe("Uploaded file path or opaque hosted upload reference"),
     format: z
       .enum(["pptx", "docx", "pdf", "fig", "auto"])
       .optional()
@@ -60,15 +57,15 @@ export default defineAction({
       ),
   }),
   run: async ({ filePath, format, deckId, importIntoDeck, maxChars }) => {
-    const absPath = resolveUserUploadedFile(filePath);
+    const uploaded = await readUserUploadedFile(filePath);
     const sourceLimit = maxChars ?? DEFAULT_MAX_SOURCE_CHARS;
-
-    const fileBuffer = await fs.promises.readFile(absPath);
+    const fileBuffer = uploaded.data;
+    const filename = uploaded.filename;
 
     // Detect format from extension if auto
     let detectedFormat = format;
     if (detectedFormat === "auto") {
-      const ext = path.extname(absPath).toLowerCase();
+      const ext = path.extname(filename).toLowerCase();
       if (ext === ".pptx") detectedFormat = "pptx";
       else if (ext === ".docx") detectedFormat = "docx";
       else if (ext === ".pdf") detectedFormat = "pdf";
@@ -86,12 +83,12 @@ export default defineAction({
           "Figma .fig imports start Builder design-system indexing, not slide replacements. Re-run without importIntoDeck.",
         );
       }
-      const title = titleFromPath(absPath);
+      const title = titleFromPath(filename);
       const result = await startBuilderDesignSystemIndex({
         projectName: title,
         files: [
           {
-            name: path.basename(absPath),
+            name: path.basename(filename),
             data: fileBuffer,
             mimeType: "application/octet-stream",
           },
@@ -126,7 +123,7 @@ export default defineAction({
       const { convertToSlideHtml } =
         await import("../server/handlers/import/html-converter.js");
       const presentation = await parsePptx(fileBuffer);
-      const title = presentation.title || titleFromPath(absPath);
+      const title = presentation.title || titleFromPath(filename);
 
       if (importIntoDeck) {
         if (!deckId) throw new Error("deckId is required to import into deck");
@@ -172,7 +169,7 @@ export default defineAction({
         await import("../server/handlers/import/html-converter.js");
       const doc = await parseDocx(fileBuffer);
       const slideHtmlArray = convertSectionsToSlides(doc.sections);
-      const title = doc.title || titleFromPath(absPath);
+      const title = doc.title || titleFromPath(filename);
 
       if (importIntoDeck) {
         if (!deckId) throw new Error("deckId is required to import into deck");
@@ -221,7 +218,7 @@ export default defineAction({
       const result = await pdf.getText();
       const pages = normalizePdfPages(result);
       const textPages = pages.filter((p) => p.text.trim());
-      const title = titleFromPath(absPath);
+      const title = titleFromPath(filename);
 
       if (textPages.length === 0) {
         throw new Error(

package/corpus/templates/slides/actions/import-pptx.ts

@@ -1,5 +1,3 @@
-import fs from "fs";
-
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import {
@@ -15,7 +13,7 @@ import { notifyClients } from "../server/handlers/decks.js";
 import { convertToSlideHtml } from "../server/handlers/import/html-converter.js";
 import { parsePptx } from "../server/handlers/import/pptx-parser.js";
 import { getDeckUrl } from "./_app-url.js";
-import { resolveUserUploadedFile } from "./_uploaded-files.js";
+import { readUserUploadedFile } from "./_uploaded-files.js";
 
 export default defineAction({
   description:
@@ -26,9 +24,7 @@ export default defineAction({
   schema: z.object({
     filePath: z
       .string()
-      .describe(
-        "Server path to the uploaded PPTX file (e.g. data/uploads/presentation.pptx)",
-      ),
+      .describe("Uploaded PPTX path or opaque hosted upload reference"),
     deckId: z
       .string()
       .optional()
@@ -43,9 +39,7 @@ export default defineAction({
       ),
   }),
   run: async ({ filePath, deckId, title }) => {
-    const absPath = resolveUserUploadedFile(filePath);
-
-    const fileBuffer = await fs.promises.readFile(absPath);
+    const { data: fileBuffer } = await readUserUploadedFile(filePath);
     const presentation = await parsePptx(fileBuffer);
 
     const deckTitle = title || presentation.title || "Imported Presentation";

package/corpus/templates/slides/changelog/2026-07-14-powerpoint-template-uploads-now-work-in-hosted-slides-deploy.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-14
+---
+
+PowerPoint template uploads now work in hosted Slides deployments.

package/corpus/templates/slides/server/handlers/uploads.ts

@@ -1,7 +1,6 @@
 import fs from "fs";
 import path from "path";
 
-import { getSession } from "@agent-native/core/server";
 import {
   defineEventHandler,
   setResponseStatus,
@@ -14,7 +13,15 @@ import {
   isSlidesReferenceFileExtension,
 } from "../../shared/upload-types";
 import { tenantUploadDir } from "../lib/tenant-files.js";
+import {
+  isHostedSlidesRuntime,
+  storeUploadedReferenceBlob,
+} from "../lib/uploaded-reference-storage.js";
 import { canSaveAsUploadedAsset, uploadImageAsset } from "./assets.js";
+import {
+  resolveSlidesRequestAuthContext,
+  withSlidesRequestContext,
+} from "./request-auth-context.js";
 
 export const MAX_REFERENCE_FILE_BYTES = 50 * 1024 * 1024;
 export const MAX_FIG_REFERENCE_FILE_BYTES = 200 * 1024 * 1024;
@@ -113,6 +120,7 @@ function pathForAgent(absPath: string): string {
 
 export async function saveUploadedReferenceFile(args: {
   email: string;
+  orgId?: string | null;
   originalName: string;
   data: Uint8Array;
   type?: string;
@@ -127,14 +135,43 @@ export async function saveUploadedReferenceFile(args: {
   if (!hasExpectedSignature(ext, args.data)) {
     throw new Error(`File contents do not match ${ext} upload type`);
   }
-  const uploadDir = tenantUploadDir(args.email);
-  await fs.promises.mkdir(uploadDir, { recursive: true });
-  const destPath = path.join(uploadDir, filename);
-  await fs.promises.writeFile(destPath, args.data);
-  // For images, also push to the file-upload provider so the agent can embed
-  // a hosted URL (in slide HTML, chat replies, etc.). For non-image reference
-  // files (PPTX, DOCX, PDF), the on-disk path is what the agent uses via
-  // shell — no provider URL is required.
+  let uploadedPath: string;
+  if (isHostedSlidesRuntime()) {
+    let reference: string | null;
+    try {
+      reference = await storeUploadedReferenceBlob({
+        email: args.email,
+        orgId: args.orgId,
+        data: args.data,
+        filename,
+        mimeType: args.type || "application/octet-stream",
+      });
+    } catch {
+      throw Object.assign(
+        new Error("Private file storage failed while saving the upload."),
+        { statusCode: 503 },
+      );
+    }
+    if (!reference) {
+      throw Object.assign(
+        new Error(
+          "Private file storage is not configured. Connect Builder.io or another file provider before uploading reference files in a hosted Slides deployment.",
+        ),
+        { statusCode: 503 },
+      );
+    }
+    uploadedPath = reference;
+  } else {
+    const uploadDir = tenantUploadDir(args.email);
+    await fs.promises.mkdir(uploadDir, { recursive: true });
+    const destPath = path.join(uploadDir, filename);
+    await fs.promises.writeFile(destPath, args.data);
+    uploadedPath = pathForAgent(destPath);
+  }
+  // For images, also push to the public file-upload provider so the agent can
+  // embed a hosted URL (in slide HTML, chat replies, etc.). The `path` above
+  // remains the private import source: a tenant path locally and an encrypted,
+  // owner-scoped blob reference in hosted deployments.
   let url: string | undefined;
   if (
     canSaveAsUploadedAsset({
@@ -159,7 +196,7 @@ export async function saveUploadedReferenceFile(args: {
     }
   }
   return {
-    path: pathForAgent(destPath),
+    path: uploadedPath,
     url,
     originalName: args.originalName,
     filename,
@@ -170,54 +207,67 @@ export async function saveUploadedReferenceFile(args: {
 
 // Upload one or more files
 export const uploadFiles = defineEventHandler(async (event) => {
-  const session = await getSession(event).catch(() => null);
-  if (!session?.email) {
+  const authContext = await resolveSlidesRequestAuthContext(event);
+  const email = authContext.email;
+  if (!email) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };
   }
 
-  const parts = await readMultipartFormData(event);
-  const fileParts =
-    parts?.filter((p) => (p.name === "files" || p.name === "file") && p.data) ??
-    [];
+  return withSlidesRequestContext(
+    event,
+    async ({ orgId }) => {
+      const parts = await readMultipartFormData(event);
+      const fileParts =
+        parts?.filter(
+          (p) => (p.name === "files" || p.name === "file") && p.data,
+        ) ?? [];
 
-  if (fileParts.length === 0) {
-    setResponseStatus(event, 400);
-    return { error: "No files uploaded" };
-  }
+      if (fileParts.length === 0) {
+        setResponseStatus(event, 400);
+        return { error: "No files uploaded" };
+      }
 
-  const MAX_FILES = 20;
+      const MAX_FILES = 20;
 
-  if (fileParts.length > MAX_FILES) {
-    setResponseStatus(event, 413);
-    return { error: `Too many files (max ${MAX_FILES})` };
-  }
+      if (fileParts.length > MAX_FILES) {
+        setResponseStatus(event, 413);
+        return { error: `Too many files (max ${MAX_FILES})` };
+      }
 
-  const oversized = fileParts.find(
-    (p) => p.data.length > maxReferenceFileBytes(p.filename),
-  );
-  if (oversized) {
-    const limit = maxReferenceFileBytes(oversized.filename);
-    setResponseStatus(event, 413);
-    return { error: `File too large (max ${formatMaxFileSize(limit)})` };
-  }
+      const oversized = fileParts.find(
+        (p) => p.data.length > maxReferenceFileBytes(p.filename),
+      );
+      if (oversized) {
+        const limit = maxReferenceFileBytes(oversized.filename);
+        setResponseStatus(event, 413);
+        return { error: `File too large (max ${formatMaxFileSize(limit)})` };
+      }
 
-  let results;
-  try {
-    results = await Promise.all(
-      fileParts.map(async (part) => {
-        return saveUploadedReferenceFile({
-          email: session.email,
-          originalName: part.filename || "upload",
-          data: part.data,
-          type: part.type,
-        });
-      }),
-    );
-  } catch (err) {
-    setResponseStatus(event, 400);
-    return { error: err instanceof Error ? err.message : "Invalid upload" };
-  }
+      let results;
+      try {
+        results = await Promise.all(
+          fileParts.map(async (part) => {
+            return saveUploadedReferenceFile({
+              email,
+              orgId,
+              originalName: part.filename || "upload",
+              data: part.data,
+              type: part.type,
+            });
+          }),
+        );
+      } catch (err) {
+        const statusCode =
+          typeof (err as { statusCode?: unknown })?.statusCode === "number"
+            ? (err as { statusCode: number }).statusCode
+            : 400;
+        setResponseStatus(event, statusCode);
+        return { error: err instanceof Error ? err.message : "Invalid upload" };
+      }
 
-  return results;
+      return results;
+    },
+    authContext,
+  );
 });