@tangle-network/agent-runtime 0.30.1 → 0.33.0

package/dist/loops.d.ts

@@ -1,11 +1,116 @@
+import { AgentProfile, SandboxEvent } from '@tangle-network/sandbox';
 export { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
-import { D as Driver, I as Iteration, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, L as LoopWinner, a as LoopResult } from './types-Cbe54nB7.js';
-export { b as LoopDecisionPayload, c as LoopEndedPayload, d as LoopIterationDispatchPayload, e as LoopIterationEndedPayload, f as LoopIterationStartedPayload, g as LoopSandboxClient, h as LoopSandboxPlacement, i as LoopStartedPayload, j as LoopTraceEmitter, k as LoopTraceEvent, l as ValidationCtx } from './types-Cbe54nB7.js';
-import { DefaultVerdict } from '@tangle-network/agent-eval';
+import { I as Iteration, D as Driver, L as LoopSandboxClient, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, a as LoopWinner, b as LoopResult } from './types-CpCX1pfx.js';
+export { c as LoopDecisionPayload, d as LoopEndedPayload, e as LoopIterationDispatchPayload, f as LoopIterationEndedPayload, g as LoopIterationStartedPayload, h as LoopSandboxPlacement, i as LoopStartedPayload, j as LoopTokenUsage, k as LoopTraceEmitter, l as LoopTraceEvent, m as ValidationCtx } from './types-CpCX1pfx.js';
+import { DefaultVerdict, AgentProfile as AgentProfile$1 } from '@tangle-network/agent-eval';
 export { DefaultVerdict } from '@tangle-network/agent-eval';
+import { Scenario, DispatchFn, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
 import './runtime-run-B8VIiOhI.js';
 import './types-CsCCryln.js';
 
+/**
+ * @experimental
+ *
+ * Dynamic driver — the agent authors the loop topology at runtime.
+ *
+ * Where `refine` and `fanout-vote` encode a fixed shape as a pure function of
+ * history, this driver delegates the per-round shape to an injected
+ * `TopologyPlanner`. Each round the planner inspects the task + iteration
+ * history and emits one `TopologyMove`:
+ *   - `refine` → one task next round (optionally rewritten from the prior attempt)
+ *   - `fanout` → N tasks next round (the kernel round-robins `agentRuns`, so a
+ *     2-harness fanout dispatches branch 0 to harness A and branch 1 to harness B)
+ *   - `stop`   → terminate; the kernel selects the winner across all iterations
+ *
+ * The planner is the brain; this driver is the structure. It maps moves onto
+ * the kernel's `plan`/`decide` contract, enforces the iteration + fanout caps,
+ * and fails loud on a malformed move. The planner is injected exactly like
+ * `refine`'s `refineTask` and `fanout-vote`'s `selector` — so a test can drive
+ * a deterministic policy through the real kernel, and production can wire it to
+ * an LLM via `createSandboxPlanner`.
+ *
+ * Topology is orthogonal to harness: the planner never names a backend. Which
+ * harness runs a branch is decided by the `AgentRunSpec` the kernel round-robins
+ * to, so one dynamic driver works across claude-code, codex, opencode, pi —
+ * including fanning a single round across several at once.
+ */
+
+/** Terminal once `decide` returns `'done'` (a kernel terminal decision). */
+type DynamicDecision = 'continue' | 'done';
+/**
+ * One topology decision for the next round. `fanout` carries explicit tasks
+ * rather than a count so the planner can issue heterogeneous branches (a
+ * different sub-task per harness); pass N copies of one task for a homogeneous
+ * fanout that relies on `agentRuns` diversity instead.
+ *
+ * @experimental
+ */
+type TopologyMove<Task> = {
+    kind: 'refine';
+    task: Task;
+    rationale?: string;
+} | {
+    kind: 'fanout';
+    tasks: Task[];
+    rationale?: string;
+} | {
+    kind: 'stop';
+    rationale?: string;
+};
+/** @experimental */
+interface PlannerContext<Task, Output> {
+    /** The root task the loop was invoked with — stable across rounds. */
+    task: Task;
+    /** Every iteration so far, in dispatch order, with outputs + verdicts. */
+    history: ReadonlyArray<Iteration<Task, Output>>;
+    /** `history.length` — iterations already spent. */
+    iterationsSpent: number;
+    /** Iterations left before the driver's `maxIterations` cap forces a stop. */
+    iterationsRemaining: number;
+}
+/**
+ * Chooses the next topology move from the task + history. Sync or async; an
+ * async planner is where an LLM call goes (see `createSandboxPlanner`).
+ *
+ * @experimental
+ */
+type TopologyPlanner<Task, Output> = (ctx: PlannerContext<Task, Output>) => TopologyMove<Task> | Promise<TopologyMove<Task>>;
+/** @experimental */
+interface CreateDynamicDriverOptions<Task, Output> {
+    /** The agent-authored topology policy. Invoked once per round in `plan`. */
+    planner: TopologyPlanner<Task, Output>;
+    /**
+     * Hard safety cap on total iterations. When reached, the driver stops before
+     * consulting the planner. Default 8. Set the kernel's `runLoop`
+     * `maxIterations >= ` this so the driver's cap governs and the loop closes on
+     * a clean `'done'` rather than a truncated `'continue'`.
+     */
+    maxIterations?: number;
+    /** Max branches a single `fanout` move may dispatch. Default 4. */
+    maxFanout?: number;
+    /** Stable identifier surfaced in trace events. Default `'dynamic'`. */
+    name?: string;
+}
+/** @experimental */
+declare function createDynamicDriver<Task, Output>(options: CreateDynamicDriverOptions<Task, Output>): Driver<Task, Output, DynamicDecision>;
+/**
+ * Compact, planner-friendly view of iteration history — what an LLM planner
+ * needs to choose the next move without the raw event streams. Output is
+ * truncated so a long run's prompt stays bounded.
+ *
+ * @experimental
+ */
+declare function summarizeHistory<Task, Output>(history: ReadonlyArray<Iteration<Task, Output>>, opts?: {
+    maxOutputChars?: number;
+}): Array<{
+    index: number;
+    agentRunName: string;
+    valid?: boolean;
+    score?: number;
+    error?: string;
+    output?: string;
+}>;
+
 /**
  * @experimental
  *
@@ -87,6 +192,64 @@ declare function createRefineDriver<Task, Output>(options?: CreateRefineDriverOp
  */
 declare function refineWinnerIndex<Task, Output>(iterations: ReadonlyArray<Iteration<Task, Output>>): number | undefined;
 
+/**
+ * @experimental
+ *
+ * `createSandboxPlanner` — wire the dynamic driver's `TopologyPlanner` to a
+ * real agent. Each round it spins a sandbox on `profile`, streams a prompt that
+ * carries the history summary, and decodes the agent's chosen `TopologyMove`
+ * from a JSON envelope it emits. This is the "agent authors its own loop
+ * topology" path: the planner profile can be any harness (claude-code, codex,
+ * opencode, pi) — its only job is to read what happened and emit the next move.
+ *
+ * The planner profile is deliberately distinct from the worker `agentRuns`: a
+ * cheap fast model can steer topology while expensive workers do the labor, and
+ * the planner never names which harness runs a branch — the kernel's
+ * `agentRuns` round-robin decides that.
+ *
+ * Envelope contract the agent must emit (fenced ```json or a structured
+ * `result`/`final` event payload):
+ *   { "kind": "refine" | "fanout" | "stop",
+ *     "tasks"?: [ <task>, ... ],   // decoded via `decodeTask`
+ *     "n"?: number,                // fanout shorthand: N copies of the root task
+ *     "rationale"?: string }
+ *
+ * A missing / unparseable / unknown-kind envelope throws `PlannerError` — the
+ * loop never silently runs a topology the agent did not choose.
+ */
+
+/** Raw, pre-decode envelope an agent emits to choose the next move. */
+interface TopologyMoveEnvelope {
+    kind: string;
+    tasks?: unknown[];
+    n?: number;
+    rationale?: string;
+}
+/** @experimental */
+interface CreateSandboxPlannerOptions<Task, Output> {
+    /** Sandbox client — the planner calls `.create()` once per round. */
+    client: LoopSandboxClient;
+    /** The planner agent. Steers topology; does not run the work. */
+    profile: AgentProfile;
+    /**
+     * Decode one raw task from the envelope's `tasks[]` into a domain `Task`.
+     * Required because `Task` is opaque to this module — only the caller knows
+     * its shape. Throw to reject a malformed task; the error surfaces as a
+     * `PlannerError`.
+     */
+    decodeTask: (raw: unknown, ctx: PlannerContext<Task, Output>) => Task;
+    /** Override the default prompt (history summary + envelope contract). */
+    buildPrompt?: (ctx: PlannerContext<Task, Output>) => string;
+    /** Override envelope extraction from the event stream. */
+    parseEnvelope?: (events: SandboxEvent[]) => TopologyMoveEnvelope | undefined;
+    /** Sandbox overrides for the planner sandbox (timeouts, env, etc.). */
+    sandboxOverrides?: AgentRunSpec<Task>['sandboxOverrides'];
+    /** Cancellation for the planner's own LLM call. */
+    signal?: AbortSignal;
+}
+/** @experimental */
+declare function createSandboxPlanner<Task, Output>(opts: CreateSandboxPlannerOptions<Task, Output>): TopologyPlanner<Task, Output>;
+
 /**
  * @experimental
  *
@@ -153,4 +316,102 @@ interface RunLoopOptions<Task, Output, Decision> {
 /** @experimental */
 declare function runLoop<Task, Output, Decision>(options: RunLoopOptions<Task, Output, Decision>): Promise<LoopResult<Task, Output, Decision>>;
 
-export { AgentRunSpec, type CreateFanoutVoteDriverOptions, type CreateRefineDriverOptions, Driver, ExecCtx, type FanoutVoteDecision, type FanoutVoteScored, Iteration, LoopResult, LoopWinner, OutputAdapter, type RefineDecision, type RunLoopOptions, Validator, createFanoutVoteDriver, createRefineDriver, refineWinnerIndex, runLoop, scoreFanoutVoteIterations };
+/**
+ * Bridge a finished `runLoop` into an agent-eval campaign / profile-matrix
+ * dispatch.
+ *
+ * `runProfileMatrix` (and `runCampaign`) run the backend-integrity guard over
+ * the token usage a dispatch reports through `ctx.cost`. A dispatch that wraps
+ * `runLoop` must forward the loop's cost AND token usage, or the guard reads
+ * the run as a stub and throws. `reportLoopUsage` is that one line:
+ *
+ *   const dispatch: ProfileDispatchFn<S, A> = async (profile, scenario, ctx) => {
+ *     const result = await runLoop({ ...optsFor(profile, scenario), ctx: loopCtx })
+ *     reportLoopUsage(ctx, result)
+ *     return result.winner?.output as A
+ *   }
+ *
+ * Typed structurally against the campaign `DispatchContext.cost` so this module
+ * stays free of an agent-eval import — it works with any cost meter exposing
+ * `observe` + `observeTokens`.
+ */
+
+/** The slice of an agent-eval campaign `DispatchContext.cost` this needs. */
+interface UsageSink {
+    observe(amountUsd: number, source: string): void;
+    observeTokens(usage: {
+        input: number;
+        output: number;
+    }): void;
+}
+/**
+ * Forward a `LoopResult`'s aggregated cost + token usage into a campaign cost
+ * meter so the backend-integrity guard sees real LLM activity. `source`
+ * defaults to `'loop'`.
+ */
+declare function reportLoopUsage<Task, Output, Decision>(cost: UsageSink, result: Pick<LoopResult<Task, Output, Decision>, 'costUsd' | 'tokenUsage'>, source?: string): void;
+
+/**
+ * `loopDispatch` — turn `runLoop` into an agent-eval campaign dispatch.
+ *
+ * Without this adapter a consumer wiring `runLoop` into `runProfileMatrix` /
+ * `runCampaign` has to, by hand, every time: (a) build an `ExecCtx` with a
+ * sandbox client, (b) adapt the campaign `DispatchContext.trace` into a
+ * `LoopTraceEmitter` (or lose all loop trace correlation), and (c) remember to
+ * forward the loop's cost + tokens via `ctx.cost` (forgetting it yields a
+ * `{0,0}` cell the backend-integrity guard reads as a stub). Three foot-guns,
+ * the third silent. The fleet's products skipped (c) and fell back to a
+ * `workerRecords[]` side-channel — the exact anti-pattern the substrate exists
+ * to kill.
+ *
+ * `loopDispatch` collapses all three into one typed call:
+ *
+ *   const dispatch = loopDispatch({
+ *     sandboxClient,
+ *     toLoopOptions: (scenario, profile) => ({ driver, agentRun, output, validator, task }),
+ *   })
+ *   await runProfileMatrix({ profiles, scenarios, dispatch, judges, commitSha })
+ *
+ * Usage is reported automatically; trace events are forwarded automatically;
+ * the ctx is built automatically. The seam becomes impossible to mis-wire.
+ *
+ * Typed structurally against the campaign `DispatchContext` (imported type-only
+ * from `@tangle-network/agent-eval/campaign`) — a downward dependency, never an
+ * inversion.
+ */
+
+/** runLoop options minus the `ctx` (loopDispatch builds the ctx). */
+type LoopOptionsForDispatch<Task, Output, Decision> = Omit<RunLoopOptions<Task, Output, Decision>, 'ctx'>;
+interface LoopDispatchOptions<Task, Output, Decision, TScenario extends Scenario, TArtifact> {
+    /** Sandbox client used for every cell's `runLoop`. Supplied once. */
+    sandboxClient: LoopSandboxClient;
+    /** Build the per-cell runLoop options from the scenario (+ profile, when
+     *  used with `runProfileMatrix`). */
+    toLoopOptions: (scenario: TScenario, profile: AgentProfile$1) => LoopOptionsForDispatch<Task, Output, Decision>;
+    /** Map the finished loop to the artifact the judges score. Default:
+     *  `result.winner?.output`. A loop with no winner yields `undefined` (judges
+     *  skip the cell) — but the loop's token usage is STILL reported, so the
+     *  integrity guard sees real activity. */
+    toArtifact?: (result: LoopResult<Task, Output, Decision>) => TArtifact;
+    /** Forward `loop.*` trace events into the campaign's scoped trace so loop
+     *  spans correlate with the cell. Default true. */
+    forwardTrace?: boolean;
+    /** Cost-meter source label for the loop's spend. Default `'loop'`. */
+    costSource?: string;
+}
+/**
+ * Adapter for `runProfileMatrix` (profile is an axis). Returns a
+ * `ProfileDispatchFn` that runs `runLoop` per (profile, scenario) cell and
+ * reports usage automatically.
+ */
+declare function loopDispatch<Task, Output, Decision, TScenario extends Scenario, TArtifact>(opts: LoopDispatchOptions<Task, Output, Decision, TScenario, TArtifact>): ProfileDispatchFn<TScenario, TArtifact>;
+/**
+ * Adapter for `runCampaign` (no profile axis). `toLoopOptions` receives only
+ * the scenario; the `profile` passed to the shared core is a stable sentinel
+ * so a single `runLoop` config is reused across cells.
+ */
+declare function loopCampaignDispatch<Task, Output, Decision, TScenario extends Scenario, TArtifact>(opts: Omit<LoopDispatchOptions<Task, Output, Decision, TScenario, TArtifact>, 'toLoopOptions'> & {
+    toLoopOptions: (scenario: TScenario) => LoopOptionsForDispatch<Task, Output, Decision>;
+}): DispatchFn<TScenario, TArtifact>;
+
+export { AgentRunSpec, type CreateDynamicDriverOptions, type CreateFanoutVoteDriverOptions, type CreateRefineDriverOptions, type CreateSandboxPlannerOptions, Driver, type DynamicDecision, ExecCtx, type FanoutVoteDecision, type FanoutVoteScored, Iteration, type LoopDispatchOptions, type LoopOptionsForDispatch, LoopResult, LoopSandboxClient, LoopWinner, OutputAdapter, type PlannerContext, type RefineDecision, type RunLoopOptions, type TopologyMove, type TopologyMoveEnvelope, type TopologyPlanner, type UsageSink, Validator, createDynamicDriver, createFanoutVoteDriver, createRefineDriver, createSandboxPlanner, loopCampaignDispatch, loopDispatch, refineWinnerIndex, reportLoopUsage, runLoop, scoreFanoutVoteIterations, summarizeHistory };

package/dist/loops.js

@@ -1,19 +1,31 @@
 import {
+  createDynamicDriver,
   createRefineDriver,
+  createSandboxPlanner,
+  loopCampaignDispatch,
+  loopDispatch,
   refineWinnerIndex,
-  runLoop
-} from "./chunk-TZ53F7M7.js";
+  reportLoopUsage,
+  runLoop,
+  summarizeHistory
+} from "./chunk-GLTUUKTN.js";
 import {
   createFanoutVoteDriver,
   scoreFanoutVoteIterations
-} from "./chunk-URDSRUPQ.js";
-import "./chunk-XZYF3YJN.js";
+} from "./chunk-PY6NMZYX.js";
+import "./chunk-SQSCRJ7U.js";
 import "./chunk-DGUM43GV.js";
 export {
+  createDynamicDriver,
   createFanoutVoteDriver,
   createRefineDriver,
+  createSandboxPlanner,
+  loopCampaignDispatch,
+  loopDispatch,
   refineWinnerIndex,
+  reportLoopUsage,
   runLoop,
-  scoreFanoutVoteIterations
+  scoreFanoutVoteIterations,
+  summarizeHistory
 };
 //# sourceMappingURL=loops.js.map

package/dist/mcp/bin.js

@@ -3,15 +3,15 @@ import {
   createDefaultCoderDelegate,
   createMcpServer,
   detectExecutor
-} from "../chunk-ZJACJZF7.js";
-import "../chunk-UNQM6XQO.js";
+} from "../chunk-AAJVQRPL.js";
+import "../chunk-HSX6PFZR.js";
 import "../chunk-GLR25NG7.js";
 import {
   runLoop
-} from "../chunk-TZ53F7M7.js";
-import "../chunk-CBQVID7G.js";
-import "../chunk-URDSRUPQ.js";
-import "../chunk-XZYF3YJN.js";
+} from "../chunk-GLTUUKTN.js";
+import "../chunk-5QVVET72.js";
+import "../chunk-PY6NMZYX.js";
+import "../chunk-SQSCRJ7U.js";
 import "../chunk-DGUM43GV.js";
 
 // src/mcp/bin.ts

package/dist/mcp/index.d.ts

@@ -1,10 +1,10 @@
-import { g as LoopSandboxClient, h as LoopSandboxPlacement, j as LoopTraceEmitter } from '../types-Cbe54nB7.js';
+import { L as LoopSandboxClient, h as LoopSandboxPlacement, k as LoopTraceEmitter } from '../types-CpCX1pfx.js';
 import { SandboxInstance } from '@tangle-network/sandbox';
 import { CoderOutput } from '../profiles.js';
 import { L as LocalHarness, r as runLocalHarness } from '../local-harness-KrdFTY5R.js';
 export { a as LocalHarnessResult, R as RunLocalHarnessOptions } from '../local-harness-KrdFTY5R.js';
-import { O as OtelExporter } from '../otel-export-B2UBcPV4.js';
-export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from '../otel-export-B2UBcPV4.js';
+import { O as OtelExporter } from '../otel-export-CsgwKFq8.js';
+export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from '../otel-export-CsgwKFq8.js';
 import '@tangle-network/agent-eval';
 import '../runtime-run-B8VIiOhI.js';
 import '../types-CsCCryln.js';

package/dist/mcp/index.js

@@ -9,13 +9,13 @@ import {
   createWorktree,
   detectExecutor,
   removeWorktree
-} from "../chunk-ZJACJZF7.js";
+} from "../chunk-AAJVQRPL.js";
 import {
   createOtelExporter,
   loopEventToOtelSpan,
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "../chunk-QZEDHTT2.js";
+} from "../chunk-RO7K6JNF.js";
 import {
   DELEGATE_CODE_DESCRIPTION,
   DELEGATE_CODE_INPUT_SCHEMA,
@@ -46,14 +46,14 @@ import {
   validateDelegateResearchArgs,
   validateDelegationHistoryArgs,
   validateDelegationStatusArgs
-} from "../chunk-UNQM6XQO.js";
+} from "../chunk-HSX6PFZR.js";
 import {
   runLocalHarness
 } from "../chunk-GLR25NG7.js";
-import "../chunk-TZ53F7M7.js";
-import "../chunk-CBQVID7G.js";
-import "../chunk-URDSRUPQ.js";
-import "../chunk-XZYF3YJN.js";
+import "../chunk-GLTUUKTN.js";
+import "../chunk-5QVVET72.js";
+import "../chunk-PY6NMZYX.js";
+import "../chunk-SQSCRJ7U.js";
 import "../chunk-DGUM43GV.js";
 
 // src/mcp/trace-propagation.ts

package/dist/{otel-export-B2UBcPV4.d.ts → otel-export-CsgwKFq8.d.ts}

@@ -110,5 +110,60 @@ declare function loopEventToOtelSpan(event: {
     timestamp: number;
     payload: object;
 }, traceId: string, parentSpanId?: string): OtelSpan;
+/** Wire version the eval-runs ingest enforces (X-Tangle-Wire-Version + body). */
+declare const INTELLIGENCE_WIRE_VERSION = "2026-05-26.v1";
+interface EvalRunGeneration {
+    /** 0-based ordinal of this generation within the run (required by ingest). */
+    index: number;
+    /** Identity of the proposed surface change (content-addressed hash). */
+    surfaceHash: string;
+    /** Arbitrary provenance for this generation (rationale, evidence, source). */
+    surface?: unknown;
+    /** Per-scenario results; empty until the generation is measured. */
+    cells?: unknown[];
+    /** Mean composite score (0 when unmeasured — pair with labels.measured). */
+    compositeMean: number;
+    costUsd: number;
+    durationMs: number;
+}
+interface EvalRunEvent {
+    runId: string;
+    runDir: string;
+    /** ISO timestamp. */
+    timestamp: string;
+    status: 'started' | 'baseline-complete' | 'generation-complete' | 'gate-decided' | 'finished' | 'errored';
+    labels?: Record<string, string>;
+    baseline?: EvalRunGeneration;
+    generations?: EvalRunGeneration[];
+    gateDecision?: 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
+    holdoutLift?: number;
+    totalCostUsd: number;
+    totalDurationMs: number;
+    errorMessage?: string;
+}
+interface EvalRunsExportConfig {
+    /** Bearer key — tenant is resolved server-side from it. Reads TANGLE_API_KEY. */
+    apiKey?: string;
+    /** Intelligence base. Reads INTELLIGENCE_BASE env, else prod. */
+    base?: string;
+    /** Idempotency-Key header (e.g. the runId) — safe retries + upsert. */
+    idempotencyKey?: string;
+}
+interface EvalRunsExportResult {
+    ok: boolean;
+    status: number;
+    accepted: number;
+    rejected: Array<{
+        index: number;
+        reason: string;
+    }>;
+}
+/**
+ * Ship self-improvement eval-run events to Tangle Intelligence. Unlike the
+ * best-effort span exporter, this RESOLVES with the ingest verdict (accepted /
+ * rejected per event) so a consumer's loop can assert its provenance landed.
+ * Throws only on a missing key or network failure.
+ */
+declare function exportEvalRuns(events: EvalRunEvent[], config?: EvalRunsExportConfig): Promise<EvalRunsExportResult>;
 
-export { type OtelExporter as O, mcpToolsForRuntimeMcpSubset as a, type OtelAttribute as b, type OtelExportConfig as c, type OtelSpan as d, createOtelExporter as e, loopEventToOtelSpan as l, mcpToolsForRuntimeMcp as m };
+export { type EvalRunEvent as E, INTELLIGENCE_WIRE_VERSION as I, type OtelExporter as O, mcpToolsForRuntimeMcpSubset as a, type EvalRunGeneration as b, type EvalRunsExportConfig as c, type EvalRunsExportResult as d, type OtelAttribute as e, type OtelExportConfig as f, type OtelSpan as g, createOtelExporter as h, exportEvalRuns as i, loopEventToOtelSpan as l, mcpToolsForRuntimeMcp as m };

package/dist/profiles.d.ts

@@ -1,5 +1,5 @@
 import { AgentProfile } from '@tangle-network/sandbox';
-import { O as OutputAdapter, V as Validator, A as AgentRunSpec, D as Driver } from './types-Cbe54nB7.js';
+import { O as OutputAdapter, V as Validator, A as AgentRunSpec, D as Driver } from './types-CpCX1pfx.js';
 import '@tangle-network/agent-eval';
 import './runtime-run-B8VIiOhI.js';
 import './types-CsCCryln.js';

package/dist/profiles.js

@@ -2,9 +2,9 @@ import {
   coderProfile,
   createCoderValidator,
   multiHarnessCoderFanout
-} from "./chunk-CBQVID7G.js";
-import "./chunk-URDSRUPQ.js";
-import "./chunk-XZYF3YJN.js";
+} from "./chunk-5QVVET72.js";
+import "./chunk-PY6NMZYX.js";
+import "./chunk-SQSCRJ7U.js";
 import "./chunk-DGUM43GV.js";
 export {
   coderProfile,

package/dist/{types-Cbe54nB7.d.ts → types-CpCX1pfx.d.ts}

@@ -74,6 +74,14 @@ interface AgentRunSpec<Task> {
 interface OutputAdapter<Output> {
     parse(events: SandboxEvent[]): Output;
 }
+/** LLM token usage. Structurally matches agent-eval's `RunTokenUsage` /
+ *  `CampaignTokenUsage` ({ input, output }) so a loop result maps straight
+ *  onto `ctx.cost.observeTokens` in a `runProfileMatrix` dispatch — without
+ *  which the backend-integrity guard reads the run as a stub. */
+interface LoopTokenUsage {
+    input: number;
+    output: number;
+}
 /** @experimental */
 interface Iteration<Task, Output> {
     /** 0-based iteration index assigned by the kernel. */
@@ -89,6 +97,8 @@ interface Iteration<Task, Output> {
     startedAt: number;
     endedAt: number;
     costUsd: number;
+    /** Summed LLM token usage across every `llm_call` event in this iteration. */
+    tokenUsage: LoopTokenUsage;
 }
 /** @experimental */
 interface Driver<Task, Output, Decision> {
@@ -125,6 +135,10 @@ interface LoopResult<Task, Output, Decision> {
     durationMs: number;
     /** Sum of every iteration's `costUsd`. */
     costUsd: number;
+    /** Sum of every iteration's token usage. Forward to
+     *  `ctx.cost.observeTokens` in a `runProfileMatrix` dispatch so the
+     *  integrity guard sees real LLM activity. */
+    tokenUsage: LoopTokenUsage;
 }
 /**
  * Minimal sandbox client surface the kernel calls. Satisfied structurally by
@@ -267,4 +281,4 @@ interface ExecCtx {
     parentSpanId?: string;
 }
 
-export type { AgentRunSpec as A, Driver as D, ExecCtx as E, Iteration as I, LoopWinner as L, OutputAdapter as O, Validator as V, LoopResult as a, LoopDecisionPayload as b, LoopEndedPayload as c, LoopIterationDispatchPayload as d, LoopIterationEndedPayload as e, LoopIterationStartedPayload as f, LoopSandboxClient as g, LoopSandboxPlacement as h, LoopStartedPayload as i, LoopTraceEmitter as j, LoopTraceEvent as k, ValidationCtx as l };
+export type { AgentRunSpec as A, Driver as D, ExecCtx as E, Iteration as I, LoopSandboxClient as L, OutputAdapter as O, Validator as V, LoopWinner as a, LoopResult as b, LoopDecisionPayload as c, LoopEndedPayload as d, LoopIterationDispatchPayload as e, LoopIterationEndedPayload as f, LoopIterationStartedPayload as g, LoopSandboxPlacement as h, LoopStartedPayload as i, LoopTokenUsage as j, LoopTraceEmitter as k, LoopTraceEvent as l, ValidationCtx as m };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.30.1",
+  "version": "0.33.0",
   "description": "Reusable runtime lifecycle for domain-specific agents.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {
@@ -65,22 +65,42 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@tangle-network/agent-eval": "^0.54.0"
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepare": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check src tests examples",
+    "lint:fix": "biome check --write src tests examples",
+    "typecheck": "tsc --noEmit"
   },
+  "dependencies": {},
   "devDependencies": {
     "@biomejs/biome": "^2.4.0",
+    "@tangle-network/agent-eval": "^0.61.0",
     "@tangle-network/sandbox": "^0.4.0",
     "@types/node": "^25.6.0",
     "tsup": "^8.0.0",
     "typescript": "^5.7.0",
     "vitest": "^3.0.0"
   },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": [
+      "@tangle-network/agent-eval"
+    ],
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  },
   "engines": {
     "node": ">=20"
   },
   "license": "MIT",
+  "packageManager": "pnpm@10.28.0",
   "peerDependencies": {
+    "@tangle-network/agent-eval": ">=0.61.0 <1.0.0",
     "@tangle-network/agent-knowledge": ">=1.3.0 <2.0.0",
     "@tangle-network/sandbox": ">=0.1.2 <0.5.0"
   },
@@ -91,14 +111,5 @@
     "@tangle-network/sandbox": {
       "optional": true
     }
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "lint": "biome check src tests examples",
-    "lint:fix": "biome check --write src tests examples",
-    "typecheck": "tsc --noEmit"
   }
-}
+}