@tangle-network/agent-app 0.60.194 → 0.60.196

package/dist/assistant/index.js

@@ -9,7 +9,7 @@ import "../chunk-Y6PRDUFJ.js";
 import "../chunk-GEYACSFW.js";
 import {
   ChatComposer
-} from "../chunk-6RFNLZCK.js";
+} from "../chunk-2XUIWCRW.js";
 import "../chunk-L7MB2LLM.js";
 import "../chunk-GNBBY3KN.js";
 import "../chunk-A2GG4D4A.js";
@@ -28,7 +28,7 @@ import {
 } from "../chunk-AVP5SNIG.js";
 import "../chunk-RASGKEAL.js";
 import "../chunk-FQYAJYPW.js";
-import "../chunk-PBQYVAB6.js";
+import "../chunk-2ZRXJ3NO.js";
 import "../chunk-VBRUG4N5.js";
 import "../chunk-B7CL7ENS.js";
 import "../chunk-PV33JZKV.js";

package/dist/chat-react/index.js

@@ -1,14 +1,14 @@
 import {
   ComposerModeControls,
   EntryComposer
-} from "../chunk-6RFNLZCK.js";
+} from "../chunk-2XUIWCRW.js";
 import "../chunk-L7MB2LLM.js";
 import "../chunk-SJWIZT7B.js";
 import "../chunk-5IS3GCMR.js";
 import "../chunk-HEPEGY6Q.js";
 import "../chunk-XG6FODYO.js";
 import "../chunk-RASGKEAL.js";
-import "../chunk-PBQYVAB6.js";
+import "../chunk-2ZRXJ3NO.js";
 import "../chunk-VBRUG4N5.js";
 import "../chunk-AMUXRAUO.js";
 import "../chunk-YHRWZZJN.js";

package/dist/chat-routes/attachment-store.d.ts

@@ -98,6 +98,24 @@ export interface AttachmentWriteOptions {
  * {@link createAtomicAttachmentWriter} for ownership-safe writes.
  */
 export type WriteAttachmentFn = (scopeId: string, path: string, content: Uint8Array | string, opts: AttachmentWriteOptions) => Promise<AttachmentWriteResult>;
+/** Options for a streamed write. `size` is the exact byte count `content`
+ *  yields. `mediaType` is decided from the file name and its first bytes,
+ *  before the route has read the rest: an archive's central directory sits at
+ *  its end, so the route's response, not this value, carries the final type. */
+export interface AttachmentStreamWriteOptions extends AttachmentWriteOptions {
+    size: number;
+    mediaType: string;
+}
+/**
+ * Streamed writer port for an upload too large to hold in memory. `content`
+ * yields exactly `opts.size` bytes. The route checks the file while it
+ * streams and withholds the final bytes until the whole file has passed, so
+ * on a refusal `content` errors instead of ending. The adapter must make the
+ * bytes readable at `path` only when `content` ends cleanly, and must leave
+ * whatever was stored at `path` before untouched when it errors. A store put
+ * of a fixed-length stream (R2 `put` behind `FixedLengthStream`) does both.
+ */
+export type WriteAttachmentStreamFn = (scopeId: string, path: string, content: ReadableStream<Uint8Array>, opts: AttachmentStreamWriteOptions) => Promise<AttachmentWriteResult>;
 /** Options for an ownership-safe writer. */
 export interface AtomicAttachmentWriteOptions extends AttachmentWriteOptions {
     ownership: AttachmentWriteOwnership;

package/dist/chat-routes/attachment-upload.d.ts

@@ -14,6 +14,12 @@
  * never invents a 401 or 429 response, it only returns `auth.response`
  * verbatim on failure.
  *
+ * Two body shapes: a `multipart/form-data` batch, parsed whole, and one raw
+ * file body named by the `filename` query parameter. A raw body larger than
+ * the sniff head streams to `writeAttachmentStream` when the product supplies
+ * one: the Worker never holds the file whole, which is what lets a product
+ * admit data files of tens of MB inside a 128 MB isolate.
+ *
  * Lifted from gtm-agent's `src/routes/api.vault.upload.ts` (the hardening
  * lineage other lifted modules in this vertical cite: gtm#584 binary
  * corruption, gtm#592 sniff gate/caps, gtm#593 batch-atomic writes) and
@@ -27,14 +33,15 @@
  * vs. inline-`data:`-or-ephemeral-sandbox-workspace). See that module's doc
  * comment for the up-to-date framing between the two.
  */
-import type { ChatAttachmentKind } from './wire';
-import { type AtomicAttachmentWriter, type WriteAttachmentFn } from './attachment-store';
+import { type ChatAttachmentKind } from './wire';
+import { type AtomicAttachmentWriter, type WriteAttachmentFn, type WriteAttachmentStreamFn } from './attachment-store';
 import { type AttachmentPathCheck } from './attachment-validation';
 /** Stable authorization result for the original writer contract. */
 export type AttachmentUploadAuthorization = {
     ok: true;
     scopeId: string;
     writeAttachment?: WriteAttachmentFn;
+    writeAttachmentStream?: WriteAttachmentStreamFn;
 } | {
     ok: false;
     response: Response;
@@ -64,6 +71,12 @@ interface AttachmentUploadRouteCommonOptions {
         maxTextBytes?: number;
         /** Aggregate raw-byte ceiling. Default {@link MAX_ATTACHMENT_TOTAL_BYTES}. */
         maxTotalBytes?: number;
+        /** Largest `multipart/form-data` body this route parses. A form body is
+         *  held whole while it parses, at about three copies at peak, so a
+         *  product that admits files too large for that sets this and takes them
+         *  as raw bodies (see {@link createAttachmentUploadRoute}). Default: no
+         *  limit beyond the per-file and aggregate caps. */
+        maxFormBytes?: number;
     };
     /** Attachment kinds this route accepts. Default `['image', 'file']`. */
     allowedKinds?: ChatAttachmentKind[];
@@ -89,6 +102,11 @@ export interface CreateLegacyAttachmentUploadRouteOptions extends AttachmentUplo
     }): Promise<AttachmentUploadAuthorization>;
     /** Stable writer. `authorize` may override it per-request. */
     writeAttachment: WriteAttachmentFn;
+    /** Writer for a raw-body upload larger than {@link STREAM_SNIFF_HEAD_BYTES}:
+     *  the route checks the file while it streams to this writer, so the file
+     *  is never held whole. Without it, a raw body is read whole and goes
+     *  through `writeAttachment` under the same caps. */
+    writeAttachmentStream?: WriteAttachmentStreamFn;
 }
 /**
  * The original public route-options interface remains available for consumers

package/dist/chat-routes/attachment-validation.d.ts

@@ -58,6 +58,9 @@ export declare const MACRO_ENABLED_OOXML_SNIFFED_MIMES: ReadonlySet<string>;
  *  upload of that format fails the type gate — locked by the round-trip test
  *  that sniffs real bytes of every mime listed here. */
 export declare const ALLOWED_ATTACHMENT_SNIFFED_MIMES: ReadonlySet<string>;
+/** The sniffed mime a filename's extension implies, when its format has an
+ *  unambiguous magic-byte family (`.xlsx` → the spreadsheet mime). */
+export declare function sniffedMimeImpliedByName(fileName: string): string | undefined;
 /** Represent the result of checking an attachment's type with success or specific failure details */
 export type AttachmentTypeCheckResult = {
     succeeded: true;

package/dist/chat-routes/binary-sniff.d.ts

@@ -43,3 +43,31 @@ export declare const OOXML_PRESENTATION_MACRO_ENABLED_MIME = "application/vnd.ms
  *  nothing and does not decode as text is binary with an unknown mime —
  *  extension-based guessing happens at the call site, not here. */
 export declare function sniffBinary(bytes: Uint8Array): SniffResult;
+/** Leading bytes a streamed classification keeps. Every magic-byte family
+ *  except PKZIP is decided within them (the EBML header scan reads 4 KiB),
+ *  and a file no longer than this is classified exactly as
+ *  {@link sniffBinary} classifies it. */
+export declare const STREAM_SNIFF_HEAD_BYTES: number;
+/** Trailing bytes a streamed classification keeps for the zip reader. The
+ *  end-of-central-directory record sits within 64 KiB + 22 bytes of the end,
+ *  and an Office package's central directory is a few KB. An archive whose
+ *  directory starts earlier than this window is reported as a plain zip. */
+export declare const STREAM_SNIFF_TAIL_BYTES: number;
+/** Classifies a file from its bytes as they stream past, holding at most
+ *  {@link STREAM_SNIFF_HEAD_BYTES} + {@link STREAM_SNIFF_TAIL_BYTES} of it. */
+export interface StreamingSniffer {
+    /** Feed the next bytes in order. The sniffer keeps references to recent
+     *  chunks, so a caller must not reuse a chunk's buffer afterwards. */
+    push(chunk: Uint8Array): void;
+    /** Bytes pushed so far. */
+    readonly size: number;
+    /** The start of the file, up to {@link STREAM_SNIFF_HEAD_BYTES}. */
+    head(): Uint8Array;
+    /** Classify everything pushed. The answer is {@link sniffBinary}'s over the
+     *  whole file, except that a zip whose central directory lies outside the
+     *  tail window reads as `application/zip`, and the SVG check sees only the
+     *  head. Text validity (NUL bytes, UTF-8) is checked over every byte. */
+    finish(): SniffResult;
+}
+/** Start a {@link StreamingSniffer} for one file. */
+export declare function createStreamingSniffer(): StreamingSniffer;

package/dist/chat-routes/index.js

@@ -19,14 +19,18 @@ import {
   OOXML_SPREADSHEET_MIME,
   OOXML_WORD_MACRO_ENABLED_MIME,
   OOXML_WORD_MIME,
+  STREAM_SNIFF_HEAD_BYTES,
+  STREAM_SNIFF_TAIL_BYTES,
   attachmentSizeErrorMessage,
   attachmentTotalSizeErrorMessage,
   checkAttachmentType,
+  createStreamingSniffer,
   defaultValidateAttachmentPath,
   parseChatAttachmentInputs,
   sanitizeAttachmentFileName,
-  sniffBinary
-} from "../chunk-PBQYVAB6.js";
+  sniffBinary,
+  sniffedMimeImpliedByName
+} from "../chunk-2ZRXJ3NO.js";
 import {
   DEFAULT_STALE_TURN_LOCK_GRACE_MS,
   DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS,
@@ -2880,6 +2884,94 @@ function atomicAttachmentFailure(path, cleanupFailures = 0) {
     path
   );
 }
+var MAX_RAW_FILENAME_LENGTH = 255;
+function rawUploadTarget(request) {
+  const filename = new URL(request.url).searchParams.get("filename");
+  if (!filename || filename.length > MAX_RAW_FILENAME_LENGTH) {
+    return {
+      succeeded: false,
+      response: attachmentUploadError(
+        400,
+        "invalid_upload",
+        "Expected a multipart/form-data body with file fields, or one raw file body named by the filename query parameter"
+      )
+    };
+  }
+  const uploadLength = request.headers.get("X-Upload-Length");
+  const transportLength = request.headers.get("Content-Length");
+  if (uploadLength !== null && transportLength !== null && uploadLength !== transportLength) {
+    return { succeeded: false, response: attachmentUploadError(400, "invalid_length", "Conflicting upload lengths") };
+  }
+  const declared = uploadLength ?? transportLength;
+  if (declared === null) {
+    return {
+      succeeded: false,
+      response: attachmentUploadError(411, "length_required", "A raw upload declares its size in Content-Length or X-Upload-Length")
+    };
+  }
+  const declaredBytes = Number(declared);
+  if (!/^(0|[1-9]\d*)$/.test(declared) || !Number.isSafeInteger(declaredBytes)) {
+    return { succeeded: false, response: attachmentUploadError(400, "invalid_length", "Invalid upload length") };
+  }
+  return { succeeded: true, filename, declaredBytes };
+}
+var LENGTH_MISMATCH_MESSAGE = "Upload length does not match the file body";
+async function readRawBody(request, declaredBytes) {
+  const mismatch = { succeeded: false, response: attachmentUploadError(400, "invalid_length", LENGTH_MISMATCH_MESSAGE) };
+  const bytes = new Uint8Array(declaredBytes);
+  if (!request.body) return declaredBytes === 0 ? { succeeded: true, value: bytes } : mismatch;
+  const reader = request.body.getReader();
+  let offset = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (offset + value.length > declaredBytes) {
+        await reader.cancel().catch(() => void 0);
+        return mismatch;
+      }
+      bytes.set(value, offset);
+      offset += value.length;
+    }
+  } catch {
+    return { succeeded: false, response: attachmentUploadError(400, "invalid_upload", "The upload body ended early") };
+  }
+  return offset === declaredBytes ? { succeeded: true, value: bytes } : mismatch;
+}
+async function readBodyUpTo(request, maxBytes) {
+  const declared = Number(request.headers.get("Content-Length") ?? Number.NaN);
+  if (Number.isFinite(declared) && declared > maxBytes) return { succeeded: false, tooLarge: true };
+  if (!request.body) return { succeeded: true, value: new Uint8Array(0) };
+  const reader = request.body.getReader();
+  const chunks = [];
+  let length = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.length;
+      if (length > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        return { succeeded: false, tooLarge: true };
+      }
+      chunks.push(value);
+    }
+  } catch {
+    return { succeeded: false, tooLarge: false };
+  }
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return { succeeded: true, value: bytes };
+}
+function provisionalMediaType(name, head, sniffMime) {
+  if (!head.binary) return sniffMime(name);
+  if (head.mime === "application/zip") return sniffedMimeImpliedByName(name) ?? head.mime;
+  return head.mime ?? "application/octet-stream";
+}
 async function rollbackSuccessfulWrites(writes, scopeId, writer, logger) {
   let failures = 0;
   for (let index = writes.length - 1; index >= 0; index -= 1) {
@@ -2933,6 +3025,138 @@ function createAttachmentUploadRoute(options) {
     return crypto.randomUUID();
   }) : void 0;
   const logger = options.logger ?? console;
+  const maxFormBytes = options.limits?.maxFormBytes;
+  const streamWriter = atomic ? void 0 : options.writeAttachmentStream;
+  const limitFor = (sniff) => {
+    if (!sniff.binary) return maxTextBytes;
+    return sniff.mime === null ? maxBinaryBytes : maxBytesBySniffedMime?.get(sniff.mime) ?? maxBinaryBytes;
+  };
+  const largestFileBytes = Math.max(maxTextBytes, maxBinaryBytes, ...maxBytesBySniffedMime?.values() ?? []);
+  async function streamRawUpload(input) {
+    const { request, declaredBytes, name, path } = input;
+    if (!request.body) return attachmentUploadError(400, "invalid_length", LENGTH_MISMATCH_MESSAGE);
+    const reader = request.body.getReader();
+    const sniffer = createStreamingSniffer();
+    const head = [];
+    let refusal;
+    const tooLong = () => attachmentUploadError(400, "invalid_length", LENGTH_MISMATCH_MESSAGE);
+    try {
+      while (sniffer.size < STREAM_SNIFF_HEAD_BYTES) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (sniffer.size + value.length > declaredBytes) {
+          await reader.cancel().catch(() => void 0);
+          return tooLong();
+        }
+        sniffer.push(value);
+        head.push(value);
+      }
+    } catch {
+      return attachmentUploadError(400, "invalid_upload", "The upload body ended early");
+    }
+    const mediaTypeBeforeEnd = provisionalMediaType(name, sniffBinary(sniffer.head()), sniffMime);
+    let held = head.pop();
+    let finalSniff;
+    const refuse = (controller, response) => {
+      refusal = response;
+      controller.error(new Error("attachment upload refused"));
+    };
+    const content = new ReadableStream({
+      start(controller) {
+        for (const chunk of head) controller.enqueue(chunk);
+      },
+      async pull(controller) {
+        let next;
+        try {
+          next = await reader.read();
+        } catch {
+          refuse(controller, attachmentUploadError(400, "invalid_upload", "The upload body ended early"));
+          return;
+        }
+        if (!next.done) {
+          if (sniffer.size + next.value.length > declaredBytes) {
+            await reader.cancel().catch(() => void 0);
+            refuse(controller, tooLong());
+            return;
+          }
+          sniffer.push(next.value);
+          if (held) controller.enqueue(held);
+          held = next.value;
+          return;
+        }
+        if (sniffer.size !== declaredBytes) {
+          refuse(controller, tooLong());
+          return;
+        }
+        const sniff2 = sniffer.finish();
+        const typeCheck = checkAttachmentType(name, sniff2, allowedSniffedMimes);
+        if (!typeCheck.succeeded) {
+          refuse(controller, attachmentUploadError(
+            typeCheck.code === "attachment_type_mismatch" ? 400 : 415,
+            typeCheck.code,
+            typeCheck.message
+          ));
+          return;
+        }
+        const kind = attachmentKindForMime(sniff2.mime ?? "");
+        if (!allowedKinds.includes(kind)) {
+          refuse(controller, attachmentUploadError(
+            415,
+            "attachment_kind_not_allowed",
+            `${name} is a "${kind}" attachment, which this upload route does not accept`
+          ));
+          return;
+        }
+        const limit = limitFor(sniff2);
+        if (declaredBytes > limit) {
+          refuse(controller, attachmentUploadError(413, "attachment_too_large", attachmentSizeErrorMessage(name, declaredBytes, limit)));
+          return;
+        }
+        finalSniff = sniff2;
+        if (held) controller.enqueue(held);
+        held = void 0;
+        controller.close();
+      },
+      cancel(reason) {
+        return reader.cancel(reason).catch(() => void 0);
+      }
+    }, { highWaterMark: 0 });
+    let written;
+    try {
+      written = await input.writer(input.scopeId, path, content, {
+        mediaType: mediaTypeBeforeEnd,
+        name,
+        originalName: input.filename,
+        size: declaredBytes
+      });
+    } catch (error) {
+      if (!finalSniff) await reader.cancel().catch(() => void 0);
+      if (refusal) return refusal;
+      logAttachmentUploadError(logger, "[attachment-upload] stream writer failed", { path, error: redactErrorMessage(error) });
+      return attachmentUploadError(503, "attachment_store_unavailable", ATTACHMENT_STORAGE_FAILURE_MESSAGE, path);
+    }
+    if (!finalSniff) await reader.cancel().catch(() => void 0);
+    if (refusal) return refusal;
+    const result = inspectLegacyAttachmentWriteResult(written);
+    if (!result || result.ok && !finalSniff) {
+      logAttachmentUploadError(logger, "[attachment-upload] stream writer returned without a checked file", { path });
+      return attachmentUploadError(503, "attachment_store_unavailable", ATTACHMENT_STORAGE_FAILURE_MESSAGE, path);
+    }
+    if (!result.ok) {
+      const reason = redactErrorMessage(result.reason);
+      logAttachmentUploadError(logger, "[attachment-upload] stream write rejected", { path, error: reason });
+      return attachmentUploadError(413, "attachment_write_failed", reason, path);
+    }
+    const sniff = finalSniff;
+    const uploaded = {
+      path,
+      name,
+      size: declaredBytes,
+      mediaType: sniff.mime ?? sniffMime(name),
+      kind: attachmentKindForMime(sniff.mime ?? "")
+    };
+    return Response.json({ files: [uploaded] });
+  }
   return async function attachmentUpload(request) {
     const auth = await options.authorize({ request });
     if (!auth.ok) return auth.response;
@@ -2941,16 +3165,55 @@ function createAttachmentUploadRoute(options) {
     if (atomic && !atomicWriter) {
       return attachmentUploadError(503, "attachment_store_unavailable", ATTACHMENT_STORAGE_FAILURE_MESSAGE);
     }
-    let form;
-    try {
-      form = await request.formData();
-    } catch {
-      return attachmentUploadError(400, "invalid_upload", "Expected a multipart/form-data body with file fields");
-    }
     const files = [];
-    form.forEach((value) => {
-      if (value instanceof File) files.push(value);
-    });
+    const contentType = request.headers.get("Content-Type")?.toLowerCase() ?? "";
+    if (!contentType.startsWith("multipart/form-data")) {
+      const target = rawUploadTarget(request);
+      if (!target.succeeded) return target.response;
+      const { filename, declaredBytes } = target;
+      const name = sanitizeAttachmentFileName(filename);
+      if (declaredBytes > largestFileBytes) {
+        return attachmentUploadError(413, "attachment_too_large", attachmentSizeErrorMessage(name, declaredBytes, largestFileBytes));
+      }
+      if (declaredBytes > maxTotalBytes) {
+        return attachmentUploadError(413, "attachments_total_too_large", attachmentTotalSizeErrorMessage(declaredBytes, maxTotalBytes));
+      }
+      if (streamWriter && declaredBytes > STREAM_SNIFF_HEAD_BYTES) {
+        const path = pathFor(name);
+        const pathCheck = validatePath(path);
+        if (!pathCheck.succeeded) return attachmentUploadError(400, "invalid_attachment_path", pathCheck.error, path);
+        const writer = auth.writeAttachmentStream ?? streamWriter;
+        return streamRawUpload({ request, scopeId: auth.scopeId, writer, filename, name, path, declaredBytes });
+      }
+      const body = await readRawBody(request, declaredBytes);
+      if (!body.succeeded) return body.response;
+      files.push(new File([body.value], filename));
+    } else {
+      let formSource = request;
+      if (maxFormBytes !== void 0) {
+        const bounded = await readBodyUpTo(request, maxFormBytes);
+        if (!bounded.succeeded && !bounded.tooLarge) {
+          return attachmentUploadError(400, "invalid_upload", "The upload body ended early");
+        }
+        if (!bounded.succeeded) {
+          return attachmentUploadError(
+            413,
+            "form_upload_too_large",
+            `Form uploads are limited to ${formatBytes(maxFormBytes)}; send a larger file as a raw request body named by the filename query parameter`
+          );
+        }
+        formSource = new Response(bounded.value, { headers: { "Content-Type": request.headers.get("Content-Type") ?? "" } });
+      }
+      let form;
+      try {
+        form = await formSource.formData();
+      } catch {
+        return attachmentUploadError(400, "invalid_upload", "Expected a multipart/form-data body with file fields");
+      }
+      form.forEach((value) => {
+        if (value instanceof File) files.push(value);
+      });
+    }
     if (files.length === 0) {
       return attachmentUploadError(400, "invalid_upload", "No files in the upload body");
     }
@@ -2992,10 +3255,7 @@ function createAttachmentUploadRoute(options) {
           `${name} is a "${kind}" attachment, which this upload route does not accept`
         );
       }
-      let limit = maxTextBytes;
-      if (sniff.binary) {
-        limit = sniff.mime === null ? maxBinaryBytes : maxBytesBySniffedMime?.get(sniff.mime) ?? maxBinaryBytes;
-      }
+      const limit = limitFor(sniff);
       if (bytes.length > limit) {
         return attachmentUploadError(
           413,
@@ -3521,6 +3781,8 @@ export {
   OOXML_WORD_MIME,
   PROMOTE_MAX_FILE_BYTES,
   RUNTIME_RESTARTED_ERROR,
+  STREAM_SNIFF_HEAD_BYTES,
+  STREAM_SNIFF_TAIL_BYTES,
   TOOL_ABORTED_ERROR,
   TURN_INTENT_EVENT,
   TURN_PHASE_EVENT,
@@ -3554,6 +3816,7 @@ export {
   createRouterTurnProducer,
   createSandboxChatProducer,
   createSandboxFileIndexRoute,
+  createStreamingSniffer,
   createUploadRoute,
   defaultValidateAttachmentPath,
   fileMentionsToParts,
@@ -3590,6 +3853,7 @@ export {
   settleTurnResponse,
   sniffBinary,
   sniffMimeFromName,
+  sniffedMimeImpliedByName,
   storeSupportsDraftPersistence,
   streamChatRouteAsSandboxEvents,
   streamPlanFollowUpEvents,