@tangle-network/agent-app 0.43.50 → 0.43.52

package/dist/chat-routes/index.js

@@ -1,6 +1,17 @@
 import {
-  createSandboxFileIndexRoute
-} from "../chunk-LCNY3DCM.js";
+  ALLOWED_ATTACHMENT_SNIFFED_MIMES,
+  ATTACHMENT_ACCEPT,
+  ATTACHMENT_MAX_COUNT,
+  MAX_ATTACHMENT_TOTAL_BYTES,
+  MAX_BINARY_ATTACHMENT_BYTES,
+  MAX_TEXT_ATTACHMENT_BYTES,
+  attachmentSizeErrorMessage,
+  attachmentTotalSizeErrorMessage,
+  checkAttachmentType,
+  createSandboxFileIndexRoute,
+  sanitizeAttachmentFileName,
+  sniffBinary
+} from "../chunk-3EKOSBYL.js";
 import {
   DEFAULT_STALE_TURN_LOCK_GRACE_MS,
   DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS,
@@ -759,6 +770,59 @@ function createSandboxChatProducer(options) {
   };
 }
 
+// src/chat-routes/detached-turn.ts
+var TERMINAL_ERROR_TYPES = /* @__PURE__ */ new Set(["error", "session.run.failed"]);
+function errorMessageOf(ev) {
+  const rec = ev;
+  const raw = rec?.data?.message ?? rec?.data?.reason ?? rec?.message;
+  return typeof raw === "string" && raw ? raw : "run failed";
+}
+function hasUsage(usage) {
+  return typeof usage.inputTokens === "number" && usage.inputTokens > 0;
+}
+async function runDetachedTurn(opts) {
+  const { store, turnId, scopeId } = opts;
+  const prior = await store.getStatus(turnId).catch(() => null);
+  if (prior === "complete") {
+    const final = opts.completedResult ? await opts.completedResult().catch(() => null) : null;
+    return { state: "completed", text: final?.text ?? "", usage: final?.usage ?? {}, cached: true };
+  }
+  const tap = createBufferedTurnTap({
+    store,
+    turnId,
+    scopeId,
+    coalesce: opts.coalesce ?? coalesceDeltas
+  });
+  await tap.onEvent({ type: "turn", turnId });
+  const producer = createSandboxChatProducer({
+    events: opts.events,
+    model: opts.model,
+    log: opts.log
+  });
+  let runError;
+  try {
+    for await (const ev of producer.stream) {
+      const type = ev.type;
+      if (typeof type === "string" && TERMINAL_ERROR_TYPES.has(type)) runError = errorMessageOf(ev);
+      await tap.onEvent(ev);
+    }
+    await tap.done(runError ? "error" : "complete");
+  } catch (err) {
+    await tap.done("error").catch(() => {
+    });
+    throw err;
+  }
+  const text = producer.finalText?.() ?? "";
+  let usage = producer.usage?.() ?? {};
+  if (!runError && !hasUsage(usage)) {
+    const final = opts.completedResult ? await opts.completedResult().catch(() => null) : null;
+    if (final?.usage) usage = { ...usage, ...final.usage };
+    if (!text && final?.text) return { state: "completed", text: final.text, usage, cached: false };
+  }
+  if (runError) return { state: "failed", text, usage, error: runError, cached: false };
+  return { state: "completed", text, usage, cached: false };
+}
+
 // src/chat-routes/durable-projection.ts
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -896,12 +960,7 @@ function createUploadRoute(options) {
 }
 
 // src/chat-routes/resolve-attachments.ts
-var ATTACHMENT_MAX_COUNT = 10;
-var MAX_ATTACHMENT_TOTAL_BYTES = 25 * 1024 * 1024;
 var MAX_ATTACHMENT_NAME_LENGTH = 256;
-function attachmentTotalSizeErrorMessage(totalBytes, limitBytes) {
-  return `Attachments total ${formatBytes(totalBytes)}; each message is limited to ${formatBytes(limitBytes)}`;
-}
 function isAttachmentKind(value) {
   return value === "image" || value === "file";
 }
@@ -995,164 +1054,6 @@ async function resolveChatAttachments(value, options) {
   return { succeeded: true, value: inputs.map(attachmentInputToPart) };
 }
 
-// src/chat-routes/dispatch-parts.ts
-function byteLen(value) {
-  return new TextEncoder().encode(value).length;
-}
-async function readSandboxMention(box, absolutePath, options) {
-  const stat = await statSandboxFileSize(box, absolutePath);
-  if (!stat.succeeded) {
-    return { succeeded: false, error: `mentioned sandbox file missing or unreadable: ${absolutePath} \u2014 ${stat.error}` };
-  }
-  if (!options.readBytes) return { succeeded: true, value: { size: stat.value } };
-  const read = await readSandboxBinaryBytes(box, absolutePath, stat.value);
-  if (!read.succeeded) {
-    return { succeeded: false, error: `mentioned sandbox file read failed: ${absolutePath} \u2014 ${read.error}` };
-  }
-  return { succeeded: true, value: { size: stat.value, base64: bytesToBase64(read.value.bytes) } };
-}
-function violatesUrlPathXor(part) {
-  if (part.type === "text") return false;
-  const hasUrl = typeof part.url === "string" && part.url.startsWith("data:");
-  const hasPath = typeof part.path === "string" && part.path.startsWith("/");
-  return hasUrl === hasPath;
-}
-function readResultToBase64(read) {
-  if (typeof read.base64 === "string") return read.base64;
-  if (read.bytes) return bytesToBase64(read.bytes);
-  return void 0;
-}
-async function buildDispatchParts(input) {
-  const readMention = input.readSandboxMention ?? readSandboxMention;
-  const resolveMentionPath = input.resolveMentionPath ?? input.resolveAttachmentPath;
-  const forcePath = input.forcePath ?? false;
-  const mentions = input.mentions ?? [];
-  const requestMaxBytes = input.requestMaxBytes ?? DISPATCH_REQUEST_MAX_BYTES;
-  const structuralReserveBytes = input.structuralReserveBytes ?? DISPATCH_STRUCTURAL_RESERVE_BYTES;
-  const maxParts = input.maxParts ?? DISPATCH_MAX_PARTS;
-  const parts = [{ type: "text", text: input.text }];
-  const emittedAbsPaths = /* @__PURE__ */ new Set();
-  const flattenedForSizing = flattenHistory(input.text, input.history);
-  const inlineBudget = requestMaxBytes - base64WireLen(byteLen(flattenedForSizing)) - byteLen(JSON.stringify(input.systemPrompt)) - input.profileWireBytes - structuralReserveBytes;
-  let runningInline = 0;
-  for (const attachment of input.attachments) {
-    if (!attachment.path) {
-      return { succeeded: false, error: `attachment path must be non-empty: ${attachment.name}` };
-    }
-    let read;
-    try {
-      read = await input.readAttachment(input.scopeId, attachment.path);
-    } catch (err) {
-      return {
-        succeeded: false,
-        error: `attachment store read failed: ${attachment.path} \u2014 ${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-    if (!read.ok) return { succeeded: false, error: read.reason };
-    const base64 = readResultToBase64(read);
-    if (base64 === void 0) {
-      return { succeeded: false, error: `attachment store read produced no content: ${attachment.path}` };
-    }
-    const mediaType = attachment.mediaType ?? read.mediaType;
-    if (attachment.type === "image" && !mediaType) {
-      return { succeeded: false, error: `attachment is missing a mediaType required for an image data URI: ${attachment.path}` };
-    }
-    const absPath = input.resolveAttachmentPath(attachment.path);
-    emittedAbsPaths.add(absPath);
-    if (attachment.type === "image") {
-      const inlinePart2 = {
-        type: "image",
-        filename: attachment.name,
-        mediaType,
-        url: `data:${mediaType};base64,${base64}`
-      };
-      const cost2 = byteLen(JSON.stringify(inlinePart2));
-      if (!forcePath && runningInline + cost2 <= inlineBudget) {
-        parts.push(inlinePart2);
-        runningInline += cost2;
-      } else {
-        parts.push({ type: "image", filename: attachment.name, mediaType, path: absPath });
-      }
-      continue;
-    }
-    const fileMediaType = mediaType ?? "application/octet-stream";
-    const inlinePart = {
-      type: "file",
-      filename: attachment.name,
-      mediaType: fileMediaType,
-      url: `data:${fileMediaType};base64,${base64}`
-    };
-    const cost = byteLen(JSON.stringify(inlinePart));
-    if (!forcePath && runningInline + cost <= inlineBudget) {
-      parts.push(inlinePart);
-      runningInline += cost;
-    } else {
-      parts.push({ type: "file", path: absPath });
-    }
-  }
-  if (mentions.length > 0 && !input.box) {
-    return { succeeded: false, error: "internal error: sandbox mentions require a box to read from" };
-  }
-  for (const mention of mentions) {
-    if (!mention.path) {
-      return { succeeded: false, error: `mention path must be non-empty: ${mention.name}` };
-    }
-    const absPath = resolveMentionPath(mention.path);
-    if (emittedAbsPaths.has(absPath)) continue;
-    emittedAbsPaths.add(absPath);
-    const isImage = mention.mentionKind === "image";
-    const mediaType = isImage ? mediaTypeForMentionPath(mention.path) : void 0;
-    let stat;
-    try {
-      stat = await readMention(input.box, absPath, { readBytes: false });
-    } catch (err) {
-      return { succeeded: false, error: `mention read failed: ${absPath} \u2014 ${err instanceof Error ? err.message : String(err)}` };
-    }
-    if (!stat.succeeded) return { succeeded: false, error: stat.error };
-    const projectedInlineCost = base64WireLen(stat.value.size) + byteLen(JSON.stringify({ type: "image", filename: mention.name, mediaType: mediaType ?? "", url: "" }));
-    if (isImage && mediaType && !forcePath && runningInline + projectedInlineCost <= inlineBudget) {
-      let read;
-      try {
-        read = await readMention(input.box, absPath, { readBytes: true });
-      } catch (err) {
-        return { succeeded: false, error: `mention read failed: ${absPath} \u2014 ${err instanceof Error ? err.message : String(err)}` };
-      }
-      if (!read.succeeded) return { succeeded: false, error: read.error };
-      if (!read.value.base64) return { succeeded: false, error: `mentioned image produced no bytes: ${absPath}` };
-      const inlinePart = {
-        type: "image",
-        filename: mention.name,
-        mediaType,
-        url: `data:${mediaType};base64,${read.value.base64}`
-      };
-      const cost = byteLen(JSON.stringify(inlinePart));
-      if (runningInline + cost <= inlineBudget) {
-        parts.push(inlinePart);
-        runningInline += cost;
-        continue;
-      }
-    }
-    parts.push(
-      isImage && mediaType ? { type: "image", filename: mention.name, mediaType, path: absPath } : { type: "file", path: absPath }
-    );
-  }
-  for (const part of parts) {
-    if (violatesUrlPathXor(part)) {
-      return { succeeded: false, error: "internal error: emitted media part violates the url/path exclusivity invariant" };
-    }
-  }
-  const textPartSize = base64WireLen(byteLen(flattenedForSizing));
-  const mediaPartsSize = parts.slice(1).reduce((total, part) => total + byteLen(JSON.stringify(part)), 0);
-  const systemPromptSize = byteLen(JSON.stringify(input.systemPrompt));
-  if (textPartSize + mediaPartsSize + systemPromptSize + input.profileWireBytes + structuralReserveBytes > requestMaxBytes) {
-    return { succeeded: false, error: "dispatch parts exceed the sandbox proxy request cap even after path demotion" };
-  }
-  if (parts.length > maxParts) {
-    return { succeeded: false, error: `dispatch parts exceed the sidecar per-request cap of ${maxParts}` };
-  }
-  return { succeeded: true, value: parts };
-}
-
 // src/chat-routes/promote-file-part.ts
 var PROMOTE_MAX_FILE_BYTES = 10 * 1024 * 1024;
 var EXT_TO_MIME = {
@@ -1192,10 +1093,6 @@ function sniffMimeFromName(filename) {
   if (!ext) return "text/plain";
   return EXT_TO_MIME[ext] ?? "text/plain";
 }
-function sanitizeAttachmentFileName(name) {
-  const sanitized = name.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[.-]+/, "");
-  return sanitized || "file";
-}
 function base64ToBytes(base64) {
   const binary = atob(base64);
   const bytes = new Uint8Array(binary.length);
@@ -1328,7 +1225,295 @@ async function promoteAgentFilePart(options) {
     }
   };
 }
+
+// src/chat-routes/attachment-upload.ts
+function attachmentUploadError(status, code, message, path) {
+  return Response.json(
+    { error: path === void 0 ? { code, message } : { code, message, path } },
+    { status }
+  );
+}
+function createAttachmentUploadRoute(options) {
+  const maxCount = options.limits?.maxCount ?? ATTACHMENT_MAX_COUNT;
+  const maxBinaryBytes = options.limits?.maxBinaryBytes ?? MAX_BINARY_ATTACHMENT_BYTES;
+  const maxTextBytes = options.limits?.maxTextBytes ?? MAX_TEXT_ATTACHMENT_BYTES;
+  const maxTotalBytes = options.limits?.maxTotalBytes ?? MAX_ATTACHMENT_TOTAL_BYTES;
+  const allowedKinds = options.allowedKinds ?? ["image", "file"];
+  const allowedSniffedMimes = options.allowedSniffedMimes ?? ALLOWED_ATTACHMENT_SNIFFED_MIMES;
+  const pathFor = options.pathFor ?? ((name) => name);
+  const validatePath = options.validatePath ?? defaultValidateAttachmentPath;
+  const sniffMime = options.sniffMime ?? sniffMimeFromName;
+  return async function attachmentUpload(request) {
+    const auth = await options.authorize({ request });
+    if (!auth.ok) return auth.response;
+    const write = auth.writeAttachment ?? options.writeAttachment;
+    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);
+    });
+    if (files.length === 0) {
+      return attachmentUploadError(400, "invalid_upload", "No files in the upload body");
+    }
+    if (files.length > maxCount) {
+      return attachmentUploadError(
+        400,
+        "attachment_count_exceeded",
+        `Too many files \u2014 the ${maxCount}-file limit was exceeded`
+      );
+    }
+    const advisoryTotal = files.reduce((sum, file) => sum + file.size, 0);
+    if (advisoryTotal > maxTotalBytes) {
+      return attachmentUploadError(
+        413,
+        "attachments_total_too_large",
+        attachmentTotalSizeErrorMessage(advisoryTotal, maxTotalBytes)
+      );
+    }
+    const prepared = [];
+    const seenPaths = /* @__PURE__ */ new Set();
+    let totalBytes = 0;
+    for (const file of files) {
+      const bytes = new Uint8Array(await file.arrayBuffer());
+      const sniff = sniffBinary(bytes);
+      const name = sanitizeAttachmentFileName(file.name);
+      const typeCheck = checkAttachmentType(name, sniff, allowedSniffedMimes);
+      if (!typeCheck.succeeded) {
+        return attachmentUploadError(
+          typeCheck.code === "attachment_type_mismatch" ? 400 : 415,
+          typeCheck.code,
+          typeCheck.message
+        );
+      }
+      const kind = attachmentKindForMime(sniff.mime ?? "");
+      if (!allowedKinds.includes(kind)) {
+        return attachmentUploadError(
+          415,
+          "attachment_kind_not_allowed",
+          `${name} is a "${kind}" attachment, which this upload route does not accept`
+        );
+      }
+      const limit = sniff.binary ? maxBinaryBytes : maxTextBytes;
+      if (bytes.length > limit) {
+        return attachmentUploadError(
+          413,
+          "attachment_too_large",
+          attachmentSizeErrorMessage(name, bytes.length, limit)
+        );
+      }
+      const path = pathFor(name);
+      const pathCheck = validatePath(path);
+      if (!pathCheck.succeeded) {
+        return attachmentUploadError(400, "invalid_attachment_path", pathCheck.error, path);
+      }
+      if (seenPaths.has(path)) {
+        return attachmentUploadError(
+          400,
+          "attachment_duplicate_path",
+          `attachments must not repeat a path within one upload: ${path}`,
+          path
+        );
+      }
+      seenPaths.add(path);
+      totalBytes += bytes.length;
+      if (totalBytes > maxTotalBytes) {
+        return attachmentUploadError(
+          413,
+          "attachments_total_too_large",
+          attachmentTotalSizeErrorMessage(totalBytes, maxTotalBytes)
+        );
+      }
+      const mediaType = sniff.mime ?? sniffMime(name);
+      prepared.push({ path, name, bytes, originalName: file.name, size: bytes.length, mediaType, kind });
+    }
+    const uploaded = [];
+    for (const input of prepared) {
+      const written = await write(auth.scopeId, input.path, input.bytes, {
+        mediaType: input.mediaType,
+        name: input.name,
+        originalName: input.originalName,
+        size: input.size
+      });
+      if (!written.ok) {
+        return attachmentUploadError(413, "attachment_write_failed", written.reason, input.path);
+      }
+      uploaded.push({
+        path: input.path,
+        name: input.name,
+        size: input.size,
+        mediaType: input.mediaType,
+        kind: input.kind
+      });
+    }
+    return Response.json({ files: uploaded });
+  };
+}
+
+// src/chat-routes/dispatch-parts.ts
+function byteLen(value) {
+  return new TextEncoder().encode(value).length;
+}
+async function readSandboxMention(box, absolutePath, options) {
+  const stat = await statSandboxFileSize(box, absolutePath);
+  if (!stat.succeeded) {
+    return { succeeded: false, error: `mentioned sandbox file missing or unreadable: ${absolutePath} \u2014 ${stat.error}` };
+  }
+  if (!options.readBytes) return { succeeded: true, value: { size: stat.value } };
+  const read = await readSandboxBinaryBytes(box, absolutePath, stat.value);
+  if (!read.succeeded) {
+    return { succeeded: false, error: `mentioned sandbox file read failed: ${absolutePath} \u2014 ${read.error}` };
+  }
+  return { succeeded: true, value: { size: stat.value, base64: bytesToBase64(read.value.bytes) } };
+}
+function violatesUrlPathXor(part) {
+  if (part.type === "text") return false;
+  const hasUrl = typeof part.url === "string" && part.url.startsWith("data:");
+  const hasPath = typeof part.path === "string" && part.path.startsWith("/");
+  return hasUrl === hasPath;
+}
+function readResultToBase64(read) {
+  if (typeof read.base64 === "string") return read.base64;
+  if (read.bytes) return bytesToBase64(read.bytes);
+  return void 0;
+}
+async function buildDispatchParts(input) {
+  const readMention = input.readSandboxMention ?? readSandboxMention;
+  const resolveMentionPath = input.resolveMentionPath ?? input.resolveAttachmentPath;
+  const forcePath = input.forcePath ?? false;
+  const mentions = input.mentions ?? [];
+  const requestMaxBytes = input.requestMaxBytes ?? DISPATCH_REQUEST_MAX_BYTES;
+  const structuralReserveBytes = input.structuralReserveBytes ?? DISPATCH_STRUCTURAL_RESERVE_BYTES;
+  const maxParts = input.maxParts ?? DISPATCH_MAX_PARTS;
+  const parts = [{ type: "text", text: input.text }];
+  const emittedAbsPaths = /* @__PURE__ */ new Set();
+  const flattenedForSizing = flattenHistory(input.text, input.history);
+  const inlineBudget = requestMaxBytes - base64WireLen(byteLen(flattenedForSizing)) - byteLen(JSON.stringify(input.systemPrompt)) - input.profileWireBytes - structuralReserveBytes;
+  let runningInline = 0;
+  for (const attachment of input.attachments) {
+    if (!attachment.path) {
+      return { succeeded: false, error: `attachment path must be non-empty: ${attachment.name}` };
+    }
+    let read;
+    try {
+      read = await input.readAttachment(input.scopeId, attachment.path);
+    } catch (err) {
+      return {
+        succeeded: false,
+        error: `attachment store read failed: ${attachment.path} \u2014 ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (!read.ok) return { succeeded: false, error: read.reason };
+    const base64 = readResultToBase64(read);
+    if (base64 === void 0) {
+      return { succeeded: false, error: `attachment store read produced no content: ${attachment.path}` };
+    }
+    const mediaType = attachment.mediaType ?? read.mediaType;
+    if (attachment.type === "image" && !mediaType) {
+      return { succeeded: false, error: `attachment is missing a mediaType required for an image data URI: ${attachment.path}` };
+    }
+    const absPath = input.resolveAttachmentPath(attachment.path);
+    emittedAbsPaths.add(absPath);
+    if (attachment.type === "image") {
+      const inlinePart2 = {
+        type: "image",
+        filename: attachment.name,
+        mediaType,
+        url: `data:${mediaType};base64,${base64}`
+      };
+      const cost2 = byteLen(JSON.stringify(inlinePart2));
+      if (!forcePath && runningInline + cost2 <= inlineBudget) {
+        parts.push(inlinePart2);
+        runningInline += cost2;
+      } else {
+        parts.push({ type: "image", filename: attachment.name, mediaType, path: absPath });
+      }
+      continue;
+    }
+    const fileMediaType = mediaType ?? "application/octet-stream";
+    const inlinePart = {
+      type: "file",
+      filename: attachment.name,
+      mediaType: fileMediaType,
+      url: `data:${fileMediaType};base64,${base64}`
+    };
+    const cost = byteLen(JSON.stringify(inlinePart));
+    if (!forcePath && runningInline + cost <= inlineBudget) {
+      parts.push(inlinePart);
+      runningInline += cost;
+    } else {
+      parts.push({ type: "file", path: absPath });
+    }
+  }
+  if (mentions.length > 0 && !input.box) {
+    return { succeeded: false, error: "internal error: sandbox mentions require a box to read from" };
+  }
+  for (const mention of mentions) {
+    if (!mention.path) {
+      return { succeeded: false, error: `mention path must be non-empty: ${mention.name}` };
+    }
+    const absPath = resolveMentionPath(mention.path);
+    if (emittedAbsPaths.has(absPath)) continue;
+    emittedAbsPaths.add(absPath);
+    const isImage = mention.mentionKind === "image";
+    const mediaType = isImage ? mediaTypeForMentionPath(mention.path) : void 0;
+    let stat;
+    try {
+      stat = await readMention(input.box, absPath, { readBytes: false });
+    } catch (err) {
+      return { succeeded: false, error: `mention read failed: ${absPath} \u2014 ${err instanceof Error ? err.message : String(err)}` };
+    }
+    if (!stat.succeeded) return { succeeded: false, error: stat.error };
+    const projectedInlineCost = base64WireLen(stat.value.size) + byteLen(JSON.stringify({ type: "image", filename: mention.name, mediaType: mediaType ?? "", url: "" }));
+    if (isImage && mediaType && !forcePath && runningInline + projectedInlineCost <= inlineBudget) {
+      let read;
+      try {
+        read = await readMention(input.box, absPath, { readBytes: true });
+      } catch (err) {
+        return { succeeded: false, error: `mention read failed: ${absPath} \u2014 ${err instanceof Error ? err.message : String(err)}` };
+      }
+      if (!read.succeeded) return { succeeded: false, error: read.error };
+      if (!read.value.base64) return { succeeded: false, error: `mentioned image produced no bytes: ${absPath}` };
+      const inlinePart = {
+        type: "image",
+        filename: mention.name,
+        mediaType,
+        url: `data:${mediaType};base64,${read.value.base64}`
+      };
+      const cost = byteLen(JSON.stringify(inlinePart));
+      if (runningInline + cost <= inlineBudget) {
+        parts.push(inlinePart);
+        runningInline += cost;
+        continue;
+      }
+    }
+    parts.push(
+      isImage && mediaType ? { type: "image", filename: mention.name, mediaType, path: absPath } : { type: "file", path: absPath }
+    );
+  }
+  for (const part of parts) {
+    if (violatesUrlPathXor(part)) {
+      return { succeeded: false, error: "internal error: emitted media part violates the url/path exclusivity invariant" };
+    }
+  }
+  const textPartSize = base64WireLen(byteLen(flattenedForSizing));
+  const mediaPartsSize = parts.slice(1).reduce((total, part) => total + byteLen(JSON.stringify(part)), 0);
+  const systemPromptSize = byteLen(JSON.stringify(input.systemPrompt));
+  if (textPartSize + mediaPartsSize + systemPromptSize + input.profileWireBytes + structuralReserveBytes > requestMaxBytes) {
+    return { succeeded: false, error: "dispatch parts exceed the sandbox proxy request cap even after path demotion" };
+  }
+  if (parts.length > maxParts) {
+    return { succeeded: false, error: `dispatch parts exceed the sidecar per-request cap of ${maxParts}` };
+  }
+  return { succeeded: true, value: parts };
+}
 export {
+  ALLOWED_ATTACHMENT_SNIFFED_MIMES,
+  ATTACHMENT_ACCEPT,
   ATTACHMENT_MAX_COUNT,
   ChatTurnInputError,
   DEFAULT_STALE_TURN_LOCK_GRACE_MS,
@@ -1339,17 +1524,22 @@ export {
   DISPATCH_STRUCTURAL_RESERVE_BYTES,
   INLINE_PARTS_MAX_BYTES,
   MAX_ATTACHMENT_TOTAL_BYTES,
+  MAX_BINARY_ATTACHMENT_BYTES,
+  MAX_TEXT_ATTACHMENT_BYTES,
   MENTION_MAX_COUNT,
   PROMOTE_MAX_FILE_BYTES,
   UPLOAD_INLINE_MAX_BYTES,
   UPLOAD_MAX_FILE_BYTES,
   assertPromptPartsWithinCap,
+  attachmentSizeErrorMessage,
   attachmentTotalSizeErrorMessage,
   base64WireLen,
   buildDispatchParts,
   buildMentionPromptBlock,
   bytesToBase64,
   chatTurnRequestInit,
+  checkAttachmentType,
+  createAttachmentUploadRoute,
   createChatTurnRoutes,
   createSandboxChatProducer,
   createSandboxFileIndexRoute,
@@ -1365,7 +1555,10 @@ export {
   promptPartsByteSize,
   reconcileStaleTurnLock,
   resolveChatAttachments,
+  runDetachedTurn,
+  sanitizeAttachmentFileName,
   sanitizeUploadFilename,
+  sniffBinary,
   sniffMimeFromName,
   validateSandboxMentionPath,
   withDurableChatProjection