@tangle-network/agent-runtime 0.264.0 → 0.271.0

package/dist/{stream-agent-turn-D1zelVx6.d.ts → stream-agent-turn-DbEsKgb_.d.ts}

@@ -1,4 +1,4 @@
-import { Bi as LoopTokenUsage, C as ExecutorToolCall, Da as RuntimeStreamEvent, Dn as TraceSource, Ei as ExecCtx, In as ExecutorProgress, Ji as SandboxClient, X as Scope, Y as Runtime, Zi as Validator, _a as BackendErrorDetail, b as ExecutorRegistry, f as ExecutorCancellation, g as ExecutorFactory, ga as AgentTaskStatus, mt as UsageEvent, p as ExecutorCancellationRequest, rt as Spend, s as DefaultVerdict, y as ExecutorProgressEvent } from "./types-BV14WTyW.js";
+import { An as TraceSource, C as ExecutorToolCall, Da as AgentTaskStatus, Li as ExecCtx, Oa as BackendErrorDetail, Ra as RuntimeStreamEvent, X as Scope, Y as Runtime, Zi as LoopTokenUsage, aa as SandboxClient, b as ExecutorRegistry, ca as Validator, f as ExecutorCancellation, g as ExecutorFactory, gt as UsageEvent, kr as UnavailablePausePolicy, p as ExecutorCancellationRequest, rt as Spend, s as DefaultVerdict, y as ExecutorProgressEvent, zn as ExecutorProgress } from "./types-Bo7z5aG5.js";
 import { t as AgentCandidateArtifactPort } from "./types-CuXu5zuS.js";
 import { AgentCandidateWorkspaceSnapshotEvidence, AgentProfile, AgentProfileMcpServer, AgentProfileValidationResult, HarnessType, ReasoningEffort, StreamEvent } from "@tangle-network/agent-interface";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
@@ -47,11 +47,29 @@ declare function resolveRedactor(redact: Redactor | false | undefined): Redactor
  *
  * @experimental
  */
+/**
+ * MCP tool annotations (protocol 2025-03-26 and later). Hints a client reads
+ * before calling, for example to run a read-only tool without confirmation.
+ * They describe the tool; they do not enforce anything. @experimental
+ */
+interface McpToolAnnotations {
+  title?: string;
+  /** The tool does not modify its environment. */
+  readOnlyHint?: boolean;
+  /** The tool may perform destructive updates. Meaningful only when not read-only. */
+  destructiveHint?: boolean;
+  /** Repeating a call with the same arguments has no additional effect. */
+  idempotentHint?: boolean;
+  /** The tool may reach entities outside its own data, such as the web. */
+  openWorldHint?: boolean;
+}
 /** A callable MCP tool exposed by either stdio server. @experimental */
 interface McpToolDescriptor {
   name: string;
   description: string;
   inputSchema: Record<string, unknown>;
+  /** Published in `tools/list` when present. */
+  annotations?: McpToolAnnotations;
   handler: (raw: unknown) => Promise<unknown>;
 }
 /** Stdio-shaped transport used by the shared JSON-RPC server implementation. @experimental */
@@ -993,6 +1011,22 @@ interface ProviderExecutorOptions {
   profileForCreate?: (profile: AgentProfile) => AgentProfile;
   /** Map the task while retaining the kernel's canonical prompt mapping by default. */
   taskToTurn?: (task: unknown, specProfile: AgentProfile, defaultTurn: AgentTurnInput) => AgentTurnInput;
+  /**
+   * How a supervised leaf waits out an upstream that cannot serve now.
+   *
+   * When the model provider refuses a leaf's turn for capacity (a quota, a rate limit, an
+   * overload, or the router's own refused credential; see `upstreamUnavailableSignal`), the leaf
+   * keeps its environment, pauses, and continues in the same environment and session with a
+   * short instruction to pick up where it stopped. The pause starts at `unavailablePauseMs`
+   * (15 s) and doubles to `maxUnavailablePauseMs` (5 min), the same rule a driver follows. Only
+   * the leaf's deadline, cancellation and budget end it. Each pause is journaled as a `paused`
+   * spawn event, and each continuation as the node's next `execution-input`.
+   *
+   * Applies to a retained execution under a Scope, the path a supervised leaf takes on a provider
+   * that declares `retainedControl`, and not with `workspaceRetention`. `false` ends the execution
+   * on the refused turn.
+   */
+  unavailablePause?: UnavailablePausePolicy | false;
 }
 /** Adapt an environment provider into an `ExecutorFactory` for `createExecutor`.
  *
@@ -1251,6 +1285,162 @@ interface SandboxLeafOut {
   outcome?: AgentRunOutcome;
 }
 //#endregion
+//#region src/runtime/shared-box.d.ts
+/**
+ * The most workers one default box carries at once.
+ *
+ * It keeps a worker count that the 512-task pids limit of a Tangle box can hold with headroom
+ * for the sidecar's own processes and the workers' tool shells: 118 idle tasks plus 8 workers at
+ * about 34 tasks each is 390. Memory is not the binding limit: 8 workers used about 4 GB in a
+ * 16 GB box. Raise it only for a box whose pids limit was raised with it.
+ */
+declare const DEFAULT_SHARED_BOX_WORKERS = 8;
+/** The box shape the default placement creates: memory for 8 workers at about 0.5 GB each plus
+ *  the sidecar, and 4 cores, because the workers wait on the model most of the time. */
+declare const DEFAULT_SHARED_BOX_RESOURCES: Readonly<{
+  cpuCores: 4;
+  memoryMB: 8192;
+}>;
+/** The request header the router records as a usage row's `clientName`. */
+declare const ROUTER_CLIENT_HEADER = "x-tangle-client";
+/**
+ * The router client name of the worker that runs supervised node `nodeId`.
+ *
+ * The node id is already in the spawn journal, so a keeper joins a router row to a node without
+ * a new record: the row whose `clientName` is `agent-runtime-node/<nodeId>` is that node's spend.
+ */
+declare function sharedWorkerClientName(nodeId: string): string;
+/** The Sandbox box surface a shared box uses. The Sandbox SDK's `SandboxInstance` satisfies it. */
+interface SharedBoxHandle {
+  readonly id: string;
+  exec(command: string, options?: {
+    timeoutMs?: number;
+  }): Promise<{
+    exitCode?: number | null;
+    stdout?: string;
+    stderr?: string;
+  }>;
+  readonly fs: {
+    read(path: string): Promise<string>;
+    write(path: string, content: string): Promise<unknown>;
+  };
+  readonly process: {
+    spawnExact(executable: string, args: readonly string[], options?: {
+      cwd?: string;
+      env?: Record<string, string>;
+      timeoutMs?: number;
+    }): Promise<SharedBoxProcess>;
+    list(): Promise<ReadonlyArray<{
+      pid: number;
+      command?: string;
+      cwd?: string;
+    }>>;
+    get(pid: number): Promise<SharedBoxProcess | null>;
+  };
+  delete(): Promise<unknown>;
+}
+/** One process in a shared box, as the Sandbox SDK's process manager returns it. */
+interface SharedBoxProcess {
+  readonly pid: number;
+  wait(): Promise<number>;
+  kill(signal?: 'SIGTERM' | 'SIGKILL', options?: {
+    tree?: boolean;
+  }): Promise<void>;
+  stdout(): AsyncIterable<string>;
+  stderr(): AsyncIterable<string>;
+}
+/** Options for {@link sharedBoxPlacement}. */
+interface SharedBoxPlacementOptions {
+  /** The Sandbox client that creates and deletes the shared boxes. */
+  client: SandboxClient;
+  /**
+   * Create options for every shared box: resources, egress, secrets, lifetime and billing.
+   * Runtime owns `backend`, so the box's sidecar never serves a worker turn.
+   */
+  box?: Omit<CreateSandboxOptions, 'backend'>;
+  /** The most workers one box carries at once. Defaults to {@link DEFAULT_SHARED_BOX_WORKERS}. */
+  workersPerBox?: number;
+  /** Absolute directory in each box that holds one directory per worker. */
+  workerRoot?: string;
+  /** First wait before repeating a Sandbox call that failed transiently; doubles per attempt. */
+  retryDelayMs?: number;
+  /**
+   * How a worker waits out a model provider that cannot serve now: a quota, a rate limit, an
+   * overload, or the router's own refused credential (`unavailableSignalOfFailure`). The worker
+   * pauses 15 s, doubling to 5 min, the rule a driver and a dedicated leaf follow, then continues
+   * its own opencode session in its own directory. Only cancellation, the turn's `timeoutMs` and
+   * the node's deadline and budget, which abort the turn, end the pauses. `false` ends the turn on
+   * the refused run.
+   */
+  unavailablePause?: UnavailablePausePolicy | false;
+}
+/** Counts that show how the pool placed its workers. */
+interface SharedBoxStats {
+  readonly boxesCreated: number;
+  readonly boxesLive: number;
+  readonly workersPlaced: number;
+  readonly workersLive: number;
+  /** The most workers any one box carried at the same time. */
+  readonly peakWorkersPerBox: number;
+  /** Every box this pool created, with the workers it served. */
+  readonly boxes: ReadonlyArray<{
+    readonly id: string;
+    readonly workersServed: number;
+    readonly deleted: boolean;
+    /** Milliseconds from the create request to a box that runs processes. */
+    readonly createMs: number;
+  }>;
+}
+/** What {@link SharedBoxPlacement.close} did to each box. */
+interface SharedBoxCloseReceipt {
+  readonly boxId: string;
+  readonly deleted: boolean;
+  readonly error?: string;
+}
+/** Who a shared worker is, for the router rows its model calls leave on the box's key. */
+interface SharedWorkerIdentity {
+  /** The supervised node the worker runs. Absent for a worker outside a supervised tree. */
+  readonly nodeId?: string;
+}
+/** A shared-box placement: the provider Runtime uses for a profile the placement accepts. */
+interface SharedBoxPlacement {
+  /**
+   * The environment provider that places one accepted worker in a shared box. A worker with a
+   * `nodeId` sends `x-tangle-client: agent-runtime-node/<nodeId>` on its router calls; without
+   * one, its calls carry no client name and stay charged to the box.
+   */
+  providerFor(worker?: SharedWorkerIdentity): AgentEnvironmentProvider;
+  /** Public identity of this placement, recorded on every execution it serves. */
+  readonly identity: {
+    readonly id: string;
+    readonly digest: string;
+  };
+  /** Why a shared box cannot carry this profile, or `undefined` when it can. */
+  refusal(profile: AgentProfile): string | undefined;
+  stats(): SharedBoxStats;
+  /** Delete every box this placement created and still holds. Call it when the run settles. */
+  close(): Promise<ReadonlyArray<SharedBoxCloseReceipt>>;
+}
+/**
+ * Why a shared box cannot carry `profile`, or `undefined` when it can.
+ *
+ * A shared box carries a profile whose whole behavior reaches an opencode process through its own
+ * working directory, its own configuration and the box's own model credential. Everything else
+ * keeps a dedicated box: another harness, a model the box credential cannot reach, a replaced
+ * system prompt, MCP servers, connections, hooks, subagents, extensions, tool grants, and any
+ * resource the materializer does not lower into the worker's directory.
+ */
+declare function sharedBoxRefusal(profile: AgentProfile): string | undefined;
+/**
+ * Place accepted workers as processes in a pool of shared Sandbox boxes.
+ *
+ * The pool fills a box before it creates the next one and deletes a box when its last worker
+ * releases it. Runtime reaches this placement through `createExecutor({ backend: 'provider',
+ * shared })`: a profile that {@link SharedBoxPlacement.refusal} accepts runs here, and every other
+ * profile keeps the dedicated provider.
+ */
+declare function sharedBoxPlacement(options: SharedBoxPlacementOptions): SharedBoxPlacement;
+//#endregion
 //#region src/runtime/harness-usage.d.ts
 /**
  * One harness's own token-usage report for one turn, in the runtime's field names.
@@ -1862,6 +2052,13 @@ interface ProviderSeam extends ProviderExecutorOptions {
    * creation and session semantics.
    */
   steering?: SandboxSteeringOptions;
+  /**
+   * Place each worker whose profile a shared box can carry as its own process in a pool of shared
+   * boxes, and keep a dedicated environment from `provider` for every other profile. Build it with
+   * `sharedBoxPlacement`. A manager never uses it: its coordination credential is create-time
+   * environment that every co-tenant of a shared box could read.
+   */
+  shared?: SharedBoxPlacement;
 }
 /**
  * Router seam WITH tool use — the tool-using router backend. Same direct
@@ -2072,5 +2269,5 @@ declare function streamAgentTurn(backend: AgentTurnBackend, input: AgentTurnInpu
  */
 declare function collectAgentTurn(stream: AsyncIterable<RuntimeStreamEvent>): Promise<CollectedAgentTurn>;
 //#endregion
-export { decodeHarnessUsage as $, JsonRpcResponse as $n, ProviderPlacement as $t, createInbox as A, ToolLoopCompaction as An, CreateAgentEnvironmentInput$1 as At, secretEnvOfMcpServer as B, PeerMailLimits as Bn, ResourceRequest as Bt, SteerableSandboxArgs as C, localHarnessExecutable as Cn, AgentProfileRef$1 as Ct, Inbox as D, ToolSpec as Dn, AgentTurnResult$2 as Dt, AuthorityInboxMessage as E, RouterTransportConfig as En, AgentSessionStatus$1 as Et, ResolvedMcpServerLaunch as F, DEFAULT_PEER_MAIL_LIMITS as Fn, PlacementInfo as Ft, CodexRolloutStoreRef as G, PeerMailbox as Gn, providerAsSandboxClient as Gt, CodexRolloutIdentity as H, PeerMailReadout as Hn, WorkspaceRequest as Ht, envKeyProvider as I, PEER_MAIL_WIRE_KEY as In, ProviderAsSandboxClientOptions as It, addHarnessUsage as J, createPeerMailbox as Jn, CreateTangleSandboxExactProcessProviderOptions as Jt, CodexRolloutTurn as K, PeerMailboxOptions as Kn, resolveAgentEnvironmentProvider as Kt, mcpSecretEnvMetadataKey as L, PeerMailEnvelope as Ln, ProviderExecutorOptions as Lt, BridgeModelCredential as M, ToolLoopMessageRecord as Mn, ExecRequest as Mt, BridgeSeam as N, ToolLoopToolCall as Nn, ExecResult as Nt, InboxMessage as O, ToolLoopCallContext as On, CheckpointRef as Ot, KeyProvider as P, AUTHORITY_MARKERS as Pn, ForkRequest as Pt, HarnessUsage as Q, JsonRpcMessage as Qn, ProviderWorkspaceRetentionPort as Qt, resolveMcpServerLaunch as R, PeerMailEvent as Rn, ProviderLeafOut as Rt, SandboxSteeringOptions as S, harnessSupportsReasoningEffort as Sn, AgentEnvironmentSummary as St, createSteerableSandboxSession as T, runLocalHarness as Tn, AgentSessionRef as Tt, CodexRolloutSession as U, PeerMailRefusal as Un, createAgentEnvironmentProviderRegistry as Ut, CodexForkBoundary as V, PeerMailOutcome as Vn, SandboxClientProviderOptions as Vt, CodexRolloutStoreReader as W, PeerMailSendInput as Wn, providerAsExecutor as Wt, harnessUsageIsEmpty as X, peerMailTools as Xn, createTangleSandboxExactProcessProvider as Xt, createCodexRolloutStoreReader as Y, isPeerMailEnvelope as Yn, SandboxControlClient as Yt, readCodexRolloutSession as Z, peerMailVerbNames as Zn, ProviderWorkspaceRetentionContext as Zt, cliInPlaceExecutor as _, DEFAULT_LOCAL_HARNESS as _n, AgentEnvironmentProvider$1 as _t, StreamAgentTurnOptions as a, CreateWorktreeOptions as an, assertSandboxServedModel as at, createExecutorRegistry as b, LocalHarnessResult as bn, AgentEnvironmentQuery as bt, CliInPlaceSeam as c, GitRunner as cn, extractLlmCallEvent as ct, CliWorktreeSeam as d, captureWorktreeDiff as dn, sandboxEventServedBackend as dt, InPlaceHarnessResult as en, McpToolDescriptor as er, SandboxLeafOut as et, ExecutorConfig as f, createWorktree as fn, sandboxProgressEvents as ft, SandboxSeam as g, CodexTokenUsage as gn, AgentEnvironmentEvent$1 as gt, RouterToolsSeam as h, CodexExecutionPolicy as hn, AgentEnvironmentCapabilities$1 as ht, CollectedAgentTurn as i, WorktreeProfileMaterializationReceipt as in, resolveRedactor as ir, SandboxUsageLedger as it, BridgeHarnessStore as j, ToolLoopCompactionOptions as jn, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as jt, PeerInboxMessage as k, ToolLoopChat as kn, CheckpointRequest as kt, CliSeam as l, RemoveWorktreeOptions as ln, mapSandboxEvent as lt, RouterSeam as m, CodexExecutionEvidence as mn, AgentEnvironment$1 as mt, AgentTurnInput$1 as n, WorktreeCommandResult as nn, Redactor as nr, SandboxServedBackend as nt, collectAgentTurn as o, DiffOptions as on, createSandboxToolPartState as ot, ProviderSeam as p, removeWorktree as pn, sumSandboxUsage as pt, CodexStoreDelta as q, claimsAuthority as qn, sandboxClientAsProvider as qt, AgentTurnUsage as r, WorktreeHarnessResult as rn, defaultRedactor as rr, SandboxToolPartState as rt, streamAgentTurn as s, DiffResult as sn, createSandboxUsageLedger as st, AgentTurnBackend as t, WorktreeCheckRunner as tn, McpTransport as tr, SandboxOutputMarker as tt, CliWorktreeBridgeSeam as u, WorktreeHandle as un, mapSandboxToolEvent as ut, cliWorktreeExecutor as v, LOCAL_HARNESSES as vn, AgentEnvironmentProviderRef as vt, SteerableSandboxSession as w, parseCodexTokenUsage as wn, AgentSession as wt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as x, RunLocalHarnessOptions as xn, AgentEnvironmentStatus as xt, createExecutor as y, LocalHarness as yn, AgentEnvironmentProviderRegistry as yt, resolveSecretEnv as z, PeerMailKind as zn, ProviderPromptOptions as zt };
-//# sourceMappingURL=stream-agent-turn-D1zelVx6.d.ts.map
+export { decodeHarnessUsage as $, PeerMailLimits as $n, ResourceRequest as $t, createInbox as A, DEFAULT_LOCAL_HARNESS as An, AgentEnvironmentProvider$1 as At, secretEnvOfMcpServer as B, ToolSpec as Bn, AgentTurnResult$2 as Bt, SteerableSandboxArgs as C, WorktreeHandle as Cn, mapSandboxToolEvent as Ct, Inbox as D, CodexExecutionEvidence as Dn, AgentEnvironment$1 as Dt, AuthorityInboxMessage as E, removeWorktree as En, sumSandboxUsage as Et, ResolvedMcpServerLaunch as F, harnessSupportsReasoningEffort as Fn, AgentEnvironmentSummary as Ft, CodexRolloutStoreRef as G, ToolLoopMessageRecord as Gn, ExecRequest as Gt, CodexRolloutIdentity as H, ToolLoopChat as Hn, CheckpointRequest as Ht, envKeyProvider as I, localHarnessExecutable as In, AgentProfileRef$1 as It, addHarnessUsage as J, DEFAULT_PEER_MAIL_LIMITS as Jn, PlacementInfo as Jt, CodexRolloutTurn as K, ToolLoopToolCall as Kn, ExecResult as Kt, mcpSecretEnvMetadataKey as L, parseCodexTokenUsage as Ln, AgentSession as Lt, BridgeModelCredential as M, LocalHarness as Mn, AgentEnvironmentProviderRegistry as Mt, BridgeSeam as N, LocalHarnessResult as Nn, AgentEnvironmentQuery as Nt, InboxMessage as O, CodexExecutionPolicy as On, AgentEnvironmentCapabilities$1 as Ot, KeyProvider as P, RunLocalHarnessOptions as Pn, AgentEnvironmentStatus as Pt, HarnessUsage as Q, PeerMailKind as Qn, ProviderPromptOptions as Qt, resolveMcpServerLaunch as R, runLocalHarness as Rn, AgentSessionRef as Rt, SandboxSteeringOptions as S, RemoveWorktreeOptions as Sn, mapSandboxEvent as St, createSteerableSandboxSession as T, createWorktree as Tn, sandboxProgressEvents as Tt, CodexRolloutSession as U, ToolLoopCompaction as Un, CreateAgentEnvironmentInput$1 as Ut, CodexForkBoundary as V, ToolLoopCallContext as Vn, CheckpointRef as Vt, CodexRolloutStoreReader as W, ToolLoopCompactionOptions as Wn, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as Wt, harnessUsageIsEmpty as X, PeerMailEnvelope as Xn, ProviderExecutorOptions as Xt, createCodexRolloutStoreReader as Y, PEER_MAIL_WIRE_KEY as Yn, ProviderAsSandboxClientOptions as Yt, readCodexRolloutSession as Z, PeerMailEvent as Zn, ProviderLeafOut as Zt, cliInPlaceExecutor as _, WorktreeProfileMaterializationReceipt as _n, defaultRedactor as _r, SandboxUsageLedger as _t, StreamAgentTurnOptions as a, resolveAgentEnvironmentProvider as an, PeerMailboxOptions as ar, SharedBoxPlacement as at, createExecutorRegistry as b, DiffResult as bn, createSandboxUsageLedger as bt, CliInPlaceSeam as c, SandboxControlClient as cn, isPeerMailEnvelope as cr, SharedBoxStats as ct, CliWorktreeSeam as d, ProviderWorkspaceRetentionPort as dn, JsonRpcMessage as dr, sharedBoxRefusal as dt, SandboxClientProviderOptions as en, PeerMailOutcome as er, DEFAULT_SHARED_BOX_RESOURCES as et, ExecutorConfig as f, ProviderPlacement as fn, JsonRpcResponse as fr, sharedWorkerClientName as ft, SandboxSeam as g, WorktreeHarnessResult as gn, Redactor as gr, SandboxToolPartState as gt, RouterToolsSeam as h, WorktreeCommandResult as hn, McpTransport as hr, SandboxServedBackend as ht, CollectedAgentTurn as i, providerAsSandboxClient as in, PeerMailbox as ir, SharedBoxHandle as it, BridgeHarnessStore as j, LOCAL_HARNESSES as jn, AgentEnvironmentProviderRef as jt, PeerInboxMessage as k, CodexTokenUsage as kn, AgentEnvironmentEvent$1 as kt, CliSeam as l, createTangleSandboxExactProcessProvider as ln, peerMailTools as lr, SharedWorkerIdentity as lt, RouterSeam as m, WorktreeCheckRunner as mn, McpToolDescriptor as mr, SandboxOutputMarker as mt, AgentTurnInput$1 as n, createAgentEnvironmentProviderRegistry as nn, PeerMailRefusal as nr, ROUTER_CLIENT_HEADER as nt, collectAgentTurn as o, sandboxClientAsProvider as on, claimsAuthority as or, SharedBoxPlacementOptions as ot, ProviderSeam as p, InPlaceHarnessResult as pn, McpToolAnnotations as pr, SandboxLeafOut as pt, CodexStoreDelta as q, AUTHORITY_MARKERS as qn, ForkRequest as qt, AgentTurnUsage as r, providerAsExecutor as rn, PeerMailSendInput as rr, SharedBoxCloseReceipt as rt, streamAgentTurn as s, CreateTangleSandboxExactProcessProviderOptions as sn, createPeerMailbox as sr, SharedBoxProcess as st, AgentTurnBackend as t, WorkspaceRequest as tn, PeerMailReadout as tr, DEFAULT_SHARED_BOX_WORKERS as tt, CliWorktreeBridgeSeam as u, ProviderWorkspaceRetentionContext as un, peerMailVerbNames as ur, sharedBoxPlacement as ut, cliWorktreeExecutor as v, CreateWorktreeOptions as vn, resolveRedactor as vr, assertSandboxServedModel as vt, SteerableSandboxSession as w, captureWorktreeDiff as wn, sandboxEventServedBackend as wt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as x, GitRunner as xn, extractLlmCallEvent as xt, createExecutor as y, DiffOptions as yn, createSandboxToolPartState as yt, resolveSecretEnv as z, RouterTransportConfig as zn, AgentSessionStatus$1 as zt };
+//# sourceMappingURL=stream-agent-turn-DbEsKgb_.d.ts.map

package/dist/{structural-rollout-D17I5CwF.js → structural-rollout-I92sIfNl.js}

@@ -1,4 +1,4 @@
-import { Ai as projectSandboxOutcome, Ei as executableAgentProfileSnapshot, Fi as createSandboxUsageLedger, Li as isSandboxTerminalEvent, Ni as canonicalStreamEventFromSandboxEvent, Pi as createSandboxToolPartState, Ri as mapSandboxEvent, Si as runtimeOwnedPendingExecutorMaterialization, Ti as unknownMaterializationReceipt, Tt as InMemorySpawnJournal, _a as providerMessageText, bi as runtimeOwnedExecutorMaterialization, fa as armDeadlineTimer, ft as captureReusableExecutorConfig, ga as promptOptionsFromAgentTurnInput, gt as createExecutorRegistry, ha as promptFromAgentTurnInput, ht as createExecutor, ji as readSandboxOutcome, jn as observedModelMatchesDeclared, mi as knownMaterializationReceipt, n as createSupervisor, pi as knownExecutionBindingReceipt, ua as awaitAbortable, ui as authoredProfileDigest, wi as unknownExecutionBindingReceipt, wt as InMemoryResultBlobStore, y as withDriverExecutor, yi as runtimeOwnedExecutorExecutionBinding, zi as mapSandboxToolEvent } from "./supervisor-C26k7X5-.js";
+import { Ai as runtimeOwnedExecutorMaterialization, Bi as projectSandboxOutcome, Ci as knownExecutionBindingReceipt, Da as providerMessageText, Ea as promptOptionsFromAgentTurnInput, Et as InMemorySpawnJournal, Fi as unknownMaterializationReceipt, Gi as createSandboxUsageLedger, Ii as executableAgentProfileSnapshot, In as observedModelMatchesDeclared, Ji as mapSandboxEvent, Mi as runtimeOwnedPendingExecutorMaterialization, Pi as unknownExecutionBindingReceipt, Sa as armDeadlineTimer, Ta as promptFromAgentTurnInput, Tt as InMemoryResultBlobStore, Ui as canonicalStreamEventFromSandboxEvent, Vi as readSandboxOutcome, Wi as createSandboxToolPartState, Yi as mapSandboxToolEvent, _t as createExecutorRegistry, b as withDriverExecutor, ba as awaitAbortable, bi as authoredProfileDigest, gt as createExecutor, ki as runtimeOwnedExecutorExecutionBinding, pt as captureReusableExecutorConfig, qi as isSandboxTerminalEvent, r as createSupervisor, wi as knownMaterializationReceipt } from "./supervisor-Cvd5mf7x.js";
 import { m as ValidationError, p as SessionMismatchError, r as BackendTransportError } from "./errors-DodWX-cb.js";
 import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile } from "./model-policy-BbSCSak0.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, renderInputPartsAsText } from "@tangle-network/agent-interface";
@@ -2870,4 +2870,4 @@ function structuralRollout(config = {}) {
 //#endregion
 export { collectAgentTurn as A, defaultAnalystInstruction as C, profileOptimizerModelCall as D, profileChatClient as E, InMemoryRuntimeSessionStore as F, newRuntimeSession as I, nowIso as L, createIterableBackend as M, createSandboxPromptBackend as N, optimizerMethod as O, normalizeBackendStreamEvent as P, startOrResumeRuntimeSession as R, ObservationError as S, renderReport as T, depthStrategy as _, defaultStructuralRolloutPolicy as a, sample as b, officialChecksFromMeta as c, selectBestIndex as d, structuralRollout as f, defineStrategy as g, breadthStrategy as h, defaultExtractCandidate as i, streamAgentTurn as j, strategyAuthorMethod as k, resolveEntrySymbol as l, adaptiveRefine as m, compareCheckOutcomes as n, filterAuthoredAsserts as o, visibleCheckScore as p, composeCheckSources as r, modelAuthoredChecks as s, canDisplace as t, sandboxCheckRunner as u, refine as v, observe as w, sampleThenRefine as x, runAgentic as y, touchSession as z };
 
-//# sourceMappingURL=structural-rollout-D17I5CwF.js.map
+//# sourceMappingURL=structural-rollout-I92sIfNl.js.map