@tangle-network/agent-app 0.49.1 → 0.49.3

package/dist/chat-routes/completed-sandbox-turn.d.ts

@@ -7,7 +7,7 @@
  * session. This adapter joins them without guessing across turns, then returns
  * the same `DetachedTurnFinal` shape `runDetachedTurn` already consumes.
  */
-import type { SandboxInstance } from '@tangle-network/sandbox';
+import type { SandboxInstance, SessionMessage } from '@tangle-network/sandbox';
 import type { DetachedTurnFinal } from './detached-turn';
 /** The official Sandbox methods needed for completed-turn recovery. */
 export type CompletedSandboxTurnSource = Pick<SandboxInstance, 'findCompletedTurn' | 'session'>;
@@ -17,6 +17,13 @@ export interface ReadCompletedSandboxTurnOptions {
     sessionId: string;
     log?: (message: string, meta?: Record<string, unknown>) => void;
 }
+/**
+ * Recover the durable content a Sandbox recorder attached to one assistant
+ * message. The caller is responsible for proving that the message belongs to
+ * the exact terminal turn; this projection deliberately makes no conclusion
+ * about whether that terminal state was completed or interrupted.
+ */
+export declare function recoverSandboxAssistantMessage(message: SessionMessage): DetachedTurnFinal;
 /**
  * Read the exact completed turn from its keyed cache and completed message.
  * Never borrow a session-wide aggregate from a concurrently advancing session.

package/dist/chat-routes/index.d.ts

@@ -18,6 +18,7 @@ export * from './model-failover-stream';
 export * from './draft-persistence';
 export * from './detached-turn';
 export * from './completed-sandbox-turn';
+export * from './native-completion';
 export * from './durable-projection';
 export * from './upload';
 export * from './file-index';

package/dist/chat-routes/index.js

@@ -61,7 +61,7 @@ import {
   rowIdOf,
   storeSupportsDraftPersistence,
   streamChatRouteAsSandboxEvents
-} from "../chunk-MFLUDFD3.js";
+} from "../chunk-V4YGTOCS.js";
 import "../chunk-ZSSCVT6H.js";
 import "../chunk-EA4UVS4T.js";
 import {
@@ -125,18 +125,18 @@ import {
 import {
   coalesceDeltas,
   createBufferedTurnTap
-} from "../chunk-N4RR4WAI.js";
+} from "../chunk-HXTJXODG.js";
 
 // src/chat-routes/model-failover-stream.ts
 var TERMINAL_FAILURE_TYPES = /* @__PURE__ */ new Set(["error", "session.run.failed"]);
 var NON_COMMITTING_PART_TYPES = /* @__PURE__ */ new Set(["step-start", "step-finish"]);
 function isCommittingSandboxEvent(event) {
-  const record = asRecord(event);
-  if (!record) return false;
-  const type = asString(record.type) ?? "";
+  const record2 = asRecord(event);
+  if (!record2) return false;
+  const type = asString(record2.type) ?? "";
   if (!type) return false;
   if (type === "message.part.updated") {
-    const part = asRecord(asRecord(record.data)?.part);
+    const part = asRecord(asRecord(record2.data)?.part);
     const partType = asString(part?.type) ?? "";
     if (NON_COMMITTING_PART_TYPES.has(partType)) return false;
     if (partType === "text" || partType === "reasoning") {
@@ -168,13 +168,13 @@ function isLiveLifecycleEvent(event) {
   return type === "start" || type === "execution.started" || type === "status" || type === "model-processing" || type === "model.processing" || type === "session.created" || type === "session.updated" || type === "session.idle";
 }
 function classifyTerminalFailure(event) {
-  const record = asRecord(event);
-  if (!record) return null;
-  const type = asString(record.type) ?? "";
+  const record2 = asRecord(event);
+  if (!record2) return null;
+  const type = asString(record2.type) ?? "";
   if (!TERMINAL_FAILURE_TYPES.has(type)) return null;
-  const data = asRecord(record.data);
-  const outage = isUpstreamUnavailable(data) || isUpstreamUnavailable(record);
-  const reason = asString(data?.message) ?? asString(data?.error) ?? asString(data?.reason) ?? asString(record.message) ?? `sandbox stream reported ${type}`;
+  const data = asRecord(record2.data);
+  const outage = isUpstreamUnavailable(data) || isUpstreamUnavailable(record2);
+  const reason = asString(data?.message) ?? asString(data?.error) ?? asString(data?.reason) ?? asString(record2.message) ?? `sandbox stream reported ${type}`;
   const code = asString(data?.errorCode) ?? asString(data?.code);
   return { outage, reason, ...code ? { code } : {} };
 }
@@ -217,11 +217,11 @@ function deadlineAfter(timeoutMs) {
   };
 }
 function isEmptyTerminalReceipt(event) {
-  const record = asRecord(event);
-  if (!record) return false;
-  const type = asString(record.type) ?? "";
+  const record2 = asRecord(event);
+  if (!record2) return false;
+  const type = asString(record2.type) ?? "";
   if (type !== "result" && type !== "done") return false;
-  const data = asRecord(record.data);
+  const data = asRecord(record2.data);
   const text = asString(data?.finalText) ?? asString(data?.text) ?? "";
   return text.trim().length === 0;
 }
@@ -640,8 +640,8 @@ function applyTerminalUsage(reported, usage) {
   if (reported.costUsd !== void 0) usage.costUsd = reported.costUsd;
 }
 function sandboxStreamErrorMessage(data) {
-  const record = asRecord(data);
-  const message = asString(record?.message) ?? asString(record?.error);
+  const record2 = asRecord(data);
+  const message = asString(record2?.message) ?? asString(record2?.error);
   if (message) return message;
   try {
     return JSON.stringify(data) || "Sandbox stream returned an error event without details.";
@@ -805,12 +805,12 @@ function createSandboxChatProducer(options) {
   async function* stream() {
     try {
       for await (const raw of source) {
-        const record = asRecord(raw);
-        captureEffectiveBackend(asRecord(record?.data));
+        const record2 = asRecord(raw);
+        captureEffectiveBackend(asRecord(record2?.data));
         yield* drainModelNotices();
-        if (!record || typeof record.type !== "string") continue;
-        const normalized = normalizeToolEvent({ type: record.type, data: asRecord(record.data) });
-        const event = normalized.type === "message.part.updated" ? normalized : { type: record.type, data: asRecord(record.data) };
+        if (!record2 || typeof record2.type !== "string") continue;
+        const normalized = normalizeToolEvent({ type: record2.type, data: asRecord(record2.data) });
+        const event = normalized.type === "message.part.updated" ? normalized : { type: record2.type, data: asRecord(record2.data) };
         if (event.type === "message.part.updated") {
           const part = asRecord(event.data?.part);
           if (!part) continue;
@@ -911,7 +911,7 @@ function createSandboxChatProducer(options) {
           continue;
         }
         if (event.type === "interaction") {
-          const parsed = parseInteractionRequest(asRecord(record.data));
+          const parsed = parseInteractionRequest(asRecord(record2.data));
           if (!parsed.succeeded) {
             log("[chat-routes] dropping malformed interaction event", { error: parsed.error });
             continue;
@@ -922,7 +922,7 @@ function createSandboxChatProducer(options) {
               void 0,
               interactionPartKey(parsed.value.id)
             );
-            yield toProducerWireEvent(record);
+            yield toProducerWireEvent(record2);
             continue;
           }
           let declineFailed = false;
@@ -950,7 +950,7 @@ function createSandboxChatProducer(options) {
           continue;
         }
         if (event.type === "interaction.cancel") {
-          const parsed = parseInteractionCancel(asRecord(record.data));
+          const parsed = parseInteractionCancel(asRecord(record2.data));
           if (!parsed.succeeded) {
             log("[chat-routes] dropping malformed interaction.cancel event", { error: parsed.error });
             continue;
@@ -964,17 +964,17 @@ function createSandboxChatProducer(options) {
               ...parsed.value.reason ? { cancelReason: parsed.value.reason } : {}
             }, void 0, key);
           }
-          yield toProducerWireEvent(record);
+          yield toProducerWireEvent(record2);
           continue;
         }
         if (event.type === "plan.submitted") {
-          const parsed = parsePlanSubmittedEvent(record);
+          const parsed = parsePlanSubmittedEvent(record2);
           if (!parsed.succeeded) {
             log("[chat-routes] dropping malformed plan.submitted event", { error: parsed.error });
             continue;
           }
           recordPersistedPart(planToPersistedPart(parsed.value), void 0);
-          yield toProducerWireEvent(record);
+          yield toProducerWireEvent(record2);
           continue;
         }
         if (event.type === "warning") {
@@ -987,13 +987,13 @@ function createSandboxChatProducer(options) {
             recordPersistedPart(notice, void 0, noticePartKey(notice.id));
             yield { type: "notice", id: notice.id, noticeKind: "warning", text };
           }
-          yield toProducerWireEvent(record);
+          yield toProducerWireEvent(record2);
           continue;
         }
         if (event.type === "usage") {
-          const reported = extractUsageSnapshot(asRecord(record.usage));
+          const reported = extractUsageSnapshot(asRecord(record2.usage));
           if (reported) applyTerminalUsage(reported, usage);
-          yield toProducerWireEvent(record);
+          yield toProducerWireEvent(record2);
           continue;
         }
         if (event.type === "result") {
@@ -1022,7 +1022,7 @@ function createSandboxChatProducer(options) {
             yield* emitFinalUsage();
           }
           yield* emitTerminalizedTools();
-          yield toProducerWireEvent(record);
+          yield toProducerWireEvent(record2);
           continue;
         }
         if (event.type === "error") {
@@ -1040,10 +1040,10 @@ ${errorContent}` : errorContent;
           interactionOutcome = "expired";
           yield { type: "text", text: errorDelta };
           yield* emitTerminalizedTools();
-          yield toProducerWireEvent(record);
+          yield toProducerWireEvent(record2);
           continue;
         }
-        yield toProducerWireEvent(record);
+        yield toProducerWireEvent(record2);
       }
       yield* drainModelNotices();
     } catch (streamErr) {
@@ -1159,10 +1159,10 @@ function createProtectedRuntimeChatProducer(options) {
             return error.settlement;
           });
           usage = {
-            inputTokens: settlement.calls.reduce((sum, call) => sum + call.accountedInputTokens, 0),
-            outputTokens: settlement.calls.reduce((sum, call) => sum + call.outputTokens, 0),
-            reasoningTokens: settlement.calls.reduce((sum, call) => sum + call.reasoningTokens, 0),
-            costUsd: settlement.calls.reduce((sum, call) => sum + call.costUsdNanos, 0) / 1e9
+            inputTokens: settlement.calls.reduce((sum2, call) => sum2 + call.accountedInputTokens, 0),
+            outputTokens: settlement.calls.reduce((sum2, call) => sum2 + call.outputTokens, 0),
+            reasoningTokens: settlement.calls.reduce((sum2, call) => sum2 + call.reasoningTokens, 0),
+            costUsd: settlement.calls.reduce((sum2, call) => sum2 + call.costUsdNanos, 0) / 1e9
           };
           budgetEnforced = settlement.usageWithinLimits;
           if (!budgetEnforced) throw new Error("Provider settlement exceeded execution limits");
@@ -1366,12 +1366,12 @@ async function runDetachedTurn(opts) {
   const settleRow = async (base, cachedPersisted) => {
     const persisted = cachedPersisted ?? (!producer ? await persistedRow() : void 0);
     const info = producer?.modelFailover?.();
-    const attribution = producer?.modelAttribution?.();
+    const attribution2 = producer?.modelAttribution?.();
     const model = producer?.model ?? persisted?.model ?? opts.model;
-    const requestedModel = attribution?.requestedModel ?? persisted?.requestedModel ?? opts.model;
-    const servedModel = attribution?.servedModel ?? persisted?.servedModel;
-    const servedProvider = attribution?.servedProvider ?? persisted?.servedProvider;
-    const servedSource = attribution?.servedSource ?? (persisted?.servedSource === "request" || persisted?.servedSource === "environment" || persisted?.servedSource === "profile" ? persisted.servedSource : void 0);
+    const requestedModel = attribution2?.requestedModel ?? persisted?.requestedModel ?? opts.model;
+    const servedModel = attribution2?.servedModel ?? persisted?.servedModel;
+    const servedProvider = attribution2?.servedProvider ?? persisted?.servedProvider;
+    const servedSource = attribution2?.servedSource ?? (persisted?.servedSource === "request" || persisted?.servedSource === "environment" || persisted?.servedSource === "profile" ? persisted.servedSource : void 0);
     const result = {
       ...base,
       ...model ? { model } : {},
@@ -1500,9 +1500,9 @@ function finiteNumber(value) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
-function firstNumber(record, keys) {
+function firstNumber(record2, keys) {
   for (const key of keys) {
-    const value = finiteNumber(record?.[key]);
+    const value = finiteNumber(record2?.[key]);
     if (value !== void 0) return value;
   }
   return void 0;
@@ -1544,9 +1544,9 @@ function normalizedMessageParts(message) {
   const normalized = [];
   const usage = {};
   for (const raw of message.parts) {
-    const record = asRecord(raw);
-    if (!record) continue;
-    const part = normalizePersistedPart(record);
+    const record2 = asRecord(raw);
+    if (!record2) continue;
+    const part = normalizePersistedPart(record2);
     if (!part) continue;
     normalized.push(part);
     if (part.type === "step-finish") addStepFinishUsage(part, usage);
@@ -1567,6 +1567,14 @@ function projectMessageParts(parts, finalText) {
   }
   return finalizeAssistantParts(order, map, finalText);
 }
+function recoverSandboxAssistantMessage(message) {
+  const recovered = normalizedMessageParts(message);
+  return {
+    ...recovered.derivedText ? { text: recovered.derivedText } : {},
+    ...hasUsage2(recovered.usage) ? { usage: recovered.usage } : {},
+    parts: projectMessageParts(recovered.parts, recovered.derivedText)
+  };
+}
 function hasUsage2(usage) {
   return Object.values(usage).some(
     (value) => typeof value === "number" && Number.isFinite(value)
@@ -1636,6 +1644,193 @@ async function readCompletedSandboxTurn(box, options) {
   };
 }
 
+// src/chat-routes/native-completion.ts
+var DEFAULT_ABSENT_DISPATCH_DEADLINE_MS = 10 * 6e4;
+var DEFAULT_RECEIPT_DEADLINE_MS = 10 * 6e4;
+function timestamp(value) {
+  if (value instanceof Date) return value.getTime();
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function isSandboxNotFoundError(value) {
+  const error = record(value);
+  return error?.name === "NotFoundError" || error?.code === "NOT_FOUND" || error?.status === 404;
+}
+function attribution(result) {
+  const metadata = record(result?.metadata);
+  const modelAttribution = record(result?.modelAttribution) ?? record(metadata?.modelAttribution);
+  const backend = record(result?.effectiveBackend) ?? record(metadata?.effectiveBackend);
+  const source = nonEmptyString(result?.servedSource) ?? nonEmptyString(modelAttribution?.servedSource) ?? nonEmptyString(backend?.source);
+  const servedSource = source === "request" || source === "environment" || source === "profile" ? source : void 0;
+  const servedModel = nonEmptyString(result?.servedModel) ?? nonEmptyString(modelAttribution?.servedModel) ?? nonEmptyString(backend?.model);
+  const servedProvider = nonEmptyString(result?.servedProvider) ?? nonEmptyString(modelAttribution?.servedProvider) ?? nonEmptyString(backend?.provider);
+  return {
+    ...servedModel ? { servedModel } : {},
+    ...servedProvider ? { servedProvider } : {},
+    ...servedSource ? { servedSource } : {}
+  };
+}
+function usageFromResult2(result) {
+  const raw = record(result?.usage) ?? record(result?.tokenUsage);
+  const number = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  return {
+    ...number(raw?.inputTokens) !== void 0 ? { inputTokens: number(raw?.inputTokens) } : {},
+    ...number(raw?.outputTokens) !== void 0 ? { outputTokens: number(raw?.outputTokens) } : {},
+    ...number(raw?.cacheReadTokens) !== void 0 ? { cacheReadTokens: number(raw?.cacheReadTokens) } : {},
+    ...number(raw?.cacheWriteTokens) !== void 0 ? { cacheWriteTokens: number(raw?.cacheWriteTokens) } : {},
+    ...number(result?.costUsd) !== void 0 ? { costUsd: number(result?.costUsd) } : {}
+  };
+}
+function interruptedMessages(messages, turnId) {
+  return messages.filter(
+    (message) => message.role === "assistant" && message.metadata?.turnId === turnId && (message.metadata.interrupted === true || message.metadata.status === "interrupted")
+  );
+}
+function mergeUsage(messageUsage, resultUsage) {
+  return { ...messageUsage, ...resultUsage };
+}
+function consistent(values) {
+  if (values.length === 0 || values.some((value) => value === void 0)) return void 0;
+  const first = values[0];
+  return values.every((value) => value === first) ? first : void 0;
+}
+function sum(values) {
+  if (values.some((value) => value === void 0)) return void 0;
+  return values.reduce((total, value) => total + value, 0);
+}
+function aggregateNativeCompletionReceipts(turns) {
+  const failed = turns.some((turn) => turn.state === "failed");
+  const usage = {};
+  for (const key of ["inputTokens", "outputTokens", "reasoningTokens", "cacheReadTokens", "cacheWriteTokens", "costUsd"]) {
+    const total = sum(turns.map((turn) => turn.usage[key]));
+    if (total !== void 0) usage[key] = total;
+  }
+  const error = turns.find(
+    (turn) => turn.error?.startsWith("Admitted native execution did not produce") || turn.error?.startsWith("Native Sandbox execution ledger is missing")
+  )?.error ?? turns.find((turn) => turn.error)?.error;
+  return {
+    state: failed ? "failed" : "completed",
+    text: turns.map((turn) => turn.text).join(""),
+    parts: turns.flatMap((turn) => turn.parts),
+    usage,
+    ...consistent(turns.map((turn) => turn.servedModel)) ? { servedModel: consistent(turns.map((turn) => turn.servedModel)) } : {},
+    ...consistent(turns.map((turn) => turn.servedProvider)) ? { servedProvider: consistent(turns.map((turn) => turn.servedProvider)) } : {},
+    ...consistent(turns.map((turn) => turn.servedSource)) ? { servedSource: consistent(turns.map((turn) => turn.servedSource)) } : {},
+    ...error ? { error } : {},
+    completedTurnIds: turns.map((turn) => turn.turnId)
+  };
+}
+function missingTurnReceipt(turnId, error) {
+  return { turnId, state: "failed", text: "", parts: [], usage: {}, error };
+}
+async function observeNativeCompletion(options) {
+  const now = options.now ?? Date.now();
+  let admission = await options.admissionStore.read(options.executionId);
+  if (!admission) throw new Error("Native completion admission is missing");
+  if (admission.executionId !== options.executionId) throw new Error("Native completion admission identity conflict");
+  const leaseUntil = timestamp(admission.ownerLeaseUntil) ?? 0;
+  const source = options.source;
+  const session = source?.session(options.sessionId);
+  let status;
+  if (!session) {
+    status = null;
+  } else {
+    try {
+      status = await session.status();
+    } catch (error) {
+      if (!isSandboxNotFoundError(error)) throw error;
+      status = null;
+    }
+  }
+  if (!status || !session || !source) {
+    if (admission.state === "open" && leaseUntil <= now) {
+      admission = await options.admissionStore.closeExpired(options.executionId, new Date(now)) ?? admission;
+    }
+    if (admission.state === "open" || now - options.registeredAt < (options.absentDispatchDeadlineMs ?? DEFAULT_ABSENT_DISPATCH_DEADLINE_MS)) {
+      return { state: "running" };
+    }
+    return {
+      state: "failed",
+      receipt: aggregateNativeCompletionReceipts([
+        missingTurnReceipt(options.turnId, "Native Sandbox dispatch was not observed before the admission deadline")
+      ])
+    };
+  }
+  const exactSession = session;
+  if (admission.state === "open") {
+    if (status.status === "queued" || status.status === "running") {
+      admission = await options.admissionStore.renew(options.executionId, new Date(now)) ?? admission;
+    } else if (leaseUntil <= now) {
+      admission = await options.admissionStore.closeExpired(options.executionId, new Date(now)) ?? admission;
+    }
+    if (admission.state === "open") return { state: "running" };
+  }
+  const admittedTurnIds = [...admission.admittedTurnIds];
+  if (admittedTurnIds.length === 0 || admittedTurnIds[0] !== options.turnId) {
+    throw new Error("Native completion admission has an invalid turn sequence");
+  }
+  const runs = await exactSession.runs();
+  const runsByTurnId = new Map(runs.map((run) => [run.executionId, run]));
+  const missingExecution = admittedTurnIds.find((turnId) => !runsByTurnId.has(turnId));
+  if (missingExecution && now - options.registeredAt < (options.absentDispatchDeadlineMs ?? DEFAULT_ABSENT_DISPATCH_DEADLINE_MS)) {
+    return { state: "running" };
+  }
+  if (admittedTurnIds.some((turnId) => runsByTurnId.get(turnId)?.status === "active")) return { state: "running" };
+  const messages = await exactSession.messages({ limit: 1e3 });
+  const recovered = [];
+  for (const turnId of admittedTurnIds) {
+    const run = runsByTurnId.get(turnId);
+    if (!run) {
+      recovered.push(missingTurnReceipt(turnId, "Native Sandbox execution ledger is missing the admitted turn"));
+      continue;
+    }
+    const completed = run.status === "completed" ? await readCompletedSandboxTurn(source, { turnId, sessionId: options.sessionId }) : null;
+    const cached = run.status === "completed" ? await source.findCompletedTurn(turnId, { sessionId: options.sessionId }) : null;
+    if (run.status === "completed" && completed) {
+      recovered.push({
+        turnId,
+        state: "completed",
+        text: completed.text ?? "",
+        parts: completed.parts ?? [],
+        usage: completed.usage ?? {},
+        ...attribution(cached?.result)
+      });
+      continue;
+    }
+    const interrupted = interruptedMessages(messages, turnId);
+    if ((run.status === "failed" || run.status === "cancelled") && interrupted.length === 1) {
+      const message = recoverSandboxAssistantMessage(interrupted[0]);
+      const result = await exactSession.result({ executionId: turnId });
+      recovered.push({
+        turnId,
+        state: "failed",
+        text: message.text ?? result.response ?? "",
+        parts: message.parts ?? [],
+        usage: mergeUsage(message.usage ?? {}, {
+          ...usageFromResult2(result),
+          ...result.costUsd !== void 0 ? { costUsd: result.costUsd } : {}
+        }),
+        ...attribution(result),
+        error: result.error ?? interrupted[0].metadata?.interruptReason ?? status.failureReason?.message
+      });
+      continue;
+    }
+    const closedAt = timestamp(admission.closedAt) ?? timestamp(admission.updatedAt) ?? options.registeredAt;
+    if (now - closedAt < (options.receiptDeadlineMs ?? DEFAULT_RECEIPT_DEADLINE_MS)) return { state: "running" };
+    recovered.push(missingTurnReceipt(
+      turnId,
+      `Admitted native execution did not produce an exact completion: ${turnId}`
+    ));
+  }
+  const receipt = aggregateNativeCompletionReceipts(recovered);
+  return receipt.state === "completed" ? { state: "completed", receipt } : { state: "failed", receipt };
+}
+
 // src/chat-routes/durable-projection.ts
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -1829,12 +2024,12 @@ function parseAttachmentInput(value, index, validatePath) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return { succeeded: false, error: `attachments[${index}] must be an object` };
   }
-  const record = value;
-  const path = record.path;
+  const record2 = value;
+  const path = record2.path;
   if (typeof path !== "string" || !path) {
     return { succeeded: false, error: `attachments[${index}].path must be a non-empty string` };
   }
-  const name = record.name;
+  const name = record2.name;
   if (typeof name !== "string" || !name.trim()) {
     return { succeeded: false, error: `attachments[${index}].name must be a non-empty string` };
   }
@@ -1844,18 +2039,18 @@ function parseAttachmentInput(value, index, validatePath) {
   if (CONTROL_CHARS.test(name)) {
     return { succeeded: false, error: `attachments[${index}].name must not contain control characters` };
   }
-  const size = record.size;
+  const size = record2.size;
   if (typeof size !== "number" || !Number.isFinite(size)) {
     return { succeeded: false, error: `attachments[${index}].size must be a finite number` };
   }
   if (size < 0) {
     return { succeeded: false, error: `attachments[${index}].size must not be negative` };
   }
-  const mediaType = record.mediaType;
+  const mediaType = record2.mediaType;
   if (typeof mediaType !== "string") {
     return { succeeded: false, error: `attachments[${index}].mediaType must be a string` };
   }
-  const kind = record.kind;
+  const kind = record2.kind;
   if (!isAttachmentKind(kind)) {
     return { succeeded: false, error: `attachments[${index}].kind must be "image" or "file"` };
   }
@@ -1883,7 +2078,7 @@ async function resolveChatAttachments(value, options) {
     seenPaths.add(parsed.value.path);
     inputs.push(parsed.value);
   }
-  const advisoryTotal = inputs.reduce((sum, input) => sum + input.size, 0);
+  const advisoryTotal = inputs.reduce((sum2, input) => sum2 + input.size, 0);
   if (advisoryTotal > maxTotalBytes) {
     return { succeeded: false, error: attachmentTotalSizeErrorMessage(advisoryTotal, maxTotalBytes) };
   }
@@ -2369,7 +2564,7 @@ function createAttachmentUploadRoute(options) {
         `Too many files \u2014 the ${maxCount}-file limit was exceeded`
       );
     }
-    const advisoryTotal = files.reduce((sum, file) => sum + file.size, 0);
+    const advisoryTotal = files.reduce((sum2, file) => sum2 + file.size, 0);
     if (advisoryTotal > maxTotalBytes) {
       return attachmentUploadError(
         413,
@@ -2826,6 +3021,7 @@ export {
   PROMOTE_MAX_FILE_BYTES,
   UPLOAD_INLINE_MAX_BYTES,
   UPLOAD_MAX_FILE_BYTES,
+  aggregateNativeCompletionReceipts,
   assertPromptPartsWithinCap,
   assistantRowIdForTurn,
   attachmentSizeErrorMessage,
@@ -2855,12 +3051,14 @@ export {
   mediaTypeForMentionPath,
   mentionKindForPath,
   normalizeChatPromptForSandbox,
+  observeNativeCompletion,
   parseChatTurnParts,
   parseFileMentions,
   promoteAgentFilePart,
   promptPartsByteSize,
   readCompletedSandboxTurn,
   reconcileStaleTurnLock,
+  recoverSandboxAssistantMessage,
   resolveChatAttachments,
   resolveEmptyTurnRetries,
   rowIdOf,