@tangle-network/agent-runtime 0.52.0 → 0.54.0

package/dist/router-client-30Y_pca8.d.ts

@@ -0,0 +1,120 @@
+/**
+ * The one router chat client: direct OpenAI-compatible completions through the
+ * Tangle router — the cheapest dial, no sandbox. Three layers: `routerChatWithUsage`
+ * (chat-only), `routerChatWithTools` (one completion with function tools), and
+ * `routerToolLoop` (the off-box agentic loop over tool-calling). Shared by the
+ * built-in executors and the bench/lab harnesses.
+ *
+ * Reports REAL token usage so the backend-integrity guard sees a real backend.
+ * Returns `undefined` usage when the provider omitted it — never a fabricated 0
+ * (a phantom 0 reads as a free call downstream, which the gate would act on).
+ */
+interface RouterConfig {
+    routerBaseUrl: string;
+    routerKey: string;
+    model: string;
+}
+interface RouterChatResult {
+    content: string;
+    /** REAL usage, or undefined when the provider reported none. */
+    usage?: {
+        input: number;
+        output: number;
+    };
+    /** Derived from usage via `estimateCost` when the model is priced; else undefined. */
+    costUsd?: number;
+}
+declare function routerChatWithUsage(cfg: RouterConfig, messages: Array<{
+    role: string;
+    content: string;
+}>, opts?: {
+    temperature?: number;
+    signal?: AbortSignal;
+    maxTokens?: number;
+}): Promise<RouterChatResult>;
+/** A tool-call the model emitted (provider-neutral; mirrors the runtime's ToolCallRequest). */
+interface RouterToolCall {
+    id: string;
+    name: string;
+    /** Raw JSON arguments string as emitted by the model. */
+    arguments: string;
+}
+interface RouterChatToolsResult {
+    content: string | null;
+    toolCalls: RouterToolCall[];
+    usage?: {
+        input: number;
+        output: number;
+    };
+    costUsd?: number;
+}
+/**
+ * A router completion WITH tool-calling — the operator driver's LLM seam. Passes OpenAI-shape
+ * `messages` (system/user/assistant-with-tool_calls/tool roles) + function `tools`, and returns the
+ * assistant text plus the tool calls the model wants run. Same fail-loud + real-usage discipline as
+ * `routerChatWithUsage`. `tool_choice: 'auto'` lets the model decide; the driver loops on the result.
+ */
+declare function routerChatWithTools(cfg: RouterConfig, messages: ReadonlyArray<Record<string, unknown>>, tools: ReadonlyArray<{
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: unknown;
+    };
+}>, opts?: {
+    temperature?: number;
+    signal?: AbortSignal;
+    toolChoice?: 'auto' | 'required' | 'none';
+    maxTokens?: number;
+}): Promise<RouterChatToolsResult>;
+interface ToolSpec {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: unknown;
+    };
+}
+interface RouterToolLoopResult {
+    /** The model's final assistant text (the turn where it stopped calling tools, or the budget turn). */
+    final: string;
+    /** Inference turns spent (≤ maxTurns) — the equal-budget unit vs random@k. */
+    turns: number;
+    toolCalls: number;
+    /** The behavior trace: each tool call + its result, in order. What a trace-analyst
+     *  steerer reads (behavior, never the verdict) to diagnose + redirect the next shot. */
+    toolTrace: Array<{
+        name: string;
+        args: string;
+        result: string;
+    }>;
+    usage: {
+        input: number;
+        output: number;
+    };
+    /** The full conversation after the loop (seed + every assistant/tool turn). Lets a caller
+     *  CARRY the messages into the next shot (depth continuation) and read the trajectory. */
+    messages: Array<Record<string, unknown>>;
+}
+/**
+ * The tool-using router backend: a real agentic loop OVER the Tangle router (which
+ * supports tool-calling), off-box — no sandbox. Each turn is one router completion
+ * with `tools`; if the model emits tool_calls, `execute` runs them on the host and
+ * their results are folded back as `tool` messages; the loop repeats until the
+ * model answers without a tool call or the turn budget is hit. One turn = one
+ * inference call, so `maxTurns` is the equal-compute unit against random@k.
+ *
+ * This is the depth substrate for agentic gates (the worker ACTS, observes the real
+ * result, and continues) that the chat-only `routerChatWithUsage` cannot express.
+ */
+declare function routerToolLoop(cfg: RouterConfig, system: string, user: string, tools: ReadonlyArray<ToolSpec>, execute: (name: string, args: Record<string, unknown>) => Promise<string>, opts?: {
+    maxTurns?: number;
+    temperature?: number;
+    signal?: AbortSignal;
+    maxTokens?: number;
+    /** Seed the loop with an existing conversation (depth continuation) instead of
+     *  `[system, user]`. When set, `system`/`user` are ignored. The array is copied. */
+    initialMessages?: ReadonlyArray<Record<string, unknown>>;
+}): Promise<RouterToolLoopResult>;
+
+export { type RouterConfig as R, type ToolSpec as T, type RouterChatResult as a, type RouterChatToolsResult as b, type RouterToolCall as c, type RouterToolLoopResult as d, routerChatWithUsage as e, routerToolLoop as f, routerChatWithTools as r };

package/dist/{run-loop-BIineL1T.d.ts → run-loop-DluzfJ2h.d.ts}

@@ -1,5 +1,5 @@
 import { SandboxInstance } from '@tangle-network/sandbox';
-import { D as Driver, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, I as Iteration, L as LoopWinner, a as LoopLineageOptions, S as SandboxClient, b as LoopResult } from './types-BEQsBhOE.js';
+import { D as Driver, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, I as Iteration, L as LoopWinner, a as LoopLineageOptions, S as SandboxClient, b as LoopResult } from './types-C8rNlxfV.js';
 
 /**
  * @experimental