@robota-sdk/agent-core 3.0.0-beta.82 → 3.0.0-beta.84

package/dist/node/{index-D2rky0wZ.d.ts → index-gEUh4G-t.d.cts}

@@ -1,4 +1,4 @@
-import { C as IModelEffortResolution, F as IUniversalObjectValue, I as TPrimitiveValue, L as TUniversalArrayValue, R as TUniversalValue, S as IModelEffortOutcome, _ as IOutboundTraceContext, a as IHookErrorOutcome, b as TSubprocessTraceClass, c as IHookTypeExecutor, d as TGuardrail, f as THookDefinition, h as THooksConfig, j as TModelEffortSelection, k as TModelEffortOutcomeCallback, m as THookOutcome, p as THookEvent, s as IHookInput, v as IRunTraceContext, w as IProviderModelEffortTable, y as ISubprocessTraceEnv } from "./types-gNrckgFE.js";
+import { C as IModelEffortResolution, F as IUniversalObjectValue, I as TPrimitiveValue, L as TUniversalArrayValue, R as TUniversalValue, S as IModelEffortOutcome, _ as IOutboundTraceContext, a as IHookErrorOutcome, b as TSubprocessTraceClass, c as IHookTypeExecutor, d as TGuardrail, f as THookDefinition, h as THooksConfig, j as TModelEffortSelection, k as TModelEffortOutcomeCallback, m as THookOutcome, p as THookEvent, s as IHookInput, v as IRunTraceContext, w as IProviderModelEffortTable, y as ISubprocessTraceEnv } from "./types-BQ-sKCQS.cjs";
 import { TypeOf, ZodType } from "zod";
 //#region src/interfaces/types.d.ts
 /**
@@ -38,146 +38,37 @@ declare const TypeUtils: {
   isUniversalValue: (value: TUniversalValue) => value is TUniversalValue;
 };
 //#endregion
-//#region src/interfaces/cache.d.ts
-/**
- * Cache key identifying a unique LLM execution request
- */
-interface ICacheKey {
-  /** SHA-256 hash of the serialized request */
-  hash: string;
-  /** Model identifier */
-  model: string;
-  /** Provider name */
-  provider: string;
-}
-/**
- * Cached LLM response entry
- */
-interface ICacheEntry {
-  /** Cache key that produced this entry */
-  key: ICacheKey;
-  /** Cached response content */
-  response: string;
-  /** When the entry was cached */
-  timestamp: number;
-  /** SHA-256 integrity hash of the response */
-  integrityHash: string;
-}
-/**
- * Cache storage interface for pluggable backends
- */
-interface ICacheStorage {
-  /** Retrieve a cached entry by key hash */
-  get(hash: string): ICacheEntry | undefined;
-  /** Store a cache entry */
-  set(entry: ICacheEntry): void;
-  /** Delete a cached entry by key hash */
-  delete(hash: string): boolean;
-  /** Clear all cached entries */
-  clear(): void;
-  /** Get cache statistics */
-  getStats(): ICacheStats;
-}
-/**
- * Cache performance statistics
- */
-interface ICacheStats {
-  /** Number of cache hits */
-  hits: number;
-  /** Number of cache misses */
-  misses: number;
-  /** Current number of cached entries */
-  entries: number;
-  /** Hit rate (hits / (hits + misses)), 0 if no lookups */
-  hitRate: number;
+//#region src/interfaces/tool-continuation.d.ts
+/** Core-owned identity, independent of a provider's reusable tool-call identifier. */
+interface IToolActionIdentity {
+  executionId: string;
+  actionId: string;
+  parentCallId: string;
+  toolCallId: string;
+  toolName: string;
 }
-/**
- * Configuration options for execution caching
- */
-interface ICacheOptions {
-  /** Whether caching is enabled */
-  enabled: boolean;
-  /** Maximum number of cached entries */
-  maxEntries: number;
-  /** Time-to-live in milliseconds */
-  ttlMs: number;
+interface IToolContinuationPrompt {
+  kind: string;
+  data: TToolParameters;
 }
-//#endregion
-//#region src/interfaces/interaction.d.ts
-/**
- * UI-agnostic "ask the user" contract (CMD-004).
- *
- * The SSOT for the interaction action lives in agent-core so every interaction *source* can reach it:
- * command execution (`ICommandHostContext`, agent-framework) AND tool execution
- * (`IToolExecutionContext`, agent-core, for model-issued questions — CMD-005). These are pure types
- * with no runtime dependency, so the contract crosses a serialization/transport boundary unchanged
- * (no function-valued fields).
- *
- * A single shape covers every interaction kind, parameterised by fields rather than split into
- * variants:
- * - confirm    → two options, `maxSelect` 1
- * - single     → options, `maxSelect` 1
- * - multi      → options, `maxSelect` > 1
- * - free text  → no options, `allowFreeText` true
- * - secret     → free text with `masked` true
- */
-/** One predefined option the user can choose. */
-interface IActionOption {
-  value: string;
-  label: string;
-  description?: string;
+interface IToolWaitRequest extends IToolActionIdentity, IToolContinuationPrompt {
+  requestId: string;
 }
-/** Pre-selected option values and/or prefilled free text for an action request. */
-interface IActionDefault {
-  values?: readonly string[];
-  text?: string;
+interface IToolWaitResponse {
+  requestId: string;
+  responseId: string;
+  response: TToolParameters;
 }
-/** One request for the user to answer. See the module doc for how the fields encode each kind. */
-interface IActionRequest {
-  /** Correlation key; the ask port resolves a given id exactly once (idempotent, first-answer wins). */
-  id: string;
-  title: string;
-  description?: string;
-  /** Predefined options. Empty/omitted ⇒ pure free-text entry. */
-  options?: readonly IActionOption[];
-  /** Minimum selections required (default 1). */
-  minSelect?: number;
-  /** Maximum selections allowed (default 1 ⇒ single; > 1 ⇒ multi). */
-  maxSelect?: number;
-  /** Allow a typed custom answer in addition to / instead of the options. */
-  allowFreeText?: boolean;
-  /** Free-text entry is masked (secret entry such as an API key); the renderer hides input. */
-  masked?: boolean;
-  /** Allow submitting empty free text. */
-  allowEmpty?: boolean;
-  /** Placeholder shown in the free-text field. */
-  placeholder?: string;
-  /** Maximum options shown before scrolling (renderer hint). */
-  maxVisible?: number;
-  /** Pre-selected option values and/or prefilled free text. */
-  default?: IActionDefault;
+interface IToolWaitState {
+  request: IToolWaitRequest;
+  response?: IToolWaitResponse;
 }
-/**
- * The user's answer to an {@link IActionRequest}. `answer` carries the selected option values and/or
- * the typed text; `cancelled` means the user dismissed the request, or no interactive renderer was
- * available to answer it.
- */
-type TActionResponse = {
-  type: 'answer';
-  values: readonly string[];
-  text?: string;
-} | {
-  type: 'cancelled';
-};
-/**
- * The injected "ask the user" port — a single seam reachable by every interaction source (command
- * execution now; tool execution for model-issued questions later) and rendered per-environment by each
- * transport. The concurrency model (broadcast to attached interactive channels, first answer wins,
- * later answers for an already-resolved `id` ignored) is owned by the port implementation, not the
- * contract.
- */
-interface IUserInteraction {
-  ask(request: IActionRequest): Promise<TActionResponse>;
+/** Available before effect admission. The runtime owns interpretation and authorization. */
+interface IToolContinuation {
+  readonly action: IToolActionIdentity;
+  readonly waits: readonly IToolWaitState[];
+  /** Return a saved response or persist a request and suspend this execution. */
+  request(prompt: IToolContinuationPrompt): Promise<TToolParameters>;
 }
 //#endregion
 //#region src/interfaces/messages.d.ts
@@ -529,10 +420,14 @@ declare class RateLimitError extends RobotaError {
  */
 declare class NetworkError extends RobotaError {
   readonly originalError?: Error | undefined;
+  /** `undefined` for a network failure with no provider context (e.g. a generic timeout). */
+  readonly provider?: string | undefined;
   readonly code = "NETWORK_ERROR";
   readonly category: "system";
   readonly recoverable = true;
-  constructor(message: string, originalError?: Error | undefined, context?: TErrorContextData);
+  constructor(message: string, originalError?: Error | undefined, context?: TErrorContextData,
+  /** `undefined` for a network failure with no provider context (e.g. a generic timeout). */
+  provider?: string | undefined);
 }
 /**
  * Tool execution errors
@@ -573,11 +468,24 @@ declare class SameToolInputLoopError extends RobotaError {
  * Model not available errors
  */
 declare class ModelNotAvailableError extends RobotaError {
+  /** `undefined` when the failure names no model — a provider adapter classifying a raw HTTP
+   *  response by status alone does not always know which model the vendor meant. */
+  readonly model: string | undefined;
+  readonly provider: string;
   readonly availableModels?: string[] | undefined;
   readonly code = "MODEL_NOT_AVAILABLE";
   readonly category: "user";
   readonly recoverable = false;
-  constructor(model: string, provider: string, availableModels?: string[] | undefined, context?: TErrorContextData);
+  constructor(
+  /** `undefined` when the failure names no model — a provider adapter classifying a raw HTTP
+   *  response by status alone does not always know which model the vendor meant. */
+  model: string | undefined, provider: string, availableModels?: string[] | undefined,
+  /**
+   * `context.originalMessage`, when given, is the vendor's own text (already scrubbed of any
+   * credential by the caller) — folded into `message` so a "Details" disclosure built from
+   * `message` alone still shows the real cause instead of just this class's fixed sentence.
+   */
+  context?: TErrorContextData);
 }
 /**
  * Circuit breaker open error
@@ -618,6 +526,25 @@ declare class CacheIntegrityError extends RobotaError {
 }
 //#endregion
 //#region src/utils/provider-failure.d.ts
+/**
+ * Strip anything that reads like a credential out of vendor text before it is kept on a typed error.
+ * A vendor's error body is not supposed to echo request headers, but a misconfigured self-hosted
+ * gateway can bounce the raw request back (an `Authorization` header, a `Bearer` token, an `api_key=`
+ * query parameter, or the whole request re-serialized as JSON) — this runs once, ahead of every
+ * classification below, so nothing built from `message` (the wire frame's `message`, a GUI "Details"
+ * disclosure) can leak one.
+ *
+ * Each pattern gets its own fixed replacement, bounded to the credential token — never a shared
+ * callback keyed on "does this match have a capture group", which for a pattern with none receives
+ * the match's numeric offset instead of `undefined` and silently prints that number.
+ *
+ * The key-name and value quotes are each optional and captured (`(")?`) rather than matched and
+ * dropped: JSON re-serializes a header as `"Authorization": "Bearer sk-..."`, and the closing quote
+ * right after the key name breaks a match that only expects `\s*[:=]` next — capturing it lets the
+ * replacement echo it back (`Authorization$1: $2[REDACTED]`) so quoted and unquoted text both read
+ * naturally, and `SECRET_VALUE` excluding `"` leaves a closing value quote alone to survive untouched.
+ */
+declare function scrubSecrets(text: string): string;
 /** Why a provider call failed, as far as switching models is concerned. */
 type TProviderFailureReason = 'overloaded' | 'service-unavailable' | 'server-error' | 'model-unavailable' | 'authentication' | 'billing' | 'rate-limit' | 'invalid-request' | 'network' | 'aborted' | 'unknown';
 interface IProviderFailureClassification {
@@ -637,9 +564,15 @@ declare function readProviderFailureDetails(error: unknown): IProviderFailureDet
 /**
  * Turn whatever an adapter caught into a typed provider failure.
  *
- * Aborts and errors already in the taxonomy pass through unchanged, a rate limit becomes a
- * `RateLimitError`, and anything else becomes a `ProviderError` carrying the status and type the
- * vendor reported, with the original kept as `originalError`.
+ * Aborts and errors already in the taxonomy pass through unchanged. Everything else is classified by
+ * the same status/type rules `classifyLayer` uses to decide switchability — a rate limit, an
+ * authentication failure, a model the vendor does not serve, and a transport failure each become
+ * their own typed error (so `AuthenticationError`/`ModelNotAvailableError`/`NetworkError` are actually
+ * thrown, not just recognized after the fact); anything left over becomes a `ProviderError` carrying
+ * the status and type the vendor reported, with the original kept as `originalError`. Every branch
+ * keeps the vendor's own (scrubbed) message and status/type — as the text baked into `message` for
+ * the types that already carry a free-form one, and as `context` alongside it — so a "Details"
+ * disclosure built from `message` downstream never has less to say than the vendor did.
  */
 declare function toProviderError(error: unknown, provider: string, operation: string): Error;
 /**
@@ -871,6 +804,19 @@ interface ITokenUsage {
   completionTokens: number;
   totalTokens: number;
 }
+/**
+ * The usage triple ({@link ITokenUsage}) plus the prompt-cache read a provider reported for it.
+ *
+ * Derived from the triple rather than widening it: the triple is also the persisted and wired usage
+ * shape (background-task results, subagent IPC), whose decoders declare exactly its three keys.
+ */
+interface ITokenUsageWithCacheRead extends ITokenUsage {
+  /**
+   * The part of `promptTokens` the provider served from its prompt cache — a subset of
+   * `promptTokens`, not an addition to it. Present only when the provider reported it.
+   */
+  cacheReadTokens?: number;
+}
 /**
  * Raw provider response interface
  */
@@ -1133,213 +1079,306 @@ type TProviderOptionValueBase = string | number | boolean | undefined | null | T
   [key: string]: TProviderOptionValueBase;
 };
 //#endregion
-//#region src/interfaces/response-format.d.ts
+//#region src/event-service/interfaces.d.ts
 /**
- * Response format configuration
+ * @fileoverview Event service interface definitions.
+ *
+ * These interfaces are the single source of truth for event-related contracts
+ * within @robota-sdk/agent-core.
  */
-interface IResponseFormatConfig {
-  type?: 'text' | 'json_object' | 'json_schema';
-  /** JSON schema payload; required when `type` is `'json_schema'` (CORE-015). */
-  schema?: Record<string, TConfigValue>;
-  /** Schema name forwarded to provider native structured-output surfaces. */
-  name?: string;
-}
 /**
- * Safety setting configuration
+ * Primitive value types for event payloads.
  */
-interface ISafetySetting {
-  category: string;
-  threshold: string;
-  [key: string]: TConfigValue;
-}
-//#endregion
-//#region src/schema/zod-schema-types.d.ts
-interface IZodParseResult {
-  success: boolean;
-  data?: unknown;
-  error?: unknown;
-}
-interface IZodSchemaDef {
-  typeName?: string;
-  innerType?: IZodSchema;
-  valueType?: IZodSchema;
-  checks?: Array<{
-    kind: string;
-    value?: TUniversalValue;
-  }>;
-  shape?: () => Record<string, IZodSchema>;
-  type?: IZodSchema;
-  /**
-   * `ZodEnum` holds an ARRAY here; `ZodNativeEnum` holds the enum OBJECT itself (CORE-041). One Zod
-   * field name, two shapes — the converter narrows before reading it.
-   */
-  values?: TUniversalValue[] | Record<string, TUniversalValue>;
-  description?: string;
-  unknownKeys?: 'passthrough' | 'strip' | 'strict';
-  /** `ZodEffects` (`.refine()` / `.transform()`) holds the schema it wraps here. */
-  schema?: IZodSchema;
-  /** `ZodUnion` / `ZodDiscriminatedUnion` members. */
-  options?: IZodSchema[];
-  /** `ZodLiteral` value. */
-  value?: TUniversalValue;
-}
-interface IZodSchema {
-  parse(value: unknown): unknown;
-  safeParse(value: unknown): IZodParseResult;
-  _def?: IZodSchemaDef;
-}
+type TEventPrimitiveValue = string | number | boolean | null | undefined;
 /**
- * Schema conversion options
+ * Recursive universal value type for event payloads (JSON-like + Date).
  */
-interface ISchemaConversionOptions {
-  includeDescription?: boolean;
-  strictTypes?: boolean;
-  allowAdditionalProperties?: boolean;
-}
-//#endregion
-//#region src/schema/structured-output.d.ts
-/** Explicit raw-JSON-schema form of `IRunOptions.output`. */
-interface IJsonSchemaOutput {
-  /** JSON Schema (object root, universal subset) the response must match. */
-  jsonSchema: IToolSchema['parameters'];
-  /** Optional schema name forwarded to provider native surfaces. */
-  name?: string;
-}
-/** Accepted `IRunOptions.output` values: a Zod schema or an explicit JSON-schema wrapper. */
-type TStructuredOutputSchema = IZodSchema | IJsonSchemaOutput;
-type TStructuredOutputValidation = {
-  success: true;
-  value: unknown;
-} | {
-  success: false;
-  issues: string[];
-};
-/** Internal SSOT representation every `output` value normalizes to. */
-interface IStructuredOutputSpec {
-  name: string;
-  jsonSchema: IToolSchema['parameters'];
-  validate(value: unknown): TStructuredOutputValidation;
+type TEventUniversalValue = TEventPrimitiveValue | Date | TEventUniversalValue[] | IEventObjectValue;
+interface IEventObjectValue {
+  [key: string]: TEventUniversalValue;
 }
-/** Normalize an accepted `output` value into the internal spec. */
-declare function normalizeStructuredOutput(output: TStructuredOutputSchema): IStructuredOutputSpec;
 /**
- * Validate a value against the universal JSON-schema subset (`IParameterSchema`). Covers type,
- * required, enum, items, nested properties, unions and numeric bounds — the full expressible
- * surface of the subset, at every level.
- *
- * CORE-039: this is the ONE complete walk. `parameter-validator` delegates its depth here rather
- * than keeping a second, shallower copy, and the two must therefore agree by construction.
+ * Logger data type for event metadata.
  */
-declare function validateAgainstJsonSchema(schema: IParameterSchema, value: unknown, path: string): string[];
+type TEventLoggerData = Record<string, TEventUniversalValue | Date | Error>;
 /**
- * Parse the model's final text into a JSON value. Tolerates a fenced
- * ```json code block wrapper (providers without native enforcement commonly
- * emit one); the parsed value is still strictly schema-validated afterwards.
+ * A single segment in an explicit ownerPath.
+ *
+ * Path-only rule:
+ * - Relationships must be derived from these explicit segments, not from parsing IDs.
  */
-declare function parseStructuredResponseText(text: string): {
-  success: true;
-  value: unknown;
-} | {
-  success: false;
-  issue: string;
+interface IOwnerPathSegment {
+  type: string;
+  id: string;
+}
+/**
+ * Event context that accompanies an emitted event.
+ * This is the single source of truth for deterministic linking in subscribers.
+ */
+interface IEventContext {
+  ownerType: string;
+  ownerId: string;
+  ownerPath: IOwnerPathSegment[];
+  /** Depth of the current execution in the hierarchy (0 = root) */
+  depth?: number;
+  /** Unique span identifier for distributed tracing correlation */
+  spanId?: string;
+  /** Optional structured metadata for debugging/observability */
+  metadata?: TEventLoggerData;
+}
+/**
+ * Allowed extension values for event payloads.
+ */
+type TEventExtensionValue = TEventUniversalValue | TEventLoggerData | Error | IEventContext | IOwnerPathSegment[];
+/**
+ * Base event payload shape.
+ * Emitters may add additional fields, but MUST keep linkage information explicit.
+ */
+interface IBaseEventData {
+  /** Timestamp when the event was emitted. This is required for deterministic ordering. */
+  timestamp: Date;
+  /** Optional structured metadata */
+  metadata?: TEventLoggerData;
+  /** Extensible fields for event-specific payloads */
+  [key: string]: TEventExtensionValue | undefined;
+}
+/**
+ * Execution-related event payload.
+ */
+interface IExecutionEventData extends IBaseEventData {}
+/**
+ * Tool-related event payload.
+ */
+interface IToolEventData extends IBaseEventData {
+  toolName?: string;
+  parameters?: Record<string, TEventUniversalValue>;
+}
+/**
+ * Agent-related event payload.
+ */
+interface IAgentEventData extends IBaseEventData {
+  agentId?: string;
+}
+type TEventListener = (eventType: string, data: IBaseEventData, context?: IEventContext) => void;
+/**
+ * Minimal EventService contract for emitting events.
+ */
+interface IEventService {
+  emit(eventType: string, data: IBaseEventData, context?: IEventContext): void;
+  subscribe(listener: TEventListener): void;
+  unsubscribe(listener: TEventListener): void;
+}
+/**
+ * Explicit owner binding information used for scoped event emission.
+ */
+interface IEventServiceOwnerBinding {
+  ownerType: string;
+  ownerId: string;
+  ownerPath: IOwnerPathSegment[];
+}
+//#endregion
+//#region src/event-service/event-service.d.ts
+/**
+ * Abstract base for event services.
+ * Concrete implementations decide how events are delivered.
+ */
+declare abstract class AbstractEventService implements IEventService {
+  private listeners;
+  abstract emit(eventType: string, data: IBaseEventData, context?: IEventContext): void;
+  subscribe(listener: TEventListener): void;
+  unsubscribe(listener: TEventListener): void;
+  protected notifyListeners(eventType: string, data: IBaseEventData, context?: IEventContext): void;
+}
+/**
+ * Default no-op event service (production-safe).
+ * When injected, emit() intentionally does nothing.
+ */
+declare class DefaultEventService extends AbstractEventService {
+  emit(_eventType: string, _data: IBaseEventData, _context?: IEventContext): void;
+}
+/**
+ * Singleton default event service instance.
+ */
+declare const DEFAULT_ABSTRACT_EVENT_SERVICE: IEventService;
+/**
+ * Check if a given service is the default no-op implementation.
+ */
+declare function isDefaultEventService(service: IEventService): boolean;
+/**
+ * Compose a full event name from owner prefix and local name.
+ * Local names must not contain dots.
+ */
+declare function composeEventName(ownerType: string, localName: string): string;
+/**
+ * Generate a unique span ID for distributed tracing correlation. Exported so a per-operation timing
+ * source (SELFHOST-004) can mint a span id it puts on BOTH the event payload and the event context.
+ */
+declare function generateSpanId(): string;
+/**
+ * A scoped event service that always emits with an owner binding applied.
+ */
+declare class StructuredEventService extends AbstractEventService {
+  private readonly base;
+  private readonly binding;
+  constructor(base: IEventService, binding: IEventServiceOwnerBinding);
+  emit(eventType: string, data: IBaseEventData, context?: IEventContext): void;
+  subscribe(listener: TEventListener): void;
+  unsubscribe(listener: TEventListener): void;
+}
+/**
+ * Bind an EventService to an explicit owner path.
+ * This is the standard entry point for scoped emission (path-only architecture).
+ */
+declare function bindWithOwnerPath(base: IEventService, binding: IEventServiceOwnerBinding): IEventService;
+/**
+ * Alias for bindWithOwnerPath for historical call sites.
+ * Intentionally forwards to the single authoritative implementation.
+ */
+declare function bindEventServiceOwner(base: IEventService, binding: IEventServiceOwnerBinding): IEventService;
+/**
+ * Observable EventService that notifies subscribed listeners.
+ */
+declare class ObservableEventService extends AbstractEventService {
+  emit(eventType: string, data: IBaseEventData, context?: IEventContext): void;
+}
+//#endregion
+//#region src/event-service/task-events.d.ts
+declare const TASK_EVENTS: {
+  readonly ASSIGNED: "assigned";
+  readonly COMPLETED: "completed";
 };
+declare const TASK_EVENT_PREFIX: "task";
 //#endregion
-//#region src/interfaces/run-options.d.ts
+//#region src/event-service/user-events.d.ts
+declare const USER_EVENTS: {
+  readonly MESSAGE: "message";
+  readonly INPUT: "input";
+};
+declare const USER_EVENT_PREFIX: "user";
+type TUserEvent = (typeof USER_EVENTS)[keyof typeof USER_EVENTS];
+//#endregion
+//#region src/event-service/span-events.d.ts
 /**
- * The per-RUN contract: what one `run()` may override or observe, as distinct from the agent's
- * standing configuration in `IAgentConfig`.
- *
- * Split out of `agent.ts` when PEER-007 added `driverId`. That file sits at a frozen size baseline,
- * and the anti-monolith rule asks for a split rather than one more field on a file already at its
- * limit. The two execution-event types come along because `onExecutionEvent` is their only consumer
- * — leaving them behind would have made this module import back from `agent.ts`.
+ * SELFHOST-004: per-operation span lifecycle event names. Mirrors the `TASK_EVENTS`/`USER_EVENTS`
+ * pattern (a const name set + a prefix). The local name is distinctive (`span_completed`, not a bare
+ * `completed`) so a consumer can identify a span-completion regardless of the emitting owner's prefix.
  */
-type TExecutionEventData = Record<string, unknown>;
-type TExecutionEventCallback = (event: string, data: TExecutionEventData) => void;
+declare const SPAN_EVENTS: {
+  readonly COMPLETED: "span_completed";
+};
+/** Content-free completion of one provider round, separate from legacy tool timing events. */
+declare const PROVIDER_CALL_EVENTS: {
+  readonly COMPLETED: "provider_call_completed";
+};
+/** A provider request moved to another model after the one it was on failed. */
+declare const PROVIDER_FALLBACK_EVENTS: {
+  readonly SWITCHED: "provider_fallback";
+};
+/** The notice a `provider_fallback` event carries, or `undefined` when the payload is malformed. */
+declare function readModelFallbackNotice(data: Readonly<Record<string, unknown>>): IModelFallbackNotice | undefined;
+/** Content-free completion of the body actually awaited by one permitted tool call. */
+declare const TOOL_BODY_EVENTS: {
+  readonly COMPLETED: "tool_body_completed";
+};
+/** Content-free decision reached for one tool call before any body runs. */
+declare const TOOL_PERMISSION_EVENTS: {
+  readonly DECIDED: "tool_permission_decided";
+};
+declare const SPAN_EVENT_PREFIX: "span";
+type TSpanEvent = (typeof SPAN_EVENTS)[keyof typeof SPAN_EVENTS];
 /**
- * Agent run options - type-safe interface for all agent execution options
+ * SELFHOST-004: span-completion event payload — JOINS the span id with its measured duration and the
+ * operation name (raw scalars ONLY; references no transport type). Emitted by the per-operation timing
+ * source (e.g. `FunctionTool`) so a consuming layer (`agent-framework`) can build a record span entry
+ * WITHOUT `agent-core` depending on `agent-interface-transport` (no cycle). The payload `spanId` is the
+ * AUTHORITATIVE id a consumer reads; owner/turn correlation is applied by the event service's binding
+ * (`ownerPath` on the emitted `IEventContext`). Note the context's own auto-minted `spanId` is a
+ * separate scope tag and need not equal this payload id — always read the payload id for the span.
  */
-interface IRunOptions {
-  /** Run-scoped temperature override — wins over `defaultModel.temperature` (CORE-016). */
-  temperature?: number;
-  /** Run-scoped max output tokens override — wins over `defaultModel.maxTokens` (CORE-016). */
-  maxTokens?: number;
-  /**
-   * Run-scoped tool-invocation directive — wins over `defaultModel.toolChoice` (CORE-017).
-   * `'auto'` (model decides), `'none'` (suppress tool calls), `'required'` (must call some
-   * tool), or `{ tool: name }` (must call the named tool; the name is validated against the
-   * run's tool list and a miss throws). Forcing applies to the run's first model call only;
-   * rounds after tool results revert to `'auto'` (see `TToolChoice`).
-   */
-  toolChoice?: TToolChoice;
-  /**
-   * Leave a provider's own hosted tools (a vendor-run web search) out of this run's requests. They
-   * run at the vendor and never pass the permission gate, so a run whose tools a policy restricts
-   * must not reach them.
-   */
-  withholdHostedTools?: boolean;
-  sessionId?: string;
-  userId?: string;
-  /**
-   * PEER-007 (issue #1915): who this run is attributed to, for display. Per-run because it changes
-   * per turn — one session serves the operator and any peer addressing it. Never authorization.
-   */
-  driverId?: string;
-  metadata?: TMetadata;
-  /**
-   * Run-scoped EPHEMERAL system context (SELFHOST-008 P3). A transient system-role block included in THIS
-   * run's provider request(s) only — it is **never written to the conversation store** and never persisted,
-   * so it does not bloat history or force a static-system-prompt rebuild. Content-free neutral channel: the
-   * caller decides what to put here (e.g. per-turn recalled memory). Absent ⇒ no change.
-   */
-  ephemeralSystemContext?: string;
-  /**
-   * Host-owned trace context for this run's provider calls. Each invoked call — forced summary
-   * included, cache hits excluded — gets a `traceparent` whose parent is that call's own span, and
-   * only an adapter whose origin is listed sends it. Never recorded in execution events.
-   */
-  traceContext?: IRunTraceContext;
-  /** AbortSignal for cancelling execution */
-  signal?: AbortSignal;
-  /** Join an aborted/timed-out provider call before completing; an uncooperative call may remain pending. */
-  awaitProviderSettlement?: boolean;
-  /** Per-run streaming text callback. Prefer this over mutating provider callback state. */
-  onTextDelta?: TTextDeltaCallback;
-  /** Per-run replay event callback for provider/tool execution boundaries. */
-  onExecutionEvent?: TExecutionEventCallback;
-  /**
-   * Maximum execution rounds for this run. A **round** is one provider (model) call plus the
-   * execution of every tool call that reply requested; a reply with no tool calls ends the loop,
-   * so a plain Q&A turn is exactly 1 round. This caps model/tool cycles within ONE `run()` — it is
-   * not a tool-count limit and not a multi-turn conversation limit. When the cap is hit the run
-   * stops after the current round. Use 0 for no core round cap. Defaults to
-   * `IAgentConfig.maxExecutionRounds`.
-   */
-  maxExecutionRounds?: number;
-  /** Max times the same tool may be called with identical input before aborting. Unset = no limit. */
-  maxSameToolInputs?: number;
-  /**
-   * Treat a turn that ends in tool calls (no trailing text) as a valid completion instead of
-   * forcing one extra provider call to generate a summary (CORE-011). For decision-agent patterns
-   * (router/orchestrator/classifier) the tool call IS the answer — this removes the one-call tax.
-   * The run result's content may be empty; consumers read the outcome from the tool results.
-   */
-  allowToolOnlyCompletion?: boolean;
-  /**
-   * Schema-enforced structured output (CORE-015). Accepts a Zod schema or an explicit
-   * `{ jsonSchema }` wrapper. `run` then resolves to the validated, typed object instead of a
-   * string: the schema is forwarded to the provider's native structured-output surface where one
-   * exists, and the final response is always parsed and validated core-side; a violation triggers
-   * a bounded retry with the validation issues fed back as the next turn's input. Every attempt is
-   * a real conversation turn (history stays append-only). Exhausted retries throw
-   * `StructuredOutputError`.
-   */
-  output?: TStructuredOutputSchema;
-  /**
-   * Retry budget for structured output validation failures — the number of additional attempts
-   * after the first (default 2). Only meaningful with `output` set.
-   */
-  outputRetries?: number;
+interface ISpanCompletionEventData extends IBaseEventData {
+  /** The span id (equals the emitted event's context `spanId`). */
+  spanId: string;
+  /** Measured wall-clock duration of the operation, in milliseconds. */
+  durationMs: number;
+  /** The operation name (e.g. the tool name). */
+  op: string;
+}
+//#endregion
+//#region src/interfaces/interaction.d.ts
+/**
+ * UI-agnostic "ask the user" contract (CMD-004).
+ *
+ * The SSOT for the interaction action lives in agent-core so every interaction *source* can reach it:
+ * command execution (`ICommandHostContext`, agent-framework) AND tool execution
+ * (`IToolExecutionContext`, agent-core, for model-issued questions — CMD-005). These are pure types
+ * with no runtime dependency, so the contract crosses a serialization/transport boundary unchanged
+ * (no function-valued fields).
+ *
+ * A single shape covers every interaction kind, parameterised by fields rather than split into
+ * variants:
+ * - confirm    → two options, `maxSelect` 1
+ * - single     → options, `maxSelect` 1
+ * - multi      → options, `maxSelect` > 1
+ * - free text  → no options, `allowFreeText` true
+ * - secret     → free text with `masked` true
+ */
+/** One predefined option the user can choose. */
+interface IActionOption {
+  value: string;
+  label: string;
+  description?: string;
+}
+/** Pre-selected option values and/or prefilled free text for an action request. */
+interface IActionDefault {
+  values?: readonly string[];
+  text?: string;
+}
+/** One request for the user to answer. See the module doc for how the fields encode each kind. */
+interface IActionRequest {
+  /** Correlation key; the ask port resolves a given id exactly once (idempotent, first-answer wins). */
+  id: string;
+  title: string;
+  description?: string;
+  /** Predefined options. Empty/omitted ⇒ pure free-text entry. */
+  options?: readonly IActionOption[];
+  /** Minimum selections required (default 1). */
+  minSelect?: number;
+  /** Maximum selections allowed (default 1 ⇒ single; > 1 ⇒ multi). */
+  maxSelect?: number;
+  /** Allow a typed custom answer in addition to / instead of the options. */
+  allowFreeText?: boolean;
+  /** Free-text entry is masked (secret entry such as an API key); the renderer hides input. */
+  masked?: boolean;
+  /** Allow submitting empty free text. */
+  allowEmpty?: boolean;
+  /** Placeholder shown in the free-text field. */
+  placeholder?: string;
+  /** Maximum options shown before scrolling (renderer hint). */
+  maxVisible?: number;
+  /** Pre-selected option values and/or prefilled free text. */
+  default?: IActionDefault;
+}
+/**
+ * The user's answer to an {@link IActionRequest}. `answer` carries the selected option values and/or
+ * the typed text; `cancelled` means the user dismissed the request, or no interactive renderer was
+ * available to answer it.
+ */
+type TActionResponse = {
+  type: 'answer';
+  values: readonly string[];
+  text?: string;
+} | {
+  type: 'cancelled';
+};
+/**
+ * The injected "ask the user" port — a single seam reachable by every interaction source (command
+ * execution now; tool execution for model-issued questions later) and rendered per-environment by each
+ * transport. The concurrency model (broadcast to attached interactive channels, first answer wins,
+ * later answers for an already-resolved `id` ignored) is owned by the port implementation, not the
+ * contract.
+ */
+interface IUserInteraction {
+  ask(request: IActionRequest): Promise<TActionResponse>;
 }
 //#endregion
 //#region src/interfaces/tool-search.d.ts
@@ -1363,660 +1402,898 @@ type TToolSearchMode = 'on' | 'off';
  *
  * Narrow on purpose: a tool that can list and load must not be able to register, remove or execute.
  */
-interface IDeferredToolCatalog {
-  /**
-   * Deferred tools not yet loaded — the population a search can still discover. Empty while
-   * deferral is not engaged, because nothing is withheld then.
-   */
-  listDeferredTools(): IToolSchema[];
-  /**
-   * Mark the named deferred tools loaded for the rest of the session and return their schemas. A
-   * resident name is returned as it is (it was never withheld); an unknown name throws, naming the
-   * entry, and then nothing is loaded — the check runs over every name before the first load.
-   */
-  loadDeferredTools(names: readonly string[]): IToolSchema[];
-}
-//#endregion
-//#region src/plugins/event-emitter/types.d.ts
-declare const EXECUTION_EVENT_NAMES: {
-  readonly START: "execution.start";
-  readonly COMPLETE: "execution.complete";
-  readonly ERROR: "execution.error";
-};
-declare const TOOL_EVENT_NAMES: {
-  readonly CALL_START: "tool.call_start";
-  readonly CALL_COMPLETE: "tool.call_complete";
-  readonly CALL_ERROR: "tool.call_error";
-};
-declare const AGENT_EVENT_NAMES: {
-  readonly EXECUTION_START: "agent.execution_start";
-  readonly EXECUTION_COMPLETE: "agent.execution_complete";
-  readonly EXECUTION_ERROR: "agent.execution_error";
-  readonly CREATED: "agent.created";
-};
-type TExecutionEventName = (typeof EXECUTION_EVENT_NAMES)[keyof typeof EXECUTION_EVENT_NAMES];
-type TToolEventName = (typeof TOOL_EVENT_NAMES)[keyof typeof TOOL_EVENT_NAMES];
-type TAgentEventName = (typeof AGENT_EVENT_NAMES)[keyof typeof AGENT_EVENT_NAMES];
-/**
- * Event types that can be emitted.
- *
- * IMPORTANT:
- * - Do not use string literals for event names outside this module.
- * - Import and use EVENT_EMITTER_EVENTS instead.
- */
-declare const EVENT_EMITTER_EVENTS: {
-  readonly EXECUTION_START: "execution.start";
-  readonly EXECUTION_COMPLETE: "execution.complete";
-  readonly EXECUTION_ERROR: "execution.error";
-  readonly TOOL_BEFORE_EXECUTE: "tool.beforeExecute";
-  readonly TOOL_AFTER_EXECUTE: "tool.afterExecute";
-  readonly TOOL_SUCCESS: "tool.success";
-  readonly TOOL_ERROR: "tool.call_error";
-  readonly CONVERSATION_START: "conversation.start";
-  readonly CONVERSATION_COMPLETE: "conversation.complete";
-  readonly CONVERSATION_ERROR: "conversation.error";
-  readonly AGENT_EXECUTION_START: "agent.execution_start";
-  readonly AGENT_EXECUTION_COMPLETE: "agent.execution_complete";
-  readonly AGENT_EXECUTION_ERROR: "agent.execution_error";
-  readonly AGENT_CREATED: "agent.created";
-  readonly AGENT_DESTROYED: "agent.destroyed";
-  readonly PLUGIN_LOADED: "plugin.loaded";
-  readonly PLUGIN_UNLOADED: "plugin.unloaded";
-  readonly PLUGIN_ERROR: "plugin.error";
-  readonly ERROR_OCCURRED: "error.occurred";
-  readonly WARNING_OCCURRED: "warning.occurred";
-  readonly MODULE_INITIALIZE_START: "module.initialize.start";
-  readonly MODULE_INITIALIZE_COMPLETE: "module.initialize.complete";
-  readonly MODULE_INITIALIZE_ERROR: "module.initialize.error";
-  readonly MODULE_EXECUTION_START: "module.execution.start";
-  readonly MODULE_EXECUTION_COMPLETE: "module.execution.complete";
-  readonly MODULE_EXECUTION_ERROR: "module.execution.error";
-  readonly MODULE_DISPOSE_START: "module.dispose.start";
-  readonly MODULE_DISPOSE_COMPLETE: "module.dispose.complete";
-  readonly MODULE_DISPOSE_ERROR: "module.dispose.error";
-  readonly MODULE_REGISTERED: "module.registered";
-  readonly MODULE_UNREGISTERED: "module.unregistered";
-  readonly EXECUTION_HIERARCHY: "execution.hierarchy";
-  readonly EXECUTION_REALTIME: "execution.realtime";
-  readonly TOOL_REALTIME: "tool.realtime";
-  readonly CUSTOM: "custom";
-};
-type TEventName = TExecutionEventName | TToolEventName | TAgentEventName | 'tool.beforeExecute' | 'tool.afterExecute' | 'tool.success' | 'conversation.start' | 'conversation.complete' | 'conversation.error' | 'agent.destroyed' | 'plugin.loaded' | 'plugin.unloaded' | 'plugin.error' | 'error.occurred' | 'warning.occurred' | 'module.initialize.start' | 'module.initialize.complete' | 'module.initialize.error' | 'module.execution.start' | 'module.execution.complete' | 'module.execution.error' | 'module.dispose.start' | 'module.dispose.complete' | 'module.dispose.error' | 'module.registered' | 'module.unregistered' | 'execution.hierarchy' | 'execution.realtime' | 'tool.realtime' | 'custom';
-/**
- * Valid event data value types
- */
-type TEventDataValue = string | number | boolean | Date | null | undefined | TEventDataValue[] | {
-  [key: string]: TEventDataValue;
-};
-/**
- * Event data structure
- */
-interface IEventEmitterEventData {
-  type: TEventName;
-  timestamp: Date;
-  executionId?: string;
-  sessionId?: string;
-  userId?: string;
-  data?: Record<string, TEventDataValue>;
-  error?: Error;
-  metadata?: Record<string, TEventDataValue>;
-}
-/**
- * Event listener function
- */
-type TEventEmitterListener = (event: IEventEmitterEventData) => void | Promise<void>;
-/**
- * Console-like interface for the EventEmitterPlugin.
- *
- * Use this interface for typing instead of the concrete EventEmitterPlugin class.
- */
-interface IEventEmitterPlugin {
-  on(eventType: TEventName, listener: TEventEmitterListener, options?: {
-    once?: boolean;
-    filter?: (event: IEventEmitterEventData) => boolean;
-  }): string;
-  once(eventType: TEventName, listener: TEventEmitterListener, filter?: (event: IEventEmitterEventData) => boolean): string;
-  off(eventType: TEventName, handlerIdOrListener: string | TEventEmitterListener): boolean;
-  emit(eventType: TEventName, eventData?: Partial<IEventEmitterEventData>): Promise<void>;
-}
-//#endregion
-//#region src/abstracts/abstract-module-types.d.ts
-/** Module execution context */
-interface IModuleExecutionContext {
-  executionId?: string;
-  sessionId?: string;
-  userId?: string;
-  agentName?: string;
-  metadata?: Record<string, string | number | boolean | Date>;
-  [key: string]: string | number | boolean | Date | Record<string, string | number | boolean | Date> | undefined;
-}
-/** Module execution result */
-interface IModuleExecutionResult {
-  success: boolean;
-  data?: IModuleResultData;
-  error?: Error;
-  duration?: number;
-  metadata?: Record<string, string | number | boolean | Date>;
-}
-/** Module result data */
-interface IModuleResultData {
-  [key: string]: string | number | boolean | Record<string, string | number | boolean> | undefined;
-}
-/** Base module options */
-interface IBaseModuleOptions {
-  enabled?: boolean;
-  config?: Record<string, string | number | boolean>;
-}
-/** Module capabilities */
-interface IModuleCapabilities {
-  capabilities: string[];
-  dependencies?: string[];
-  optionalDependencies?: string[];
-}
-/** Module type descriptor */
-interface IModuleDescriptor {
-  type: string;
-  category: ModuleCategory;
-  layer: ModuleLayer;
-  dependencies?: string[];
-  capabilities?: string[];
-}
-/** Module categories */
-declare enum ModuleCategory {
-  CORE = "core",
-  STORAGE = "storage",
-  PROCESSING = "processing",
-  INTEGRATION = "integration",
-  INTERFACE = "interface",
-  CAPABILITY = "capability"
-}
-/** Module layers */
-declare enum ModuleLayer {
-  INFRASTRUCTURE = "infrastructure",
-  CORE = "core",
-  APPLICATION = "application",
-  DOMAIN = "domain",
-  PRESENTATION = "presentation"
-}
-/** Module data for introspection */
-interface IModuleData {
-  name: string;
-  version: string;
-  type: string;
-  enabled: boolean;
-  initialized: boolean;
-  capabilities: IModuleCapabilities;
-  metadata?: Record<string, string | number | boolean>;
-}
-/** Module statistics */
-interface IModuleStats {
-  enabled: boolean;
-  initialized: boolean;
-  executionCount: number;
-  errorCount: number;
-  lastActivity?: Date;
-  averageExecutionTime?: number;
-  [key: string]: string | number | boolean | Date | undefined;
-}
-/** Type-safe module interface */
-interface IModule<TOptions extends IBaseModuleOptions = IBaseModuleOptions, TStats = IModuleStats> {
-  name: string;
-  version: string;
-  enabled: boolean;
-  initialize(options?: TOptions, eventEmitter?: IEventEmitterPlugin): Promise<void>;
-  dispose?(): Promise<void>;
-  execute?(context: IModuleExecutionContext): Promise<IModuleExecutionResult>;
-  getModuleType(): IModuleDescriptor;
-  getCapabilities(): IModuleCapabilities;
-  getData?(): IModuleData;
-  getStats?(): TStats;
-  isEnabled(): boolean;
-  isInitialized(): boolean;
+interface IDeferredToolCatalog {
+  /**
+   * Deferred tools not yet loaded — the population a search can still discover. Empty while
+   * deferral is not engaged, because nothing is withheld then.
+   */
+  listDeferredTools(): IToolSchema[];
+  /**
+   * Mark the named deferred tools loaded for the rest of the session and return their schemas. A
+   * resident name is returned as it is (it was never withheld); an unknown name throws, naming the
+   * entry, and then nothing is loaded — the check runs over every name before the first load.
+   */
+  loadDeferredTools(names: readonly string[]): IToolSchema[];
 }
 //#endregion
-//#region src/event-service/interfaces.d.ts
+//#region src/interfaces/tool.d.ts
+/** Awaited host admission for effective parameters, immediately before a tool body. */
+type TToolEffectAdmission<TParameters = TToolParameters> = (parameters: TParameters) => Promise<void>;
+type TToolContextExtensionValue = TUniversalValue | Date | Error | TLoggerData | TContextData | TToolParameters | TToolMetadata;
 /**
- * @fileoverview Event service interface definitions.
+ * Tool metadata structure - specific type definition
+ */
+type TToolMetadata = Record<string, string | number | boolean | string[] | number[] | boolean[] | TToolParameters>;
+/**
+ * Tool execution data - domain payload for tool results.
  *
- * These interfaces are the single source of truth for event-related contracts
- * within @robota-sdk/agent-core.
+ * IMPORTANT:
+ * - This must support structured tool outputs without resorting to `any`.
+ * - Prefer `ToolResultData` (derived from the canonical `UniversalValue` axis).
  */
 /**
- * Primitive value types for event payloads.
+ * Tool execution result - extended for ToolExecutionData compatibility
  */
-type TEventPrimitiveValue = string | number | boolean | null | undefined;
+interface IToolResult {
+  success: boolean;
+  data?: TUniversalValue;
+  error?: string;
+  metadata?: TToolMetadata;
+  [key: string]: TToolContextExtensionValue | undefined;
+}
 /**
- * Recursive universal value type for event payloads (JSON-like + Date).
+ * Enhanced tool execution result with additional metadata
  */
-type TEventUniversalValue = TEventPrimitiveValue | Date | TEventUniversalValue[] | IEventObjectValue;
-interface IEventObjectValue {
-  [key: string]: TEventUniversalValue;
+interface IToolExecutionResult {
+  /** Whether execution was successful */
+  success: boolean;
+  /** Tool name that was executed */
+  toolName?: string;
+  /** Execution result or data */
+  result?: TUniversalValue;
+  /** Error message if execution failed */
+  error?: string;
+  /** Execution duration in milliseconds */
+  duration?: number;
+  /** Unique execution ID */
+  executionId?: string;
+  /** Additional metadata */
+  metadata?: TToolMetadata;
 }
 /**
- * Logger data type for event metadata.
+ * Tool execution context - type-safe context for tool execution
+ * Enhanced with hierarchical execution tracking support
  */
-type TEventLoggerData = Record<string, TEventUniversalValue | Date | Error>;
+interface IToolExecutionContext {
+  toolName: string;
+  parameters: TToolParameters;
+  /** Runtime-owned barrier, consumed after permission and before entering the tool. */
+  beforeToolEffect?: TToolEffectAdmission;
+  /** Journaled pre-effect request/response port for admission-aware runtime wrappers. */
+  continuation?: IToolContinuation;
+  /**
+   * Run-scoped cancellation signal (CORE-018). Long-running tools MUST honor it: terminate
+   * the underlying work (kill the child process, abort the network request) and return an
+   * interrupted/failed result. Completing silently after an abort is a contract violation.
+   */
+  signal?: AbortSignal;
+  /** Direct remote calls deny decisions that would require human interaction. */
+  permissionInteraction?: 'interactive' | 'deny';
+  executionId?: string;
+  userId?: string;
+  sessionId?: string;
+  metadata?: TToolMetadata;
+  /** Parent execution ID for hierarchical tool execution tracking */
+  parentExecutionId?: string;
+  /** Root execution ID (Team/Agent level) for complete execution tree tracking */
+  rootExecutionId?: string;
+  /** Execution depth level (0: Team, 1: Agent, 2: Tool, etc.) */
+  executionLevel?: number;
+  /** Execution path array showing the complete execution hierarchy */
+  executionPath?: string[];
+  /** Real-time execution data for accurate tracking (no simulation) */
+  realTimeData?: {
+    /** Actual execution start time */
+    startTime: Date;
+    /** Actual input parameters passed to the tool */
+    actualParameters: TToolParameters;
+    /** Tool-provided estimated duration (optional) */
+    estimatedDuration?: number;
+  };
+  /**
+   * Additional tool execution context extensions.
+   *
+   * IMPORTANT:
+   * - Avoid ad-hoc top-level fields to keep the contract stable.
+   * - Use this map for forward-compatible extra data with constrained value types.
+   */
+  extensions?: Record<string, TToolContextExtensionValue>;
+  /** Owner context propagated from EventService */
+  ownerType?: string;
+  ownerId?: string;
+  ownerPath?: IOwnerPathSegment[];
+  sourceId?: string;
+  /**
+   * Tool-call scoped EventService instance.
+   * Caller (ExecutionService/ToolExecutionService) is responsible for providing
+   * an ownerPath-bound EventService for this tool call.
+   */
+  eventService?: IEventService;
+  /**
+   * Unbound base EventService instance.
+   *
+   * Required when a tool needs to create another owner-bound EventService
+   * for a different owner (e.g., creating an agent from a tool call).
+   *
+   * NOTE: Do not wrap an already owner-bound EventService to bind a different owner.
+   * Owner-bound instances must not be layered across different owners.
+   */
+  baseEventService?: IEventService;
+  /**
+   * The service this call's caller would give the tool with `setEventService`, carried with the
+   * call instead. One tool instance can serve several agents, and the service set on it is
+   * whichever agent set one last; a tool that emits events of its own (the `FunctionTool` span)
+   * emits them here when present, so they reach the agent that made the call. The no-op default
+   * service means that caller wants none.
+   */
+  instanceEventService?: IEventService;
+  /**
+   * Injected "ask the user" port (CMD-004). Present when an interactive renderer is attached, letting
+   * a tool solicit a structured answer from the user (the model-issued question seam consumed by
+   * CMD-005). Absent in non-interactive contexts; a tool that asks must treat absence as "no human
+   * available" (never a silent guess).
+   */
+  ask?: IUserInteraction['ask'];
+  /**
+   * CLI-1990: the deferred-tool catalog the runtime injects (`ToolExecutionService`), so a search
+   * tool can list what is withheld and load it for the rest of the session. Present on every tool
+   * call the execution loop issues; a tool other than the search tool has no reason to read it.
+   */
+  deferredTools?: IDeferredToolCatalog;
+  /**
+   * The ID core mints for this one tool body, unique even when a vendor reuses its tool call ID.
+   * The body's exported span is derived from it, so it is also what a propagated parent names.
+   */
+  toolBodyId?: string;
+  /**
+   * Present only when the run carries trusted trace context: the `traceparent` naming this body's
+   * span and the exact origins it may be sent to. A tool that makes outbound requests sends it only
+   * to a listed origin.
+   */
+  outboundTraceContext?: IOutboundTraceContext;
+  /**
+   * Present only when the host lets shell children inherit the trace: the environment naming this
+   * body's span. Only the foreground shell tool applies it, to its own child.
+   */
+  shellTraceEnv?: ISubprocessTraceEnv;
+  /**
+   * Present only when the host lets command hooks inherit the trace: the environment naming the
+   * prompt root, for the hooks fired around this body. Separate from {@link shellTraceEnv}, whose
+   * span is the body's own.
+   */
+  hookTraceEnv?: ISubprocessTraceEnv;
+}
 /**
- * A single segment in an explicit ownerPath.
- *
- * Path-only rule:
- * - Relationships must be derived from these explicit segments, not from parsing IDs.
+ * Parameter validation result
  */
-interface IOwnerPathSegment {
-  type: string;
-  id: string;
+interface IParameterValidationResult {
+  /** Whether parameters are valid */
+  isValid: boolean;
+  /** Validation error messages */
+  errors: string[];
 }
 /**
- * Event context that accompanies an emitted event.
- * This is the single source of truth for deterministic linking in subscribers.
+ * Generic tool executor function
  */
-interface IEventContext {
-  ownerType: string;
-  ownerId: string;
-  ownerPath: IOwnerPathSegment[];
-  /** Depth of the current execution in the hierarchy (0 = root) */
-  depth?: number;
-  /** Unique span identifier for distributed tracing correlation */
-  spanId?: string;
-  /** Optional structured metadata for debugging/observability */
-  metadata?: TEventLoggerData;
+type TToolExecutor<TParams = TToolParameters, TResult = TUniversalValue> = (parameters: TParams, context?: IToolExecutionContext) => Promise<TResult>;
+/**
+ * Base tool interface
+ */
+interface ITool {
+  /** Tool schema */
+  schema: IToolSchema;
+  /**
+   * Execute the tool with given parameters
+   */
+  execute(parameters: TToolParameters, context?: IToolExecutionContext): Promise<IToolResult>;
+  /**
+   * Validate tool parameters
+   */
+  validate(parameters: TToolParameters): boolean;
+  /**
+   * Validate tool parameters with detailed result
+   */
+  validateParameters(parameters: TToolParameters): IParameterValidationResult;
+  /**
+   * Get tool description
+   */
+  getDescription(): string;
 }
 /**
- * Allowed extension values for event payloads.
+ * Function tool implementation
  */
-type TEventExtensionValue = TEventUniversalValue | TEventLoggerData | Error | IEventContext | IOwnerPathSegment[];
+interface IFunctionTool extends ITool {
+  /** Function to execute */
+  fn: TToolExecutor;
+}
 /**
- * Base event payload shape.
- * Emitters may add additional fields, but MUST keep linkage information explicit.
+ * Tool registry interface
  */
-interface IBaseEventData {
-  /** Timestamp when the event was emitted. This is required for deterministic ordering. */
-  timestamp: Date;
-  /** Optional structured metadata */
-  metadata?: TEventLoggerData;
-  /** Extensible fields for event-specific payloads */
-  [key: string]: TEventExtensionValue | undefined;
+interface IToolRegistry {
+  /**
+   * Register a tool
+   */
+  register(tool: ITool): void;
+  /**
+   * Unregister a tool
+   */
+  unregister(name: string): void;
+  /**
+   * Get tool by name
+   */
+  get(name: string): ITool | undefined;
+  /**
+   * Get all registered tools
+   */
+  getAll(): ITool[];
+  /**
+   * Get tool schemas
+   */
+  getSchemas(): IToolSchema[];
+  /**
+   * Check if tool exists
+   */
+  has(name: string): boolean;
+  /**
+   * Clear all tools
+   */
+  clear(): void;
+}
+//#endregion
+//#region src/interfaces/execution-journal.d.ts
+/** Data-only provider options; callbacks, signals, tracing and adapter credentials are excluded. */
+type TJournalModelOptions = Pick<IChatOptions, 'model' | 'tools' | 'maxTokens' | 'temperature' | 'effort' | 'toolChoice' | 'nativeWebTools' | 'responseFormat'>;
+interface IJournalIdentity {
+  recordId: string;
+  executionId: string;
+}
+interface IJournalModelIdentity {
+  callId: string;
+  providerId: string;
+  modelId: string;
+}
+interface IJournalActionIdentity {
+  actionId: string;
+  parentCallId: string;
+  toolCallId: string;
+  toolName: string;
 }
-/**
- * Execution-related event payload.
- */
-interface IExecutionEventData extends IBaseEventData {}
-/**
- * Tool-related event payload.
- */
-interface IToolEventData extends IBaseEventData {
-  toolName?: string;
-  parameters?: Record<string, TEventUniversalValue>;
+interface IExecutionContinuationState {
+  version: 1;
+  kind: 'round' | 'summary';
+  startedAt: string;
+  turnMessageId: string;
+  model: Pick<IChatOptions, 'maxTokens' | 'temperature' | 'effort' | 'toolChoice'> & {
+    provider: string;
+    model: string;
+    topP?: number;
+  };
+  timeout?: number;
+  toolSearch?: TToolSearchSetting;
+  structuredOutput: boolean;
+  /** Versioned data contract; runtime callbacks and signals are supplied by the recovering host. */
+  options: Pick<IChatOptions, 'maxTokens' | 'temperature' | 'toolChoice'> & {
+    maxExecutionRounds: number;
+    maxSameToolInputs?: number;
+    allowToolOnlyCompletion: boolean;
+    withholdHostedTools: boolean;
+    ephemeralSystemContext?: string;
+    sessionId?: string;
+    userId?: string;
+    metadata?: TMetadata;
+  };
+  toolsExecuted: string[];
+  consecutiveUnknownToolFailureRounds: number;
+  forcedSummaryInstruction?: string;
+  loadedDeferredTools?: string[];
+}
+/** Canonical private history, separate from transformed/ephemeral provider input. */
+interface IExecutionRoundCheckpoint {
+  version: 1;
+  effectAdmission: 'required';
+  messages: TUniversalMessage[];
+  round: number;
+  contextLimit: number;
+  cumulativeInputTokens: number;
+  sameToolInputCounts: Array<[string, number]>;
+  maxSameToolInputs?: number;
+  continuation?: IExecutionContinuationState;
+  /** Versioned state belonging to a runtime wrapper, never inferred from transcript text. */
+  owner?: {
+    kind: string;
+    version: number;
+    state: TToolParameters;
+  };
 }
-/**
- * Agent-related event payload.
- */
-interface IAgentEventData extends IBaseEventData {
-  agentId?: string;
+type TExecutionJournalRecord = IJournalIdentity & ((IJournalModelIdentity & {
+  kind: 'model-request';
+  messages: TUniversalMessage[];
+  options: TJournalModelOptions;
+  checkpoint?: IExecutionRoundCheckpoint;
+}) | (IJournalModelIdentity & {
+  kind: 'model-response';
+  response: TUniversalMessage;
+}) | (IJournalModelIdentity & {
+  kind: 'model-cache-hit';
+  response: TUniversalMessage;
+  checkpoint?: IExecutionRoundCheckpoint;
+}) | (IJournalModelIdentity & {
+  kind: 'model-failure';
+  error: {
+    name: string;
+    message: string;
+  };
+}) | (IJournalActionIdentity & {
+  kind: 'tool-intent';
+  parameters: TToolParameters;
+}) | (IJournalActionIdentity & {
+  kind: 'tool-dispatch';
+}) | (IJournalActionIdentity & {
+  kind: 'tool-effect-start';
+  parameters: TToolParameters;
+}) | (IJournalActionIdentity & {
+  kind: 'tool-wait';
+  request: IToolContinuationPrompt & {
+    requestId: string;
+  };
+}) | (IJournalActionIdentity & {
+  kind: 'tool-response';
+  response: IToolWaitResponse;
+}) | (IJournalActionIdentity & {
+  kind: 'tool-result';
+  result: IToolExecutionResult;
+  loadedDeferredTools?: string[];
+}));
+/**
+ * Awaited, fail-closed execution boundary. Rejection stops this run before further dispatch.
+ * The host owns storage, serialization of message dates, idempotency and recovery decisions.
+ * Model records describe an adapter invocation, not its opaque retries or network requests.
+ * Only a supported mandatory-effect checkpoint can prove an unstarted action; an intent alone cannot.
+ */
+interface IExecutionJournal {
+  append(record: TExecutionJournalRecord): Promise<void>;
+}
+/**
+ * Reads the complete, ordered, current prefix from the same authority used for append.
+ * The host must hold exclusive fenced ownership and drain the old runtime before recovery.
+ * Appending an identical recordId is idempotent; conflicting content must be rejected.
+ */
+interface IRecoverableExecutionJournal extends IExecutionJournal {
+  read(executionId: string): Promise<readonly TExecutionJournalRecord[]>;
+}
+interface IResumeToolCallsOptions {
+  executionId: string;
+  callId: string;
+  journal: IRecoverableExecutionJournal;
+  /** Exact replies to saved requests; receipts are persisted before further execution. */
+  toolResponses?: readonly IToolWaitResponse[];
+  signal?: AbortSignal;
+  /** Observe newly committed recovery history using the ordinary history-mutation contract. */
+  onExecutionEvent?: (event: string, data: Record<string, unknown>) => void;
 }
-type TEventListener = (eventType: string, data: IBaseEventData, context?: IEventContext) => void;
 /**
- * Minimal EventService contract for emitting events.
+ * Continue the latest settled invocation on the original provider/model under exclusive host ownership.
+ * Structured-output validators and unknown effects require reconciliation rather than automatic replay.
+ * Turn-level lifecycle hooks are omitted because their effects have no durable receipts;
+ * hosts requiring those effects must settle them separately. Recovered history remains available.
  */
-interface IEventService {
-  emit(eventType: string, data: IBaseEventData, context?: IEventContext): void;
-  subscribe(listener: TEventListener): void;
-  unsubscribe(listener: TEventListener): void;
+interface IResumeExecutionOptions extends Omit<IResumeToolCallsOptions, 'callId'> {
+  onTextDelta?: IChatOptions['onTextDelta'];
+  traceContext?: IRunTraceContext;
 }
-/**
- * Explicit owner binding information used for scoped event emission.
- */
-interface IEventServiceOwnerBinding {
-  ownerType: string;
-  ownerId: string;
-  ownerPath: IOwnerPathSegment[];
+interface IResumeToolCallsResult {
+  executionId: string;
+  callId: string;
+  messages: TUniversalMessage[];
+}
+/** Host-owned identity for a journaled provider invocation, including routing changes. */
+interface IModelJournalContext {
+  journal: IExecutionJournal;
+  executionId: string;
+  callId: string;
+  checkpoint?: IExecutionRoundCheckpoint;
+  route(): {
+    providerId: string;
+    modelId: string;
+  };
 }
 //#endregion
-//#region src/event-service/event-service.d.ts
+//#region src/interfaces/cache.d.ts
 /**
- * Abstract base for event services.
- * Concrete implementations decide how events are delivered.
+ * Cache key identifying a unique LLM execution request
  */
-declare abstract class AbstractEventService implements IEventService {
-  private listeners;
-  abstract emit(eventType: string, data: IBaseEventData, context?: IEventContext): void;
-  subscribe(listener: TEventListener): void;
-  unsubscribe(listener: TEventListener): void;
-  protected notifyListeners(eventType: string, data: IBaseEventData, context?: IEventContext): void;
+interface ICacheKey {
+  /** SHA-256 hash of the serialized request */
+  hash: string;
+  /** Model identifier */
+  model: string;
+  /** Provider name */
+  provider: string;
 }
 /**
- * Default no-op event service (production-safe).
- * When injected, emit() intentionally does nothing.
+ * Cached LLM response entry
  */
-declare class DefaultEventService extends AbstractEventService {
-  emit(_eventType: string, _data: IBaseEventData, _context?: IEventContext): void;
+interface ICacheEntry {
+  /** Cache key that produced this entry */
+  key: ICacheKey;
+  /** Cached response content */
+  response: string;
+  /** When the entry was cached */
+  timestamp: number;
+  /** SHA-256 integrity hash of the response */
+  integrityHash: string;
 }
 /**
- * Singleton default event service instance.
- */
-declare const DEFAULT_ABSTRACT_EVENT_SERVICE: IEventService;
-/**
- * Check if a given service is the default no-op implementation.
- */
-declare function isDefaultEventService(service: IEventService): boolean;
-/**
- * Compose a full event name from owner prefix and local name.
- * Local names must not contain dots.
- */
-declare function composeEventName(ownerType: string, localName: string): string;
-/**
- * Generate a unique span ID for distributed tracing correlation. Exported so a per-operation timing
- * source (SELFHOST-004) can mint a span id it puts on BOTH the event payload and the event context.
- */
-declare function generateSpanId(): string;
-/**
- * A scoped event service that always emits with an owner binding applied.
+ * Cache storage interface for pluggable backends
  */
-declare class StructuredEventService extends AbstractEventService {
-  private readonly base;
-  private readonly binding;
-  constructor(base: IEventService, binding: IEventServiceOwnerBinding);
-  emit(eventType: string, data: IBaseEventData, context?: IEventContext): void;
-  subscribe(listener: TEventListener): void;
-  unsubscribe(listener: TEventListener): void;
+interface ICacheStorage {
+  /** Retrieve a cached entry by key hash */
+  get(hash: string): ICacheEntry | undefined;
+  /** Store a cache entry */
+  set(entry: ICacheEntry): void;
+  /** Delete a cached entry by key hash */
+  delete(hash: string): boolean;
+  /** Clear all cached entries */
+  clear(): void;
+  /** Get cache statistics */
+  getStats(): ICacheStats;
 }
 /**
- * Bind an EventService to an explicit owner path.
- * This is the standard entry point for scoped emission (path-only architecture).
- */
-declare function bindWithOwnerPath(base: IEventService, binding: IEventServiceOwnerBinding): IEventService;
-/**
- * Alias for bindWithOwnerPath for historical call sites.
- * Intentionally forwards to the single authoritative implementation.
+ * Cache performance statistics
  */
-declare function bindEventServiceOwner(base: IEventService, binding: IEventServiceOwnerBinding): IEventService;
+interface ICacheStats {
+  /** Number of cache hits */
+  hits: number;
+  /** Number of cache misses */
+  misses: number;
+  /** Current number of cached entries */
+  entries: number;
+  /** Hit rate (hits / (hits + misses)), 0 if no lookups */
+  hitRate: number;
+}
 /**
- * Observable EventService that notifies subscribed listeners.
+ * Configuration options for execution caching
  */
-declare class ObservableEventService extends AbstractEventService {
-  emit(eventType: string, data: IBaseEventData, context?: IEventContext): void;
+interface ICacheOptions {
+  /** Whether caching is enabled */
+  enabled: boolean;
+  /** Maximum number of cached entries */
+  maxEntries: number;
+  /** Time-to-live in milliseconds */
+  ttlMs: number;
 }
 //#endregion
-//#region src/event-service/task-events.d.ts
-declare const TASK_EVENTS: {
-  readonly ASSIGNED: "assigned";
-  readonly COMPLETED: "completed";
-};
-declare const TASK_EVENT_PREFIX: "task";
-//#endregion
-//#region src/event-service/user-events.d.ts
-declare const USER_EVENTS: {
-  readonly MESSAGE: "message";
-  readonly INPUT: "input";
-};
-declare const USER_EVENT_PREFIX: "user";
-type TUserEvent = (typeof USER_EVENTS)[keyof typeof USER_EVENTS];
-//#endregion
-//#region src/event-service/span-events.d.ts
+//#region src/interfaces/response-format.d.ts
 /**
- * SELFHOST-004: per-operation span lifecycle event names. Mirrors the `TASK_EVENTS`/`USER_EVENTS`
- * pattern (a const name set + a prefix). The local name is distinctive (`span_completed`, not a bare
- * `completed`) so a consumer can identify a span-completion regardless of the emitting owner's prefix.
+ * Response format configuration
  */
-declare const SPAN_EVENTS: {
-  readonly COMPLETED: "span_completed";
-};
-/** Content-free completion of one provider round, separate from legacy tool timing events. */
-declare const PROVIDER_CALL_EVENTS: {
-  readonly COMPLETED: "provider_call_completed";
-};
-/** A provider request moved to another model after the one it was on failed. */
-declare const PROVIDER_FALLBACK_EVENTS: {
-  readonly SWITCHED: "provider_fallback";
-};
-/** The notice a `provider_fallback` event carries, or `undefined` when the payload is malformed. */
-declare function readModelFallbackNotice(data: Readonly<Record<string, unknown>>): IModelFallbackNotice | undefined;
-/** Content-free completion of the body actually awaited by one permitted tool call. */
-declare const TOOL_BODY_EVENTS: {
-  readonly COMPLETED: "tool_body_completed";
-};
-/** Content-free decision reached for one tool call before any body runs. */
-declare const TOOL_PERMISSION_EVENTS: {
-  readonly DECIDED: "tool_permission_decided";
-};
-declare const SPAN_EVENT_PREFIX: "span";
-type TSpanEvent = (typeof SPAN_EVENTS)[keyof typeof SPAN_EVENTS];
+interface IResponseFormatConfig {
+  type?: 'text' | 'json_object' | 'json_schema';
+  /** JSON schema payload; required when `type` is `'json_schema'` (CORE-015). */
+  schema?: Record<string, TConfigValue>;
+  /** Schema name forwarded to provider native structured-output surfaces. */
+  name?: string;
+}
 /**
- * SELFHOST-004: span-completion event payload — JOINS the span id with its measured duration and the
- * operation name (raw scalars ONLY; references no transport type). Emitted by the per-operation timing
- * source (e.g. `FunctionTool`) so a consuming layer (`agent-framework`) can build a record span entry
- * WITHOUT `agent-core` depending on `agent-interface-transport` (no cycle). The payload `spanId` is the
- * AUTHORITATIVE id a consumer reads; owner/turn correlation is applied by the event service's binding
- * (`ownerPath` on the emitted `IEventContext`). Note the context's own auto-minted `spanId` is a
- * separate scope tag and need not equal this payload id — always read the payload id for the span.
+ * Safety setting configuration
  */
-interface ISpanCompletionEventData extends IBaseEventData {
-  /** The span id (equals the emitted event's context `spanId`). */
-  spanId: string;
-  /** Measured wall-clock duration of the operation, in milliseconds. */
-  durationMs: number;
-  /** The operation name (e.g. the tool name). */
-  op: string;
+interface ISafetySetting {
+  category: string;
+  threshold: string;
+  [key: string]: TConfigValue;
+}
+//#endregion
+//#region src/schema/zod-schema-types.d.ts
+interface IZodParseResult {
+  success: boolean;
+  data?: unknown;
+  error?: unknown;
+}
+interface IZodSchemaDef {
+  typeName?: string;
+  innerType?: IZodSchema;
+  valueType?: IZodSchema;
+  checks?: Array<{
+    kind: string;
+    value?: TUniversalValue;
+  }>;
+  shape?: () => Record<string, IZodSchema>;
+  type?: IZodSchema;
+  /**
+   * `ZodEnum` holds an ARRAY here; `ZodNativeEnum` holds the enum OBJECT itself (CORE-041). One Zod
+   * field name, two shapes — the converter narrows before reading it.
+   */
+  values?: TUniversalValue[] | Record<string, TUniversalValue>;
+  description?: string;
+  unknownKeys?: 'passthrough' | 'strip' | 'strict';
+  /** `ZodEffects` (`.refine()` / `.transform()`) holds the schema it wraps here. */
+  schema?: IZodSchema;
+  /** `ZodUnion` / `ZodDiscriminatedUnion` members. */
+  options?: IZodSchema[];
+  /** `ZodLiteral` value. */
+  value?: TUniversalValue;
+}
+interface IZodSchema {
+  parse(value: unknown): unknown;
+  safeParse(value: unknown): IZodParseResult;
+  _def?: IZodSchemaDef;
 }
-//#endregion
-//#region src/interfaces/tool.d.ts
-type TToolContextExtensionValue = TUniversalValue | Date | Error | TLoggerData | TContextData | TToolParameters | TToolMetadata;
 /**
- * Tool metadata structure - specific type definition
+ * Schema conversion options
  */
-type TToolMetadata = Record<string, string | number | boolean | string[] | number[] | boolean[] | TToolParameters>;
+interface ISchemaConversionOptions {
+  includeDescription?: boolean;
+  strictTypes?: boolean;
+  allowAdditionalProperties?: boolean;
+}
+//#endregion
+//#region src/schema/structured-output.d.ts
+/** Explicit raw-JSON-schema form of `IRunOptions.output`. */
+interface IJsonSchemaOutput {
+  /** JSON Schema (object root, universal subset) the response must match. */
+  jsonSchema: IToolSchema['parameters'];
+  /** Optional schema name forwarded to provider native surfaces. */
+  name?: string;
+}
+/** Accepted `IRunOptions.output` values: a Zod schema or an explicit JSON-schema wrapper. */
+type TStructuredOutputSchema = IZodSchema | IJsonSchemaOutput;
+type TStructuredOutputValidation = {
+  success: true;
+  value: unknown;
+} | {
+  success: false;
+  issues: string[];
+};
+/** Internal SSOT representation every `output` value normalizes to. */
+interface IStructuredOutputSpec {
+  name: string;
+  jsonSchema: IToolSchema['parameters'];
+  validate(value: unknown): TStructuredOutputValidation;
+}
+/** Normalize an accepted `output` value into the internal spec. */
+declare function normalizeStructuredOutput(output: TStructuredOutputSchema): IStructuredOutputSpec;
 /**
- * Tool execution data - domain payload for tool results.
+ * Validate a value against the universal JSON-schema subset (`IParameterSchema`). Covers type,
+ * required, enum, items, nested properties, unions and numeric bounds — the full expressible
+ * surface of the subset, at every level.
  *
- * IMPORTANT:
- * - This must support structured tool outputs without resorting to `any`.
- * - Prefer `ToolResultData` (derived from the canonical `UniversalValue` axis).
+ * CORE-039: this is the ONE complete walk. `parameter-validator` delegates its depth here rather
+ * than keeping a second, shallower copy, and the two must therefore agree by construction.
  */
+declare function validateAgainstJsonSchema(schema: IParameterSchema, value: unknown, path: string): string[];
 /**
- * Tool execution result - extended for ToolExecutionData compatibility
+ * Parse the model's final text into a JSON value. Tolerates a fenced
+ * ```json code block wrapper (providers without native enforcement commonly
+ * emit one); the parsed value is still strictly schema-validated afterwards.
  */
-interface IToolResult {
-  success: boolean;
-  data?: TUniversalValue;
-  error?: string;
-  metadata?: TToolMetadata;
-  [key: string]: TToolContextExtensionValue | undefined;
-}
+declare function parseStructuredResponseText(text: string): {
+  success: true;
+  value: unknown;
+} | {
+  success: false;
+  issue: string;
+};
+//#endregion
+//#region src/interfaces/run-options.d.ts
 /**
- * Enhanced tool execution result with additional metadata
+ * The per-RUN contract: what one `run()` may override or observe, as distinct from the agent's
+ * standing configuration in `IAgentConfig`.
+ *
+ * Split out of `agent.ts` when PEER-007 added `driverId`. That file sits at a frozen size baseline,
+ * and the anti-monolith rule asks for a split rather than one more field on a file already at its
+ * limit. The two execution-event types come along because `onExecutionEvent` is their only consumer
+ * — leaving them behind would have made this module import back from `agent.ts`.
  */
-interface IToolExecutionResult {
-  /** Whether execution was successful */
-  success: boolean;
-  /** Tool name that was executed */
-  toolName?: string;
-  /** Execution result or data */
-  result?: TUniversalValue;
-  /** Error message if execution failed */
-  error?: string;
-  /** Execution duration in milliseconds */
-  duration?: number;
-  /** Unique execution ID */
-  executionId?: string;
-  /** Additional metadata */
-  metadata?: TToolMetadata;
-}
+type TExecutionEventData = Record<string, unknown>;
+type TExecutionEventCallback = (event: string, data: TExecutionEventData) => void;
 /**
- * Tool execution context - type-safe context for tool execution
- * Enhanced with hierarchical execution tracking support
+ * Agent run options - type-safe interface for all agent execution options
  */
-interface IToolExecutionContext {
-  toolName: string;
-  parameters: TToolParameters;
+interface IRunOptions {
+  /** Run-scoped temperature override — wins over `defaultModel.temperature` (CORE-016). */
+  temperature?: number;
+  /** Run-scoped max output tokens override — wins over `defaultModel.maxTokens` (CORE-016). */
+  maxTokens?: number;
   /**
-   * Run-scoped cancellation signal (CORE-018). Long-running tools MUST honor it: terminate
-   * the underlying work (kill the child process, abort the network request) and return an
-   * interrupted/failed result. Completing silently after an abort is a contract violation.
+   * Run-scoped tool-invocation directive — wins over `defaultModel.toolChoice` (CORE-017).
+   * `'auto'` (model decides), `'none'` (suppress tool calls), `'required'` (must call some
+   * tool), or `{ tool: name }` (must call the named tool; the name is validated against the
+   * run's tool list and a miss throws). Forcing applies to the run's first model call only;
+   * rounds after tool results revert to `'auto'` (see `TToolChoice`).
    */
-  signal?: AbortSignal;
-  /** Direct remote calls deny decisions that would require human interaction. */
-  permissionInteraction?: 'interactive' | 'deny';
-  executionId?: string;
-  userId?: string;
+  toolChoice?: TToolChoice;
+  /**
+   * Leave a provider's own hosted tools (a vendor-run web search) out of this run's requests. They
+   * run at the vendor and never pass the permission gate, so a run whose tools a policy restricts
+   * must not reach them.
+   */
+  withholdHostedTools?: boolean;
   sessionId?: string;
-  metadata?: TToolMetadata;
-  /** Parent execution ID for hierarchical tool execution tracking */
-  parentExecutionId?: string;
-  /** Root execution ID (Team/Agent level) for complete execution tree tracking */
-  rootExecutionId?: string;
-  /** Execution depth level (0: Team, 1: Agent, 2: Tool, etc.) */
-  executionLevel?: number;
-  /** Execution path array showing the complete execution hierarchy */
-  executionPath?: string[];
-  /** Real-time execution data for accurate tracking (no simulation) */
-  realTimeData?: {
-    /** Actual execution start time */
-    startTime: Date;
-    /** Actual input parameters passed to the tool */
-    actualParameters: TToolParameters;
-    /** Tool-provided estimated duration (optional) */
-    estimatedDuration?: number;
-  };
+  userId?: string;
   /**
-   * Additional tool execution context extensions.
-   *
-   * IMPORTANT:
-   * - Avoid ad-hoc top-level fields to keep the contract stable.
-   * - Use this map for forward-compatible extra data with constrained value types.
+   * PEER-007 (issue #1915): who this run is attributed to, for display. Per-run because it changes
+   * per turn — one session serves the operator and any peer addressing it. Never authorization.
    */
-  extensions?: Record<string, TToolContextExtensionValue>;
-  /** Owner context propagated from EventService */
-  ownerType?: string;
-  ownerId?: string;
-  ownerPath?: IOwnerPathSegment[];
-  sourceId?: string;
+  driverId?: string;
   /**
-   * Tool-call scoped EventService instance.
-   * Caller (ExecutionService/ToolExecutionService) is responsible for providing
-   * an ownerPath-bound EventService for this tool call.
+   * Where this run's turn came from (a peer's message, an external event, an agent wake-up), stored
+   * beside `driverId` on the user message so a transcript carried elsewhere still says it. Display
+   * only, like `driverId`; absent for the operator's own turn.
    */
-  eventService?: IEventService;
+  turnSource?: string;
+  metadata?: TMetadata;
   /**
-   * Unbound base EventService instance.
-   *
-   * Required when a tool needs to create another owner-bound EventService
-   * for a different owner (e.g., creating an agent from a tool call).
-   *
-   * NOTE: Do not wrap an already owner-bound EventService to bind a different owner.
-   * Owner-bound instances must not be layered across different owners.
+   * Run-scoped EPHEMERAL system context (SELFHOST-008 P3). A transient system-role block included in THIS
+   * run's provider request(s) only — it is **never written to the conversation store**. An explicitly
+   * configured execution journal records it as request/recovery state. It does not bloat conversation
+   * history or force a static-system-prompt rebuild. Content-free neutral channel: the
+   * caller decides what to put here (e.g. per-turn recalled memory). Absent ⇒ no change.
    */
-  baseEventService?: IEventService;
+  ephemeralSystemContext?: string;
   /**
-   * Injected "ask the user" port (CMD-004). Present when an interactive renderer is attached, letting
-   * a tool solicit a structured answer from the user (the model-issued question seam consumed by
-   * CMD-005). Absent in non-interactive contexts; a tool that asks must treat absence as "no human
-   * available" (never a silent guess).
+   * Host-owned trace context for this run's provider calls. Each invoked call — forced summary
+   * included, cache hits excluded — gets a `traceparent` whose parent is that call's own span, and
+   * only an adapter whose origin is listed sends it. Never recorded in execution events.
    */
-  ask?: IUserInteraction['ask'];
+  traceContext?: IRunTraceContext;
   /**
-   * CLI-1990: the deferred-tool catalog the runtime injects (`ToolExecutionService`), so a search
-   * tool can list what is withheld and load it for the rest of the session. Present on every tool
-   * call the execution loop issues; a tool other than the search tool has no reason to read it.
+   * AbortSignal for cancelling execution. Aborting an in-flight run does not throw: `run()` resolves
+   * (and `runStream()` returns) the last assistant text the turn committed before the abort, possibly
+   * `''`; a reply cut off mid-stream is kept in history with `state: 'interrupted'`. Read
+   * `signal.aborted` to tell an interrupted run from a completed one.
    */
-  deferredTools?: IDeferredToolCatalog;
+  signal?: AbortSignal;
+  /** Join an aborted/timed-out provider call before completing; an uncooperative call may remain pending. */
+  awaitProviderSettlement?: boolean;
+  /** Per-run streaming text callback. Prefer this over mutating provider callback state. */
+  onTextDelta?: TTextDeltaCallback;
+  /** Per-run replay event callback for provider/tool execution boundaries. */
+  onExecutionEvent?: TExecutionEventCallback;
+  /** Awaited model/tool admission and result records. Failures terminate this run. */
+  executionJournal?: IExecutionJournal;
   /**
-   * The ID core mints for this one tool body, unique even when a vendor reuses its tool call ID.
-   * The body's exported span is derived from it, so it is also what a propagated parent names.
+   * Maximum execution rounds for this run. A **round** is one provider (model) call plus the
+   * execution of every tool call that reply requested; a reply with no tool calls ends the loop,
+   * so a plain Q&A turn is exactly 1 round. This caps model/tool cycles within ONE `run()` — it is
+   * not a tool-count limit and not a multi-turn conversation limit. When the cap is hit the run
+   * stops after the current round. Use 0 for no core round cap. Defaults to
+   * `IAgentConfig.maxExecutionRounds`.
    */
-  toolBodyId?: string;
+  maxExecutionRounds?: number;
+  /** Max times the same tool may be called with identical input before aborting. Unset = no limit. */
+  maxSameToolInputs?: number;
   /**
-   * Present only when the run carries trusted trace context: the `traceparent` naming this body's
-   * span and the exact origins it may be sent to. A tool that makes outbound requests sends it only
-   * to a listed origin.
+   * Treat a turn that ends in tool calls (no trailing text) as a valid completion instead of
+   * forcing one extra provider call to generate a summary (CORE-011). For decision-agent patterns
+   * (router/orchestrator/classifier) the tool call IS the answer — this removes the one-call tax.
+   * The summary call is the one made when the round cap ends the loop on a tool round; before the cap
+   * the model is called again after tool results as usual, so a decision agent sets
+   * `maxExecutionRounds` too (e.g. `1`). The run resolves with the turn's text, or `''` when it
+   * produced none; consumers read the outcome from the tool results.
    */
-  outboundTraceContext?: IOutboundTraceContext;
+  allowToolOnlyCompletion?: boolean;
   /**
-   * Present only when the host lets shell children inherit the trace: the environment naming this
-   * body's span. Only the foreground shell tool applies it, to its own child.
+   * Schema-enforced structured output (CORE-015). Accepts a Zod schema or an explicit
+   * `{ jsonSchema }` wrapper. `run` then resolves to the validated, typed object instead of a
+   * string: the schema is forwarded to the provider's native structured-output surface where one
+   * exists, and the final response is always parsed and validated core-side; a violation triggers
+   * a bounded retry with the validation issues fed back as the next turn's input. Every attempt is
+   * a real conversation turn (history stays append-only). Exhausted retries throw
+   * `StructuredOutputError`.
    */
-  shellTraceEnv?: ISubprocessTraceEnv;
+  output?: TStructuredOutputSchema;
   /**
-   * Present only when the host lets command hooks inherit the trace: the environment naming the
-   * prompt root, for the hooks fired around this body. Separate from {@link shellTraceEnv}, whose
-   * span is the body's own.
+   * Retry budget for structured output validation failures — the number of additional attempts
+   * after the first (default 2). Only meaningful with `output` set.
    */
-  hookTraceEnv?: ISubprocessTraceEnv;
+  outputRetries?: number;
 }
+//#endregion
+//#region src/plugins/event-emitter/types.d.ts
+declare const EXECUTION_EVENT_NAMES: {
+  readonly START: "execution.start";
+  readonly COMPLETE: "execution.complete";
+  readonly ERROR: "execution.error";
+};
+declare const TOOL_EVENT_NAMES: {
+  readonly CALL_START: "tool.call_start";
+  readonly CALL_COMPLETE: "tool.call_complete";
+  readonly CALL_ERROR: "tool.call_error";
+};
+declare const AGENT_EVENT_NAMES: {
+  readonly EXECUTION_START: "agent.execution_start";
+  readonly EXECUTION_COMPLETE: "agent.execution_complete";
+  readonly EXECUTION_ERROR: "agent.execution_error";
+  readonly CREATED: "agent.created";
+};
+type TExecutionEventName = (typeof EXECUTION_EVENT_NAMES)[keyof typeof EXECUTION_EVENT_NAMES];
+type TToolEventName = (typeof TOOL_EVENT_NAMES)[keyof typeof TOOL_EVENT_NAMES];
+type TAgentEventName = (typeof AGENT_EVENT_NAMES)[keyof typeof AGENT_EVENT_NAMES];
 /**
- * Parameter validation result
+ * Event types that can be emitted.
+ *
+ * IMPORTANT:
+ * - Do not use string literals for event names outside this module.
+ * - Import and use EVENT_EMITTER_EVENTS instead.
  */
-interface IParameterValidationResult {
-  /** Whether parameters are valid */
-  isValid: boolean;
-  /** Validation error messages */
-  errors: string[];
-}
+declare const EVENT_EMITTER_EVENTS: {
+  readonly EXECUTION_START: "execution.start";
+  readonly EXECUTION_COMPLETE: "execution.complete";
+  readonly EXECUTION_ERROR: "execution.error";
+  readonly TOOL_BEFORE_EXECUTE: "tool.beforeExecute";
+  readonly TOOL_AFTER_EXECUTE: "tool.afterExecute";
+  readonly TOOL_SUCCESS: "tool.success";
+  readonly TOOL_ERROR: "tool.call_error";
+  readonly CONVERSATION_START: "conversation.start";
+  readonly CONVERSATION_COMPLETE: "conversation.complete";
+  readonly CONVERSATION_ERROR: "conversation.error";
+  readonly AGENT_EXECUTION_START: "agent.execution_start";
+  readonly AGENT_EXECUTION_COMPLETE: "agent.execution_complete";
+  readonly AGENT_EXECUTION_ERROR: "agent.execution_error";
+  readonly AGENT_CREATED: "agent.created";
+  readonly AGENT_DESTROYED: "agent.destroyed";
+  readonly PLUGIN_LOADED: "plugin.loaded";
+  readonly PLUGIN_UNLOADED: "plugin.unloaded";
+  readonly PLUGIN_ERROR: "plugin.error";
+  readonly ERROR_OCCURRED: "error.occurred";
+  readonly WARNING_OCCURRED: "warning.occurred";
+  readonly MODULE_INITIALIZE_START: "module.initialize.start";
+  readonly MODULE_INITIALIZE_COMPLETE: "module.initialize.complete";
+  readonly MODULE_INITIALIZE_ERROR: "module.initialize.error";
+  readonly MODULE_EXECUTION_START: "module.execution.start";
+  readonly MODULE_EXECUTION_COMPLETE: "module.execution.complete";
+  readonly MODULE_EXECUTION_ERROR: "module.execution.error";
+  readonly MODULE_DISPOSE_START: "module.dispose.start";
+  readonly MODULE_DISPOSE_COMPLETE: "module.dispose.complete";
+  readonly MODULE_DISPOSE_ERROR: "module.dispose.error";
+  readonly MODULE_REGISTERED: "module.registered";
+  readonly MODULE_UNREGISTERED: "module.unregistered";
+  readonly EXECUTION_HIERARCHY: "execution.hierarchy";
+  readonly EXECUTION_REALTIME: "execution.realtime";
+  readonly TOOL_REALTIME: "tool.realtime";
+  readonly CUSTOM: "custom";
+};
+type TEventName = TExecutionEventName | TToolEventName | TAgentEventName | 'tool.beforeExecute' | 'tool.afterExecute' | 'tool.success' | 'conversation.start' | 'conversation.complete' | 'conversation.error' | 'agent.destroyed' | 'plugin.loaded' | 'plugin.unloaded' | 'plugin.error' | 'error.occurred' | 'warning.occurred' | 'module.initialize.start' | 'module.initialize.complete' | 'module.initialize.error' | 'module.execution.start' | 'module.execution.complete' | 'module.execution.error' | 'module.dispose.start' | 'module.dispose.complete' | 'module.dispose.error' | 'module.registered' | 'module.unregistered' | 'execution.hierarchy' | 'execution.realtime' | 'tool.realtime' | 'custom';
 /**
- * Generic tool executor function
+ * Valid event data value types
  */
-type TToolExecutor<TParams = TToolParameters, TResult = TUniversalValue> = (parameters: TParams, context?: IToolExecutionContext) => Promise<TResult>;
+type TEventDataValue = string | number | boolean | Date | null | undefined | TEventDataValue[] | {
+  [key: string]: TEventDataValue;
+};
 /**
- * Base tool interface
+ * Event data structure
  */
-interface ITool {
-  /** Tool schema */
-  schema: IToolSchema;
-  /**
-   * Execute the tool with given parameters
-   */
-  execute(parameters: TToolParameters, context?: IToolExecutionContext): Promise<IToolResult>;
-  /**
-   * Validate tool parameters
-   */
-  validate(parameters: TToolParameters): boolean;
-  /**
-   * Validate tool parameters with detailed result
-   */
-  validateParameters(parameters: TToolParameters): IParameterValidationResult;
-  /**
-   * Get tool description
-   */
-  getDescription(): string;
+interface IEventEmitterEventData {
+  type: TEventName;
+  timestamp: Date;
+  executionId?: string;
+  sessionId?: string;
+  userId?: string;
+  data?: Record<string, TEventDataValue>;
+  error?: Error;
+  metadata?: Record<string, TEventDataValue>;
 }
 /**
- * Function tool implementation
+ * Event listener function
  */
-interface IFunctionTool extends ITool {
-  /** Function to execute */
-  fn: TToolExecutor;
-}
+type TEventEmitterListener = (event: IEventEmitterEventData) => void | Promise<void>;
 /**
- * Tool registry interface
+ * Console-like interface for the EventEmitterPlugin.
+ *
+ * Use this interface for typing instead of the concrete EventEmitterPlugin class.
  */
-interface IToolRegistry {
-  /**
-   * Register a tool
-   */
-  register(tool: ITool): void;
-  /**
-   * Unregister a tool
-   */
-  unregister(name: string): void;
-  /**
-   * Get tool by name
-   */
-  get(name: string): ITool | undefined;
-  /**
-   * Get all registered tools
-   */
-  getAll(): ITool[];
-  /**
-   * Get tool schemas
-   */
-  getSchemas(): IToolSchema[];
-  /**
-   * Check if tool exists
-   */
-  has(name: string): boolean;
-  /**
-   * Clear all tools
-   */
-  clear(): void;
+interface IEventEmitterPlugin {
+  on(eventType: TEventName, listener: TEventEmitterListener, options?: {
+    once?: boolean;
+    filter?: (event: IEventEmitterEventData) => boolean;
+  }): string;
+  once(eventType: TEventName, listener: TEventEmitterListener, filter?: (event: IEventEmitterEventData) => boolean): string;
+  off(eventType: TEventName, handlerIdOrListener: string | TEventEmitterListener): boolean;
+  emit(eventType: TEventName, eventData?: Partial<IEventEmitterEventData>): Promise<void>;
+}
+//#endregion
+//#region src/abstracts/abstract-module-types.d.ts
+/** Module execution context */
+interface IModuleExecutionContext {
+  executionId?: string;
+  sessionId?: string;
+  userId?: string;
+  agentName?: string;
+  metadata?: Record<string, string | number | boolean | Date>;
+  [key: string]: string | number | boolean | Date | Record<string, string | number | boolean | Date> | undefined;
+}
+/** Module execution result */
+interface IModuleExecutionResult {
+  success: boolean;
+  data?: IModuleResultData;
+  error?: Error;
+  duration?: number;
+  metadata?: Record<string, string | number | boolean | Date>;
+}
+/** Module result data */
+interface IModuleResultData {
+  [key: string]: string | number | boolean | Record<string, string | number | boolean> | undefined;
+}
+/** Base module options */
+interface IBaseModuleOptions {
+  enabled?: boolean;
+  config?: Record<string, string | number | boolean>;
+}
+/** Module capabilities */
+interface IModuleCapabilities {
+  capabilities: string[];
+  dependencies?: string[];
+  optionalDependencies?: string[];
+}
+/** Module type descriptor */
+interface IModuleDescriptor {
+  type: string;
+  category: ModuleCategory;
+  layer: ModuleLayer;
+  dependencies?: string[];
+  capabilities?: string[];
+}
+/** Module categories */
+declare enum ModuleCategory {
+  CORE = "core",
+  STORAGE = "storage",
+  PROCESSING = "processing",
+  INTEGRATION = "integration",
+  INTERFACE = "interface",
+  CAPABILITY = "capability"
+}
+/** Module layers */
+declare enum ModuleLayer {
+  INFRASTRUCTURE = "infrastructure",
+  CORE = "core",
+  APPLICATION = "application",
+  DOMAIN = "domain",
+  PRESENTATION = "presentation"
+}
+/** Module data for introspection */
+interface IModuleData {
+  name: string;
+  version: string;
+  type: string;
+  enabled: boolean;
+  initialized: boolean;
+  capabilities: IModuleCapabilities;
+  metadata?: Record<string, string | number | boolean>;
+}
+/** Module statistics */
+interface IModuleStats {
+  enabled: boolean;
+  initialized: boolean;
+  executionCount: number;
+  errorCount: number;
+  lastActivity?: Date;
+  averageExecutionTime?: number;
+  [key: string]: string | number | boolean | Date | undefined;
+}
+/** Type-safe module interface */
+interface IModule<TOptions extends IBaseModuleOptions = IBaseModuleOptions, TStats = IModuleStats> {
+  name: string;
+  version: string;
+  enabled: boolean;
+  initialize(options?: TOptions, eventEmitter?: IEventEmitterPlugin): Promise<void>;
+  dispose?(): Promise<void>;
+  execute?(context: IModuleExecutionContext): Promise<IModuleExecutionResult>;
+  getModuleType(): IModuleDescriptor;
+  getCapabilities(): IModuleCapabilities;
+  getData?(): IModuleData;
+  getStats?(): TStats;
+  isEnabled(): boolean;
+  isInitialized(): boolean;
 }
 //#endregion
 //#region src/abstracts/abstract-plugin-types.d.ts
@@ -2350,6 +2627,11 @@ interface IAbstractTool<TParams = TToolParameters, TResult = IToolResult> {
 interface IToolContract<TParameters = TToolParameters, TResult = IToolResult> {
   readonly schema: IToolSchema;
   execute(parameters: TParameters, context: IToolExecutionContext): Promise<TResult>;
+  /**
+   * Wrappers await admission exactly once with final canonical arguments after preconditions and before
+   * the body. Denial returns without admission. Admission failures propagate unchanged.
+   */
+  executeWithAdmission?(parameters: TParameters, context: IToolExecutionContext, admit: TToolEffectAdmission<TParameters>): Promise<TResult>;
   validate(parameters: TParameters): boolean;
   validateParameters(parameters: TParameters): IParameterValidationResult;
   getDescription(): string;
@@ -2960,6 +3242,8 @@ interface IToolManager {
    * deferral is not engaged. The same member `IDeferredToolCatalog` declares.
    */
   listDeferredTools(): IToolSchema[];
+  /** Loaded residency for compatible execution checkpoints. */
+  getLoadedDeferredTools?(): string[];
   /**
    * CLI-1990: mark deferred tools loaded for the rest of the session and return their schemas; an
    * unknown name throws, naming it, before anything is loaded. The same member
@@ -4284,6 +4568,35 @@ declare class ErrorUtils {
   static wrapProviderError(error: TErrorExternalInput, provider: string, operation: string): ProviderError;
 }
 //#endregion
+//#region src/utils/execution-journal-error.d.ts
+/** A persistence/admission failure must never become a model-visible, retryable tool failure. */
+declare class ExecutionJournalError extends Error {
+  readonly code = "EXECUTION_JOURNAL_FAILED";
+  readonly recordId: string;
+  readonly kind: TExecutionJournalRecord['kind'];
+  constructor(record: TExecutionJournalRecord, cause: unknown);
+}
+//#endregion
+//#region src/utils/execution-suspended-error.d.ts
+/** A persisted wait is control flow, never a failed tool result or semantic completion. */
+declare class ExecutionSuspendedError extends Error {
+  readonly code = "EXECUTION_SUSPENDED";
+  readonly requests: readonly IToolWaitRequest[];
+  constructor(requests: readonly IToolWaitRequest[]);
+}
+//#endregion
+//#region src/utils/execution-recovery-error.d.ts
+type TExecutionRecoveryErrorCode = 'EXECUTION_RECOVERY_INVALID' | 'EXECUTION_RECOVERY_REQUIRED' | 'EXECUTION_RECOVERY_CONFLICT';
+/** Recovery refuses unproven effects or history instead of guessing whether to replay them. */
+declare class ExecutionRecoveryError extends Error {
+  readonly code: TExecutionRecoveryErrorCode;
+  readonly actionIds: readonly string[];
+  constructor(code: TExecutionRecoveryErrorCode, message: string, actionIds?: readonly string[]);
+}
+//#endregion
+//#region src/utils/execution-control-error.d.ts
+declare function isExecutionControlError(error: unknown): error is ExecutionJournalError | ExecutionRecoveryError | ExecutionSuspendedError;
+//#endregion
 //#region src/utils/timer-types.d.ts
 /**
  * Cross-platform timer identifier type.
@@ -4391,6 +4704,9 @@ declare function subprocessTraceEnvironment(base: Readonly<Record<string, string
  */
 declare function traceHeadersFor(baseUrl: string | undefined, traceContext: IOutboundTraceContext | undefined): Readonly<Record<string, string>>;
 //#endregion
+//#region src/services/execution-journal.d.ts
+declare function callJournaledProvider(chat: (messages: TUniversalMessage[], options: IChatOptions) => Promise<TUniversalMessage>, messages: TUniversalMessage[], options: IChatOptions, context?: IModelJournalContext): Promise<TUniversalMessage>;
+//#endregion
 //#region src/schema/zod-to-json-schema.d.ts
 /**
  * Convert a Zod schema to the universal JSON-schema subset.
@@ -5037,6 +5353,7 @@ declare class FunctionTool implements IFunctionTool {
    * Set EventService for post-construction injection.
    * Accepts EventService as-is without transformation.
    * Caller is responsible for providing properly configured EventService.
+   * A call whose context carries `instanceEventService` emits there instead.
    */
   setEventService(eventService: IEventService | undefined): void;
   /**
@@ -5320,6 +5637,7 @@ declare class Tools extends AbstractManager implements IToolManager {
   /** Whether a call to this tool would execute now: registered, and offered by the projection. */
   isToolOffered(name: string): boolean;
   /** Deferred tools not yet loaded — the population a search discovers. Empty while deferral is off. */
+  getLoadedDeferredTools(): string[];
   listDeferredTools(): IToolSchema[];
   /**
    * Mark deferred tools loaded for the rest of the session. Every name is resolved before any is
@@ -5459,6 +5777,16 @@ declare class Robota extends RobotaBase implements IAgent<IAgentConfig, IRunOpti
   listRuntimeTools(): Promise<IToolSchema[]>;
   /** Explicit tool invocation through the same executor used by model turns. */
   invokeRuntimeTool(name: string, parameters: TToolParameters, context: IToolExecutionContext): Promise<IToolExecutionResult>;
+  /**
+   * Resume a compatible journaled execution without adding input or repeating settled calls.
+   * Retain restored history for the host to checkpoint or discard, including on interruption.
+   */
+  resume(value: IResumeExecutionOptions): Promise<string>;
+  /**
+   * Restore the latest journaled tool batch without a model call or new user input.
+   * The host must own the journal exclusively and settle the previous runtime first.
+   */
+  resumeToolCalls(value: IResumeToolCallsOptions): Promise<IResumeToolCallsResult>;
   /**
    * Concurrency contract (CORE-012): a Robota instance owns ONE conversation history, so
    * concurrent `run`/`runStream` calls on the same instance are serialized on an internal queue —
@@ -5839,6 +6167,19 @@ declare function isRegistryTransactionError(error: unknown): error is IRegistryT
  */
 declare function runRegistryTransaction(steps: readonly IRegistryTransactionStep[]): Promise<void>;
 //#endregion
+//#region src/services/provider-call-usage.d.ts
+type TProviderUsageProvenance = 'complete' | 'partial' | 'absent';
+interface IVerifiedProviderCallUsage {
+  readonly provenance: TProviderUsageProvenance;
+  readonly promptTokens?: number;
+  readonly completionTokens?: number;
+  readonly totalTokens?: number;
+  /** The part of `promptTokens` served from the provider's prompt cache, when it was reported. */
+  readonly cacheReadTokens?: number;
+}
+/** Keep billing/telemetry stricter than context-window heuristics: only adapter-attested totals count. */
+declare function verifiedProviderCallUsage(message: TUniversalMessage | undefined): IVerifiedProviderCallUsage;
+//#endregion
 //#region src/services/execution-usage.d.ts
 /**
  * Aggregate token totals over a whole session/sub-session history.
@@ -5847,19 +6188,43 @@ declare function runRegistryTransaction(steps: readonly IRegistryTransactionStep
  * same triple by definition, so it is derived rather than re-declared.
  */
 type ISessionUsageTotals = ITokenUsage;
+/**
+ * Sum the token usage the provider reported on the assistant messages of `messages`.
+ *
+ * `promptTokens` sums each message's input tokens, `completionTokens` its output tokens, and
+ * `totalTokens` is their sum — which can differ from the totals providers reported (a thinking
+ * model's total also counts thought tokens). `cacheReadTokens` — the part of `promptTokens` served
+ * from the provider's prompt cache — is present only when at least one message reported it, and is a
+ * lower bound when only some did. Returns undefined when no assistant message reported usage.
+ *
+ * One run's usage (every provider call it made, tool rounds and a forced summary included):
+ *
+ * ```ts
+ * const before = agent.getHistory().length;
+ * await agent.run(prompt);
+ * const usage = sumMessagesUsage(agent.getHistory().slice(before));
+ * ```
+ */
+declare function sumMessagesUsage(messages: readonly TUniversalMessage[]): ITokenUsageWithCacheRead | undefined;
 /**
  * ANALYTICS-001 (Phase 2): sum assistant token usage across a history timeline — used to capture a
  * subagent / background task's total usage so it can be attributed to its source in the parent log.
  * Returns undefined when no usage was reported (so callers can skip recording an empty entry).
+ *
+ * The result is exactly the usage triple: it is persisted as a background task's usage, whose record
+ * declares no other key. Use {@link sumMessagesUsage} for the prompt-cache read as well.
  */
 declare function sumHistoryUsage(history: readonly IHistoryEntry[]): ISessionUsageTotals | undefined;
 interface IAssistantUsageMetadata {
   inputTokens: number;
   outputTokens: number;
+  /** The part of `inputTokens` served from the provider's prompt cache, when it was reported. */
+  cacheReadTokens?: number;
   usage: {
     totalTokens: number;
     inputTokens: number;
     outputTokens: number;
+    cacheReadTokens?: number;
   };
 }
 declare function collectAssistantUsageMetadata(message: TUniversalMessage): IAssistantUsageMetadata | undefined;
@@ -6682,6 +7047,10 @@ interface IContextTokenUsage {
   inputTokens: number;
   outputTokens: number;
   cacheCreationTokens?: number;
+  /**
+   * Anthropic-style: cache reads counted in addition to `inputTokens`. Not the message-usage
+   * `cacheReadTokens` (`IMessageTokenUsage`), which is a part of the input.
+   */
   cacheReadTokens?: number;
 }
 /** Context window state snapshot */
@@ -6721,6 +7090,11 @@ interface IMessageTokenUsage {
   readonly inputTokens: number;
   readonly outputTokens: number;
   readonly totalTokens?: number;
+  /**
+   * The part of `inputTokens` the provider served from its prompt cache (a subset of `inputTokens`).
+   * Present only when the provider reported it.
+   */
+  readonly cacheReadTokens?: number;
 }
 /** Read normalized provider usage from a universal message when present. */
 declare function readTokenUsageFromMessage(message: TUniversalMessage): IMessageTokenUsage | undefined;
@@ -6894,5 +7268,5 @@ declare function decodeHookVerdict(raw: string, source: THookDefinition['type'],
 /** Does a hook that reached no verdict block at this event? */
 declare function isEnforcing(event: THookEvent): boolean;
 //#endregion
-export { parseParameterRule as $, IAgentConfig as $a, resolveModelCapabilities as $c, isConfirmed as $i, createImageProviderFromDefinition as $n, TASK_EVENT_PREFIX as $o, IToolSchemaProjectionProfile as $r, IRawProviderResponse as $s, lifecycleOf as $t, allowRulesForAutoMode as A, IProviderStructuredOutputCapability as Aa, AuthenticationError as Ac, IRemoteExecutorConfig as Ai, ICacheEntry as Al, IEventEmitterMetricsSnapshot as An, PluginPriority as Ao, TTimerId as Ar, TOOL_SEARCH_TOOL_NAME as As, IHandoffOrchestrationSpec as At, IPermissionPolicyProjection as B, IProviderProfileConfig as Ba, RobotaError as Bc, TConversationContextMetadata as Bi, TMetadata as Bl, isEnvReference as Bn, ISpanCompletionEventData as Bo, TMessageConverterRegistry as Br, normalizeStructuredOutput as Bs, AGENT_EVENTS as Bt, IContextTokenEstimate as C, IVideoGenerationRequest as Ca, IModelFallbackNotice as Cc, IEventHistorySnapshot as Ci, isUserMessage as Cl, assertResidentToolRemains as Cn, IPluginErrorContext as Co, IPlatformShell as Cr, EVENT_EMITTER_EVENTS as Cs, createExecutionProxy as Ct, estimateToolSchemaTokens as D, TProviderMediaResult as Da, classifyProviderFailure as Dc, IExecutorStreamMessageEvent as Di, IActionRequest as Dl, IEventEmitterHierarchicalEventData as Dn, IPluginOptions as Do, resolvePlatformShell as Dr, TEventName as Ds, ORCHESTRATION_EVENT_PREFIX as Dt, estimateSerializedContextTokens as E, TImageInputSource as Ea, TProviderFailureReason as Ec, IExecutorChatResult as Ei, IActionOption as El, EventEmitterPlugin as En, IPluginHooks as Eo, UnsupportedShellError as Er, TEventEmitterListener as Es, ORCHESTRATION_EVENTS as Et, IPermissionPatternProblem as F, IProviderDefinitionConfig as Fa, ModelNotAvailableError as Fc, IConversationResponse as Fi, TComplexConfigValue as Fl, TOutputRetention as Fn, IToolExecutionResult as Fo, validateApiKey as Fr, TExecutionEventData as Fs, IOrchestrationStep as Ft, IToolPermissionArgument as G, TProviderModelCatalogStatus as Ga, TErrorExternalInput as Gc, TToolProgressCallback as Gi, createAssistantMessage as Gn, TOOL_BODY_EVENTS as Go, AbstractExecutor as Gr, IZodSchema as Gs, IAssistantUsageMetadata as Gt, IParameterRule as H, IProviderSetupHelpLink as Ha, StorageError as Hc, TToolExecutionParameters as Hi, TToolParameters as Hl, IAIProviderInstance as Hn, PROVIDER_FALLBACK_EVENTS as Ho, TProviderMessage as Hr, validateAgainstJsonSchema as Hs, peerDriverOf as Ht, findInvalidPermissionPatterns as I, IProviderEndpoint as Ia, NetworkError as Ic, IConversationService as Ii, TConfigData as Il, createBoundedOutput as In, IToolRegistry as Io, validateModelName as Ir, IJsonSchemaOutput as Is, IOrchestrationStepResult as It, clearRegisteredToolProfiles as J, TProviderSetupHelpLinkKind as Ja, IModelRef as Jc, isProgressReportingTool as Ji, createUserMessage as Jn, readModelFallbackNotice as Jo, IExecutorAwareProviderConfig as Jr, IAIProvider as Js, sumHistoryUsage as Jt, IToolPermissionProfile as K, TProviderModelLifecycle as Ka, ToolExecutionError as Kc, getToolEstimatedDuration as Ki, createSystemMessage as Kn, TOOL_PERMISSION_EVENTS as Ko, AbstractPlugin as Kr, IZodSchemaDef as Ks, ISessionUsageTotals as Kt, findPermissionPatternWarnings as L, IProviderModelCatalog as La, PluginError as Lc, IConversationServiceOptions as Li, TConfigValue as Ll, ENV_REFERENCE_PREFIX as Ln, IToolResult as Lo, validateProviderName as Lr, IStructuredOutputSpec as Ls, IParallelOrchestrationSpec as Lt, splitCommandSegments as M, TStructuredOutputProvenance as Ma, CircuitBreakerOpenError as Mc, TExecutorStreamEvent as Mi, ICacheOptions as Ml, shellArgumentForDisplay as Mn, IParameterValidationResult as Mo, ISimpleValidationResult as Mr, TToolSearchSetting as Ms, IOrchestrationDelegation as Mt, applyPresetToolLists as N, IProviderCredentialRequirement as Na, ConfigurationError as Nc, IContextOptions as Ni, ICacheStats as Nl, IBoundedOutput as Nn, ITool as No, Validator as Nr, IRunOptions as Ns, IOrchestrationEventData as Nt, IContextTokenUsage as O, isImageGenerationProvider as Oa, readProviderFailureDetails as Oc, IExecutorStreamTerminalEvent as Oi, IUserInteraction as Ol, IEventEmitterPluginOptions as On, IPluginStats as Oo, startPeriodicTask as Or, TExecutionEventName as Os, TOrchestrationEvent as Ot, toolNamesToPatterns as P, IProviderDefinition as Pa, IProviderFailureDetails as Pc, IConversationContext as Pi, ICacheStorage as Pl, IBoundedOutputOptions as Pn, IToolExecutionContext as Po, validateAgentConfig as Pr, TExecutionEventCallback as Ps, IOrchestrationRunResult as Pt, matchesAnyPattern as Q, IAgent as Qa, modelDeclaresCapability as Qc, confirmAction as Qi, IMediaProviderOverrides as Qn, TASK_EVENTS as Qo, IToolSchemaProjectionChange as Qr, IProviderRequest as Qs, isRegistryTransactionError as Qt, validatePermissionPattern as R, IProviderModelCatalogEntry as Ra, ProviderError as Rc, IStreamingChunk as Ri, TContextData as Rl, formatEnvReference as Rn, TToolExecutor as Ro, validateUserInput as Rr, TStructuredOutputSchema as Rs, ISequentialOrchestrationSpec as Rt, CONTEXT_ESTIMATE_CHARS_PER_TOKEN as S, IVideoGenerationProvider as Sa, createDefaultProviderCapabilities as Sc, IEventHistoryRecord as Si, isToolMessage as Sl, DEFERRED_WITHOUT_LOADER_MESSAGE as Sn, IPluginData as So, traceHeadersFor as Sr, TEventUniversalValue as Ss, ExecutionProxy as St, estimateContextTokensFromMessages as T, IVideoJobSnapshot as Ta, IProviderFailureClassification as Tc, IExecutor as Ti, IActionDefault as Tl, ToolRegistry as Tn, IPluginExecutionResult as To, TShellKind as Tr, IEventEmitterPlugin as Ts, IExecutionProxyConfig as Tt, IPermissionEvaluationContext as U, IProviderSetupStepDefinition as Ua, StructuredOutputError as Uc, IProgressReportingTool as Ui, TypeUtils as Ul, LocalExecutor as Un, SPAN_EVENTS as Uo, isAbortFailure as Ur, ISchemaConversionOptions as Us, printablePeerDriver as Ut, projectPermissionPolicy as V, IProviderProfileDefaults as Va, SameToolInputLoopError as Vc, TResponseMetadata as Vi, TMetadataValue as Vl, resolveEnvReference as Vn, PROVIDER_CALL_EVENTS as Vo, TMessageFormatConverter as Vr, parseStructuredResponseText as Vs, AGENT_EVENT_PREFIX as Vt, IPermissionLists as W, TProviderCredentialField as Wa, TErrorContextData as Wc, IToolExecutionStep as Wi, ConversationHistory as Wn, SPAN_EVENT_PREFIX as Wo, AbstractTool as Wr, IZodParseResult as Ws, EventHistoryModule as Wt, getToolPermissionProfile as X, formatSupportedProviderTypes as Xa, IModelCapabilityDeviation as Xc, CONFIRM_NO as Xi, createProviderFromConfig as Xn, USER_EVENTS as Xo, TProviderLoggingData as Xr, IProviderNativeRawPayloadEvent as Xs, IRegistryTransactionError as Xt, evaluatePermission as Y, findProviderDefinition as Ya, TRoleModelMap as Yc, setToolProgressCallback as Yi, ConversationStore as Yn, TUserEvent as Yo, IProviderRuntimeConfig as Yr, IChatOptions as Ys, IRegistryOwnedLifecycle as Yt, isToolDeniedOutright as Z, getProviderCredentialRequirement as Za, IProviderCapabilityTable as Zc, CONFIRM_YES as Zi, normalizeProviderConfig as Zn, USER_EVENT_PREFIX as Zo, IToolSchemaProjection as Zr, IProviderOptions as Zs, IRegistryTransactionStep as Zt, getModelName as _, IImageGenerationResult as _a, IProviderFunctionCallingCapability as _c, IStats as _i, chatEntryToMessage as _l, IDestroyResult as _n, setGlobalLoggerSink as _o, providerCallSpanId as _r, IOwnerPathSegment as _s, TBackgroundPermissionPolicy as _t, IModelPrice as a, IAIProviderManager as aa, TProviderOptionValueBase as ac, TToolSchemaProjectionOutcome as ai, IInlineImageMessagePart as al, IAgentFactoryOptions as an, TToolExecutionFunction as ao, IStructuredOutputResolutionInput as ar, bindEventServiceOwner as as, PROTECTED_FILE_NAMES as at, readTokenUsageFromMessage as b, IProviderMediaError as ba, IProviderNativeWebToolRequest as bc, ITerminalOutput as bi, isChatEntry as bl, TOOL_EVENTS as bn, IPluginContext as bo, toolTraceContextFor as br, TEventListener as bs, TRUST_TO_MODE as bt, estimateBlendedCostPer1000 as c, IMediaProviderConfig as ca, getProviderCapabilities as cc, projectToolSchema as ci, IToolCall as cl, DEFAULT_TOOL_RESULT_WARNING_CHARS as cn, ILoggerOptions as co, getSchemaTypeName as cr, generateSpanId as cs, RISK_CLASS_POLICY as ct, DEFAULT_MAX_OUTPUT as d, findMediaProviderDefinition as da, IToolSchema as dc, AbstractAgent as di, IUserMessage as dl, MAX_TOOL_RESULT_CHARS as dn, TUtilLogLevel as do, ISchemaClosureOptions as dr, IBaseEventData as ds, TArgumentKind as dt, multiSelectAction as ea, ITokenUsage as ec, PARAMETER_SCHEMA_KEYWORDS as ei, resolveModelCapability as el, runRegistryTransaction as en, IAgentTemplate as eo, createVideoProviderFromDefinition as er, AbstractEventService as es, registerToolPermissionProfile as et, IModelDefinition as f, isMediaProviderDefinition as fa, TJSONSchemaEnum as fc, ICredentialKey as fi, TMessageState as fl, TToolResultAdmissionErrorCode as fn, createLogger as fo, closeObjectSchemas as fr, IEventContext as fs, TMatchDirection as ft, getModelMaxOutput as g, IImageGenerationRequest as ga, IProviderCapabilities as gc, IFileSystemAsync as gi, TUniversalMessageRole as gl, Robota as gn, setGlobalLogLevel as go, outboundTraceContextFor as gr, IExecutionEventData as gs, DEFAULT_BACKGROUND_PERMISSION_POLICY as gt, getModelContextWindow as h, IImageGenerationProvider as ha, IProviderSpecificOptions as hc, IFileSystem as hi, TUniversalMessagePart as hl, wasToolResultAdmitted as hn, logger as ho, isMintedSpanId as hr, IEventServiceOwnerBinding as hs, isReadOnlyCommandLine as ht, runHooks as i, IToolFactory as ia, TProviderNativeRawPayloadKind as ic, TOOL_SCHEMA_PROJECTION_MAX_NODES as ii, IHistoryEntry as il, IAgentCreationStats as in, IToolWithEventService as io, processEnvResolver as ir, StructuredEventService as is, PROTECTED_DIRECTORY_NAMES as it, isBroadExecutionAllowRule as j, TStructuredOutputMechanism as ja, CacheIntegrityError as jc, IStreamExecutionRequest as ji, ICacheKey as jl, InMemoryEventEmitterMetrics as jn, IFunctionTool as jo, ErrorUtils as jr, TToolSearchMode as js, IHierarchicalOrchestrationSpec as jt, IContextWindowState as k, isVideoGenerationProvider as ka, toProviderError as kc, ILocalExecutorConfig as ki, TActionResponse as kl, IEventEmitterMetrics as kn, PluginCategory as ko, stopPeriodicTask as kr, IDeferredToolCatalog as ks, IGroupChatOrchestrationSpec as kt, lookupModelPrice as l, IMediaProviderCredentialRequirement as la, IObjectParameterSchema as lc, AbstractManager as li, IToolMessage as ll, IToolResultAdmissionOptions as ln, IUtilLogEntry as lo, hasValidationConstraints as lr, isDefaultEventService as ls, TToolRiskClass as lt, formatTokenCount as m, IImageEditRequest as ma, TParameterDefaultValue as mc, IDirent as mi, TUniversalMessageMetadata as ml, admitToolResult as mn, getGlobalLoggerSink as mo, buildTraceparent as mr, IEventService as ms, TResolveInWorkspace as mt, decodeHookVerdict as n, textAction as na, TProviderNativeRawPayload as nc, STRICT_TOOL_SCHEMA_PROFILE as ni, IAssistantMessage as nl, AgentTemplates as nn, IAbstractToolOptions as no, TEnvResolver as nr, DefaultEventService as ns, toolNameMatches as nt, MODEL_PRICES as o, IToolManager as oa, TTextDeltaCallback as oc, TToolSchemaProjectionProfileBase as oi, ISystemMessage as ol, IAgentLifecycleEvents as on, ConsoleLogger as oo, resolveStructuredOutputCapability as or, bindWithOwnerPath as os, isProtectedPath as ot, findModelDefinition as p, IImageComposeRequest as pa, TJSONSchemaKind as pc, ICredentialStore as pi, TUniversalMessage as pl, ToolResultAdmissionError as pn, getGlobalLogLevel as po, zodToJsonSchema as pr, IEventObjectValue as ps, IReadOnlyCommandContext as pt, TToolArgs as q, TProviderSetupField as qa, ValidationError as qc, getToolExecutionSteps as qi, createToolMessage as qn, TSpanEvent as qo, AbstractAIProvider as qr, IResponseFormatConfig as qs, collectAssistantUsageMetadata as qt, GuardrailExecutor as r, IOpenAPIToolConfig as ra, TProviderNativeRawPayloadCallback as rc, TOOL_SCHEMA_PROJECTION_MAX_DEPTH as ri, IBaseMessage as rl, ITemplateApplicationResult as rn, IToolContract as ro, createRecordEnvResolver as rr, ObservableEventService as rs, ICriticalPathContext as rt, calculateModelCost as s, TManagerToolParameters as sa, TToolChoice as sc, hashToolSchema as si, ITextMessagePart as sl, DEFAULT_TOOL_RESULT_HARD_CHARS as sn, ILogger as so, extractEnumValues as sr, composeEventName as ss, removesCriticalPath as st, isEnforcing as t, selectAction as ta, TProviderConfigValue as tc, PERMISSIVE_TOOL_SCHEMA_PROFILE as ti, TProviderModelCapability as tl, AgentFactory as tn, IAbstractTool as to, resolveMediaProviderConfig as tr, DEFAULT_ABSTRACT_EVENT_SERVICE as ts, requiresFreshApproval as tt, DEFAULT_CONTEXT_WINDOW as u, IMediaProviderDefinition as ua, IParameterSchema as uc, IManagerLifecycleOptions as ui, IUriImageMessagePart as ul, IToolResultSpillStore as un, SilentLogger as uo, ISchemaClosureChange as ur, IAgentEventData as us, UNCLASSIFIED_TOOL_FALLBACK as ut, registerModelMetadata as v, IInlineImageInputSource as va, IProviderNativeWebToolCapabilities as vc, ISession as vi, getMessagesForAPI as vl, EXECUTION_EVENTS as vn, IPlugin as vo, spanIdFromMintedId as vr, IToolEventData as vs, TPermissionDecision$1 as vt, IContextTokenEstimateOptions as w, IVideoJobAccepted as wa, TModelFallbackCallback as wc, IChatExecutionRequest as wi, messageToHistoryEntry as wl, FunctionTool as wn, IPluginExecutionContext as wo, IPlatformShellResolutionRequest as wr, IEventEmitterEventData as ws, withEventEmission as wt, readTokenUsageFromMetadata as x, IUriImageInputSource as xa, assertProviderNativeWebToolsAvailable as xc, IEventHistoryModule as xi, isSystemMessage as xl, TOOL_EVENT_PREFIX as xn, IPluginContract as xo, traceEnvFor as xr, TEventLoggerData as xs, TTrustLevel as xt, IMessageTokenUsage as y, IMediaOutputRef as ya, IProviderNativeWebToolCapability as yc, ISpinner as yi, isAssistantMessage as yl, EXECUTION_EVENT_PREFIX as yn, IPluginConfig as yo, subprocessTraceEnvironment as yr, TEventExtensionValue as ys, TPermissionMode as yt, IPermissionPolicyContext as z, IProviderProbeResult as za, RateLimitError as zc, IToolExecutionRequest as zi, TLoggerData as zl, hasUsableSecretReference as zn, TToolMetadata as zo, MessageConverter as zr, TStructuredOutputValidation as zs, TOrchestrationPrimitive as zt };
-//# sourceMappingURL=index-D2rky0wZ.d.ts.map
+export { parseParameterRule as $, IProviderSetupStepDefinition as $a, assertProviderNativeWebToolsAvailable as $c, IProgressReportingTool as $i, isChatEntry as $l, ConversationStore as $n, TStructuredOutputValidation as $o, isAbortFailure as $r, USER_EVENT_PREFIX as $s, IRegistryOwnedLifecycle as $t, allowRulesForAutoMode as A, IProviderMediaError as Aa, IRawProviderResponse as Ac, ITerminalOutput as Ai, IProviderCapabilityTable as Al, EventEmitterPlugin as An, IPluginContext as Ao, TShellKind as Ar, TToolEffectAdmission as As, IHandoffOrchestrationSpec as At, IPermissionPolicyProjection as B, IProviderStructuredOutputCapability as Ba, getProviderCapabilities as Bc, IRemoteExecutorConfig as Bi, ITextMessagePart as Bl, createBoundedOutput as Bn, PluginPriority as Bo, ExecutionJournalError as Br, IUserInteraction as Bs, AGENT_EVENTS as Bt, IContextTokenEstimate as C, IImageComposeRequest as Ca, TEventLoggerData as Cc, ICredentialStore as Ci, TErrorContextData as Cl, EXECUTION_EVENT_PREFIX as Cn, getGlobalLogLevel as Co, spanIdFromMintedId as Cr, IFunctionTool as Cs, createExecutionProxy as Ct, estimateToolSchemaTokens as D, IImageGenerationResult as Da, IProviderNativeRawPayloadEvent as Dc, IStats as Di, IModelRef as Dl, assertResidentToolRemains as Dn, setGlobalLoggerSink as Do, traceHeadersFor as Dr, IToolExecutionResult as Ds, ORCHESTRATION_EVENT_PREFIX as Dt, estimateSerializedContextTokens as E, IImageGenerationRequest as Ea, IChatOptions as Ec, IFileSystemAsync as Ei, ValidationError as El, DEFERRED_WITHOUT_LOADER_MESSAGE as En, setGlobalLogLevel as Eo, traceEnvFor as Er, IToolExecutionContext as Es, ORCHESTRATION_EVENTS as Et, IPermissionPatternProblem as F, IVideoJobSnapshot as Fa, TProviderNativeRawPayloadCallback as Fc, IExecutor as Fi, IAssistantMessage as Fl, InMemoryEventEmitterMetrics as Fn, IPluginExecutionResult as Fo, TTimerId as Fr, TToolSearchMode as Fs, IOrchestrationStep as Ft, IToolPermissionArgument as G, IProviderDefinitionConfig as Ga, TJSONSchemaKind as Gc, IConversationResponse as Gi, TMessageState as Gl, resolveEnvReference as Gn, TEventName as Go, validateApiKey as Gr, SPAN_EVENTS as Gs, IAssistantUsageMetadata as Gt, IParameterRule as H, TStructuredOutputProvenance as Ha, IParameterSchema as Hc, TExecutorStreamEvent as Hi, IToolMessage as Hl, formatEnvReference as Hn, IEventEmitterEventData as Ho, ISimpleValidationResult as Hr, ISpanCompletionEventData as Hs, peerDriverOf as Ht, findInvalidPermissionPatterns as I, TImageInputSource as Ia, TProviderNativeRawPayloadKind as Ic, IExecutorChatResult as Ii, IBaseMessage as Il, shellArgumentForDisplay as In, IPluginHooks as Io, isExecutionControlError as Ir, TToolSearchSetting as Is, IOrchestrationStepResult as It, clearRegisteredToolProfiles as J, IProviderModelCatalogEntry as Ja, IProviderCapabilities as Jc, IStreamingChunk as Ji, TUniversalMessagePart as Jl, ConversationHistory as Jn, TExecutionEventCallback as Jo, validateUserInput as Jr, TOOL_PERMISSION_EVENTS as Js, sumHistoryUsage as Jt, IToolPermissionProfile as K, IProviderEndpoint as Ka, TParameterDefaultValue as Kc, IConversationService as Ki, TUniversalMessage as Kl, IAIProviderInstance as Kn, TExecutionEventName as Ko, validateModelName as Kr, SPAN_EVENT_PREFIX as Ks, ISessionUsageTotals as Kt, findPermissionPatternWarnings as L, TProviderMediaResult as La, TProviderOptionValueBase as Lc, IExecutorStreamMessageEvent as Li, IHistoryEntry as Ll, IBoundedOutput as Ln, IPluginOptions as Lo, ExecutionRecoveryError as Lr, IActionDefault as Ls, IParallelOrchestrationSpec as Lt, splitCommandSegments as M, IVideoGenerationProvider as Ma, ITokenUsageWithCacheRead as Mc, IEventHistoryRecord as Mi, resolveModelCapabilities as Ml, IEventEmitterPluginOptions as Mn, IPluginData as Mo, resolvePlatformShell as Mr, TToolMetadata as Ms, IOrchestrationDelegation as Mt, applyPresetToolLists as N, IVideoGenerationRequest as Na, TProviderConfigValue as Nc, IEventHistorySnapshot as Ni, resolveModelCapability as Nl, IEventEmitterMetrics as Nn, IPluginErrorContext as No, startPeriodicTask as Nr, IDeferredToolCatalog as Ns, IOrchestrationEventData as Nt, IContextTokenUsage as O, IInlineImageInputSource as Oa, IProviderOptions as Oc, ISession as Oi, TRoleModelMap as Ol, FunctionTool as On, IPlugin as Oo, IPlatformShell as Or, IToolRegistry as Os, TOrchestrationEvent as Ot, toolNamesToPatterns as P, IVideoJobAccepted as Pa, TProviderNativeRawPayload as Pc, IChatExecutionRequest as Pi, TProviderModelCapability as Pl, IEventEmitterMetricsSnapshot as Pn, IPluginExecutionContext as Po, stopPeriodicTask as Pr, TOOL_SEARCH_TOOL_NAME as Ps, IOrchestrationRunResult as Pt, matchesAnyPattern as Q, IProviderSetupHelpLink as Qa, IProviderNativeWebToolRequest as Qc, TToolExecutionParameters as Qi, isAssistantMessage as Ql, createUserMessage as Qn, TStructuredOutputSchema as Qo, TProviderMessage as Qr, USER_EVENTS as Qs, verifiedProviderCallUsage as Qt, validatePermissionPattern as R, isImageGenerationProvider as Ra, TTextDeltaCallback as Rc, IExecutorStreamTerminalEvent as Ri, IInlineImageMessagePart as Rl, IBoundedOutputOptions as Rn, IPluginStats as Ro, TExecutionRecoveryErrorCode as Rr, IActionOption as Rs, ISequentialOrchestrationSpec as Rt, CONTEXT_ESTIMATE_CHARS_PER_TOKEN as S, isMediaProviderDefinition as Sa, TEventListener as Sc, ICredentialKey as Si, StructuredOutputError as Sl, EXECUTION_EVENTS as Sn, createLogger as So, providerCallSpanId as Sr, TJournalModelOptions as Ss, ExecutionProxy as St, estimateContextTokensFromMessages as T, IImageGenerationProvider as Ta, IAIProvider as Tc, IFileSystem as Ti, ToolExecutionError as Tl, TOOL_EVENT_PREFIX as Tn, logger as To, toolTraceContextFor as Tr, ITool as Ts, IExecutionProxyConfig as Tt, IPermissionEvaluationContext as U, IProviderCredentialRequirement as Ua, IToolSchema as Uc, IContextOptions as Ui, IUriImageMessagePart as Ul, hasUsableSecretReference as Un, IEventEmitterPlugin as Uo, Validator as Ur, PROVIDER_CALL_EVENTS as Us, printablePeerDriver as Ut, projectPermissionPolicy as V, TStructuredOutputMechanism as Va, IObjectParameterSchema as Vc, IStreamExecutionRequest as Vi, IToolCall as Vl, ENV_REFERENCE_PREFIX as Vn, EVENT_EMITTER_EVENTS as Vo, ErrorUtils as Vr, TActionResponse as Vs, AGENT_EVENT_PREFIX as Vt, IPermissionLists as W, IProviderDefinition as Wa, TJSONSchemaEnum as Wc, IConversationContext as Wi, IUserMessage as Wl, isEnvReference as Wn, TEventEmitterListener as Wo, validateAgentConfig as Wr, PROVIDER_FALLBACK_EVENTS as Ws, EventHistoryModule as Wt, getToolPermissionProfile as X, IProviderProfileConfig as Xa, IProviderNativeWebToolCapabilities as Xc, TConversationContextMetadata as Xi, chatEntryToMessage as Xl, createSystemMessage as Xn, IJsonSchemaOutput as Xo, TMessageConverterRegistry as Xr, readModelFallbackNotice as Xs, IVerifiedProviderCallUsage as Xt, evaluatePermission as Y, IProviderProbeResult as Ya, IProviderFunctionCallingCapability as Yc, IToolExecutionRequest as Yi, TUniversalMessageRole as Yl, createAssistantMessage as Yn, TExecutionEventData as Yo, MessageConverter as Yr, TSpanEvent as Ys, sumMessagesUsage as Yt, isToolDeniedOutright as Z, IProviderProfileDefaults as Za, IProviderNativeWebToolCapability as Zc, TResponseMetadata as Zi, getMessagesForAPI as Zl, createToolMessage as Zn, IStructuredOutputSpec as Zo, TMessageFormatConverter as Zr, TUserEvent as Zs, TProviderUsageProvenance as Zt, getModelName as _, TManagerToolParameters as _a, IEventServiceOwnerBinding as _c, hashToolSchema as _i, ProviderError as _l, ToolResultAdmissionError as _n, ILogger as _o, zodToJsonSchema as _r, IRecoverableExecutionJournal as _s, TBackgroundPermissionPolicy as _t, TToolParameters as _u, IModelPrice as a, setToolProgressCallback as aa, ObservableEventService as ac, IProviderRuntimeConfig as ai, classifyProviderFailure as al, AgentFactory as an, findProviderDefinition as ao, resolveMediaProviderConfig as ar, IZodSchema as as, PROTECTED_FILE_NAMES as at, IToolContinuation as au, readTokenUsageFromMessage as b, IMediaProviderDefinition as ba, IToolEventData as bc, IManagerLifecycleOptions as bi, SameToolInputLoopError as bl, Robota as bn, SilentLogger as bo, isMintedSpanId as br, IResumeToolCallsResult as bs, TRUST_TO_MODE as bt, estimateBlendedCostPer1000 as c, confirmAction as ca, bindWithOwnerPath as cc, IToolSchemaProjectionChange as ci, toProviderError as cl, IAgentCreationStats as cn, IAgent as co, processEnvResolver as cr, ICacheEntry as cs, RISK_CLASS_POLICY as ct, IToolWaitResponse as cu, DEFAULT_MAX_OUTPUT as d, selectAction as da, isDefaultEventService as dc, PERMISSIVE_TOOL_SCHEMA_PROFILE as di, CircuitBreakerOpenError as dl, DEFAULT_TOOL_RESULT_HARD_CHARS as dn, IAbstractTool as do, extractEnumValues as dr, ICacheStats as ds, TArgumentKind as dt, TConfigData as du, IToolExecutionStep as ea, TASK_EVENTS as ec, AbstractTool as ei, createDefaultProviderCapabilities as el, IRegistryTransactionError as en, TProviderCredentialField as eo, createProviderFromConfig as er, normalizeStructuredOutput as es, registerToolPermissionProfile as et, isSystemMessage as eu, IModelDefinition as f, textAction as fa, IAgentEventData as fc, STRICT_TOOL_SCHEMA_PROFILE as fi, ConfigurationError as fl, DEFAULT_TOOL_RESULT_WARNING_CHARS as fn, IAbstractToolOptions as fo, getSchemaTypeName as fr, ICacheStorage as fs, TMatchDirection as ft, TConfigValue as fu, getModelMaxOutput as g, IToolManager as ga, IEventService as gc, TToolSchemaProjectionProfileBase as gi, PluginError as gl, TToolResultAdmissionErrorCode as gn, ConsoleLogger as go, closeObjectSchemas as gr, IModelJournalContext as gs, DEFAULT_BACKGROUND_PERMISSION_POLICY as gt, TMetadataValue as gu, getModelContextWindow as h, IAIProviderManager as ha, IEventObjectValue as hc, TToolSchemaProjectionOutcome as hi, NetworkError as hl, MAX_TOOL_RESULT_CHARS as hn, TToolExecutionFunction as ho, ISchemaClosureOptions as hr, IExecutionRoundCheckpoint as hs, isReadOnlyCommandLine as ht, TMetadata as hu, runHooks as i, isProgressReportingTool as ia, DefaultEventService as ic, IExecutorAwareProviderConfig as ii, TProviderFailureReason as il, runRegistryTransaction as in, TProviderSetupHelpLinkKind as io, createVideoProviderFromDefinition as ir, IZodParseResult as is, PROTECTED_DIRECTORY_NAMES as it, IToolActionIdentity as iu, isBroadExecutionAllowRule as j, IUriImageInputSource as ja, ITokenUsage as jc, IEventHistoryModule as ji, modelDeclaresCapability as jl, IEventEmitterHierarchicalEventData as jn, IPluginContract as jo, UnsupportedShellError as jr, TToolExecutor as js, IHierarchicalOrchestrationSpec as jt, IContextWindowState as k, IMediaOutputRef as ka, IProviderRequest as kc, ISpinner as ki, IModelCapabilityDeviation as kl, ToolRegistry as kn, IPluginConfig as ko, IPlatformShellResolutionRequest as kr, IToolResult as ks, IGroupChatOrchestrationSpec as kt, lookupModelPrice as l, isConfirmed as la, composeEventName as lc, IToolSchemaProjectionProfile as li, AuthenticationError as ll, IAgentFactoryOptions as ln, IAgentConfig as lo, IStructuredOutputResolutionInput as lr, ICacheKey as ls, TToolRiskClass as lt, IToolWaitState as lu, formatTokenCount as m, IToolFactory as ma, IEventContext as mc, TOOL_SCHEMA_PROJECTION_MAX_NODES as mi, ModelNotAvailableError as ml, IToolResultSpillStore as mn, IToolWithEventService as mo, ISchemaClosureChange as mr, IExecutionJournal as ms, TResolveInWorkspace as mt, TLoggerData as mu, decodeHookVerdict as n, getToolEstimatedDuration as na, AbstractEventService as nc, AbstractPlugin as ni, TModelFallbackCallback as nl, isRegistryTransactionError as nn, TProviderModelLifecycle as no, IMediaProviderOverrides as nr, validateAgainstJsonSchema as ns, toolNameMatches as nt, isUserMessage as nu, MODEL_PRICES as o, CONFIRM_NO as oa, StructuredEventService as oc, TProviderLoggingData as oi, readProviderFailureDetails as ol, AgentTemplates as on, formatSupportedProviderTypes as oo, TEnvResolver as or, IZodSchemaDef as os, isProtectedPath as ot, IToolContinuationPrompt as ou, findModelDefinition as p, IOpenAPIToolConfig as pa, IBaseEventData as pc, TOOL_SCHEMA_PROJECTION_MAX_DEPTH as pi, IProviderFailureDetails as pl, IToolResultAdmissionOptions as pn, IToolContract as po, hasValidationConstraints as pr, IExecutionContinuationState as ps, IReadOnlyCommandContext as pt, TContextData as pu, TToolArgs as q, IProviderModelCatalog as qa, IProviderSpecificOptions as qc, IConversationServiceOptions as qi, TUniversalMessageMetadata as ql, LocalExecutor as qn, IRunOptions as qo, validateProviderName as qr, TOOL_BODY_EVENTS as qs, collectAssistantUsageMetadata as qt, GuardrailExecutor as r, getToolExecutionSteps as ra, DEFAULT_ABSTRACT_EVENT_SERVICE as rc, AbstractAIProvider as ri, IProviderFailureClassification as rl, lifecycleOf as rn, TProviderSetupField as ro, createImageProviderFromDefinition as rr, ISchemaConversionOptions as rs, ICriticalPathContext as rt, messageToHistoryEntry as ru, calculateModelCost as s, CONFIRM_YES as sa, bindEventServiceOwner as sc, IToolSchemaProjection as si, scrubSecrets as sl, ITemplateApplicationResult as sn, getProviderCredentialRequirement as so, createRecordEnvResolver as sr, IResponseFormatConfig as ss, removesCriticalPath as st, IToolWaitRequest as su, isEnforcing as t, TToolProgressCallback as ta, TASK_EVENT_PREFIX as tc, AbstractExecutor as ti, IModelFallbackNotice as tl, IRegistryTransactionStep as tn, TProviderModelCatalogStatus as to, normalizeProviderConfig as tr, parseStructuredResponseText as ts, requiresFreshApproval as tt, isToolMessage as tu, DEFAULT_CONTEXT_WINDOW as u, multiSelectAction as ua, generateSpanId as uc, PARAMETER_SCHEMA_KEYWORDS as ui, CacheIntegrityError as ul, IAgentLifecycleEvents as un, IAgentTemplate as uo, resolveStructuredOutputCapability as ur, ICacheOptions as us, UNCLASSIFIED_TOOL_FALLBACK as ut, TComplexConfigValue as uu, registerModelMetadata as v, IMediaProviderConfig as va, IExecutionEventData as vc, projectToolSchema as vi, RateLimitError as vl, admitToolResult as vn, ILoggerOptions as vo, callJournaledProvider as vr, IResumeExecutionOptions as vs, TPermissionDecision$1 as vt, TypeUtils as vu, IContextTokenEstimateOptions as w, IImageEditRequest as wa, TEventUniversalValue as wc, IDirent as wi, TErrorExternalInput as wl, TOOL_EVENTS as wn, getGlobalLoggerSink as wo, subprocessTraceEnvironment as wr, IParameterValidationResult as ws, withEventEmission as wt, readTokenUsageFromMetadata as x, findMediaProviderDefinition as xa, TEventExtensionValue as xc, AbstractAgent as xi, StorageError as xl, IDestroyResult as xn, TUtilLogLevel as xo, outboundTraceContextFor as xr, TExecutionJournalRecord as xs, TTrustLevel as xt, IMessageTokenUsage as y, IMediaProviderCredentialRequirement as ya, IOwnerPathSegment as yc, AbstractManager as yi, RobotaError as yl, wasToolResultAdmitted as yn, IUtilLogEntry as yo, buildTraceparent as yr, IResumeToolCallsOptions as ys, TPermissionMode as yt, IPermissionPolicyContext as z, isVideoGenerationProvider as za, TToolChoice as zc, ILocalExecutorConfig as zi, ISystemMessage as zl, TOutputRetention as zn, PluginCategory as zo, ExecutionSuspendedError as zr, IActionRequest as zs, TOrchestrationPrimitive as zt };
+//# sourceMappingURL=index-gEUh4G-t.d.cts.map