@tangle-network/agent-app 0.43.53 → 0.43.55

package/dist/chat-routes/index.js

@@ -11,7 +11,7 @@ import {
   createSandboxFileIndexRoute,
   sanitizeAttachmentFileName,
   sniffBinary
-} from "../chunk-3EKOSBYL.js";
+} from "../chunk-K63OWUDJ.js";
 import {
   DEFAULT_STALE_TURN_LOCK_GRACE_MS,
   DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS,
@@ -54,21 +54,25 @@ import {
   promptPartsByteSize,
   toChatMessageParts,
   validateSandboxMentionPath
-} from "../chunk-JGYOYY5D.js";
+} from "../chunk-XKBIYSSM.js";
 import {
   asRecord,
   asString,
   finalizeAssistantParts,
+  finalizePendingInteractionParts,
   getPartKey,
   mergePersistedPart,
   normalizePersistedPart,
-  normalizeToolEvent
+  normalizeToolEvent,
+  terminalizeDanglingAssistantToolUpdates
 } from "../chunk-5MG74GVQ.js";
 import {
   cancelStatusFor,
   interactionPartKey,
   interactionToPersistedPart,
   isRenderableInteractionKind,
+  noticePart,
+  noticePartKey,
   parseInteractionCancel,
   parseInteractionRequest
 } from "../chunk-XAWFPMAR.js";
@@ -573,6 +577,72 @@ function usageFromStepFinish(part, usage) {
   const cost = Number(part.cost);
   if (Number.isFinite(cost)) usage.costUsd = (usage.costUsd ?? 0) + cost;
 }
+function toFiniteNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function extractReportedTurnUsage(data) {
+  const tokenUsage = asRecord(data?.tokenUsage);
+  if (!tokenUsage) return null;
+  const inputTokens = toFiniteNumber(tokenUsage.inputTokens);
+  const outputTokens = toFiniteNumber(tokenUsage.outputTokens);
+  if (inputTokens === null || outputTokens === null) return null;
+  const reported = { inputTokens, outputTokens };
+  const reasoningTokens = toFiniteNumber(tokenUsage.reasoningTokens);
+  if (reasoningTokens !== null) reported.reasoningTokens = reasoningTokens;
+  const cacheReadTokens = toFiniteNumber(tokenUsage.cacheReadInputTokens);
+  if (cacheReadTokens !== null) reported.cacheReadTokens = cacheReadTokens;
+  const cacheWriteTokens = toFiniteNumber(tokenUsage.cacheCreationInputTokens);
+  if (cacheWriteTokens !== null) reported.cacheWriteTokens = cacheWriteTokens;
+  const costUsd = toFiniteNumber(data?.totalCostUsd) ?? toFiniteNumber(tokenUsage.cost);
+  if (costUsd !== null) reported.costUsd = costUsd;
+  return reported;
+}
+function applyTerminalUsage(reported, usage) {
+  usage.inputTokens = reported.inputTokens;
+  usage.outputTokens = reported.outputTokens;
+  if (reported.reasoningTokens !== void 0) usage.reasoningTokens = reported.reasoningTokens;
+  if (reported.cacheReadTokens !== void 0) usage.cacheReadTokens = reported.cacheReadTokens;
+  if (reported.cacheWriteTokens !== void 0) usage.cacheWriteTokens = reported.cacheWriteTokens;
+  if (reported.costUsd !== void 0) usage.costUsd = reported.costUsd;
+}
+function sandboxStreamErrorMessage(data) {
+  const record = asRecord(data);
+  const message = asString(record?.message) ?? asString(record?.error);
+  if (message) return message;
+  try {
+    return JSON.stringify(data) || "Sandbox stream returned an error event without details.";
+  } catch {
+    return "Sandbox stream returned an error event without details.";
+  }
+}
+function toProducerWireEvent(event) {
+  return event;
+}
+function sandboxStreamFailureDiagnostic(error) {
+  const streamMessage = error?.streamMessage;
+  const message = typeof streamMessage === "string" ? streamMessage : error instanceof Error ? error.message : "Sandbox stream failed";
+  const diagnostics = asRecord(error?.diagnostics);
+  let diagnosticText;
+  if (diagnostics) {
+    try {
+      diagnosticText = JSON.stringify(diagnostics);
+    } catch {
+      diagnosticText = "[unserializable diagnostics]";
+    }
+  }
+  const userMessage = [
+    "The sandbox model stream stopped before a clean completion.",
+    `Error: ${message}`,
+    "Please retry. If it repeats, send these support details to the team."
+  ].join("\n\n");
+  const failureNote = diagnosticText ? `sandbox-stream: ${message}; ${diagnosticText}` : `sandbox-stream: ${message}`;
+  return { userMessage, failureNote };
+}
 function createSandboxChatProducer(options) {
   const log = options.log ?? ((message, meta) => console.error(message, meta ?? ""));
   const renderable = options.isRenderableInteraction ?? isRenderableInteractionKind;
@@ -584,6 +654,9 @@ function createSandboxChatProducer(options) {
   const announcedTools = /* @__PURE__ */ new Set();
   const settledTools = /* @__PURE__ */ new Set();
   let stepCounter = 0;
+  let danglingToolsTerminalized = false;
+  let interactionOutcome = "answered";
+  let warningCount = 0;
   const promotedFileParts = /* @__PURE__ */ new Map();
   function recordPersistedPart(part, delta, keyOverride) {
     const persisted = normalizePersistedPart(part);
@@ -592,179 +665,288 @@ function createSandboxChatProducer(options) {
     if (!partMap.has(key)) partOrder.push(key);
     partMap.set(key, mergePersistedPart(partMap.get(key), persisted, delta));
   }
+  function* emitTerminalizedTools() {
+    if (danglingToolsTerminalized) return;
+    danglingToolsTerminalized = true;
+    const updates = terminalizeDanglingAssistantToolUpdates(partOrder, partMap, fullText);
+    for (const part of updates) {
+      const toolId = asString(part.id);
+      if (!toolId || settledTools.has(toolId)) continue;
+      settledTools.add(toolId);
+      const state = asRecord(part.state);
+      yield {
+        type: "tool_result",
+        toolCallId: toolId,
+        toolName: asString(part.tool) ?? "tool",
+        outcome: {
+          ok: false,
+          ...asString(state?.error) ? { message: asString(state?.error) } : {}
+        }
+      };
+    }
+  }
+  function* emitFinalUsage() {
+    const promptTokens = usage.inputTokens ?? 0;
+    const completionTokens = usage.outputTokens ?? 0;
+    if (promptTokens || completionTokens) {
+      yield { type: "usage", usage: { promptTokens, completionTokens } };
+    }
+  }
   async function* stream() {
-    for await (const raw of options.events) {
-      const record = asRecord(raw);
-      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 : record;
-      if (event.type === "message.part.updated") {
-        const part = asRecord(event.data?.part);
-        if (!part) continue;
-        const rawDelta = event.data?.delta;
-        const partType = String(part.type ?? "");
-        if (partType === "text" || partType === "reasoning") {
-          const key = getPartKey(part);
-          const delta = textDelta(tracker, key, part, rawDelta);
-          recordPersistedPart(part, delta || void 0);
-          if (delta) {
-            if (partType === "text") fullText += delta;
-            yield { type: partType, text: delta };
+    try {
+      for await (const raw of options.events) {
+        const record = asRecord(raw);
+        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 (event.type === "message.part.updated") {
+          const part = asRecord(event.data?.part);
+          if (!part) continue;
+          const rawDelta = event.data?.delta;
+          const partType = String(part.type ?? "");
+          if (partType === "text" || partType === "reasoning") {
+            const key = getPartKey(part);
+            const delta = textDelta(tracker, key, part, rawDelta);
+            recordPersistedPart(part, delta || void 0);
+            if (delta) {
+              if (partType === "text") fullText += delta;
+              yield { type: partType, text: delta };
+            }
+            continue;
           }
-          continue;
-        }
-        if (partType === "tool") {
-          recordPersistedPart(part, void 0);
-          const persisted = partMap.get(getPartKey(part));
-          const state = asRecord(persisted?.state);
-          const toolId = String(persisted?.id ?? "");
-          const toolName = String(persisted?.tool ?? "tool");
-          if (toolId && !announcedTools.has(toolId)) {
-            announcedTools.add(toolId);
-            yield {
-              type: "tool_call",
-              call: { toolCallId: toolId, toolName, args: asRecord(state?.input) ?? {} }
-            };
+          if (partType === "tool") {
+            recordPersistedPart(part, void 0);
+            const persisted = partMap.get(getPartKey(part));
+            const state = asRecord(persisted?.state);
+            const toolId = String(persisted?.id ?? "");
+            const toolName = String(persisted?.tool ?? "tool");
+            if (toolId && !announcedTools.has(toolId)) {
+              announcedTools.add(toolId);
+              yield {
+                type: "tool_call",
+                call: { toolCallId: toolId, toolName, args: asRecord(state?.input) ?? {} }
+              };
+            }
+            const status = String(state?.status ?? "");
+            if (toolId && (status === "completed" || status === "error") && !settledTools.has(toolId)) {
+              settledTools.add(toolId);
+              yield {
+                type: "tool_result",
+                toolCallId: toolId,
+                toolName,
+                outcome: {
+                  ok: status === "completed",
+                  ...state?.output !== void 0 ? { result: state.output } : {},
+                  ...asString(state?.error) ? { message: asString(state?.error) } : {}
+                }
+              };
+            }
+            continue;
           }
-          const status = String(state?.status ?? "");
-          if (toolId && (status === "completed" || status === "error") && !settledTools.has(toolId)) {
-            settledTools.add(toolId);
-            yield {
-              type: "tool_result",
-              toolCallId: toolId,
-              toolName,
-              outcome: {
-                ok: status === "completed",
-                ...state?.output !== void 0 ? { result: state.output } : {},
-                ...asString(state?.error) ? { message: asString(state?.error) } : {}
-              }
-            };
+          if (partType === "step-finish") {
+            usageFromStepFinish(part, usage);
+            recordPersistedPart(part, void 0, `step-finish:#${stepCounter++}`);
+            const promptTokens = usage.inputTokens ?? 0;
+            const completionTokens = usage.outputTokens ?? 0;
+            if (promptTokens || completionTokens) {
+              yield { type: "usage", usage: { promptTokens, completionTokens } };
+            }
+            continue;
           }
-          continue;
-        }
-        if (partType === "step-finish") {
-          usageFromStepFinish(part, usage);
-          recordPersistedPart(part, void 0, `step-finish:#${stepCounter++}`);
-          const promptTokens = usage.inputTokens ?? 0;
-          const completionTokens = usage.outputTokens ?? 0;
-          if (promptTokens || completionTokens) {
-            yield { type: "usage", usage: { promptTokens, completionTokens } };
+          if (partType === "step-start") {
+            recordPersistedPart(part, void 0, `step-start:#${stepCounter}`);
+            continue;
           }
+          if (partType === "file" && options.promoteFilePart) {
+            const promote = options.promoteFilePart;
+            const rawId = asString(part.id);
+            const rawUrl = asString(part.url);
+            const memoKey = rawId ? `id:${rawId}` : rawUrl ? `url:${rawUrl}` : void 0;
+            const attempt = () => Promise.resolve().then(() => promote(part)).catch((err) => {
+              const reason = err instanceof Error ? err.message : String(err);
+              log("[chat-routes] file part promotion threw", { key: memoKey ?? "(keyless)", error: reason });
+              return { succeeded: false, reason };
+            });
+            let pending;
+            if (memoKey) {
+              pending = promotedFileParts.get(memoKey) ?? attempt();
+              promotedFileParts.set(memoKey, pending);
+            } else {
+              pending = attempt();
+            }
+            const outcome = await pending;
+            if (outcome.succeeded) {
+              recordPersistedPart(outcome.part, void 0, outcome.key);
+            } else if (outcome.part) {
+              recordPersistedPart(outcome.part, void 0, outcome.key);
+            } else {
+              recordPersistedPart(part, void 0);
+            }
+            continue;
+          }
+          recordPersistedPart(part, void 0);
           continue;
         }
-        if (partType === "step-start") {
-          recordPersistedPart(part, void 0, `step-start:#${stepCounter}`);
-          continue;
-        }
-        if (partType === "file" && options.promoteFilePart) {
-          const promote = options.promoteFilePart;
-          const rawId = asString(part.id);
-          const rawUrl = asString(part.url);
-          const memoKey = rawId ? `id:${rawId}` : rawUrl ? `url:${rawUrl}` : void 0;
-          const attempt = () => Promise.resolve().then(() => promote(part)).catch((err) => {
-            const reason = err instanceof Error ? err.message : String(err);
-            log("[chat-routes] file part promotion threw", { key: memoKey ?? "(keyless)", error: reason });
-            return { succeeded: false, reason };
-          });
-          let pending;
-          if (memoKey) {
-            pending = promotedFileParts.get(memoKey) ?? attempt();
-            promotedFileParts.set(memoKey, pending);
-          } else {
-            pending = attempt();
+        if (event.type === "interaction") {
+          const parsed = parseInteractionRequest(asRecord(record.data));
+          if (!parsed.succeeded) {
+            log("[chat-routes] dropping malformed interaction event", { error: parsed.error });
+            continue;
           }
-          const outcome = await pending;
-          if (outcome.succeeded) {
-            recordPersistedPart(outcome.part, void 0, outcome.key);
-          } else if (outcome.part) {
-            recordPersistedPart(outcome.part, void 0, outcome.key);
+          if (renderable(parsed.value.kind)) {
+            recordPersistedPart(
+              interactionToPersistedPart(parsed.value, "pending"),
+              void 0,
+              interactionPartKey(parsed.value.id)
+            );
+            yield toProducerWireEvent(record);
+            continue;
+          }
+          let declineFailed = false;
+          if (options.declineInteraction) {
+            try {
+              await options.declineInteraction(parsed.value.id);
+            } catch (err) {
+              declineFailed = true;
+              log("[chat-routes] failed to auto-decline interaction", {
+                id: parsed.value.id,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            }
           } else {
-            recordPersistedPart(part, void 0);
+            declineFailed = true;
+            log("[chat-routes] non-renderable interaction with no declineInteraction wired", {
+              id: parsed.value.id,
+              kind: parsed.value.kind
+            });
           }
+          const text = declineFailed ? `The agent requested ${parsed.value.kind} approval; declining it failed \u2014 it will expire on its own.` : `The agent requested ${parsed.value.kind} approval \u2014 auto-declined by policy.`;
+          const notice = noticePart("auto-declined", `auto-declined-${parsed.value.id}`, text);
+          recordPersistedPart(notice, void 0, noticePartKey(notice.id));
+          yield { type: "notice", id: notice.id, noticeKind: "auto-declined", text };
           continue;
         }
-        recordPersistedPart(part, void 0);
-        continue;
-      }
-      if (event.type === "interaction") {
-        const parsed = parseInteractionRequest(asRecord(record.data));
-        if (!parsed.succeeded) {
-          log("[chat-routes] dropping malformed interaction event", { error: parsed.error });
+        if (event.type === "interaction.cancel") {
+          const parsed = parseInteractionCancel(asRecord(record.data));
+          if (!parsed.succeeded) {
+            log("[chat-routes] dropping malformed interaction.cancel event", { error: parsed.error });
+            continue;
+          }
+          const key = interactionPartKey(parsed.value.id);
+          const existing = partMap.get(key);
+          if (existing?.type === "interaction" && existing.status === "pending") {
+            recordPersistedPart({
+              ...existing,
+              status: cancelStatusFor(parsed.value.reason),
+              ...parsed.value.reason ? { cancelReason: parsed.value.reason } : {}
+            }, void 0, key);
+          }
+          yield toProducerWireEvent(record);
           continue;
         }
-        if (renderable(parsed.value.kind)) {
-          recordPersistedPart(
-            interactionToPersistedPart(parsed.value, "pending"),
-            void 0,
-            interactionPartKey(parsed.value.id)
-          );
-          yield event;
+        if (event.type === "plan.submitted") {
+          const parsed = parsePlanSubmittedEvent(record);
+          if (!parsed.succeeded) {
+            log("[chat-routes] dropping malformed plan.submitted event", { error: parsed.error });
+            continue;
+          }
+          recordPersistedPart(planToPersistedPart(parsed.value), void 0);
+          yield toProducerWireEvent(record);
           continue;
         }
-        if (options.declineInteraction) {
-          try {
-            await options.declineInteraction(parsed.value.id);
-          } catch (err) {
-            log("[chat-routes] failed to auto-decline interaction", {
-              id: parsed.value.id,
-              error: err instanceof Error ? err.message : String(err)
-            });
+        if (event.type === "warning") {
+          const message = asString(event.data?.message);
+          if (message) {
+            warningCount += 1;
+            const code = asString(event.data?.code);
+            const text = code ? `${code}: ${message}` : message;
+            const notice = noticePart("warning", `warning-${warningCount}`, text);
+            recordPersistedPart(notice, void 0, noticePartKey(notice.id));
+            yield { type: "notice", id: notice.id, noticeKind: "warning", text };
           }
-        } else {
-          log("[chat-routes] non-renderable interaction with no declineInteraction wired", {
-            id: parsed.value.id,
-            kind: parsed.value.kind
-          });
+          yield toProducerWireEvent(record);
+          continue;
         }
-        continue;
-      }
-      if (event.type === "interaction.cancel") {
-        const parsed = parseInteractionCancel(asRecord(record.data));
-        if (!parsed.succeeded) {
-          log("[chat-routes] dropping malformed interaction.cancel event", { error: parsed.error });
+        if (event.type === "result") {
+          const finalText = asString(event.data?.finalText);
+          if (finalText) fullText = finalText;
+          const reported = extractReportedTurnUsage(asRecord(event.data));
+          if (reported) {
+            applyTerminalUsage(reported, usage);
+            yield* emitFinalUsage();
+          } else {
+            const resultUsage = asRecord(event.data?.usage);
+            if (resultUsage) {
+              const input = Number(resultUsage.inputTokens);
+              const output = Number(resultUsage.outputTokens);
+              if (Number.isFinite(input)) usage.inputTokens = input;
+              if (Number.isFinite(output)) usage.outputTokens = output;
+            }
+          }
+          yield* emitTerminalizedTools();
           continue;
         }
-        const key = interactionPartKey(parsed.value.id);
-        const existing = partMap.get(key);
-        if (existing?.type === "interaction" && existing.status === "pending") {
-          recordPersistedPart({
-            ...existing,
-            status: cancelStatusFor(parsed.value.reason),
-            ...parsed.value.reason ? { cancelReason: parsed.value.reason } : {}
-          }, void 0, key);
+        if (event.type === "done") {
+          const reported = extractReportedTurnUsage(asRecord(event.data));
+          if (reported) {
+            applyTerminalUsage(reported, usage);
+            yield* emitFinalUsage();
+          }
+          yield* emitTerminalizedTools();
+          yield toProducerWireEvent(record);
+          continue;
         }
-        yield event;
-        continue;
-      }
-      if (event.type === "plan.submitted") {
-        const parsed = parsePlanSubmittedEvent(record);
-        if (!parsed.succeeded) {
-          log("[chat-routes] dropping malformed plan.submitted event", { error: parsed.error });
+        if (event.type === "error") {
+          const message = sandboxStreamErrorMessage(event.data);
+          const errorContent = fullText.trim() ? `The sandbox model stream stopped before a clean completion.
+
+Error: ${message}` : `The sandbox agent returned an error before producing a visible answer.
+
+Error: ${message}`;
+          const errorDelta = fullText ? `
+
+---
+${errorContent}` : errorContent;
+          fullText += errorDelta;
+          interactionOutcome = "expired";
+          yield { type: "text", text: errorDelta };
+          yield* emitTerminalizedTools();
+          yield toProducerWireEvent(record);
           continue;
         }
-        recordPersistedPart(planToPersistedPart(parsed.value), void 0);
-        yield event;
-        continue;
+        yield toProducerWireEvent(record);
       }
-      if (event.type === "result") {
-        const finalText = asString(event.data?.finalText);
-        if (finalText) fullText = finalText;
-        const resultUsage = asRecord(event.data?.usage);
-        if (resultUsage) {
-          const input = Number(resultUsage.inputTokens);
-          const output = Number(resultUsage.outputTokens);
-          if (Number.isFinite(input)) usage.inputTokens = input;
-          if (Number.isFinite(output)) usage.outputTokens = output;
+    } catch (streamErr) {
+      const diagnostic = sandboxStreamFailureDiagnostic(streamErr);
+      log("[chat-routes] sandbox stream failed", {
+        failureNote: diagnostic.failureNote,
+        error: streamErr instanceof Error ? streamErr.message : String(streamErr)
+      });
+      const errorDelta = fullText ? `
+
+---
+${diagnostic.userMessage}` : diagnostic.userMessage;
+      fullText += errorDelta;
+      interactionOutcome = "expired";
+      yield { type: "text", text: errorDelta };
+      yield* emitTerminalizedTools();
+      yield {
+        type: "error",
+        data: {
+          message: diagnostic.userMessage,
+          code: "sandbox.stream_failed",
+          details: { failureNote: diagnostic.failureNote }
         }
-        continue;
-      }
-      yield event;
+      };
     }
   }
   return {
     stream: stream(),
     finalText: () => fullText,
-    assistantParts: () => finalizeAssistantParts(partOrder, partMap, fullText),
+    assistantParts: () => finalizePendingInteractionParts(
+      finalizeAssistantParts(partOrder, partMap, fullText),
+      interactionOutcome
+    ),
     usage: () => usage,
     ...options.model ? { model: options.model } : {}
   };