@tangle-network/agent-runtime 0.102.0 → 0.102.2

package/dist/{sanitize-BTSsdBXw.d.ts → sanitize-DEbPNtyI.d.ts}

@@ -1,64 +1,6 @@
 import { ControlEvalResult, KnowledgeReadinessReport, KnowledgeRequirement } from '@tangle-network/agent-eval';
 import { e as AgentRuntimeEvent, R as RuntimeStreamEvent, f as AgentTaskStatus } from './types-BwoZWq-i.js';
 
-/**
- * THE canonical agentic tool-loop. One inference turn → run any requested tools → fold the
- * results back as `tool` messages → repeat, until the model answers without a tool call or the
- * turn budget is hit. One turn = one inference call (the equal-compute unit vs random@k).
- *
- * The inference is an INJECTABLE seam (`ToolLoopChat`): a router model, a sandboxed CLI
- * harness, or a scripted mock all satisfy it — so the loop is backend-agnostic. The metered /
- * steerable concerns the call sites add (a driver's conserved-pool + deadline bound; an inline
- * executor's inbox flush + abort) attach via optional `hooks`; the skeleton stays one copy.
- */
-
-type Msg = Record<string, unknown>;
-/** One inference turn over the running conversation + the tool specs → the model's text, any
- *  tool calls, and token usage. The seam every brain satisfies. */
-type ToolLoopChat = (messages: ReadonlyArray<Msg>, tools: ReadonlyArray<ToolSpec>) => Promise<{
-    content?: string | null;
-    toolCalls: RouterToolCall[];
-    usage?: {
-        input: number;
-        output: number;
-    };
-    /** The turn's inference cost (usd) when the provider priced it — for callers that meter usd
-     *  into a conserved pool (the supervisor brain). `runBrainLoop` itself ignores it. */
-    costUsd?: number;
-}>;
-/** Self-compaction — bound the loop's OWN context window the way a fresh-respawn (dumb-Ralph) loop
- *  does, but in place. A stateless chat API re-sends the WHOLE running conversation every turn, so an
- *  agent that accumulates dozens of turns of tool results re-bills its entire transcript on every
- *  inference — the context-overflow-one-level-up that the conserved budget pool cannot fix. With
- *  compaction set, once the conversation exceeds `thresholdTokens` the accumulated middle (every prior
- *  assistant turn + tool result) is distilled into ONE compact progress note and the conversation is
- *  reset to `[...head, digest]`: the preserved head (system + the original task) survives, the stale
- *  turn-by-turn history does not. The model keeps deciding; it stops re-billing the whole transcript.
- *  Fires at a CLEAN turn boundary (after a turn's tool results are folded in, before the next
- *  inference) so it never orphans an assistant `tool_calls` from its `tool` replies. */
-interface ToolLoopCompaction {
-    /** Compact once the estimated token count of the conversation exceeds this. */
-    readonly thresholdTokens: number;
-    /** Distill the conversation into a compact progress note that REPLACES the middle. Receives the
-     *  full conversation (so it can summarize everything done so far); returns the digest string. */
-    readonly distill: (messages: ReadonlyArray<Msg>) => Promise<string> | string;
-    /** Leading messages preserved verbatim (system + the original task). Default 2. */
-    readonly preserveHead?: number;
-    /** Token estimator over the conversation. Default ≈ chars/4 (incl. tool-call arguments). */
-    readonly estimateTokens?: (messages: ReadonlyArray<Msg>) => number;
-    /** Notified each time a compaction fires — for observability/metering. */
-    readonly onCompact?: (info: {
-        turn: number;
-        beforeTokens: number;
-        afterTokens: number;
-    }) => void;
-}
-/** Public supervisor-facing compaction config: same knobs as the primitive, but `distill` is optional
- *  because the supervisor has a default digest that combines a brain note with live worker state. */
-type ToolLoopCompactionOptions = Omit<ToolLoopCompaction, 'distill'> & {
-    readonly distill?: ToolLoopCompaction['distill'];
-};
-
 /**
  * The one router chat client: direct OpenAI-compatible completions through the
  * Tangle router — the cheapest dial, no sandbox. Three layers: `routerChatWithUsage`
@@ -216,6 +158,64 @@ declare function routerBrain(cfg: RouterConfig, opts?: {
     temperature?: number;
 }): ToolLoopChat;
 
+/**
+ * THE canonical agentic tool-loop. One inference turn → run any requested tools → fold the
+ * results back as `tool` messages → repeat, until the model answers without a tool call or the
+ * turn budget is hit. One turn = one inference call (the equal-compute unit vs random@k).
+ *
+ * The inference is an INJECTABLE seam (`ToolLoopChat`): a router model, a sandboxed CLI
+ * harness, or a scripted mock all satisfy it — so the loop is backend-agnostic. The metered /
+ * steerable concerns the call sites add (a driver's conserved-pool + deadline bound; an inline
+ * executor's inbox flush + abort) attach via optional `hooks`; the skeleton stays one copy.
+ */
+
+type Msg = Record<string, unknown>;
+/** One inference turn over the running conversation + the tool specs → the model's text, any
+ *  tool calls, and token usage. The seam every brain satisfies. */
+type ToolLoopChat = (messages: ReadonlyArray<Msg>, tools: ReadonlyArray<ToolSpec>) => Promise<{
+    content?: string | null;
+    toolCalls: RouterToolCall[];
+    usage?: {
+        input: number;
+        output: number;
+    };
+    /** The turn's inference cost (usd) when the provider priced it — for callers that meter usd
+     *  into a conserved pool (the supervisor brain). `runBrainLoop` itself ignores it. */
+    costUsd?: number;
+}>;
+/** Self-compaction — bound the loop's OWN context window the way a fresh-respawn (dumb-Ralph) loop
+ *  does, but in place. A stateless chat API re-sends the WHOLE running conversation every turn, so an
+ *  agent that accumulates dozens of turns of tool results re-bills its entire transcript on every
+ *  inference — the context-overflow-one-level-up that the conserved budget pool cannot fix. With
+ *  compaction set, once the conversation exceeds `thresholdTokens` the accumulated middle (every prior
+ *  assistant turn + tool result) is distilled into ONE compact progress note and the conversation is
+ *  reset to `[...head, digest]`: the preserved head (system + the original task) survives, the stale
+ *  turn-by-turn history does not. The model keeps deciding; it stops re-billing the whole transcript.
+ *  Fires at a CLEAN turn boundary (after a turn's tool results are folded in, before the next
+ *  inference) so it never orphans an assistant `tool_calls` from its `tool` replies. */
+interface ToolLoopCompaction {
+    /** Compact once the estimated token count of the conversation exceeds this. */
+    readonly thresholdTokens: number;
+    /** Distill the conversation into a compact progress note that REPLACES the middle. Receives the
+     *  full conversation (so it can summarize everything done so far); returns the digest string. */
+    readonly distill: (messages: ReadonlyArray<Msg>) => Promise<string> | string;
+    /** Leading messages preserved verbatim (system + the original task). Default 2. */
+    readonly preserveHead?: number;
+    /** Token estimator over the conversation. Default ≈ chars/4 (incl. tool-call arguments). */
+    readonly estimateTokens?: (messages: ReadonlyArray<Msg>) => number;
+    /** Notified each time a compaction fires — for observability/metering. */
+    readonly onCompact?: (info: {
+        turn: number;
+        beforeTokens: number;
+        afterTokens: number;
+    }) => void;
+}
+/** Public supervisor-facing compaction config: same knobs as the primitive, but `distill` is optional
+ *  because the supervisor has a default digest that combines a brain note with live worker state. */
+type ToolLoopCompactionOptions = Omit<ToolLoopCompaction, 'distill'> & {
+    readonly distill?: ToolLoopCompaction['distill'];
+};
+
 /**
  *
  * Sanitization for runtime telemetry. The rule: nothing user-controlled leaks