@tangle-network/agent-runtime 0.85.0 → 0.87.0

package/dist/loop-runner-bin.js

@@ -2,14 +2,14 @@
 import {
   parseLoopRunnerArgv,
   runLoopRunnerCli
-} from "./chunk-QSYPMMWS.js";
+} from "./chunk-FLVVVBWV.js";
 import "./chunk-SGKPNBXE.js";
-import "./chunk-DLAEEF26.js";
-import "./chunk-XN5TIJGP.js";
+import "./chunk-VKVNDNG4.js";
+import "./chunk-6XCW3M7W.js";
 import "./chunk-UD4BHQMI.js";
 import "./chunk-BZF3KQ6G.js";
-import "./chunk-YPA5MLVE.js";
-import "./chunk-4J6RBI3K.js";
+import "./chunk-LCXXIL3U.js";
+import "./chunk-QUXZBZCS.js";
 import "./chunk-7LO5GMAO.js";
 import "./chunk-YEJR7IXO.js";
 import "./chunk-DPEUKJRO.js";

package/dist/loops.d.ts

@@ -1,6 +1,6 @@
 import { ChatClient, RunRecord, HarnessType, AgentProfile, AnalystFinding, AnalystRunInputs, ToolSpan, StreamingDetector, DetectorSignal, buildTrajectory } from '@tangle-network/agent-eval';
 export { AnalystFinding, DefaultVerdict, computeFindingId, makeFinding } from '@tangle-network/agent-eval';
-import { SandboxEvent, SandboxInstance, CreateSandboxOptions } from '@tangle-network/sandbox';
+import { SandboxEvent, SandboxInstance, CreateSandboxOptions, PromptOptions, TaskOptions } from '@tangle-network/sandbox';
 export { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
 import { d as ResultBlobStore, S as SpawnJournal, N as NodeId, j as SpawnEvent, E as ExecutorFactory, c as Agent, B as Budget, i as Scope, g as Settled, f as SupervisedResult, h as Spend, U as UsageEvent, b as ExecutorRegistry, k as Supervisor } from './types-Driepl87.js';
 export { A as AgentSpec, a as Executor, l as ExecutorContext, m as ExecutorResult, R as Runtime, n as SupervisorOpts, T as TreeView, W as WidenGate } from './types-Driepl87.js';
@@ -544,8 +544,10 @@ interface LeaderboardBenchScore {
     detail?: string;
 }
 /** Structurally `BenchmarkAdapter` (bench registry shape): `name`,
- *  `preflight()`, `loadTasks()`, deterministic `judge()`, `goldArtifact()`. */
-interface LeaderboardBenchmarkAdapter {
+ *  `preflight()`, `loadTasks()`, deterministic `judge()`, `goldArtifact()`.
+ *  Generic over the artifact channel; the `string` default IS the registry
+ *  shape, so a default-artifact adapter registers unchanged. */
+interface LeaderboardBenchmarkAdapter<TArtifact = string> {
     readonly name: string;
     preflight(): Promise<void>;
     loadTasks(opts?: {
@@ -553,10 +555,29 @@ interface LeaderboardBenchmarkAdapter {
         split?: string;
         ids?: string[];
     }): Promise<LeaderboardBenchTask[]>;
-    judge(task: LeaderboardBenchTask, artifact: string): Promise<LeaderboardBenchScore>;
+    judge(task: LeaderboardBenchTask, artifact: TArtifact): Promise<LeaderboardBenchScore>;
     goldArtifact(task: LeaderboardBenchTask): Promise<string | undefined>;
 }
-interface LeaderboardSpec<TCase> {
+/** Per-shot outcome context passed as `onCellEvents`'s third argument — how a
+ *  thrown shot (which never reaches `parseOutput`) stays visible through the
+ *  facade instead of surfacing only as an empty zero-token cell. */
+interface LeaderboardIterationInfo {
+    /** 0-based shot index within the cell. */
+    index: number;
+    /** The shot's thrown error message, when the shot failed before scoring. */
+    error?: string;
+    /** The shot's validator verdict, when the shot reached scoring. */
+    verdict?: {
+        score?: number;
+    };
+}
+/**
+ * The declarative leaderboard spec. `TArtifact` is the artifact channel the
+ * dispatch produces and the judges score — `string` (the default) is the plain
+ * agent-response-text path; a structured artifact type flows natively once the
+ * spec supplies `parseOutput` (or a LEVEL-2 `dispatch`) producing it.
+ */
+interface LeaderboardSpec<TCase, TArtifact = string> {
     /** Leaderboard name — the scenario `kind`, default profile name, and report title. */
     name: string;
     /** The case corpus. Every case needs a stable string id (see `caseId`). */
@@ -567,10 +588,10 @@ interface LeaderboardSpec<TCase> {
     /** The per-case task prompt. May be async (e.g. built by shelling out to a
      *  reference implementation); resolved ONCE per case before dispatch. */
     prompt: (c: TCase) => string | Promise<string>;
-    /** The domain grader: agent output text → score. Used BOTH as the per-shot
-     *  validator (a shot with `composite > 0` stops the naive retry loop) and,
-     *  wrapped as a campaign judge, as the recorded leaderboard score. */
-    score: (output: string, c: TCase) => number | LeaderboardScore;
+    /** The domain grader: agent output artifact → score. Used BOTH as the
+     *  per-shot validator (a shot with `composite > 0` stops the naive retry
+     *  loop) and, wrapped as a campaign judge, as the recorded leaderboard score. */
+    score: (output: TArtifact, c: TCase) => number | LeaderboardScore;
     /** Harness × model axes for `expandProfileAxes`. Defaults: the canonical
      *  `CODING_HARNESSES` × the base profile's `model.default`. `--harnesses` /
      *  `--models` override per run. */
@@ -601,22 +622,36 @@ interface LeaderboardSpec<TCase> {
     setup?: (ctx: LeaderboardRunContext) => Promise<void> | void;
     /** Runs once after the matrix, even on failure (reap boxes, close handles). */
     teardown?: (ctx: LeaderboardRunContext) => Promise<void> | void;
-    /** Per-cell event tap: the raw sandbox events of each parsed iteration,
-     *  with the case — the seam for domain metric capture (search counts,
-     *  citations) without a substrate change. */
-    onCellEvents?: (events: readonly SandboxEvent[], c: TCase) => void;
-    /** Output decode override: raw events → the scored output text. Default:
-     *  the sandbox SDK's `collectAgentResponseText` (final answer text; empty
-     *  string when the stream carried none — which then scores 0). */
-    parseOutput?: (events: readonly SandboxEvent[], c: TCase) => string;
+    /** Per-cell event tap: the raw sandbox events of EVERY shot, with the case —
+     *  the seam for domain metric capture (search counts, citations) without a
+     *  substrate change. Fires once per shot after the cell's loop settles, in
+     *  shot order, including thrown shots (whose events may be partial or empty);
+     *  the third argument carries the shot's index + error/verdict outcome. */
+    onCellEvents?: (events: readonly SandboxEvent[], c: TCase, iteration?: LeaderboardIterationInfo) => void;
+    /** Output decode override: raw events → the scored artifact. Default: the
+     *  sandbox SDK's `collectAgentResponseText` (final answer text; empty string
+     *  when the stream carried none — which then scores 0). The default only
+     *  produces `string`, so a spec with a structured `TArtifact` MUST supply
+     *  this (or a LEVEL-2 `dispatch`). */
+    parseOutput?: (events: readonly SandboxEvent[], c: TCase) => TArtifact;
+    /**
+     * Resolve the model the backend ACTUALLY served off a shot's raw events.
+     * Required for HARNESS_NATIVE_MODEL-snapped cells (a vendor-locked harness ×
+     * an out-of-family model expands to the `default` sentinel): the RunRecord
+     * must pin a real snapshot-bearing model id, which only the dispatch —
+     * reading the backend's usage/terminal events — can know. When this returns
+     * a value the default dispatch reports it via `ctx.cost.observeModel`;
+     * in-family cells (concrete declared model) never need it.
+     */
+    resolveModel?: (events: readonly SandboxEvent[]) => string | undefined;
     /** Result export. Default: write `matrix-result.json` under the run dir and
      *  print (+ write) the ranked leaderboard markdown under the export dir. */
-    export?: (result: RunProfileMatrixResult<string, LeaderboardScenario<TCase>>, ctx: LeaderboardRunContext) => Promise<void> | void;
+    export?: (result: RunProfileMatrixResult<TArtifact, LeaderboardScenario<TCase>>, ctx: LeaderboardRunContext) => Promise<void> | void;
     /** LEVEL 2 — full dispatch replacement (in-process products bring their own).
      *  The default is `loopDispatch` + `naiveDriver` over the resolved backend. */
-    dispatch?: ProfileDispatchFn<LeaderboardScenario<TCase>, string>;
+    dispatch?: ProfileDispatchFn<LeaderboardScenario<TCase>, TArtifact>;
     /** LEVEL 2 — full judge replacement. Default: `score` wrapped as one judge. */
-    judges?: JudgeConfig<string, LeaderboardScenario<TCase>>[];
+    judges?: JudgeConfig<TArtifact, LeaderboardScenario<TCase>>[];
     /** Naive-retry shot cap per cell (`--shots`). Default 1. */
     shots?: number;
     /** Replicates per cell (`--reps`). Default 1. */
@@ -624,9 +659,9 @@ interface LeaderboardSpec<TCase> {
     /** Passthrough overrides spread onto the final `runProfileMatrix` call
      *  (e.g. `maxConcurrency`, `costCeiling`, `integrity`, `storage`) — spread
      *  LAST, so anything the facade wired can be overridden. */
-    matrix?: Partial<RunProfileMatrixOptions<LeaderboardScenario<TCase>, string>>;
+    matrix?: Partial<RunProfileMatrixOptions<LeaderboardScenario<TCase>, TArtifact>>;
 }
-interface DefinedLeaderboard<TCase> {
+interface DefinedLeaderboard<TCase, TArtifact = string> {
     /**
      * Parse flags, run the matrix, export, and return the raw result.
      *
@@ -640,11 +675,11 @@ interface DefinedLeaderboard<TCase> {
      * would silently reuse a prior FAILED zero-token cell and skip dispatch —
      * only an explicit `--run-dir` opts into that resume behavior.
      */
-    run(argv?: string[]): Promise<RunProfileMatrixResult<string, LeaderboardScenario<TCase>>>;
+    run(argv?: string[]): Promise<RunProfileMatrixResult<TArtifact, LeaderboardScenario<TCase>>>;
     /** The same domain surface in the structural `BenchmarkAdapter` shape. */
-    toBenchmarkAdapter(): LeaderboardBenchmarkAdapter;
+    toBenchmarkAdapter(): LeaderboardBenchmarkAdapter<TArtifact>;
 }
-declare function defineLeaderboard<TCase>(spec: LeaderboardSpec<TCase>): DefinedLeaderboard<TCase>;
+declare function defineLeaderboard<TCase, TArtifact = string>(spec: LeaderboardSpec<TCase, TArtifact>): DefinedLeaderboard<TCase, TArtifact>;
 
 /**
  * The third-person observer — the connective tissue that closes the loop.
@@ -767,10 +802,11 @@ interface HarvestReport {
 /** Batch the firewalled `observe()` analyst over completed runs and accrete the trace-derived facts into the durable corpus — the production-traces→corpus write side of the flywheel. */
 declare function harvestCorpus(opts: HarvestCorpusOptions): Promise<HarvestReport>;
 
-/** Context handed to each `onPrompt` call. */
+/** Context handed to each `onPrompt` / `onTask` call. */
 interface InProcessPromptCtx {
-    /** 0-based round index — increments per `streamPrompt` on the SAME box (so a
-     *  refine driver's round N can differ from round N-1). Fresh boxes start at 0. */
+    /** 0-based round index — increments per `streamPrompt`/`streamTask` on the
+     *  SAME box (so a refine driver's round N can differ from round N-1). Fresh
+     *  boxes start at 0. */
     round: number;
     /** Absolute path of this box's workspace, when a `workdir` was configured.
      *  Write the deliverable / fixtures here; `fs.read`/`fs.write`/`exec` operate
@@ -778,6 +814,13 @@ interface InProcessPromptCtx {
     workdir?: string;
     /** Cooperative cancellation channel for this turn. */
     signal: AbortSignal;
+    /** Which box verb produced this call: `prompt` = `streamPrompt`,
+     *  `task` = `streamTask`. */
+    mode: 'prompt' | 'task';
+    /** The verbatim per-call options the caller passed to the box verb (minus
+     *  `signal`, surfaced above) — lets an offline test assert an options
+     *  passthrough (`model`, `sessionId`, `maxTurns`, …) actually arrived. */
+    options?: Record<string, unknown>;
 }
 /**
  * The user callback: given a prompt and its round, produce the box's event
@@ -790,6 +833,14 @@ type InProcessOnPrompt = (prompt: string, ctx: InProcessPromptCtx) => SandboxEve
 interface InProcessSandboxClientOptions {
     /** The per-turn behavior — see {@link InProcessOnPrompt}. */
     onPrompt: InProcessOnPrompt;
+    /**
+     * Task-mode behavior, driven by `box.streamTask` (the verb `streamAgentTurn`'s
+     * `box-task` backend calls). When omitted, `streamTask` drives `onPrompt` —
+     * the pseudo-box has ONE behavior callback and both verbs exercise it
+     * (`ctx.mode` tells them apart). Provide `onTask` when a test must
+     * discriminate the verbs or script different task-mode behavior.
+     */
+    onTask?: InProcessOnPrompt;
     /**
      * Opt in to a REAL filesystem-backed box. When set, each `create()` mints a
      * fresh temp directory (prefixed `<workdir>-`) and the box exposes
@@ -2052,6 +2103,51 @@ declare function sumSandboxUsage(events: readonly SandboxEvent[], agentRunName?:
     output: number;
     costUsd: number;
 };
+/**
+ * Cross-event state for {@link mapSandboxToolEvent}. Sandbox backends emit a
+ * tool invocation as MANY `message.part.updated` frames on the same call id
+ * (pending → running → completed), so faithful projection needs per-call
+ * status memory: one `tool_call` on first sighting, at most one `tool_result`
+ * on the terminal transition, nothing on intermediate re-frames. Create one
+ * state per turn via {@link createSandboxToolPartState}.
+ *
+ * @experimental
+ */
+interface SandboxToolPartState {
+    /** Last seen status per tool call id. A terminal status is sticky — later
+     *  frames on a settled call project to nothing. */
+    statusByCall: Map<string, string>;
+    /** Sequence for synthesized call ids when an event carries none. */
+    seq: number;
+}
+/** @experimental */
+declare function createSandboxToolPartState(): SandboxToolPartState;
+/**
+ * Project one `SandboxEvent` onto the `tool_call` / `tool_result` variants of
+ * `RuntimeStreamEvent` — the tool-part projection `mapSandboxEvent`
+ * deliberately does NOT perform. Opt-in and additive: `mapSandboxEvent`'s
+ * default vocabulary (text/reasoning deltas + `llm_call`) is unchanged;
+ * consumers that need the tool surface (chat UIs rendering tool activity)
+ * compose this projector alongside it — `streamAgentTurn` does exactly that
+ * under its `preserveToolParts` option.
+ *
+ * Handled shapes (observed on the opencode / claude-code sandbox backends):
+ *   - `message.part.updated` with `part.type === 'tool'` — stateful: a
+ *     `tool_call` on the call id's first frame (args from `state.input` or
+ *     `state.metadata.input`), a `tool_result` when the status transitions to
+ *     `completed` (result from `state.output` / `metadata.output`) or to a
+ *     terminal failure (result is `{ error, status, output? }` — the error
+ *     surfaced in-band, never dropped).
+ *   - bare `tool*` event types (`tool.call`, `tool_result`, …) — stateless:
+ *     `*result*` types project to `tool_result`, the rest to `tool_call`.
+ *
+ * Returns `[]` for every non-tool event.
+ *
+ * @experimental
+ */
+declare function mapSandboxToolEvent(event: SandboxEvent, state: SandboxToolPartState): (RuntimeStreamEvent & {
+    type: 'tool_call' | 'tool_result';
+})[];
 /**
  * Project one `SandboxEvent` onto the `RuntimeStreamEvent` chat-UX vocabulary,
  * for runtimes that bridge a sandbox `streamPrompt` into the
@@ -2065,6 +2161,9 @@ declare function sumSandboxUsage(events: readonly SandboxEvent[], agentRunName?:
  *   - `message.part.updated` reasoning/thinking part → `reasoning_delta`
  *   - cost-bearing events → `llm_call` (shared with the ledger extractor)
  *
+ * Tool parts are deliberately NOT mapped here (unchanged default) — compose
+ * {@link mapSandboxToolEvent} alongside when a consumer needs them.
+ *
  * The opencode backend emits incremental text as
  * `{ type: 'message.part.updated', data: { part: { type, text }, delta } }`;
  * `delta` is the increment, `part.text` the running accumulation.
@@ -2747,7 +2846,8 @@ declare function runStrategyEvolution(cfg: StrategyEvolutionConfig): Promise<Evo
 
 /**
  * `streamAgentTurn` — the ONE run-a-turn event-stream contract over every
- * execution substrate: a sandbox box (`SandboxInstance.streamPrompt`), a
+ * execution substrate: a sandbox box (`SandboxInstance.streamPrompt`, or
+ * `streamTask` via the `box-task` kind for autonomous-task semantics), a
  * one-shot `Executor` (cli-bridge / router / BYO, via `ExecutorFactory`), and
  * an in-process `AgentExecutionBackend` (the `resolveAgentBackend` output).
  *
@@ -2762,6 +2862,10 @@ declare function runStrategyEvolution(cfg: StrategyEvolutionConfig): Promise<Evo
  * adapter over code that already exists and is already hardened:
  *   - `box`      — `mapSandboxEvent` + `extractLlmCallEvent` (sandbox-events.ts)
  *                  project the sandbox event stream; nothing is re-mapped here.
+ *   - `box-task` — the same projection over `box.streamTask` (the sandbox
+ *                  SDK's autonomous-task verb: the agent works to completion,
+ *                  multi-turn, session state maintained) with per-task
+ *                  `TaskOptions` passthrough.
  *   - `executor` — `inlineSandboxClient` (the ONE executor→box adapter) turns
  *                  the factory into a box, then the box path drives it. The
  *                  executor's settle/teardown lifecycle stays in that adapter.
@@ -2781,6 +2885,15 @@ declare function runStrategyEvolution(cfg: StrategyEvolutionConfig): Promise<Evo
  * `final.status: 'failed'` — so cancellation stays distinguishable from a
  * blown deadline.
  *
+ * Mid-stream lifecycle work needs NO extra API: the generator is pull-based,
+ * so the producer is suspended between yields and resumes only when the caller
+ * pulls again. A consumer can therefore run arbitrary async work between
+ * events — sync state on each `tool_result`, decide a no-op retry after
+ * draining, run a pre-`done` flush when it receives `final` and BEFORE it
+ * forwards its own terminal event downstream. The interleaving is guaranteed
+ * (and locked by test): nothing is produced past the event the caller is
+ * holding.
+ *
  * @experimental
  */
 
@@ -2794,6 +2907,34 @@ type AgentTurnBackend = {
     /** A live sandbox box: the turn is one `box.streamPrompt(prompt)` call. */
     kind: 'box';
     box: SandboxInstance;
+    /**
+     * Per-turn `PromptOptions` forwarded verbatim to `streamPrompt`
+     * (`sessionId`, `turnId`, `model`, `backend` profile, `timeoutMs`, …).
+     * The turn's derived abort signal (caller `signal` + `timeoutMs`
+     * deadline) is always installed as `signal` — pass cancellation through
+     * `StreamAgentTurnOptions`, not here.
+     */
+    options?: Omit<PromptOptions, 'signal'>;
+    /** Model label stamped on cost-only `llm_call` events. Default `'agent'`. */
+    agentRunName?: string;
+} | {
+    /**
+     * A live sandbox box in TASK mode: the turn is one
+     * `box.streamTask(prompt)` call — the sandbox SDK's autonomous-task
+     * verb. Unlike `streamPrompt` (one chat turn), the agent works until
+     * the task completes or errors, session state is maintained for
+     * continuity, and `options.maxTurns` bounds the agent's internal turns.
+     * Event projection, usage folding, and the terminal `final` contract
+     * are identical to the `box` kind.
+     */
+    kind: 'box-task';
+    box: SandboxInstance;
+    /**
+     * Per-task `TaskOptions` forwarded verbatim to `streamTask`
+     * (`maxTurns` plus every `PromptOptions` field). The turn's derived
+     * abort signal is always installed as `signal`.
+     */
+    options?: Omit<TaskOptions, 'signal'>;
     /** Model label stamped on cost-only `llm_call` events. Default `'agent'`. */
     agentRunName?: string;
 } | {
@@ -2825,6 +2966,25 @@ interface StreamAgentTurnOptions {
      * (a blown deadline is a turn failure, not a caller cancellation).
      */
     timeoutMs?: number;
+    /**
+     * Opt-in tool-part projection for box-kind backends (`box`, `box-task`,
+     * `executor`): sandbox tool parts additionally surface in-stream as
+     * `tool_call` / `tool_result` events (`mapSandboxToolEvent`), so a consumer
+     * rendering tool activity needs no bespoke sandbox-event parser. Default
+     * off — the stream vocabulary existing consumers see is unchanged. No-op
+     * for the `chat` kind (its backend emits `RuntimeStreamEvent`s directly,
+     * tool events included when the backend produces them).
+     */
+    preserveToolParts?: boolean;
+    /**
+     * Raw-event tap for box-kind backends: called (and awaited) with every
+     * unmapped `SandboxEvent` BEFORE it is projected, so a consumer can read
+     * parts the chat-UX projection drops (part ids, step markers, custom
+     * backend events) without forking the mapper. Purely observational — it
+     * cannot alter the mapped stream. Never called for the `chat` kind, which
+     * has no sandbox events.
+     */
+    onRawEvent?: (event: SandboxEvent) => void | Promise<void>;
 }
 /**
  * Metered usage of one turn, summed over every cost-bearing event the backend
@@ -3908,4 +4068,4 @@ declare function runInWorkspace<T>(ws: Workspace, body: (cwd: string) => Promise
     commitOnInvalid?: boolean;
 }): Promise<WorkspaceRun<T>>;
 
-export { Agent, AgentRunSpec, type AgentTurnBackend, type AgentTurnUsage, type AgenticOptions, type AgenticRunResult, type AgenticSurface, type AgenticTask, type AgenticTool, AnalystRegistry, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, type ApplyContinuation, type ArtifactHandle, AssertTraceDerivedFindings, type AuditIntentInput, type AuditIntentOptions, type AuthorStrategyOptions, type AuthoredProfile, type AuthoredStrategy, type BenchmarkCell, type BenchmarkConfig, type BenchmarkLift, type BenchmarkReport, type BenchmarkStrategySummary, type BenchmarkTaskRow, Budget, type BudgetPool, type BudgetReadout, type ChampionPick, type ChampionPolicy, type CheckpointCapableBox, type CollectedAgentTurn, CombinatorShape, type CompletionAnalyst, type CompletionEvidence, type CompletionPolicy, type CompletionVerdict, CoordinationEvent, type CoordinationMcpHandle, Corpus, CorpusFilter, CorpusRecord, type CreateScopeAnalystOptions, type CriuCapableClient, DefinePersonaInput, type DefinedLeaderboard, type DelegateOptions, type Deliverable, DeliverableSpec, type DriveHarness, Driver, type DriverAgentOptions, type DumbDriverOptions, type Environment, EqualKArm, EqualKOnCostOptions, EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, ExecutorConfig, ExecutorFactory, ExecutorRegistry, FanoutOptions, FanoutWinnerSelector, FileCorpus, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, type InMemoryRunContext, type InMemoryRunContextOptions, InMemorySpawnJournal, type InProcessOnPrompt, type InProcessPromptCtx, type InProcessSandboxClientOptions, type Inbox, type InboxMessage, type IntentAudit, type Interval, Iteration, type Leaderboard, type LeaderboardBenchScore, type LeaderboardBenchTask, type LeaderboardBenchmarkAdapter, type LeaderboardFlagSpec, type LeaderboardOptions, type LeaderboardRow, type LeaderboardRunContext, type LeaderboardScenario, type LeaderboardScore, type LeaderboardSpec, type LoopCampaignDispatchOptions, type LoopDispatchOptions, LoopLineageOptions, type LoopOptionsForDispatch, LoopResult, LoopShape, LoopTokenUsage, LoopUntilSpec, LoopWinner, MakeWorkerAgent, type McpEndpoint, type McpEnvironmentOptions, MountRecorder, type NaiveDriverOptions, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunOptions, Outcome, OutputAdapter, type PairwiseOptions, type PairwiseVerdict, PanelSpec, Persona, PipelineStage, type ProfileRichness, type ProfileRichnessThresholds, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, RenderCorpusToInstructionsOptions, type ReservationTicket, type ResolveSandboxClientOptions, ResultBlobStore, RouterConfig, type RunAgenticOptions, RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, SandboxRunAbortError, Scope, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, type SessionCapableBox, type SessionTraceBox, Settled, ShapeRegistry, type Shell, type ShotPersona, type ShotSpec, Spend, SteerContext, type SteeringDecision, type Strategy, type StrategyCtx, type StrategyEvolutionConfig, type StrategyResult, type StreamAgentTurnOptions, type SuperviseOptions, type SuperviseSurfaceOptions, type SuperviseSurfaceResult, SupervisedResult, Supervisor, type SupervisorAgentDeps, type SupervisorProfile, type SurfaceScore, type SurfaceWorkerConfig, type SurfaceWorkerOut, ToolLoopChat, ToolLoopCompactionOptions, type TraceSource, type TrajectoryAnalysis, TrajectoryReport, TrajectoryReportOptions, type TurnResult, UsageEvent, type UsageSink, Validator, type VerifierEnvironmentOptions, VerifySpec, type WatchTraceOptions, type WaterfallCollector, type WaterfallReport, type WaterfallSpan, WidenSpec, WinnerStrategy, type Workspace, type WorkspaceCommit, type WorkspaceRun, acquireSandbox, adaptiveRefine, analyzeTrace, anytimeReport, asAuthoredProfile, assertModelAllowed, assertStrategyContract, assertTraceDerivedFindings, assessAuthoredProfile, auditIntent, authorStrategy, authoredWorker, breadthStrategy, buildSteerContext, builtinShapes, collectAgentTurn, completionAuthorizes, contentAddress, createBudgetPool, createInMemoryRunContext, createInbox, createMcpEnvironment, createPushTraceSource, createSandboxLineage, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, decodeToolPart, defaultAnalystInstruction, defaultAuditorInstruction, defaultDelegateBudget, defaultProfileRichnessThresholds, defaultSelectWinner, defaultToolDetectors, defineLeaderboard, definePersona, defineStrategy, delegate, depthStrategy, deterministicCompletion, discriminatingMeans, driverAgent, dumbDriver, equalKOnCost, extractLlmCallEvent, failuresAnalyst, fanout, finalizeBestDelivered, flatWidenGate, gitWorkspace, harvestCorpus, inProcessSandboxClient, inlineSandboxClient, jjWorkspace, leaderboard, localShell, loopCampaignDispatch, loopDispatch, loopUntil, mapSandboxEvent, naiveDriver, observe, openSandboxRun, pairwiseSignificance, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, profileRichnessFinding, promotionGate, refine, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderLeaderboardHtml, renderLeaderboardMarkdown, renderLeaderboardSvg, renderPairwiseMarkdown, renderReport, reportLoopUsage, resolveSandboxClient, runAgentic, runBenchmark, runInWorkspace, runLoop, runPersonified, runStrategyEvolution, sample, sampleThenRefine, sandboxSessionTraceSource, selectChampion, selectValidWinner, sentinelCompletion, serveCoordinationMcp, settledToIteration, spendFromUsageEvents, stopSentinel, strategyAuthorContract, streamAgentTurn, sumSandboxUsage, supervise, superviseSurface, supervisorAgent, supervisorInstructions, trajectoryReport, verify, watchTrace, widen, workerFromBackend };
+export { Agent, AgentRunSpec, type AgentTurnBackend, type AgentTurnUsage, type AgenticOptions, type AgenticRunResult, type AgenticSurface, type AgenticTask, type AgenticTool, AnalystRegistry, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, type ApplyContinuation, type ArtifactHandle, AssertTraceDerivedFindings, type AuditIntentInput, type AuditIntentOptions, type AuthorStrategyOptions, type AuthoredProfile, type AuthoredStrategy, type BenchmarkCell, type BenchmarkConfig, type BenchmarkLift, type BenchmarkReport, type BenchmarkStrategySummary, type BenchmarkTaskRow, Budget, type BudgetPool, type BudgetReadout, type ChampionPick, type ChampionPolicy, type CheckpointCapableBox, type CollectedAgentTurn, CombinatorShape, type CompletionAnalyst, type CompletionEvidence, type CompletionPolicy, type CompletionVerdict, CoordinationEvent, type CoordinationMcpHandle, Corpus, CorpusFilter, CorpusRecord, type CreateScopeAnalystOptions, type CriuCapableClient, DefinePersonaInput, type DefinedLeaderboard, type DelegateOptions, type Deliverable, DeliverableSpec, type DriveHarness, Driver, type DriverAgentOptions, type DumbDriverOptions, type Environment, EqualKArm, EqualKOnCostOptions, EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, ExecutorConfig, ExecutorFactory, ExecutorRegistry, FanoutOptions, FanoutWinnerSelector, FileCorpus, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, type InMemoryRunContext, type InMemoryRunContextOptions, InMemorySpawnJournal, type InProcessOnPrompt, type InProcessPromptCtx, type InProcessSandboxClientOptions, type Inbox, type InboxMessage, type IntentAudit, type Interval, Iteration, type Leaderboard, type LeaderboardBenchScore, type LeaderboardBenchTask, type LeaderboardBenchmarkAdapter, type LeaderboardFlagSpec, type LeaderboardIterationInfo, type LeaderboardOptions, type LeaderboardRow, type LeaderboardRunContext, type LeaderboardScenario, type LeaderboardScore, type LeaderboardSpec, type LoopCampaignDispatchOptions, type LoopDispatchOptions, LoopLineageOptions, type LoopOptionsForDispatch, LoopResult, LoopShape, LoopTokenUsage, LoopUntilSpec, LoopWinner, MakeWorkerAgent, type McpEndpoint, type McpEnvironmentOptions, MountRecorder, type NaiveDriverOptions, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunOptions, Outcome, OutputAdapter, type PairwiseOptions, type PairwiseVerdict, PanelSpec, Persona, PipelineStage, type ProfileRichness, type ProfileRichnessThresholds, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, RenderCorpusToInstructionsOptions, type ReservationTicket, type ResolveSandboxClientOptions, ResultBlobStore, RouterConfig, type RunAgenticOptions, RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, SandboxRunAbortError, type SandboxToolPartState, Scope, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, type SessionCapableBox, type SessionTraceBox, Settled, ShapeRegistry, type Shell, type ShotPersona, type ShotSpec, Spend, SteerContext, type SteeringDecision, type Strategy, type StrategyCtx, type StrategyEvolutionConfig, type StrategyResult, type StreamAgentTurnOptions, type SuperviseOptions, type SuperviseSurfaceOptions, type SuperviseSurfaceResult, SupervisedResult, Supervisor, type SupervisorAgentDeps, type SupervisorProfile, type SurfaceScore, type SurfaceWorkerConfig, type SurfaceWorkerOut, ToolLoopChat, ToolLoopCompactionOptions, type TraceSource, type TrajectoryAnalysis, TrajectoryReport, TrajectoryReportOptions, type TurnResult, UsageEvent, type UsageSink, Validator, type VerifierEnvironmentOptions, VerifySpec, type WatchTraceOptions, type WaterfallCollector, type WaterfallReport, type WaterfallSpan, WidenSpec, WinnerStrategy, type Workspace, type WorkspaceCommit, type WorkspaceRun, acquireSandbox, adaptiveRefine, analyzeTrace, anytimeReport, asAuthoredProfile, assertModelAllowed, assertStrategyContract, assertTraceDerivedFindings, assessAuthoredProfile, auditIntent, authorStrategy, authoredWorker, breadthStrategy, buildSteerContext, builtinShapes, collectAgentTurn, completionAuthorizes, contentAddress, createBudgetPool, createInMemoryRunContext, createInbox, createMcpEnvironment, createPushTraceSource, createSandboxLineage, createSandboxToolPartState, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, decodeToolPart, defaultAnalystInstruction, defaultAuditorInstruction, defaultDelegateBudget, defaultProfileRichnessThresholds, defaultSelectWinner, defaultToolDetectors, defineLeaderboard, definePersona, defineStrategy, delegate, depthStrategy, deterministicCompletion, discriminatingMeans, driverAgent, dumbDriver, equalKOnCost, extractLlmCallEvent, failuresAnalyst, fanout, finalizeBestDelivered, flatWidenGate, gitWorkspace, harvestCorpus, inProcessSandboxClient, inlineSandboxClient, jjWorkspace, leaderboard, localShell, loopCampaignDispatch, loopDispatch, loopUntil, mapSandboxEvent, mapSandboxToolEvent, naiveDriver, observe, openSandboxRun, pairwiseSignificance, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, profileRichnessFinding, promotionGate, refine, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderLeaderboardHtml, renderLeaderboardMarkdown, renderLeaderboardSvg, renderPairwiseMarkdown, renderReport, reportLoopUsage, resolveSandboxClient, runAgentic, runBenchmark, runInWorkspace, runLoop, runPersonified, runStrategyEvolution, sample, sampleThenRefine, sandboxSessionTraceSource, selectChampion, selectValidWinner, sentinelCompletion, serveCoordinationMcp, settledToIteration, spendFromUsageEvents, stopSentinel, strategyAuthorContract, streamAgentTurn, sumSandboxUsage, supervise, superviseSurface, supervisorAgent, supervisorInstructions, trajectoryReport, verify, watchTrace, widen, workerFromBackend };

package/dist/loops.js

@@ -89,7 +89,7 @@ import {
   watchTrace,
   widen,
   worktreeFanout
-} from "./chunk-DLAEEF26.js";
+} from "./chunk-VKVNDNG4.js";
 import {
   InMemoryResultBlobStore,
   InMemorySpawnJournal,
@@ -131,7 +131,7 @@ import {
   supervisorAgent,
   supervisorInstructions,
   workerFromBackend
-} from "./chunk-XN5TIJGP.js";
+} from "./chunk-6XCW3M7W.js";
 import "./chunk-UD4BHQMI.js";
 import {
   createAgentEnvironmentProviderRegistry,
@@ -141,10 +141,12 @@ import {
   sandboxClientAsProvider
 } from "./chunk-BZF3KQ6G.js";
 import {
+  createSandboxToolPartState,
   extractLlmCallEvent,
   mapSandboxEvent,
+  mapSandboxToolEvent,
   sumSandboxUsage
-} from "./chunk-4J6RBI3K.js";
+} from "./chunk-QUXZBZCS.js";
 import "./chunk-7LO5GMAO.js";
 import "./chunk-YEJR7IXO.js";
 import "./chunk-DPEUKJRO.js";
@@ -185,6 +187,7 @@ export {
   createMcpEnvironment,
   createPushTraceSource,
   createSandboxLineage,
+  createSandboxToolPartState,
   createScope,
   createScopeAnalyst,
   createShapeRegistry,
@@ -227,6 +230,7 @@ export {
   loopUntil,
   makeFinding,
   mapSandboxEvent,
+  mapSandboxToolEvent,
   naiveDriver,
   observe,
   openSandboxRun,

package/dist/mcp/bin.js

@@ -9,10 +9,10 @@ import {
   DelegationTaskQueue,
   FileDelegationStore,
   createMcpServer
-} from "../chunk-XN5TIJGP.js";
+} from "../chunk-6XCW3M7W.js";
 import "../chunk-UD4BHQMI.js";
 import "../chunk-BZF3KQ6G.js";
-import "../chunk-4J6RBI3K.js";
+import "../chunk-QUXZBZCS.js";
 import "../chunk-7LO5GMAO.js";
 import "../chunk-YEJR7IXO.js";
 import "../chunk-DPEUKJRO.js";

package/dist/mcp/index.js

@@ -6,7 +6,7 @@ import {
 import {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "../chunk-G7HQI6DB.js";
+} from "../chunk-MHYF2LIP.js";
 import {
   createKbGate
 } from "../chunk-SGKPNBXE.js";
@@ -14,7 +14,7 @@ import {
   assertTraceDerivedFindings,
   runCoderChecks,
   selectValidWinner
-} from "../chunk-DLAEEF26.js";
+} from "../chunk-VKVNDNG4.js";
 import {
   DELEGATE_DESCRIPTION,
   DELEGATE_FEEDBACK_DESCRIPTION,
@@ -64,7 +64,7 @@ import {
   validateDelegateUiAuditArgs,
   validateDelegationHistoryArgs,
   validateDelegationStatusArgs
-} from "../chunk-XN5TIJGP.js";
+} from "../chunk-6XCW3M7W.js";
 import "../chunk-UD4BHQMI.js";
 import {
   deleteBoxSafe,
@@ -72,7 +72,7 @@ import {
   throwAbort,
   throwIfAborted
 } from "../chunk-BZF3KQ6G.js";
-import "../chunk-4J6RBI3K.js";
+import "../chunk-QUXZBZCS.js";
 import {
   runLocalHarness
 } from "../chunk-7LO5GMAO.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.85.0",
+  "version": "0.87.0",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {

package/skills/build-with-agent-runtime/SKILL.md

@@ -64,8 +64,9 @@ agent-runtime's `AgentSpec { profile, harness }`. To sweep it as an eval axis,
 don't hand-declare a harness list — expand one base profile across
 `CODING_HARNESSES` with `expandProfileAxes` (agent-eval), run with
 `runProfileMatrix`, and pivot results by the stamped `AgentProfileCell`
-(`groupRunsByAgentProfileCell`); incompatible `(harness, model)` pairs drop via
-`harnessSupportsModel`.
+(`groupRunsByAgentProfileCell`); `harnessSupportsModel` filters per harness,
+and a vendor-locked harness that supports none of the requested models SNAPS
+to its native default (`HARNESS_NATIVE_MODEL`) — never silently dropped.
 
 | Altitude — I want to… | Use | Source |
 |---|---|---|
@@ -80,6 +81,10 @@ don't hand-declare a harness list — expand one base profile across
 | **Add a stateful tool-using domain** | implement `AgenticSurface` (5 hooks) — `/loops` | canonical-api §3.3 |
 | **Drive a team of agents over a graded `AgenticSurface` task** (workers settle on its check, driver self-improves from the failing tests) | `superviseSurface(profile, task, { surface, worker })` — `/loops` | canonical-api §2 |
 | **Benchmark: compare strategies + significance + Pareto on a domain** | `runBenchmark({ environment, tasks, worker, strategies })` — `/loops` | canonical-api §3.3 |
+| **Author a PRODUCT eval leaderboard** (cases + prompt + grader → ranked board, standard flags, fresh run-dir, export, `toBenchmarkAdapter()`) | `defineLeaderboard({ name, cases, prompt, score, axis?, backends?, flags?, setup?/teardown?, onCellEvents?, resolveModel?, export?, dispatch?, judges?, matrix? })` — `/loops` — NOT a hand-assembled flag-parsing + `runProfileMatrix` frame; `runProfileMatrix` is the escape floor, the level-2 `dispatch` override is how in-process products plug in | `src/runtime/define-leaderboard.ts` (verify vs source) |
+| **Resolve a harness-in-box backend** (box / local cli-bridge / router leaf, one `SandboxClient` shape) | `resolveSandboxClient({ backend: 'sandbox' \| 'bridge' \| 'router' })` — `/loops` — NOT a per-product backend factory or a hand-faked box (`inlineSandboxClient` / the bridge executor already exist) | `src/runtime/resolve-sandbox-client.ts` |
+| **Resolve an in-process chat backend** (the one `--backend` branch for `runChatThroughRuntime` / `runAgentTaskStream`) | `resolveAgentBackend({ kind: 'router' \| 'tcloud' \| 'cli-bridge' \| 'sandbox' })` — root `.` | `src/resolve-agent-backend.ts` |
+| **Run ONE agent turn as one normalized event stream** (box, executor, or chat backend; guaranteed terminal result+usage) | `streamAgentTurn(backend, prompt, { signal, timeoutMs })` + `collectAgentTurn(stream)` — `/loops` | canonical-api §2 |
 | **Benchmark report: multi-profile × multi-axis leaderboard** (ranked board + score matrix + SVG/HTML charts, any `RunRecord[]`) | `leaderboard(records)` + `renderLeaderboardMarkdown` / `renderLeaderboardSvg` / `renderLeaderboardHtml` — `/loops` | canonical-api §2 |
 | **Meter one `openSandboxRun` cell's token/cost usage** | `sumSandboxUsage(events)` — `/loops` | canonical-api §2 |
 | **Sweep harness × model as an eval axis** (turn one base profile into the full harness × model set) | `expandProfileAxes({ base, harnesses, models })` over `CODING_HARNESSES` → `runProfileMatrix(...)`, pivot with `groupRunsByAgentProfileCell` — `agent-eval` root — NOT a hand-declared `HARNESSES` list | agent-eval root (verify vs source) |
@@ -125,10 +130,24 @@ holds the load-bearing invariant the parallel breaks:
   (seeded, identical run-to-run; never report a point lift without `low/high/pairs`).
 - a per-product `HARNESSES` / `HarnessBackend` list + a metadata-harness reader
   **≈** `CODING_HARNESSES` + `expandProfileAxes` (the one canonical harness list;
-  incompatible `(harness, model)` pairs drop via `harnessSupportsModel`) and the
+  vendor-locked harnesses SNAP to their native model via `HARNESS_NATIVE_MODEL`,
+  never dropped) and the
   `AgentProfileCell` stamped by `runProfileMatrix`, pivoted via
   `groupRunsByAgentProfileCell` — never bake the harness into the model id so the
   same model can run under multiple harnesses.
+- a per-product leaderboard CLI (flag parsing + run-dir management + axis
+  expansion + a `runProfileMatrix` call + export/markdown) **≈**
+  `defineLeaderboard` (0.84+; it owns that whole frame — FRESH default run-dir,
+  standard `--backend`/`--harnesses`/`--models`/`--cases`/`--shots`/`--reps`
+  flags, `toBenchmarkAdapter()`; the product writes ~150-250 domain lines).
+- a backend factory / `if (backend === 'router') ... else ...` branch or a
+  hand-faked box around a non-box executor **≈** `resolveSandboxClient`
+  (harness-in-box: `'sandbox' | 'bridge' | 'router'`) or `resolveAgentBackend`
+  (in-process: `'router' | 'tcloud' | 'cli-bridge' | 'sandbox'`) — grep the
+  substrate first; `inlineSandboxClient` and the bridge executor exist.
+- a per-provider stream→event mapper for a single agent turn **≈**
+  `streamAgentTurn` + `collectAgentTurn` (0.85+; one `RuntimeStreamEvent`
+  contract over box / executor / chat, guaranteed terminal result+usage).
 
 ## End-to-end recipe
 

package/dist/chunk-4J6RBI3K.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/runtime/sandbox-events.ts"],"sourcesContent":["/**\n * Sandbox-event → runtime-event mapping.\n *\n * The sandbox SDK emits a polymorphic `SandboxEvent = { type, data, id? }`\n * whose `type` vocabulary is backend-determined (opencode, etc.) rather than\n * enumerated by the SDK. Two consumers project it:\n *   - the loop kernel's cost ledger (`extractLlmCallEvent`) — sums usage off\n *     every cost-bearing event, regardless of stream shape;\n *   - the `AgentRuntime.act` streaming contract (`mapSandboxEvent`) — projects\n *     incremental events to the `RuntimeStreamEvent` chat-UX vocabulary.\n *\n * Both live here so the empirically-observed `type` vocabulary has one home.\n */\n\nimport type { SandboxEvent } from '@tangle-network/sandbox'\nimport type { RuntimeStreamEvent } from '../types'\n\n/**\n * Extract a `RuntimeStreamEvent`-shaped `llm_call` from a sandbox event when\n * the event carries usage/cost data. Returns `undefined` for non-cost events\n * so the kernel can iterate the full stream without branching.\n *\n * Canonical cost-carrying types observed in the wild:\n *   - `llm_call` — `data: { model, tokensIn, tokensOut, costUsd, ... }`\n *   - `message.completed` / `result` — `data: { usage: { inputTokens,\n *      outputTokens, totalCostUsd? } }`\n *   - `cost.usage` / `usage` — same shape under a dedicated type\n *\n * Numeric coercion is strict: `Number.isFinite` gates every accumulator write\n * so a sentinel `NaN` from a misbehaving backend cannot poison the ledger.\n */\nexport function extractLlmCallEvent(\n  event: SandboxEvent,\n  agentRunName: string,\n): (RuntimeStreamEvent & { type: 'llm_call' }) | undefined {\n  if (!event || typeof event !== 'object') return undefined\n  const type = String(event.type ?? '')\n  const data =\n    event.data && typeof event.data === 'object'\n      ? (event.data as Record<string, unknown>)\n      : ({} as Record<string, unknown>)\n\n  if (type === 'llm_call' || type === 'cost.usage' || type === 'usage') {\n    return buildLlmCall(data, agentRunName)\n  }\n  if (type === 'message.completed' || type === 'result' || type === 'final') {\n    const usage = data.usage as Record<string, unknown> | undefined\n    if (!usage || typeof usage !== 'object') return undefined\n    return buildLlmCall({ ...usage, model: data.model ?? usage.model }, agentRunName)\n  }\n  // sandbox 0.4.0 terminal event: `data = { tokenUsage: { inputTokens, outputTokens,\n  // reasoningTokens, cacheReadInputTokens }, totalCostUsd }`. Usage lives under\n  // `tokenUsage` (not `usage`) and the cost is top-level — neither matched the\n  // branches above, so an in-process loopDispatch run reported {0,0} and the\n  // backend-integrity guard misread a real run as a stub. Reasoning tokens are\n  // billed output (reasoning models), so they fold into the output count.\n  if (type === 'done') {\n    const usage = data.tokenUsage as Record<string, unknown> | undefined\n    if (!usage || typeof usage !== 'object') return undefined\n    const out = pickFiniteNumber(usage, ['outputTokens', 'completion_tokens', 'tokensOut'])\n    const reasoning = pickFiniteNumber(usage, ['reasoningTokens'])\n    const mergedOut =\n      out !== undefined || reasoning !== undefined ? (out ?? 0) + (reasoning ?? 0) : undefined\n    return buildLlmCall(\n      {\n        inputTokens: usage.inputTokens,\n        outputTokens: mergedOut,\n        totalCostUsd: data.totalCostUsd,\n        model: data.model ?? usage.model,\n      },\n      agentRunName,\n    )\n  }\n  return undefined\n}\n\n/**\n * Sum the token usage + USD cost of a sandbox turn's events — the one honest way to meter an\n * `openSandboxRun` cell. Folds `extractLlmCallEvent` over the stream (which reads usage off EVERY backend\n * event shape), so a `runProfileMatrix` dispatch can report it to `ctx.cost`:\n *\n *     const turn = await run.start(prompt)\n *     const u = sumSandboxUsage(turn.events)\n *     if (u.input || u.output) ctx.cost.observeTokens({ input: u.input, output: u.output })\n *     if (u.costUsd) ctx.cost.observe(u.costUsd, 'sandbox-cell')\n *\n * Without this a cell reads `{tokens:0, cost:0}` and the backend-integrity guard correctly aborts the\n * matrix as a stub. `agentRunName` is the fallback model label for cost-only events (default `'agent'`).\n */\nexport function sumSandboxUsage(\n  events: readonly SandboxEvent[],\n  agentRunName = 'agent',\n): { input: number; output: number; costUsd: number } {\n  let input = 0\n  let output = 0\n  let costUsd = 0\n  for (const ev of events) {\n    const call = extractLlmCallEvent(ev, agentRunName)\n    if (!call) continue\n    input += call.tokensIn ?? 0\n    output += call.tokensOut ?? 0\n    costUsd += call.costUsd ?? 0\n  }\n  return { input, output, costUsd }\n}\n\nfunction buildLlmCall(\n  data: Record<string, unknown>,\n  agentRunName: string,\n): (RuntimeStreamEvent & { type: 'llm_call' }) | undefined {\n  const tokensIn = pickFiniteNumber(data, ['tokensIn', 'inputTokens', 'prompt_tokens'])\n  const tokensOut = pickFiniteNumber(data, ['tokensOut', 'outputTokens', 'completion_tokens'])\n  const costUsd = pickFiniteNumber(data, ['costUsd', 'totalCostUsd', 'cost_usd', 'cost'])\n  if (tokensIn === undefined && tokensOut === undefined && costUsd === undefined) {\n    return undefined\n  }\n  const model = typeof data.model === 'string' && data.model.length > 0 ? data.model : agentRunName\n  const event: RuntimeStreamEvent & { type: 'llm_call' } = {\n    type: 'llm_call',\n    model,\n  }\n  if (tokensIn !== undefined) event.tokensIn = tokensIn\n  if (tokensOut !== undefined) event.tokensOut = tokensOut\n  if (costUsd !== undefined) event.costUsd = costUsd\n  return event\n}\n\nfunction pickFiniteNumber(data: Record<string, unknown>, keys: string[]): number | undefined {\n  for (const key of keys) {\n    const value = data[key]\n    if (typeof value === 'number' && Number.isFinite(value)) return value\n  }\n  return undefined\n}\n\n/**\n * Project one `SandboxEvent` onto the `RuntimeStreamEvent` chat-UX vocabulary,\n * for runtimes that bridge a sandbox `streamPrompt` into the\n * `AgentRuntime.act` streaming contract. Returns `undefined` for events that\n * have no faithful projection — the raw stream is preserved separately for the\n * `OutputAdapter`, so an unmapped event never loses data.\n *\n * Mapped (the task-optional incremental variants — no synthesized task\n * lifecycle, no guessed tool-part shapes):\n *   - `message.part.updated` text part → `text_delta`\n *   - `message.part.updated` reasoning/thinking part → `reasoning_delta`\n *   - cost-bearing events → `llm_call` (shared with the ledger extractor)\n *\n * The opencode backend emits incremental text as\n * `{ type: 'message.part.updated', data: { part: { type, text }, delta } }`;\n * `delta` is the increment, `part.text` the running accumulation.\n */\nexport function mapSandboxEvent(\n  event: SandboxEvent,\n  opts: { agentRunName?: string } = {},\n): RuntimeStreamEvent | undefined {\n  if (!event || typeof event !== 'object') return undefined\n  const type = String(event.type ?? '')\n  const data =\n    event.data && typeof event.data === 'object'\n      ? (event.data as Record<string, unknown>)\n      : ({} as Record<string, unknown>)\n\n  if (type === 'message.part.updated') {\n    const part =\n      data.part && typeof data.part === 'object' ? (data.part as Record<string, unknown>) : {}\n    const partType = String(part.type ?? '')\n    const delta = typeof data.delta === 'string' ? data.delta : undefined\n    const text = delta ?? (typeof part.text === 'string' ? part.text : undefined)\n    if (text === undefined) return undefined\n    if (partType === 'text') return { type: 'text_delta', text }\n    if (partType === 'reasoning' || partType === 'thinking')\n      return { type: 'reasoning_delta', text }\n    return undefined\n  }\n\n  return extractLlmCallEvent(event, opts.agentRunName ?? 'agent')\n}\n"],"mappings":"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","names":[]}