@tangle-network/agent-app 0.47.5 → 0.47.6

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

@@ -13,6 +13,7 @@ export * from './turn-routes';
 export * from './gateway-adapter';
 export * from './stale-turn-lock';
 export * from './sandbox-producer';
+export * from './protected-runtime-producer';
 export * from './model-failover-stream';
 export * from './draft-persistence';
 export * from './detached-turn';

package/dist/chat-routes/index.js

@@ -49,6 +49,9 @@ 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,
@@ -1037,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) {
@@ -2583,6 +2764,7 @@ export {
   createAtomicAttachmentWriter,
   createAttachmentUploadRoute,
   createChatTurnRoutes,
+  createProtectedRuntimeChatProducer,
   createSandboxChatProducer,
   createSandboxFileIndexRoute,
   createUploadRoute,