@tangle-network/agent-runtime 0.128.0 → 0.131.0

package/dist/{environment-provider-CUFsyymu.d.ts → types-C6Q-J0Dt.d.ts}

@@ -1,10 +1,8 @@
-import { d as AgentTaskStatus, o as AgentRuntimeEvent, x as RuntimeStreamEvent } from "./types-C9j4qg6l.js";
+import { J as AgentTaskStatus, U as AgentRuntimeEvent, it as RuntimeStreamEvent, v as LoopTokenUsage, y as LoopTraceEmitter } from "./types-ebIY0dMG.js";
 import { l as RuntimeHooks } from "./runtime-hooks-sbRpjStq.js";
-import { E as SandboxClient, v as LoopTokenUsage, y as LoopTraceEmitter } from "./types-DnNGJ5Gz.js";
 import { ControlEvalResult, DefaultVerdict, KnowledgeReadinessReport, KnowledgeRequirement, ToolSpan } from "@tangle-network/agent-eval";
-import { AgentProfile as AgentProfile$1, AgentProfileValidationResult, Sha256Digest } from "@tangle-network/agent-interface";
-import { BackendType, CreateSandboxOptions, Sandbox } from "@tangle-network/sandbox";
-import { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentCapabilities as AgentEnvironmentCapabilities$1, AgentEnvironmentEvent, AgentEnvironmentProvider, AgentEnvironmentProvider as AgentEnvironmentProvider$1, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentProfileRef as AgentProfileRef$1, AgentSession, AgentSessionRef, AgentSessionStatus, AgentTurnInput, AgentTurnInput as AgentTurnInput$1, AgentTurnResult, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, CreateAgentEnvironmentInput as CreateAgentEnvironmentInput$1, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "@tangle-network/agent-interface/environment-provider";
+import { AgentProfile as AgentProfile$1, Sha256Digest } from "@tangle-network/agent-interface";
+import { BackendType } from "@tangle-network/sandbox";
 //#region src/runtime/supervise/progress.d.ts
 /** How long a worker may produce no metered activity before a `progress()` read calls it stalled.
  *  Deliberately generous: a coding harness routinely spends minutes inside one tool call, and a
@@ -876,18 +874,14 @@ interface ExecutorResult<Out> {
  * conserved pool meters all runtimes identically. `tokens` carries `LoopTokenUsage`'s
  * `{ input, output }`; `usd` is a SEPARATE channel (never folded into tokens).
  *
- * KNOWN LIMITATION (pre-existing): the `cost` variant can say its dollars are a subtotal
- * (`usdKnown: false`), and the `tokens` variant has NO twin — there is no way to report "this turn
- * happened and its token count is unknown". `Spend.tokensKnown` exists downstream, but nothing
- * upstream of `foldStream` (`scope.ts`) can ever set it, so a STREAMING executor whose provider
- * omitted usage reports the turn as costing zero tokens rather than as unmeasured. Only the
- * non-streaming path, which returns a whole `Spend`, can carry the marker today. Closing it means
- * widening this union (a `tokensKnown: false` field on `tokens`, or an `unknown` variant) and
- * threading it through `foldStream` — a change to the metering contract every executor implements,
- * which is why it is not folded into a streaming-transport fix. Filed separately.
+ * Either channel can explicitly say its numeric subtotal is incomplete. A missing provider receipt
+ * therefore remains unknown through live metering and terminal reconciliation instead of becoming
+ * a fabricated zero.
  */
 type UsageEvent = {
   kind: 'tokens';
+  /** Known token subtotal. When false, these counts are only the observed/estimated floor. */
+  tokensKnown?: false;
   input: number;
   output: number;
 } | {
@@ -902,9 +896,11 @@ type UsageEvent = {
  * External executors can register additional runtime strings without widening this type. */
 type Runtime = 'router' | 'inline' | 'sandbox' | 'cli' | (string & {});
 /**
- * `AgentProfile.harness` is a portable preference; this wrapper records the executor decision for
- * one concrete run. A caller may honor the preference, override it for a comparison cell, or supply
- * an executor directly, without changing the profile's behavioral identity.
+ * `AgentProfile` is the complete execution authority. Scope parses and snapshots it before calling
+ * any registry, including one that resolves caller-supplied executors and factories. The default
+ * registry enforces the same rule when called directly. `AgentSpec.harness` records routing for one
+ * concrete run; where a backend consumes both fields, it must agree with `AgentProfile.harness` and
+ * cannot fill or override it.
  *
  * Resolution (in `runtime.ts`):
  *  - `executorFactory` present → BYO: build it after admission with the live context.
@@ -923,7 +919,7 @@ interface AgentSpec {
   /** Per-spawn factory carrying caller configuration. Constructed only after admission, with the
    *  real child signal and nested-scope context. */
   readonly executorFactory?: ExecutorFactory<unknown>;
-  /** Bring-your-own executor: when set, overrides harness-based resolution entirely. */
+  /** Bring-your-own executor: highest routing precedence after exact-profile intake validation. */
   readonly executor?: Executor<unknown>;
 }
 /** Caller-owned identity beyond the exact profile/task bytes Scope can compute itself. */
@@ -978,7 +974,7 @@ interface ExecutorExecutionBinding {
   readonly descriptor: Readonly<Record<string, string | number | boolean | null>>;
 }
 /** Why exact materialization evidence is unavailable for a node. */
-type UnknownMaterializationReason = 'executor-did-not-report' | 'invalid-executor-report' | 'root-agent-did-not-report';
+type UnknownMaterializationReason = 'executor-did-not-report' | 'executor-receipt-pending' | 'invalid-executor-report' | 'root-agent-did-not-report';
 /** What the kernel can prove about one node's actual execution plan. */
 type ProfileMaterializationReceipt = {
   readonly status: 'known';
@@ -1033,9 +1029,9 @@ interface ExecutorNodeContext {
   readonly identity?: NodeExecutionIdentity;
 }
 /**
- * Builds a fresh `Executor` for one spawn from the resolved spec. Per-spawn (not
- * shared) so each child owns its own box/abort/teardown lifecycle. A BYO factory lets a
- * user supply construction args without pre-instantiating.
+ * Builds a fresh `Executor` for one spawn from the resolved, immutable spec. Per-spawn (not shared)
+ * so each child owns its own box/abort/teardown lifecycle. A BYO factory lets a user supply
+ * construction args without pre-instantiating; it never bypasses exact-profile validation.
  */
 type ExecutorFactory<Out> = (spec: AgentSpec, ctx: ExecutorContext) => Executor<Out>;
 /** Construction context handed to a `ExecutorFactory` — the seams a built-in needs
@@ -1043,16 +1039,22 @@ type ExecutorFactory<Out> = (spec: AgentSpec, ctx: ExecutorContext) => Executor<
  *  the factory reaching into module globals. */
 interface ExecutorContext {
   readonly signal: AbortSignal;
+  /**
+   * Request headers inherited from an enclosing task or conversation.
+   * Network executors forward these after their own connection headers so caller authorization,
+   * recursion depth, and trace identity survive the profile-to-executor boundary.
+   */
+  readonly propagatedHeaders?: Readonly<Record<string, string>>;
   /** Present when Scope constructs the executor for a supervised node. */
   readonly node?: ExecutorNodeContext;
   /** Opaque seams the registry threads through; a built-in narrows what it needs. */
   readonly seams: Readonly<Record<string, unknown>>;
 }
 /**
- * The OPEN resolver: maps an `AgentSpec` to a `ExecutorFactory`. The default
- * registry resolves the three built-ins AND accepts a BYO `executor`/factory; callers
- * register more runtimes by name. NOT a closed switch — registration is the extension
- * point, mirroring the open `Executor` interface.
+ * The OPEN resolver maps an already-admitted `AgentSpec` to an `ExecutorFactory`. Scope validates
+ * before invoking any implementation; the default registry repeats validation for direct callers,
+ * resolves the three built-ins, and accepts a BYO `executor`/factory. Callers may register more
+ * runtimes by name, but registration does not waive exact-profile validation.
  */
 interface ExecutorRegistry {
   /** Register a factory for a named runtime. Throws on a duplicate name (fail loud). */
@@ -1130,14 +1132,10 @@ interface SpawnOpts {
  *  no dollars, an exceeded recursion ceiling, a full tree-wide worker allocation, or a `key` that
  *  is still LIVE in this scope (the same assignment may not run twice concurrently).
  *
- *  `usd-unbudgeted` is separate from `budget-exhausted` because the two call for opposite
+ * `usd-unbudgeted` is separate from `budget-exhausted` because the two call for opposite
  *  responses: an exhausted pool may admit a smaller request, while an unbudgeted dollar channel
- *  refuses every amount until the ROOT budget names a `maxUsd`.
- *
- *  `below-runtime-floor` is separate for the same reason and points the opposite way from
- *  `budget-exhausted`: the request is under what that harness spends before it reads its task, so
- *  it is unsatisfiable at that SIZE and the fix is to RAISE it, never to retry smaller. */
-type SpawnRejection = 'budget-exhausted' | 'usd-unbudgeted' | 'below-runtime-floor' | 'depth-exceeded' | 'duplicate-key' | 'invalid-identity' | 'key-conflict' | 'max-live-workers' | 'scope-aborted';
+ * refuses every amount until the ROOT budget names a `maxUsd`. */
+type SpawnRejection = 'budget-exhausted' | 'usd-unbudgeted' | 'depth-exceeded' | 'duplicate-key' | 'invalid-identity' | 'key-conflict' | 'max-live-workers' | 'scope-aborted';
 /**
  * What a KEYED spawn resolved to when the key had a prior attempt. Absent on a fresh key (and on
  * every unkeyed spawn). `'completed'` is the exactly-once path: NOTHING was spawned — the handle
@@ -1220,6 +1218,8 @@ type Settled<Out> = {
  * budget atomically from the shared pool and fails closed when the pool cannot cover it.
  * `next()` waits for one settlement from this scope's live set; `view` reads live state,
  * not the replay log.
+ *
+ * @stable
  */
 interface Scope<Out> {
   /**
@@ -1328,6 +1328,9 @@ interface Scope<Out> {
    * re-spawning committed work. A resume-blind driver simply ignores it and re-spawns — correct
    * but redundant. The scope's spawn ordinal + cursor seq are already advanced past the recorded
    * maxima, so any NEW spawn appends without colliding with a journaled event.
+   *
+   * @experimental Same-process replay only — live supervised-tree recovery after a
+   * coordinator restart is not implemented (docs/agent-managed-compute/README.md).
    */
   readonly resume?: ResumedWork<Out>;
   /** The live tree — reads the in-memory nursery, not the journal. */
@@ -1598,6 +1601,8 @@ interface ResultBlobStore {
  * Owns the conserved pool, the spawn log, the abort cascade, the OTP intensity breaker,
  * and the root handle. `run` executes the root `Agent` to completion; `attach` wires a
  * live `RootHandle` (the Q2 substrate the chat/pi-viz client later consumes).
+ *
+ * @stable
  */
 interface Supervisor<Task, Out> {
   run(root: Agent<Task, Out>, task: Task, opts: SupervisorOpts): Promise<SupervisedResult<Out>>;
@@ -1634,6 +1639,14 @@ interface SupervisorOpts {
    */
   readonly maxRestarts?: number;
   readonly withinMs?: number;
+  /**
+   * How long live children may keep running after the ROOT DRIVER FAILED, before the join barrier
+   * cascades the abort into them (#741). A root that dies did not make its children unhealthy: a
+   * child mid-unit holds work already paid for, and killing it instantly discards everything it has
+   * not yet written. The window applies ONLY to a driver failure on an un-cancelled run, and never
+   * extends past the run's own deadline. Omit/`0` = the historical immediate teardown.
+   */
+  readonly childSettleGraceMs?: number;
   /**
    * Opt into RESUME-FIRST: read any prior journal tree for this `runId` BEFORE beginning a fresh
    * one, and when a non-empty tree exists rehydrate its committed work onto `Scope.resume`
@@ -1643,6 +1656,9 @@ interface SupervisorOpts {
    *
    * Default `false` — a run always begins a fresh tree, which is the behavior every existing
    * consumer has. Resume is a durability contract the caller opts into, never a silent default.
+   *
+   * @experimental Rehydrates committed settlements only; live supervised-tree recovery after a
+   * coordinator restart is not implemented (docs/agent-managed-compute/README.md).
    */
   readonly resume?: boolean;
   readonly now?: () => number;
@@ -1783,84 +1799,5 @@ interface WidenGate<Out> {
   readonly judgeExempt?: boolean;
 }
 //#endregion
-//#region src/runtime/tangle-sandbox-exact-process-provider.d.ts
-type SandboxControlClient = Pick<Sandbox, 'create' | 'get' | 'list'>;
-interface CreateTangleSandboxExactProcessProviderOptions {
-  name?: string;
-}
-/**
- * Adapt Tangle Sandbox's managed control runtime to Runtime's exact-process provider.
- *
- * The adapter deliberately exposes no ordinary agent environment: an exact experiment
- * must start a fresh Sandbox with no managed agent and launch its declared argv directly.
- */
-declare function createTangleSandboxExactProcessProvider(client: SandboxControlClient, options?: CreateTangleSandboxExactProcessProviderOptions): AgentEnvironmentProvider;
-//#endregion
-//#region src/runtime/environment-provider.d.ts
-/** Provider object or registry name accepted by runtime provider adapters.
- * @experimental */
-type AgentEnvironmentProviderRef = AgentEnvironmentProvider | string;
-/** In-memory registry for named `AgentEnvironmentProvider` instances.
- * @experimental */
-interface AgentEnvironmentProviderRegistry {
-  register(provider: AgentEnvironmentProvider, options?: {
-    replace?: boolean;
-  }): void;
-  has(name: string): boolean;
-  get(name: string): AgentEnvironmentProvider | undefined;
-  require(name: string): AgentEnvironmentProvider;
-  names(): string[];
-  providers(): AgentEnvironmentProvider[];
-  capabilities(name: string): Promise<AgentEnvironmentCapabilities>;
-}
-/** Create a registry that resolves provider names to concrete provider instances.
- * @experimental */
-declare function createAgentEnvironmentProviderRegistry(providers?: Iterable<AgentEnvironmentProvider>): AgentEnvironmentProviderRegistry;
-/** Resolve a provider instance or registry name, failing loudly when a name is unknown.
- * @experimental */
-declare function resolveAgentEnvironmentProvider(provider: AgentEnvironmentProviderRef, registry?: AgentEnvironmentProviderRegistry): AgentEnvironmentProvider;
-/** Options for exposing an `AgentEnvironmentProvider` through the legacy sandbox client port.
- * @experimental */
-interface ProviderAsSandboxClientOptions {
-  defaults?: Partial<CreateAgentEnvironmentInput>;
-  requireTerminalEvent?: boolean;
-  /** Require declared live continuation plus concrete session controls. */
-  requireSession?: boolean;
-  mapCreateOptions?: (options: CreateSandboxOptions | undefined) => Partial<CreateAgentEnvironmentInput>;
-}
-/** Adapt a neutral environment provider to the `SandboxClient` interface used by existing loop paths.
- * @experimental */
-declare function providerAsSandboxClient(provider: AgentEnvironmentProvider, options?: ProviderAsSandboxClientOptions): SandboxClient;
-/** Options for wrapping the current Tangle sandbox client as an environment provider.
- * @experimental */
-interface SandboxClientProviderOptions {
-  name?: string;
-  defaultBackend?: BackendType;
-  capabilities?: AgentEnvironmentCapabilities | (() => AgentEnvironmentCapabilities | Promise<AgentEnvironmentCapabilities>);
-  validateProfile?: (profile: AgentProfileRef) => AgentProfileValidationResult | Promise<AgentProfileValidationResult>;
-  /** Resolve a named profile before calling Sandbox, which accepts inline profiles only. */
-  resolveProfile?: (profileId: string) => AgentProfile$1 | Promise<AgentProfile$1>;
-  mapCreateInput?: (input: CreateAgentEnvironmentInput) => CreateSandboxOptions;
-}
-/** Adapt a `SandboxClient` into the shared `AgentEnvironmentProvider` contract.
- * @experimental */
-declare function sandboxClientAsProvider(client: SandboxClient, options?: SandboxClientProviderOptions): AgentEnvironmentProvider;
-/** Options for running a provider as a supervise-mode executor.
- * @experimental */
-interface ProviderExecutorOptions {
-  defaults?: Partial<CreateAgentEnvironmentInput>;
-  runtime?: Runtime;
-  destroyOnSettle?: boolean;
-  requireTerminalEvent?: boolean;
-  /** Transform only the profile sent to `provider.create`. The original profile
-   * remains the input to `taskToTurn`, so execution-only normalization cannot
-   * rewrite the caller's task mapping. */
-  profileForCreate?: (profile: AgentProfile$1) => AgentProfile$1;
-  taskToTurn?: (task: unknown, specProfile: AgentProfile$1) => AgentTurnInput;
-}
-/** Adapt an environment provider into an `ExecutorFactory` for `createExecutor`.
- * @experimental */
-declare function providerAsExecutor(provider: AgentEnvironmentProvider, options?: ProviderExecutorOptions): ExecutorFactory<unknown>;
-//#endregion
-export { MaterializedModelIdentity as $, RuntimeEventOtelOptions as $t, providerAsSandboxClient as A, isWaitOutcome as An, WidenGate as At, DefaultVerdict as B, decodeToolPart as Bn, mergeTraceEnv as Bt, ProviderAsSandboxClientOptions as C, PendingWait as Cn, SupervisedResult as Ct, WorkspaceRequest as D, WaitRejection as Dn, UnknownMaterializationReason as Dt, SandboxClientProviderOptions as E, WaitProbeRegistry as En, TreeView as Et, createTangleSandboxExactProcessProvider as F, SessionMessageLike as Fn, readWorkerTraceContext as Ft, ExecutorExecutionBinding as G, ExecutorProgress as Gn, EvalRunsExportConfig as Gt, Executor as H, ActivityLog as Hn, traceContextToEnv as Ht, Agent as I, SessionTraceBox as In, workerTraceEnv as It, ExecutorNodeContext as J, createActivityLog as Jn, LoopSpanNode as Jt, ExecutorFactory as K, ScopeProgressInput as Kn, EvalRunsExportResult as Kt, AgentExecutionRef as L, ToolStepInput as Ln, workerTraceSeamKey as Lt, sandboxClientAsProvider as M, timerAt as Mn, WorkerTraceUnavailableReason as Mt, CreateTangleSandboxExactProcessProviderOptions as N, validateWaitSpec as Nn, WorkerTraceResolver as Nt, createAgentEnvironmentProviderRegistry as O, WaitSpec as On, UsageEvent as Ot, SandboxControlClient as P, waitUntil as Pn, WorkerTraceSeamCarrier as Pt, MaterializedExecutionIdentity as Q, OtelSpan as Qt, AgentSpec as R, TraceSource as Rn, TraceContext as Rt, PlacementInfo as S, sanitizeRuntimeStreamEvent as Sn, SteerableRootHandle as St, ResourceRequest as T, WaitProbe as Tn, SupervisorOpts as Tt, ExecutorAccounting as U, ActivityNote as Un, EvalRunEvent as Ut, ExecutionBindingReceipt as V, sandboxSessionTraceSource as Vn, readTraceContextFromEnv as Vt, ExecutorContext as W, DEFAULT_STALL_AFTER_MS as Wn, EvalRunGeneration as Wt, ExecutorResult as X, OtelExportConfig as Xt, ExecutorRegistry as Y, readWorkerProgress as Yn, OtelAttribute as Yt, Handle as Z, OtelExporter as Zt, CheckpointRequest as _, SanitizedKnowledgeRequirement as _n, SpawnJournal as _t, AgentEnvironmentProviderRef as a, exportEvalRuns as an, ProfileMaterializationReceipt as at, ExecResult as b, sanitizeAgentRuntimeEvent as bn, SpawnRejection as bt, AgentEnvironmentStatus as c, padSpanId as cn, ResumedKeyState as ct, AgentSession as d, RuntimeEventCollector as dn, RootMaterialization as dt, buildLoopOtelSpans as en, NoWinnerError as et, AgentSessionRef as f, RuntimeStreamEventCollector as fn, RootSignal as ft, CheckpointRef as g, SanitizedKnowledgeReadinessReport as gn, SpawnEvent as gt, AgentTurnResult as h, RuntimeTelemetryOptions as hn, Settled as ht, AgentEnvironmentProvider$1 as i, createOtelExporter as in, NodeStatus as it, resolveAgentEnvironmentProvider as j, pollFor as jn, WorkerTraceEvidence as jt, providerAsExecutor as k, createWaitProbes as kn, WaitOpts as kt, AgentEnvironmentSummary as l, padTraceId as ln, ResumedWork as lt, AgentTurnInput$1 as m, RuntimeStreamEventSummary as mn, Scope as mt, AgentEnvironmentCapabilities$1 as n, buildRuntimeEventOtelSpans as nn, NodeId as nt, AgentEnvironmentProviderRegistry as o, generateSpanId as on, Restart as ot, AgentSessionStatus as p, RuntimeStreamEventSink as pn, Runtime as pt, ExecutorMaterialization as q, WorkerProgress as qn, INTELLIGENCE_WIRE_VERSION as qt, AgentEnvironmentEvent as r, createOpenInferenceFileExporter as rn, NodeSnapshot as rt, AgentEnvironmentQuery as s, loopEventToOtelSpan as sn, ResultBlobStore as st, AgentEnvironment as t, buildLoopSpanNodes as tn, NodeExecutionIdentity as tt, AgentProfileRef$1 as u, toOtelAttributes as un, RootHandle as ut, CreateAgentEnvironmentInput$1 as v, createRuntimeEventCollector as vn, SpawnOpts as vt, ProviderExecutorOptions as w, WaitOutcome as wn, Supervisor as wt, ForkRequest as x, sanitizeKnowledgeReadinessReport as xn, Spend as xt, ExecRequest as y, createRuntimeStreamEventCollector as yn, SpawnPrior as yt, Budget as z, createPushTraceSource as zn, createPropagatingTraceEmitter as zt };
-//# sourceMappingURL=environment-provider-CUFsyymu.d.ts.map
+export { WorkerTraceSeamCarrier as $, waitUntil as $t, RootMaterialization as A, RuntimeEventCollector as At, Spend as B, sanitizeKnowledgeReadinessReport as Bt, NodeStatus as C, createOtelExporter as Ct, ResumedKeyState as D, padSpanId as Dt, ResultBlobStore as E, loopEventToOtelSpan as Et, SpawnEvent as F, SanitizedKnowledgeReadinessReport as Ft, TreeView as G, WaitProbeRegistry as Gt, SupervisedResult as H, PendingWait as Ht, SpawnJournal as I, SanitizedKnowledgeRequirement as It, WaitOpts as J, createWaitProbes as Jt, UnknownMaterializationReason as K, WaitRejection as Kt, SpawnOpts as L, createRuntimeEventCollector as Lt, Runtime as M, RuntimeStreamEventSink as Mt, Scope as N, RuntimeStreamEventSummary as Nt, ResumedWork as O, padTraceId as Ot, Settled as P, RuntimeTelemetryOptions as Pt, WorkerTraceResolver as Q, validateWaitSpec as Qt, SpawnPrior as R, createRuntimeStreamEventCollector as Rt, NodeSnapshot as S, createOpenInferenceFileExporter as St, Restart as T, generateSpanId as Tt, Supervisor as U, WaitOutcome as Ut, SteerableRootHandle as V, sanitizeRuntimeStreamEvent as Vt, SupervisorOpts as W, WaitProbe as Wt, WorkerTraceEvidence as X, pollFor as Xt, WidenGate as Y, isWaitOutcome as Yt, WorkerTraceUnavailableReason as Z, timerAt as Zt, MaterializedExecutionIdentity as _, OtelSpan as _t, DefaultVerdict as a, decodeToolPart as an, mergeTraceEnv as at, NodeExecutionIdentity as b, buildLoopSpanNodes as bt, ExecutorAccounting as c, ActivityNote as cn, EvalRunEvent as ct, ExecutorFactory as d, ScopeProgressInput as dn, EvalRunsExportResult as dt, SessionMessageLike as en, readWorkerTraceContext as et, ExecutorMaterialization as f, WorkerProgress as fn, INTELLIGENCE_WIRE_VERSION as ft, Handle as g, OtelExporter as gt, ExecutorResult as h, OtelExportConfig as ht, Budget as i, createPushTraceSource as in, createPropagatingTraceEmitter as it, RootSignal as j, RuntimeStreamEventCollector as jt, RootHandle as k, toOtelAttributes as kt, ExecutorContext as l, DEFAULT_STALL_AFTER_MS as ln, EvalRunGeneration as lt, ExecutorRegistry as m, readWorkerProgress as mn, OtelAttribute as mt, AgentExecutionRef as n, ToolStepInput as nn, workerTraceSeamKey as nt, ExecutionBindingReceipt as o, sandboxSessionTraceSource as on, readTraceContextFromEnv as ot, ExecutorNodeContext as p, createActivityLog as pn, LoopSpanNode as pt, UsageEvent as q, WaitSpec as qt, AgentSpec as r, TraceSource as rn, TraceContext as rt, Executor as s, ActivityLog as sn, traceContextToEnv as st, Agent as t, SessionTraceBox as tn, workerTraceEnv as tt, ExecutorExecutionBinding as u, ExecutorProgress as un, EvalRunsExportConfig as ut, MaterializedModelIdentity as v, RuntimeEventOtelOptions as vt, ProfileMaterializationReceipt as w, exportEvalRuns as wt, NodeId as x, buildRuntimeEventOtelSpans as xt, NoWinnerError as y, buildLoopOtelSpans as yt, SpawnRejection as z, sanitizeAgentRuntimeEvent as zt };
+//# sourceMappingURL=types-C6Q-J0Dt.d.ts.map