@tangle-network/agent-runtime 0.86.0 → 0.87.0

package/dist/loop-runner-bin.js

@@ -2,14 +2,14 @@
 import {
   parseLoopRunnerArgv,
   runLoopRunnerCli
-} from "./chunk-EJ7MAQN4.js";
+} from "./chunk-FLVVVBWV.js";
 import "./chunk-SGKPNBXE.js";
-import "./chunk-3TZOXS7B.js";
-import "./chunk-F7OO2SKB.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';
@@ -802,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
@@ -813,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
@@ -825,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
@@ -2087,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
@@ -2100,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.
@@ -2782,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).
  *
@@ -2797,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.
@@ -2816,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
  */
 
@@ -2829,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;
 } | {
@@ -2860,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
@@ -3943,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 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, 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-3TZOXS7B.js";
+} from "./chunk-VKVNDNG4.js";
 import {
   InMemoryResultBlobStore,
   InMemorySpawnJournal,
@@ -131,7 +131,7 @@ import {
   supervisorAgent,
   supervisorInstructions,
   workerFromBackend
-} from "./chunk-F7OO2SKB.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-F7OO2SKB.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-U4TS65XZ.js";
+} from "../chunk-MHYF2LIP.js";
 import {
   createKbGate
 } from "../chunk-SGKPNBXE.js";
@@ -14,7 +14,7 @@ import {
   assertTraceDerivedFindings,
   runCoderChecks,
   selectValidWinner
-} from "../chunk-3TZOXS7B.js";
+} from "../chunk-VKVNDNG4.js";
 import {
   DELEGATE_DESCRIPTION,
   DELEGATE_FEEDBACK_DESCRIPTION,
@@ -64,7 +64,7 @@ import {
   validateDelegateUiAuditArgs,
   validateDelegationHistoryArgs,
   validateDelegationStatusArgs
-} from "../chunk-F7OO2SKB.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.86.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