@tangle-network/agent-app 0.47.4 → 0.47.6

package/dist/chat-routes/index.js

@@ -26,15 +26,47 @@ import {
   sniffBinary
 } from "../chunk-SUO2R2ET.js";
 import {
-  createInteractionAnswerRoute
-} from "../chunk-ZSSCVT6H.js";
+  DEFAULT_STALE_TURN_LOCK_GRACE_MS,
+  DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS,
+  reconcileStaleTurnLock
+} from "../chunk-CCVWR33L.js";
+import {
+  ModelFailoverExhaustedError,
+  buildModelChain,
+  isUpstreamUnavailable,
+  readHttpStatusHint,
+  runWithModelFailover
+} from "../chunk-DEXBRUZR.js";
 import {
-  parseJsonObjectBody
-} from "../chunk-F7VH4G5C.js";
+  flattenHistory,
+  readSandboxBinaryBytes,
+  statSandboxFileSize
+} from "../chunk-P6YXUGNA.js";
+import "../chunk-MCYJON3F.js";
+import "../chunk-LWSJK546.js";
+import "../chunk-P5PIAQVS.js";
+import "../chunk-KBJL6LIW.js";
+import "../chunk-TX6S7XXU.js";
+import "../chunk-UGWQLQDS.js";
+import "../chunk-S5SRJJQG.js";
+import {
+  ProtectedModelSettlementError
+} from "../chunk-KHRIPDW5.js";
+import "../chunk-JML7WKWU.js";
+import {
+  assistantRowIdForTurn,
+  createAssistantDraftWriter,
+  createChatTurnRoutes,
+  isDraftContentEvent,
+  rowIdOf,
+  storeSupportsDraftPersistence,
+  streamChatRouteAsSandboxEvents
+} from "../chunk-LYAYNWDS.js";
+import "../chunk-ZSSCVT6H.js";
+import "../chunk-F7VH4G5C.js";
 import {
   attachmentInputToPart,
   attachmentKindForMime,
-  mentionInputToPart,
   toChatMessageParts
 } from "../chunk-IRYULX3R.js";
 import "../chunk-ZVEEWGDK.js";
@@ -59,10 +91,7 @@ import {
   promptPartsByteSize,
   validateSandboxMentionPath
 } from "../chunk-DXHUQ5NO.js";
-import {
-  normalizeClientTurnId,
-  resolveChatTurn
-} from "../chunk-JEZJ6HTF.js";
+import "../chunk-JEZJ6HTF.js";
 import {
   asRecord,
   asString,
@@ -90,1050 +119,10 @@ import {
   parsePlanSubmittedEvent,
   planToPersistedPart
 } from "../chunk-YJMCRXQQ.js";
-import {
-  DEFAULT_STALE_TURN_LOCK_GRACE_MS,
-  DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS,
-  reconcileStaleTurnLock
-} from "../chunk-CCVWR33L.js";
 import {
   coalesceDeltas,
-  createBufferedTurnTap,
-  replayTurnEvents,
-  stampReplaySeq
+  createBufferedTurnTap
 } from "../chunk-ES3I3UGP.js";
-import {
-  ModelFailoverExhaustedError,
-  buildModelChain,
-  isUpstreamUnavailable,
-  readHttpStatusHint,
-  runWithModelFailover
-} from "../chunk-DEXBRUZR.js";
-import {
-  flattenHistory,
-  readSandboxBinaryBytes,
-  statSandboxFileSize
-} from "../chunk-P6YXUGNA.js";
-import "../chunk-MCYJON3F.js";
-import "../chunk-LWSJK546.js";
-import "../chunk-P5PIAQVS.js";
-import "../chunk-KBJL6LIW.js";
-import "../chunk-TX6S7XXU.js";
-import "../chunk-UGWQLQDS.js";
-import "../chunk-S5SRJJQG.js";
-import "../chunk-JML7WKWU.js";
-
-// src/chat-routes/turn-routes.ts
-import {
-  deriveExecutionId,
-  handleChatTurn
-} from "@tangle-network/agent-runtime/durable";
-
-// src/chat-routes/draft-persistence.ts
-var CONTENT_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "reasoning",
-  "tool_call",
-  "tool_result",
-  "usage",
-  "notice",
-  "error",
-  "file",
-  "interaction",
-  "interaction.cancel",
-  "plan.submitted",
-  "message.part.updated"
-]);
-var DEFAULT_INTERVAL_MS = 2e3;
-var DEFAULT_BACKOFF_BYTES = 262144;
-var DEFAULT_MAX_DRAFT_TOOL_OUTPUT_BYTES = 32768;
-function isDraftContentEvent(event) {
-  return typeof event?.type === "string" && CONTENT_EVENT_TYPES.has(event.type);
-}
-function capDraftToolOutput(part, maxBytes) {
-  if (maxBytes <= 0) return part;
-  if (String(part.type ?? "") !== "tool") return part;
-  const state = part.state;
-  if (!state || typeof state !== "object") return part;
-  const record = state;
-  const output = record.output;
-  if (output === void 0 || output === null) return part;
-  const serialized = typeof output === "string" ? output : safeStringify(output);
-  if (serialized.length <= maxBytes) return part;
-  const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
-  return {
-    ...part,
-    state: {
-      ...record,
-      output: `${serialized.slice(0, maxBytes)}\u2026[draft-truncated ${serialized.length - maxBytes} chars]`,
-      metadata: { ...metadata, draftTruncated: true }
-    }
-  };
-}
-function safeStringify(value) {
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return String(value);
-  }
-}
-function createAssistantDraftWriter(options) {
-  const log = options.log ?? (() => {
-  });
-  const baseIntervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
-  const backoffBytes = options.backoffBytes ?? DEFAULT_BACKOFF_BYTES;
-  const maxToolOutput = options.maxDraftToolOutputBytes ?? DEFAULT_MAX_DRAFT_TOOL_OUTPUT_BYTES;
-  let dirty = false;
-  let closed = false;
-  let inFlight;
-  let lastWriteAt = 0;
-  let lastBlobBytes = 0;
-  let rowId;
-  let writes = 0;
-  function currentIntervalMs() {
-    if (lastBlobBytes >= backoffBytes * 10) return baseIntervalMs * 5;
-    if (lastBlobBytes >= backoffBytes) return Math.round(baseIntervalMs * 2.5);
-    return baseIntervalMs;
-  }
-  async function projectValues(snapshot) {
-    const transform = options.transformText;
-    const content = transform ? await transform(snapshot.content) : snapshot.content;
-    let parts;
-    if (snapshot.parts) {
-      const capped = snapshot.parts.map((part) => capDraftToolOutput(part, maxToolOutput));
-      const redacted = transform ? await Promise.all(
-        capped.map(
-          async (part) => String(part.type ?? "") === "text" ? { ...part, text: await transform(String(part.text ?? "")) } : part
-        )
-      ) : capped;
-      parts = toChatMessageParts(redacted);
-    }
-    const usage = snapshot.usage ?? {};
-    return {
-      content,
-      ...parts && parts.length > 0 ? { parts } : {},
-      ...snapshot.model ? { model: snapshot.model } : {},
-      ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
-      ...usage.outputTokens !== void 0 ? { outputTokens: usage.outputTokens } : {},
-      ...usage.reasoningTokens !== void 0 ? { reasoningTokens: usage.reasoningTokens } : {},
-      ...usage.cacheReadTokens !== void 0 ? { cacheReadTokens: usage.cacheReadTokens } : {},
-      ...usage.cacheWriteTokens !== void 0 ? { cacheWriteTokens: usage.cacheWriteTokens } : {},
-      ...usage.costUsd !== void 0 ? { costUsd: usage.costUsd } : {}
-    };
-  }
-  async function adoptRow() {
-    if (rowId) return rowId;
-    const existing = (await options.store.listMessages(options.threadId)).find(
-      (message) => message.id === options.messageId
-    );
-    if (existing) rowId = existing.id;
-    return rowId;
-  }
-  async function writeOnce(values) {
-    if (await adoptRow()) {
-      await options.store.updateMessage(rowId, values);
-      writes += 1;
-      return;
-    }
-    const inserted = await options.store.appendMessage({
-      id: options.messageId,
-      threadId: options.threadId,
-      role: "assistant",
-      ...values
-    });
-    rowId = rowIdOf(inserted) ?? options.messageId;
-    writes += 1;
-  }
-  function trigger() {
-    if (closed) return;
-    if (!dirty) return;
-    if (inFlight) return;
-    const now = Date.now();
-    if (lastWriteAt !== 0 && now - lastWriteAt < currentIntervalMs()) return;
-    const snapshot = options.snapshot();
-    if (!snapshot) return;
-    if (!snapshot.content && (!snapshot.parts || snapshot.parts.length === 0)) return;
-    dirty = false;
-    lastWriteAt = now;
-    inFlight = (async () => {
-      try {
-        const values = await projectValues(snapshot);
-        lastBlobBytes = values.parts ? safeStringify(values.parts).length : 0;
-        await writeOnce(values);
-      } catch (err) {
-        log("[chat-routes] incremental assistant persistence failed", {
-          messageId: options.messageId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      } finally {
-        inFlight = void 0;
-        if (dirty && !closed) trigger();
-      }
-    })();
-  }
-  return {
-    notify(event) {
-      if (closed) return;
-      if (isDraftContentEvent(event)) dirty = true;
-      trigger();
-    },
-    async close() {
-      closed = true;
-      if (inFlight) await inFlight;
-    },
-    async finalize(values) {
-      closed = true;
-      if (inFlight) await inFlight;
-      await writeOnce(values);
-    },
-    rowId: () => rowId,
-    async discard() {
-      closed = true;
-      if (inFlight) await inFlight;
-      if (!options.store.deleteMessage) return;
-      try {
-        if (!await adoptRow()) return;
-        await options.store.deleteMessage(rowId);
-        rowId = void 0;
-      } catch (err) {
-        log("[chat-routes] draft assistant row discard failed", {
-          messageId: options.messageId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    },
-    writeCount: () => writes
-  };
-}
-function storeSupportsDraftPersistence(store) {
-  return typeof store.updateMessage === "function";
-}
-function rowIdOf(inserted) {
-  const id = inserted?.id;
-  return typeof id === "string" && id ? id : null;
-}
-function assistantRowIdForTurn(turnKey) {
-  return `assistant:${turnKey}`;
-}
-
-// src/chat-routes/turn-routes.ts
-function failureReasonOf(data) {
-  if (!data) return void 0;
-  const message = data.message ?? data.error ?? data.reason;
-  if (typeof message === "string" && message.length > 0) return message;
-  return void 0;
-}
-function errorResponse(err) {
-  return Response.json({ code: err.code, error: err.message }, { status: err.status });
-}
-function validateTurnBody(body, maxInlinePartBytes) {
-  const threadId = typeof body.threadId === "string" ? body.threadId.trim() : "";
-  if (!threadId) throw new ChatTurnInputError("Missing threadId");
-  const rawContent = body.content ?? body.message ?? "";
-  if (typeof rawContent !== "string") throw new ChatTurnInputError("content must be a string");
-  const content = rawContent.trim();
-  const fileParts = parseChatTurnParts(body.parts);
-  const mentions = parseFileMentions(body.mentions);
-  const hasAttachments = Array.isArray(body.attachments) && body.attachments.length > 0;
-  if (!content && fileParts.length === 0 && mentions.length === 0 && !hasAttachments) {
-    throw new ChatTurnInputError("Missing content (send text, parts, mentions, attachments, or any combination)");
-  }
-  assertPromptPartsWithinCap(fileParts, maxInlinePartBytes);
-  let turnId;
-  try {
-    turnId = normalizeClientTurnId(body.turnId);
-  } catch (err) {
-    throw new ChatTurnInputError(err instanceof Error ? err.message : "Invalid turnId");
-  }
-  return {
-    // The VALIDATED, deduped mention list replaces the raw one on the payload,
-    // so every downstream seam (`authorize`, `contextGate`, `beforeTurn`,
-    // `produce`) reads checked paths and never the request's own.
-    payload: { ...body, threadId, content, mentions },
-    content,
-    fileParts,
-    mentions,
-    turnId
-  };
-}
-function userPartsWithFiles(userParts, fileParts, mentions) {
-  return toChatMessageParts([
-    ...userParts,
-    ...fileParts.map((part) => ({ ...part })),
-    ...mentions.map((mention) => ({ ...mentionInputToPart(mention) }))
-  ]);
-}
-async function* tapRawEvents(source, onRawEvent, log) {
-  for await (const event of source) {
-    try {
-      await onRawEvent(event);
-    } catch (err) {
-      log("[chat-routes] onRawEvent failed", { error: err instanceof Error ? err.message : String(err) });
-    }
-    yield event;
-  }
-}
-async function* withStreamHeartbeat(source, intervalMs, makeEvent) {
-  const iterator = source[Symbol.asyncIterator]();
-  try {
-    let pending = iterator.next();
-    let windowStart = Date.now();
-    let tick = 0;
-    for (; ; ) {
-      let timer;
-      let winner;
-      try {
-        const heartbeat = new Promise((resolve) => {
-          timer = setTimeout(() => resolve("heartbeat"), intervalMs);
-        });
-        winner = await Promise.race([pending.then(() => "event"), heartbeat]);
-      } finally {
-        if (timer !== void 0) clearTimeout(timer);
-      }
-      if (winner === "heartbeat") {
-        tick += 1;
-        yield makeEvent({ elapsedMs: Date.now() - windowStart, tick });
-        continue;
-      }
-      const result = await pending;
-      if (result.done) return;
-      yield result.value;
-      pending = iterator.next();
-      windowStart = Date.now();
-      tick = 0;
-    }
-  } finally {
-    await iterator.return?.();
-  }
-}
-function createChatTurnRoutes(options) {
-  const log = options.log ?? ((message, meta) => console.error(message, meta ?? ""));
-  const draftStore = options.store;
-  if (options.incrementalPersistence && !storeSupportsDraftPersistence(draftStore)) {
-    throw new Error(
-      "incrementalPersistence requires a store with updateMessage() \u2014 `/chat-store`'s createChatStore has it; a product store must implement it or omit the option"
-    );
-  }
-  const draftTuning = options.incrementalPersistence === false || !storeSupportsDraftPersistence(draftStore) ? null : options.incrementalPersistence ?? {};
-  async function turn(request, ctx) {
-    const [rawBody, badBody] = await parseJsonObjectBody(request);
-    if (badBody) return badBody;
-    let parsed;
-    try {
-      parsed = validateTurnBody(rawBody, options.maxInlinePartBytes);
-    } catch (err) {
-      if (err instanceof ChatTurnInputError) return errorResponse(err);
-      throw err;
-    }
-    const { payload, content, fileParts, mentions, turnId } = parsed;
-    const auth = await options.authorize({ request, intent: "turn", body: payload });
-    if (!auth.ok) return auth.response;
-    const { tenantId, userId, context } = auth;
-    const existingMessages = (await options.store.listMessages(payload.threadId)).map((m) => ({
-      id: m.id,
-      role: m.role,
-      content: m.content,
-      parts: m.parts ?? null
-    }));
-    let hasRunningTurn = false;
-    if (draftTuning && existingMessages.at(-1)?.role === "assistant") {
-      try {
-        hasRunningTurn = (await options.turnStore.listRunning?.(payload.threadId) ?? []).length > 0;
-      } catch (err) {
-        log("[chat-routes] listRunning probe failed; treating the thread as idle", {
-          threadId: payload.threadId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    const chatTurn = resolveChatTurn({ existingMessages, userContent: content, turnId, hasRunningTurn });
-    const identity = {
-      tenantId,
-      sessionId: payload.threadId,
-      userId,
-      turnIndex: chatTurn.turnIndex
-    };
-    const executionId = deriveExecutionId({
-      projectId: options.projectId,
-      sessionId: payload.threadId,
-      turnIndex: chatTurn.turnIndex
-    });
-    const turnStreamId = crypto.randomUUID();
-    const prompt = fileParts.length === 0 ? content : content ? [{ type: "text", text: content }, ...fileParts] : [...fileParts];
-    let produceArgs = {
-      request,
-      body: payload,
-      identity,
-      context,
-      prompt,
-      executionId,
-      turnStreamId,
-      priorMessages: chatTurn.priorMessages,
-      ...ctx?.executionLimits ? { executionLimits: ctx.executionLimits } : {}
-    };
-    let lockAcquired = false;
-    let lockHandle;
-    let lockReleased = false;
-    const releaseLock = async () => {
-      if (!lockAcquired || lockReleased) return;
-      lockReleased = true;
-      try {
-        await options.turnLock.release(lockHandle);
-      } catch (err) {
-        log("[chat-routes] turnLock.release failed", {
-          turnId: turnStreamId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    };
-    if (options.turnLock) {
-      const acquired = await options.turnLock.acquire(produceArgs);
-      if (!acquired.acquired) return acquired.response;
-      lockAcquired = true;
-      lockHandle = acquired.handle;
-    }
-    let producer;
-    let draft;
-    let assistantMessageId;
-    const assistantRowId = () => assistantMessageId ?? draft?.rowId() ?? null;
-    let runFailed = false;
-    let lastFailureData;
-    let turnStartedAtMs = 0;
-    let turnStarted = false;
-    let lifecycleSettled = false;
-    let gatedTurn = false;
-    const fireTerminalLifecycle = async (failed, terminalError) => {
-      if (lifecycleSettled) return;
-      lifecycleSettled = true;
-      const lifecycle = options.lifecycle;
-      if (!lifecycle) return;
-      const durationMs = Date.now() - turnStartedAtMs;
-      try {
-        if (failed) {
-          await lifecycle.onTurnError?.({
-            identity,
-            executionId,
-            turnStreamId,
-            context,
-            durationMs,
-            error: terminalError ?? lastFailureData ?? new Error("chat turn failed")
-          });
-        } else {
-          const failoverInfo = producer?.modelFailover?.();
-          const attribution = producer?.modelAttribution?.();
-          await lifecycle.onTurnComplete?.({
-            identity,
-            executionId,
-            turnStreamId,
-            context,
-            durationMs,
-            finalText: producer?.finalText() ?? "",
-            usage: producer?.usage?.() ?? {},
-            assistantMessageId: assistantRowId(),
-            ...gatedTurn ? { gated: true } : {},
-            ...producer?.model ? { model: producer.model } : {},
-            ...attribution?.requestedModel ? { requestedModel: attribution.requestedModel } : {},
-            ...attribution?.servedModel ? { servedModel: attribution.servedModel } : {},
-            ...attribution?.servedProvider ? { servedProvider: attribution.servedProvider } : {},
-            ...attribution?.servedSource ? { servedSource: attribution.servedSource } : {},
-            ...failoverInfo ? { modelFailover: failoverInfo } : {}
-          });
-        }
-      } catch (err) {
-        log("[chat-routes] lifecycle terminal hook failed", {
-          turnId: turnStreamId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    };
-    try {
-      const insertUserMessage = chatTurn.shouldInsertUserMessage && (auth.insertUserMessage ?? true);
-      let userMessageId = chatTurn.reusedUserMessageId ?? null;
-      if (insertUserMessage) {
-        userMessageId = rowIdOf(
-          await options.store.appendMessage({
-            threadId: payload.threadId,
-            role: "user",
-            content,
-            parts: userPartsWithFiles(chatTurn.userParts, fileParts, mentions)
-          })
-        );
-      }
-      produceArgs = { ...produceArgs, userMessageId };
-      if (options.contextGate) {
-        const gate = await options.contextGate(produceArgs);
-        if (gate.proceed === "handoff") {
-          await releaseLock();
-          return gate.response;
-        }
-        if (!gate.proceed) {
-          await releaseLock();
-          gatedTurn = true;
-          turnStartedAtMs = Date.now();
-          if (options.lifecycle?.onTurnStart) {
-            try {
-              await options.lifecycle.onTurnStart({
-                identity,
-                executionId,
-                turnStreamId,
-                context,
-                startedAt: turnStartedAtMs
-              });
-            } catch (err) {
-              log("[chat-routes] lifecycle.onTurnStart failed", {
-                turnId: turnStreamId,
-                error: err instanceof Error ? err.message : String(err)
-              });
-            }
-          }
-          await fireTerminalLifecycle(false, void 0);
-          return gate.response;
-        }
-      }
-      if (options.beforeTurn) {
-        const patch = await options.beforeTurn(produceArgs);
-        if (patch) produceArgs = { ...produceArgs, ...patch };
-      }
-      const tap = createBufferedTurnTap({
-        store: options.turnStore,
-        turnId: turnStreamId,
-        scopeId: payload.threadId,
-        coalesce: options.coalesceTurnEvents ?? coalesceDeltas
-      });
-      const turnMarker = { type: "turn", turnId: turnStreamId };
-      await tap.onEvent(turnMarker);
-      if (draftTuning) {
-        draft = createAssistantDraftWriter({
-          ...draftTuning,
-          store: draftStore,
-          threadId: payload.threadId,
-          messageId: options.draftMessageId ? options.draftMessageId({ identity, executionId, threadId: payload.threadId }) : assistantRowIdForTurn(executionId),
-          snapshot: () => {
-            if (!producer) return null;
-            return {
-              content: producer.finalText(),
-              ...producer.draftParts ? { parts: producer.draftParts() } : {},
-              ...producer.usage ? { usage: producer.usage() } : {},
-              ...producer.model ? { model: producer.model } : {}
-            };
-          },
-          ...options.transformFinalText ? { transformText: options.transformFinalText } : {},
-          log
-        });
-      }
-      turnStartedAtMs = Date.now();
-      turnStarted = true;
-      if (options.lifecycle?.onTurnStart) {
-        try {
-          await options.lifecycle.onTurnStart({
-            identity,
-            executionId,
-            turnStreamId,
-            context,
-            startedAt: turnStartedAtMs
-          });
-        } catch (err) {
-          log("[chat-routes] lifecycle.onTurnStart failed", {
-            turnId: turnStreamId,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-      }
-      const result = handleChatTurn({
-        identity,
-        waitUntil: ctx?.waitUntil,
-        log,
-        hooks: {
-          // The engine wants a synchronous producer; box resolution is async —
-          // defer it into the generator's first pull.
-          produce: () => ({
-            stream: (async function* () {
-              producer = await options.produce(produceArgs);
-              let source = producer.stream;
-              if (ctx?.cancelOnDisconnect) {
-                source = abortOnSignal(source, request.signal);
-              }
-              if (options.onRawEvent) {
-                source = tapRawEvents(source, (event) => options.onRawEvent(event, context), log);
-              }
-              if (options.heartbeat) {
-                source = withStreamHeartbeat(source, options.heartbeat.intervalMs, options.heartbeat.event);
-              }
-              for await (const event of source) yield event;
-            })(),
-            finalText: () => producer?.finalText() ?? ""
-          }),
-          onEvent: async (event) => {
-            if (event.type === "session.run.failed" || event.type === "error") {
-              runFailed = true;
-              lastFailureData = event.data;
-            }
-            await tap.onEvent(event);
-            draft?.notify(event);
-            if (options.onEvent) await options.onEvent(event, context);
-          },
-          ...options.transformFinalText ? { transformFinalText: options.transformFinalText } : {},
-          persistAssistantMessage: async ({ finalText }) => {
-            if (ctx?.cancelOnDisconnect && request.signal.aborted) {
-              await draft?.discard();
-              assistantMessageId = null;
-              return;
-            }
-            const rawParts = producer?.assistantParts ? producer.assistantParts() : void 0;
-            const projected = rawParts && options.transformFinalText ? await Promise.all(
-              rawParts.map(
-                async (part) => String(part.type ?? "") === "text" ? { ...part, text: await options.transformFinalText(String(part.text ?? "")) } : part
-              )
-            ) : rawParts;
-            const parts = projected ? toChatMessageParts(projected) : void 0;
-            if (!finalText.trim() && (!parts || parts.length === 0)) {
-              await draft?.discard();
-              assistantMessageId = draft?.rowId() ?? null;
-              return;
-            }
-            const usage = producer?.usage?.() ?? {};
-            const attribution = producer?.modelAttribution?.();
-            const values = {
-              content: finalText,
-              ...parts && parts.length > 0 ? { parts } : {},
-              ...producer?.model ? { model: producer.model } : {},
-              ...attribution?.requestedModel ? { requestedModel: attribution.requestedModel } : {},
-              ...attribution?.servedModel ? { servedModel: attribution.servedModel } : {},
-              ...attribution?.servedProvider ? { servedProvider: attribution.servedProvider } : {},
-              ...attribution?.servedSource ? { servedSource: attribution.servedSource } : {},
-              ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
-              ...usage.outputTokens !== void 0 ? { outputTokens: usage.outputTokens } : {},
-              ...usage.reasoningTokens !== void 0 ? { reasoningTokens: usage.reasoningTokens } : {},
-              ...usage.cacheReadTokens !== void 0 ? { cacheReadTokens: usage.cacheReadTokens } : {},
-              ...usage.cacheWriteTokens !== void 0 ? { cacheWriteTokens: usage.cacheWriteTokens } : {},
-              ...usage.costUsd !== void 0 ? { costUsd: usage.costUsd } : {}
-            };
-            if (draft) {
-              await draft.finalize(values);
-              assistantMessageId = draft.rowId() ?? null;
-              return;
-            }
-            assistantMessageId = rowIdOf(
-              await options.store.appendMessage({
-                threadId: payload.threadId,
-                role: "assistant",
-                ...values
-              })
-            );
-          },
-          ...options.onTurnComplete ? {
-            // Wired into the engine's completion hook, which fires only when
-            // the stream ended without throwing. A terminal error EVENT
-            // (not a throw) still lands here — so surface `runFailed` so the
-            // product skips billing an errored turn instead of marking it
-            // complete with empty text.
-            onTurnComplete: ({ identity: turnIdentity, finalText }) => {
-              const failoverInfo = producer?.modelFailover?.();
-              const attribution = producer?.modelAttribution?.();
-              return options.onTurnComplete({
-                identity: turnIdentity,
-                finalText,
-                context,
-                failed: runFailed,
-                assistantMessageId: assistantRowId(),
-                ...runFailed ? { failureReason: failureReasonOf(lastFailureData) } : {},
-                ...producer?.model ? { model: producer.model } : {},
-                ...attribution?.requestedModel ? { requestedModel: attribution.requestedModel } : {},
-                ...attribution?.servedModel ? { servedModel: attribution.servedModel } : {},
-                ...attribution?.servedProvider ? { servedProvider: attribution.servedProvider } : {},
-                ...attribution?.servedSource ? { servedSource: attribution.servedSource } : {},
-                ...failoverInfo ? { modelFailover: failoverInfo } : {}
-              });
-            }
-          } : {},
-          ...options.traceFlush ? { traceFlush: () => options.traceFlush(context) } : {}
-        }
-      });
-      const [clientBody, drainBody] = result.body.tee();
-      const drained = (async () => {
-        const reader = drainBody.getReader();
-        let drainError;
-        try {
-          for (; ; ) {
-            const { done } = await reader.read();
-            if (done) break;
-          }
-        } catch (err) {
-          drainError = err;
-          log("[chat-routes] turn drain failed", {
-            turnId: turnStreamId,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-        const failed = runFailed || drainError !== void 0;
-        if (ctx?.cancelOnDisconnect && request.signal.aborted) {
-          await draft?.discard();
-        } else {
-          await draft?.close();
-        }
-        try {
-          await tap.done(failed ? "error" : "complete");
-        } catch (err) {
-          log("[chat-routes] turn buffer finalize failed", {
-            turnId: turnStreamId,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-        await fireTerminalLifecycle(failed, drainError);
-        await releaseLock();
-      })();
-      if (ctx?.waitUntil) ctx.waitUntil(drained);
-      else void drained.catch(() => {
-      });
-      const encoder = new TextEncoder();
-      const marker = new ReadableStream({
-        start(controller) {
-          controller.enqueue(encoder.encode(`${JSON.stringify(turnMarker)}
-`));
-          controller.close();
-        }
-      });
-      const body = concatStreams([marker, clientBody]);
-      return new Response(body, {
-        headers: {
-          "Content-Type": result.contentType,
-          "Cache-Control": "no-cache",
-          "X-Turn-Id": turnStreamId
-        }
-      });
-    } catch (err) {
-      if (turnStarted) await fireTerminalLifecycle(true, err);
-      await releaseLock();
-      throw err;
-    }
-  }
-  async function replay(request, params) {
-    const turnId = params.turnId?.trim();
-    if (!turnId) return Response.json({ error: "Missing turnId" }, { status: 400 });
-    const auth = await options.authorize({ request, intent: "replay", turnId });
-    if (!auth.ok) return auth.response;
-    const fromSeqRaw = new URL(request.url).searchParams.get("fromSeq");
-    const fromSeq = fromSeqRaw ? Math.max(0, Math.trunc(Number(fromSeqRaw)) || 0) : 0;
-    const encoder = new TextEncoder();
-    const events = replayTurnEvents({
-      store: options.turnStore,
-      turnId,
-      fromSeq,
-      ...options.replay?.pollMs !== void 0 ? { pollMs: options.replay.pollMs } : {},
-      ...options.replay?.timeoutMs !== void 0 ? { timeoutMs: options.replay.timeoutMs } : {}
-    });
-    const body = new ReadableStream({
-      async pull(controller) {
-        const { done, value } = await events.next();
-        if (done) {
-          controller.close();
-          return;
-        }
-        controller.enqueue(encoder.encode(`${stampReplaySeq(value)}
-`));
-      },
-      cancel() {
-        void events.return(void 0);
-      }
-    });
-    return new Response(body, {
-      headers: {
-        "Content-Type": "application/x-ndjson",
-        "Cache-Control": "no-cache"
-      }
-    });
-  }
-  async function running(request) {
-    const threadId = new URL(request.url).searchParams.get("threadId")?.trim();
-    if (!threadId) return Response.json({ error: "Missing threadId" }, { status: 400 });
-    const auth = await options.authorize({ request, intent: "running", threadId });
-    if (!auth.ok) return auth.response;
-    const ids = await options.turnStore.listRunning?.(threadId) ?? [];
-    return Response.json({ running: ids });
-  }
-  return {
-    turn,
-    replay,
-    running,
-    interactions: options.interactions ? createInteractionAnswerRoute(options.interactions) : null
-  };
-}
-function concatStreams(streams) {
-  let index = 0;
-  let reader = null;
-  return new ReadableStream({
-    async pull(controller) {
-      for (; ; ) {
-        if (!reader) {
-          const next = streams[index++];
-          if (!next) {
-            controller.close();
-            return;
-          }
-          reader = next.getReader();
-        }
-        const { done, value } = await reader.read();
-        if (done) {
-          reader = null;
-          continue;
-        }
-        controller.enqueue(value);
-        return;
-      }
-    },
-    async cancel(reason) {
-      await reader?.cancel(reason);
-      for (const stream of streams.slice(index)) await stream.cancel(reason);
-    }
-  });
-}
-async function* abortOnSignal(source, signal) {
-  const iterator = source[Symbol.asyncIterator]();
-  try {
-    for (; ; ) {
-      const next = await nextWithAbort(iterator, signal);
-      if (next.done) return;
-      yield next.value;
-    }
-  } finally {
-    await closeIteratorAfterAbort(iterator);
-  }
-}
-function nextWithAbort(iterator, signal) {
-  if (signal.aborted) return Promise.reject(new Error("chat turn cancelled"));
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const cleanup = () => signal.removeEventListener("abort", onAbort);
-    const onAbort = () => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      reject(new Error("chat turn cancelled"));
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    if (signal.aborted) {
-      onAbort();
-      return;
-    }
-    Promise.resolve().then(() => iterator.next()).then(
-      (result) => {
-        if (settled) return;
-        settled = true;
-        cleanup();
-        resolve(result);
-      },
-      (error) => {
-        if (settled) return;
-        settled = true;
-        cleanup();
-        reject(error);
-      }
-    );
-  });
-}
-var ABORT_CLEANUP_TIMEOUT_MS = 50;
-async function closeIteratorAfterAbort(iterator) {
-  let closing;
-  try {
-    const result = iterator.return?.();
-    if (result) closing = Promise.resolve(result);
-  } catch {
-    return;
-  }
-  if (!closing) return;
-  let timeout;
-  try {
-    await Promise.race([
-      Promise.resolve(closing).catch(() => void 0),
-      new Promise((resolve) => {
-        timeout = setTimeout(resolve, ABORT_CLEANUP_TIMEOUT_MS);
-      })
-    ]);
-  } finally {
-    if (timeout !== void 0) clearTimeout(timeout);
-  }
-}
-
-// src/chat-routes/gateway-adapter.ts
-async function* streamChatRouteAsSandboxEvents(options) {
-  const parentSignal = options.signal ?? options.request.signal;
-  if (parentSignal.aborted) return;
-  let reader;
-  const stopForwarding = () => void reader?.cancel();
-  parentSignal.addEventListener("abort", stopForwarding, { once: true });
-  const request = new Request(options.request.url, {
-    ...chatTurnRequestInit(options.payload),
-    headers: options.request.headers
-  });
-  request.headers.set("Content-Type", "application/json");
-  let complete = false;
-  try {
-    const response = await options.routes.turn(
-      request,
-      {
-        ...options.waitUntil ? { waitUntil: options.waitUntil } : {},
-        ...options.executionLimits ? { executionLimits: options.executionLimits } : {}
-      }
-    );
-    if (!response.ok) {
-      await response.body?.cancel().catch(() => void 0);
-      throw new Error(`chat route rejected the gateway turn (${response.status})`);
-    }
-    if (!response.body) throw new Error("chat route returned no stream");
-    reader = response.body.getReader();
-    if (parentSignal.aborted) {
-      await reader.cancel().catch(() => void 0);
-      return;
-    }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    for (; ; ) {
-      const chunk = await reader.read();
-      if (chunk.done) {
-        complete = true;
-        buffer += decoder.decode();
-        const event = toSandboxEvent(parseEvent(buffer));
-        if (event) yield event;
-        break;
-      }
-      buffer += decoder.decode(chunk.value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const event = toSandboxEvent(parseEvent(line));
-        if (event) yield event;
-      }
-    }
-  } finally {
-    if (!complete) await reader?.cancel().catch(() => void 0);
-    reader?.releaseLock();
-    parentSignal.removeEventListener("abort", stopForwarding);
-  }
-}
-function parseEvent(line) {
-  if (!line.trim()) return null;
-  let value;
-  try {
-    value = JSON.parse(line);
-  } catch {
-    throw new Error("chat route returned invalid NDJSON");
-  }
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("chat route returned a non-object event");
-  }
-  const event = value;
-  if (event.type !== void 0 && typeof event.type !== "string") {
-    throw new Error("chat route returned an invalid event type");
-  }
-  const data = event.data;
-  if (data !== void 0 && (!data || typeof data !== "object" || Array.isArray(data))) {
-    throw new Error("chat route returned invalid event data");
-  }
-  const dataUsage = data && data.usage;
-  if (dataUsage !== void 0 && (!dataUsage || typeof dataUsage !== "object" || Array.isArray(dataUsage))) {
-    throw new Error("chat route returned invalid data.usage");
-  }
-  if (event.text !== void 0 && typeof event.text !== "string") {
-    throw new Error("chat route returned an invalid text event");
-  }
-  const usage = event.usage;
-  if (usage !== void 0 && (!usage || typeof usage !== "object" || Array.isArray(usage))) {
-    throw new Error("chat route returned invalid usage");
-  }
-  if (event.toolName !== void 0 && typeof event.toolName !== "string") {
-    throw new Error("chat route returned an invalid tool name");
-  }
-  return {
-    ...typeof event.type === "string" ? { type: event.type } : {},
-    ...data ? { data } : {},
-    ...typeof event.text === "string" ? { text: event.text } : {},
-    ...usage ? { usage } : {},
-    ...typeof event.toolName === "string" ? { toolName: event.toolName } : {}
-  };
-}
-function isNonNegativeSafeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function aliasedSafeInteger(usage, field, alias) {
-  const value = usage[field];
-  const aliasValue = alias ? usage[alias] : void 0;
-  for (const candidate of [value, aliasValue]) {
-    if (candidate !== void 0 && !isNonNegativeSafeInteger(candidate)) {
-      throw new Error(`chat route returned invalid usage.${field}`);
-    }
-  }
-  if (value !== void 0 && aliasValue !== void 0 && value !== aliasValue) {
-    throw new Error(`chat route returned conflicting usage.${field}`);
-  }
-  return value ?? aliasValue;
-}
-function aliasedNonNegativeNumber(usage, field, alias) {
-  const value = usage[field];
-  const aliasValue = alias ? usage[alias] : void 0;
-  for (const candidate of [value, aliasValue]) {
-    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
-      throw new Error(`chat route returned invalid usage.${field}`);
-    }
-  }
-  if (value !== void 0 && aliasValue !== void 0 && value !== aliasValue) {
-    throw new Error(`chat route returned conflicting usage.${field}`);
-  }
-  return value ?? aliasValue;
-}
-function providerUsageUpdate(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const source = value;
-  const usage = {};
-  const inputTokens = aliasedSafeInteger(source, "inputTokens", "promptTokens");
-  const outputTokens = aliasedSafeInteger(source, "outputTokens", "completionTokens");
-  const reasoningTokens = aliasedSafeInteger(source, "reasoningTokens");
-  const toolTokens = aliasedSafeInteger(source, "toolTokens");
-  const toolCallCount = aliasedSafeInteger(source, "toolCallCount");
-  const providerCostUsd = aliasedNonNegativeNumber(source, "providerCostUsd", "costUsd");
-  if (inputTokens !== void 0) usage.inputTokens = inputTokens;
-  if (outputTokens !== void 0) usage.outputTokens = outputTokens;
-  if (reasoningTokens !== void 0) usage.reasoningTokens = reasoningTokens;
-  if (toolTokens !== void 0) usage.toolTokens = toolTokens;
-  if (toolCallCount !== void 0) usage.toolCallCount = toolCallCount;
-  if (providerCostUsd !== void 0) usage.providerCostUsd = providerCostUsd;
-  if (source.budgetEnforced !== void 0) {
-    if (typeof source.budgetEnforced !== "boolean") {
-      throw new Error("chat route returned invalid usage.budgetEnforced");
-    }
-    usage.budgetEnforced = source.budgetEnforced;
-  }
-  return Object.keys(usage).length > 0 ? usage : null;
-}
-function toSandboxEvent(event) {
-  if (!event) return null;
-  if (event.type === "text") {
-    if (event.text === void 0) throw new Error("chat route text event had no text");
-    return {
-      type: "message.part.updated",
-      data: { part: { type: "text" }, delta: event.text }
-    };
-  }
-  if (event.type === "reasoning") return null;
-  if (event.type === "usage" || event.usage || event.data?.usage) {
-    const usage = providerUsageUpdate(event.usage ?? event.data?.usage);
-    if (!usage) return null;
-    return { type: "usage", data: { usage } };
-  }
-  if (event.type === "tool_result") {
-    if (!event.toolName) throw new Error("chat route tool result had no tool name");
-    return { type: "tool_result", data: { tool: { name: event.toolName } } };
-  }
-  if (event.type === "input-required" && !event.data?.inputRequired) {
-    const prompt = typeof event.data?.prompt === "string" ? event.data.prompt : void 0;
-    return {
-      type: "input-required",
-      data: { inputRequired: prompt ? { prompt } : {} }
-    };
-  }
-  return {
-    ...event.type ? { type: event.type } : {},
-    ...event.data ? { data: event.data } : {}
-  };
-}
 
 // src/chat-routes/model-failover-stream.ts
 var TERMINAL_FAILURE_TYPES = /* @__PURE__ */ new Set(["error", "session.run.failed"]);
@@ -2051,6 +1040,184 @@ ${diagnostic.userMessage}` : diagnostic.userMessage;
   };
 }
 
+// src/chat-routes/protected-runtime-producer.ts
+import { createExecutor, streamAgentTurn } from "@tangle-network/agent-runtime/kernel";
+import {
+  runProtectedAgentCandidateModelGrant
+} from "@tangle-network/agent-runtime/candidate-execution";
+function createProtectedRuntimeChatProducer(options) {
+  if (!Number.isSafeInteger(options.maxToolCalls) || options.maxToolCalls < 0) {
+    throw new Error("maxToolCalls must be a non-negative integer");
+  }
+  options = {
+    ...options,
+    grant: { ...options.grant, resolve: structuredClone(options.grant.resolve), reserve: structuredClone(options.grant.reserve) },
+    tools: options.tools.map((tool) => ({ ...tool, inputSchema: structuredClone(tool.inputSchema) })),
+    priorMessages: options.priorMessages ? structuredClone(options.priorMessages) : void 0
+  };
+  const tools = new Map(options.tools.map((tool) => [tool.name, tool]));
+  if (tools.size !== options.tools.length) throw new Error("Duplicate protected tool name");
+  const profile = structuredClone(options.profile);
+  let toolCalls = 0;
+  let usage = {};
+  let started = false;
+  let model;
+  let budgetEnforced = false;
+  let toolTokens;
+  async function* events() {
+    if (started) throw new Error("A protected chat producer can only execute once");
+    started = true;
+    const controller = new AbortController();
+    options.signal?.throwIfAborted();
+    if (Date.now() >= options.grant.deadlineAtMs) throw new Error("Protected execution deadline expired");
+    const signal = AbortSignal.any([
+      controller.signal,
+      AbortSignal.timeout(Math.max(1, options.grant.deadlineAtMs - Date.now())),
+      ...options.signal ? [options.signal] : []
+    ]);
+    const channel = new TransformStream();
+    const writer = channel.writable.getWriter();
+    const reader = channel.readable.getReader();
+    const emit = (event) => writer.write(event);
+    const execution = runProtectedAgentCandidateModelGrant({
+      ...options.grant,
+      port: {
+        resolve: (input) => options.grant.port.resolve(input),
+        reserveGrant: (input) => options.grant.port.reserveGrant(input),
+        activateGrant: (input) => options.grant.port.activateGrant(input),
+        // Runtime settles failed executions before rethrowing. Retain that receipt too.
+        settleGrant: async (input) => {
+          let auditError;
+          const settlement = await options.grant.port.settleGrant(input).catch((error) => {
+            if (!(error instanceof ProtectedModelSettlementError)) throw error;
+            auditError = error;
+            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
+          };
+          budgetEnforced = settlement.usageWithinLimits;
+          if (!budgetEnforced) throw new Error("Provider settlement exceeded execution limits");
+          if (auditError) throw auditError;
+          return settlement;
+        }
+      },
+      execute: async ({ activation, resolved }) => {
+        signal.throwIfAborted();
+        if (Date.now() >= options.grant.deadlineAtMs) throw new Error("Protected execution deadline expired");
+        model = resolved.model;
+        if (resolved.provider !== "anthropic" || resolved.reasoningEffort !== "none") {
+          throw new Error("Protected chat currently requires Anthropic without reasoning");
+        }
+        toolTokens = 0;
+        const apiKey = activation.env.OPENAI_API_KEY;
+        const baseUrl = activation.env.OPENAI_BASE_URL;
+        if (!apiKey || !baseUrl) throw new Error("Protected Router activation is missing");
+        const factory = createExecutor({
+          backend: "router-tools",
+          routerBaseUrl: baseUrl,
+          routerKey: apiKey,
+          tools: options.tools.map((tool) => ({
+            type: "function",
+            function: { name: tool.name, description: tool.description, parameters: tool.inputSchema }
+          })),
+          ...options.priorMessages?.length ? { initialMessages: options.priorMessages } : {},
+          executeToolCall: async (name, args) => {
+            signal.throwIfAborted();
+            const tool = tools.get(name);
+            if (!tool) throw new Error("Tool is not authorized for this execution");
+            if (toolCalls >= options.maxToolCalls) {
+              controller.abort(new Error("Execution tool-call limit reached"));
+              signal.throwIfAborted();
+            }
+            toolCalls += 1;
+            const id = `tool-${toolCalls}`;
+            await emit({ type: "tool_call", data: { id, name, arguments: args } });
+            try {
+              const result = await tool.run(args, { signal });
+              await emit({ type: "tool_result", data: { id, name, output: result } });
+              return JSON.stringify(result);
+            } catch (error) {
+              const message = error instanceof Error ? error.message : "Tool failed";
+              await emit({ type: "tool_result", data: { id, name, error: message } });
+              throw error;
+            }
+          }
+        });
+        let completed = false;
+        for await (const event of streamAgentTurn(
+          { kind: "executor", factory, profile },
+          { prompt: options.prompt },
+          {
+            signal,
+            callId: options.grant.reserve.executionId,
+            timeoutMs: Math.max(1, options.grant.deadlineAtMs - Date.now())
+          }
+        )) {
+          if (event.type === "text_delta" || event.type === "reasoning_delta") {
+            await emit({ type: "message.part.updated", data: {
+              part: { id: event.type, type: event.type === "text_delta" ? "text" : "reasoning" },
+              delta: event.text
+            } });
+          }
+          if (event.type === "final") {
+            if (event.status !== "completed") throw new Error(`Protected execution ${event.status}`);
+            completed = true;
+            await emit({ type: "result", data: { finalText: event.text } });
+          }
+        }
+        if (!completed) throw new Error("Protected execution ended without a terminal result");
+      }
+    }).then(async () => {
+      await writer.close();
+    }).catch((error) => writer.abort(error));
+    try {
+      for (; ; ) {
+        const next = await reader.read();
+        if (next.done) break;
+        yield next.value;
+      }
+      await execution;
+    } finally {
+      controller.abort();
+      await reader.cancel().catch(() => void 0);
+      await execution;
+      reader.releaseLock();
+      writer.releaseLock();
+    }
+  }
+  const producer = createSandboxChatProducer({ events: events(), model: profile.model?.default });
+  return {
+    ...producer,
+    stream: (async function* () {
+      let failure;
+      for await (const event of producer.stream) {
+        if (event.type === "error") failure = event;
+        else yield event;
+      }
+      if (usage.inputTokens !== void 0 && usage.outputTokens !== void 0 && usage.costUsd !== void 0) {
+        yield { type: "usage", usage: {
+          promptTokens: usage.inputTokens,
+          completionTokens: usage.outputTokens,
+          providerCostUsd: usage.costUsd,
+          reasoningTokens: usage.reasoningTokens,
+          toolTokens,
+          toolCallCount: toolCalls,
+          budgetEnforced
+        } };
+      }
+      if (failure) yield failure;
+    })(),
+    get model() {
+      return model ?? profile.model?.default;
+    },
+    usage: () => ({ ...usage })
+  };
+}
+
 // src/chat-routes/detached-turn.ts
 var TERMINAL_ERROR_TYPES = /* @__PURE__ */ new Set(["error", "session.run.failed"]);
 function errorMessageOf(ev) {
@@ -3597,6 +2764,7 @@ export {
   createAtomicAttachmentWriter,
   createAttachmentUploadRoute,
   createChatTurnRoutes,
+  createProtectedRuntimeChatProducer,
   createSandboxChatProducer,
   createSandboxFileIndexRoute,
   createUploadRoute,