@tangle-network/agent-runtime 0.109.0 → 0.109.2

package/dist/testing.js

@@ -1,10 +1,10 @@
 import { $ as parseExactAgentProfile, K as applyExactAgentProfileDiff, rt as canonicalCandidateDigest$1, st as immutableCandidateValue } from "./prepare-Pr19X93k.js";
-import { f as verifyAgentImprovementProposal } from "./improvement-cycle-CRnDDdX0.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-9O4iVFOA.js";
 import { SANDBOX_SIZE_PRESET_NAMES } from "@tangle-network/agent-interface";
 //#region src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
 	changedSurfaces: ["prompt"],
-	digest: "sha256:0111aecf13f77e5967b34600f49978a2d0fc6036e2f3285e3bf29a892c8390ae",
+	digest: "sha256:fc52fd656a37a79611a2f870079695fe1a5c055d3078d58b0f2d4c79d73c3945",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4515,7 +4515,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.109.0"
+			"runtimeVersion": "0.109.2"
 		},
 		"objectives": [
 			{
@@ -4626,8 +4626,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:0a21cbc2e244683e58623c1b00c672cf34312bb5acb17d522cd3e4a747f08418",
-			"runId": "agent-runtime-0.109.0-proposal-fixture",
+			"recordDigest": "sha256:042b806bcb6e3db2fe3b8744d543d769a0d3edf6cebe5413becb137196b00fd8",
+			"runId": "agent-runtime-0.109.2-proposal-fixture",
 			"schema": "agent-candidate-experiment"
 		}
 	},
@@ -4650,13 +4650,13 @@ var agent_improvement_proposal_default = {
 	}],
 	kind: "agent-improvement-proposal",
 	proposedAt: "2026-07-10T01:00:00.000Z",
-	runId: "agent-runtime-0.109.0-proposal-fixture"
+	runId: "agent-runtime-0.109.2-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:d91073bcdef9663a219cecd71d230f1855d286ea762a1557ffefff99830a60fd",
+	digest: "sha256:5a6888221983315e661a139d32348538dc054443e03ce2ef7f0cdf6380fb3558",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [{
@@ -6268,7 +6268,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.109.0"
+			"runtimeVersion": "0.109.2"
 		},
 		"objectives": [
 			{

package/dist/tool-loop.d.ts

@@ -0,0 +1,149 @@
+import { l as RuntimeHooks } from "./runtime-hooks-sbRpjStq.js";
+//#region src/tool-loop.d.ts
+interface ToolLoopCall {
+  toolCallId?: string;
+  toolName: string;
+  args: Record<string, unknown>;
+}
+/** Outcome of one tool dispatch — structurally compatible with a hub/integration
+ *  tool-outcome union, so callers can fold either through the loop. */
+type ToolCallOutcome = {
+  ok: true;
+  result: unknown;
+} | {
+  ok: false;
+  code: string;
+  message: string;
+  status?: number;
+};
+/** One OpenAI-shaped tool-call entry carried on an assistant message. */
+interface ToolLoopAssistantToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+/**
+ * A message in the running conversation the loop sends to `streamTurn`.
+ *
+ * The base `{ role, content }` covers `system` / `user` / plain `assistant`
+ * turns. Two optional fields carry the OpenAI function-calling contract so a
+ * strict model (Claude, and any OpenAI-compatible provider that validates tool
+ * history) reads its own tool use back instead of re-issuing the same call:
+ *
+ *   - an assistant turn that emitted tool calls carries `tool_calls`, and its
+ *     `content` is `null` when the turn was tool-only;
+ *   - each tool result is its own `{ role: 'tool', tool_call_id, content }`
+ *     message keyed to the call that produced it.
+ *
+ * Widening is additive: a `streamTurn` that reads only `role` + `content` still
+ * works; one that forwards the whole message to an OpenAI-compatible endpoint
+ * now sends correct tool history.
+ */
+type ToolLoopMessage = {
+  role: string;
+  content: string | null;
+  tool_calls?: ToolLoopAssistantToolCall[];
+  tool_call_id?: string;
+};
+type ToolLoopEvent = {
+  type: 'text';
+  text: string;
+} | {
+  type: 'tool_call';
+  call: ToolLoopCall;
+} | {
+  type: 'other';
+  event: unknown;
+};
+/** Why the loop stopped. `completed` = model finished naturally; `stuck-loop` =
+ *  ≥3 consecutive identical tool calls (same tool + args); `backstop` = hit the
+ *  runaway-backstop cap (200 by default); `deadline` = wall-clock deadlineMs
+ *  exceeded; `budget` = maxCostUsd exhausted. Non-`completed` stops are infra /
+ *  resource outcomes — eval scoring must distinguish them from capability failure. */
+type ToolLoopStopReason = 'completed' | 'stuck-loop' | 'backstop' | 'deadline' | 'budget';
+interface ToolLoopResult {
+  finalText: string;
+  toolResults: Array<{
+    call: ToolLoopCall;
+    label: string;
+    outcome: ToolCallOutcome;
+  }>;
+  turns: number;
+  stopReason: ToolLoopStopReason;
+  /** @deprecated Use `stopReason !== 'completed'` instead. */
+  cappedOut: boolean;
+}
+interface RunToolLoopOptions {
+  systemPrompt: string;
+  userMessage: string;
+  priorMessages?: ToolLoopMessage[];
+  streamTurn: (messages: ToolLoopMessage[]) => AsyncIterable<ToolLoopEvent>;
+  executeToolCall: (call: ToolLoopCall) => Promise<ToolCallOutcome>;
+  isExecutableTool: (toolName: string) => boolean;
+  /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow.
+   *  For per-workflow limits, use `maxCostUsd` or `deadlineMs` instead. */
+  maxToolTurns?: number;
+  /** Wall-clock deadline in ms since epoch (Date.now()-based). When exceeded the
+   *  loop stops with stopReason `deadline`. */
+  deadlineMs?: number;
+  /** Maximum total cost in USD. Requires `costOf` to meter each tool call. */
+  maxCostUsd?: number;
+  /** Return the USD cost of one outcome. Required for `maxCostUsd` to work. */
+  costOf?: (call: ToolLoopCall, outcome: ToolCallOutcome) => number;
+  renderResult?: (label: string, outcome: ToolCallOutcome) => string;
+  labelFor?: (call: ToolLoopCall) => string;
+  runId?: string;
+  scenarioId?: string;
+  hooks?: RuntimeHooks;
+}
+/** Run the bounded tool loop and return the final text + every executed tool
+ *  outcome. Awaitable — callers needing to stream events to a UI use
+ *  {@link streamToolLoop}. */
+declare function runToolLoop(opts: RunToolLoopOptions): Promise<ToolLoopResult>;
+type StreamToolLoopYield<Raw> = {
+  kind: 'event';
+  event: Raw;
+} | {
+  kind: 'tool_result';
+  toolName: string;
+  toolCallId?: string;
+  label: string;
+  outcome: ToolCallOutcome;
+} | {
+  kind: 'capped';
+  pending: number;
+  stopReason: Exclude<ToolLoopStopReason, 'completed'>;
+};
+interface StreamToolLoopOptions<Raw> {
+  systemPrompt: string;
+  userMessage: string;
+  priorMessages?: ToolLoopMessage[];
+  streamTurn: (messages: ToolLoopMessage[]) => AsyncIterable<Raw>;
+  extractText: (event: Raw) => string;
+  extractToolCall: (event: Raw) => ToolLoopCall | null;
+  isExecutableTool: (toolName: string) => boolean;
+  executeToolCall: (call: ToolLoopCall) => Promise<ToolCallOutcome>;
+  /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow. */
+  maxToolTurns?: number;
+  /** Wall-clock deadline in ms since epoch (Date.now()-based). */
+  deadlineMs?: number;
+  /** Maximum total cost in USD. Requires `costOf` to meter each tool call. */
+  maxCostUsd?: number;
+  /** Return the USD cost of one outcome. Required for `maxCostUsd` to work. */
+  costOf?: (call: ToolLoopCall, outcome: ToolCallOutcome) => number;
+  renderResult?: (label: string, outcome: ToolCallOutcome) => string;
+  labelFor?: (call: ToolLoopCall) => string;
+  runId?: string;
+  scenarioId?: string;
+  hooks?: RuntimeHooks;
+}
+/** Streaming bounded tool loop: yields each raw turn event (the caller maps +
+ *  telemetries + re-emits it) and each executed `tool_result`; emits one
+ *  `capped` if it stops for any non-completed reason with calls still pending. */
+declare function streamToolLoop<Raw>(opts: StreamToolLoopOptions<Raw>): AsyncGenerator<StreamToolLoopYield<Raw>, void, unknown>;
+//#endregion
+export { RunToolLoopOptions, StreamToolLoopOptions, StreamToolLoopYield, ToolCallOutcome, ToolLoopAssistantToolCall, ToolLoopCall, ToolLoopEvent, ToolLoopMessage, ToolLoopResult, ToolLoopStopReason, runToolLoop, streamToolLoop };
+//# sourceMappingURL=tool-loop.d.ts.map