la-machina-engine 0.3.0 → 0.4.0

package/dist/index.d.cts

@@ -4,6 +4,108 @@ import { ContentBlockParam, MessageParam } from '@anthropic-ai/sdk/resources/mes
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
 
+/**
+ * Public types for the `ApiCall` built-in tool (Plan 020).
+ *
+ * All names are suffixed `V1`. A future incompatible change ships as
+ * `V2` alongside, never in place — users of the V1 shapes never have
+ * to migrate.
+ *
+ * The `ApiAuthV1` union is the engine's pluggable-auth protocol:
+ *   - `none` / `bearer` / `header` / `basic` are first-class; the
+ *     engine resolves them from the `env` map at dispatch time.
+ *   - `custom` hands full control to a caller-supplied resolver,
+ *     which is where OAuth-refresh, HMAC signing, JWT minting, and
+ *     other dynamic schemes live.
+ *
+ * Secret values themselves never appear in these types. The `*Ref`
+ * fields are opaque lookup keys into the env map (for built-ins) or
+ * identifiers the resolver interprets (for `custom`).
+ */
+type ApiHttpMethodV1 = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type ApiAuthV1 = {
+    readonly type: 'none';
+} | {
+    readonly type: 'bearer';
+    readonly tokenRef: string;
+} | {
+    readonly type: 'header';
+    readonly name: string;
+    readonly valueRef: string;
+} | {
+    readonly type: 'basic';
+    readonly userRef: string;
+    readonly passRef: string;
+} | {
+    readonly type: 'custom';
+    readonly id: string;
+};
+interface ApiServiceV1 {
+    /** Stable enum value the model picks. Must be non-empty. */
+    readonly name: string;
+    /** Optional short description of the service; appears in the tool description. */
+    readonly description?: string;
+    /** Base URL prepended to the model-supplied path. No trailing slash required. */
+    readonly baseUrl: string;
+    /** Default: `{ type: 'none' }`. */
+    readonly auth?: ApiAuthV1;
+    /**
+     * Path allowlist. String entries match by `.startsWith()`; RegExp
+     * entries by `.test()`. Empty / undefined = any path allowed.
+     */
+    readonly allowedPaths?: ReadonlyArray<string | RegExp>;
+    /** HTTP methods permitted. Empty / undefined = any of the ApiHttpMethodV1 set. */
+    readonly allowedMethods?: readonly ApiHttpMethodV1[];
+    /** Default headers merged into every request (can be overridden by auth headers). */
+    readonly defaultHeaders?: Readonly<Record<string, string>>;
+    /** Request body size cap in bytes (after JSON.stringify). Default 256 KB. */
+    readonly maxBodyBytes?: number;
+}
+/** Context the engine hands to `ApiAuthResolverV1` on every dispatch. */
+interface ApiResolverCtxV1 {
+    readonly serviceName: string;
+    readonly method: ApiHttpMethodV1;
+    readonly path: string;
+}
+/**
+ * Caller-supplied auth resolver. Called once per ApiCall dispatch
+ * for `custom` auth types, or for built-in types when the caller
+ * supplies their own resolver (it wins over the engine's built-in
+ * env lookup).
+ *
+ * Must return the exact HTTP headers to attach to the outgoing
+ * fetch. The engine merges these after default + user headers, so
+ * resolver-returned headers always win.
+ */
+type ApiAuthResolverV1 = (auth: ApiAuthV1, ctx: ApiResolverCtxV1) => Promise<Readonly<Record<string, string>>>;
+/** Payload for the `onRequest` observability hook. No secrets. */
+interface ApiRequestEventV1 {
+    readonly service: string;
+    readonly method: ApiHttpMethodV1;
+    readonly path: string;
+}
+/** Payload for the `onResponse` observability hook. No secrets. */
+interface ApiResponseEventV1 extends ApiRequestEventV1 {
+    readonly status: number;
+    readonly latencyMs: number;
+    readonly bytesIn: number;
+}
+/**
+ * Fully-resolved runtime api config. `env`, `resolveAuth`, and the
+ * hook callbacks live HERE (runtime-only) rather than on the Zod-
+ * validated ResolvedConfig, so they can't leak through schema
+ * serialization. See Plan 020 §2.
+ */
+interface ResolvedApiConfigV1 {
+    readonly services: readonly ApiServiceV1[];
+    readonly env?: Readonly<Record<string, string>> | undefined;
+    readonly resolveAuth?: ApiAuthResolverV1 | undefined;
+    readonly onRequest?: ((e: ApiRequestEventV1) => void | Promise<void>) | undefined;
+    readonly onResponse?: ((e: ApiResponseEventV1) => void | Promise<void>) | undefined;
+    /** Response body size cap in bytes. Default 100 KB. */
+    readonly maxResponseBytes?: number | undefined;
+}
+
 /**
  * StorageAdapter — abstract filesystem interface for la-machina-engine.
  *
@@ -468,6 +570,24 @@ interface Tool$1<TSchema extends z.ZodTypeAny = z.ZodTypeAny> {
      * under `exactOptionalPropertyTypes`.
      */
     isConcurrencySafe?: ((input: unknown) => boolean) | undefined;
+    /**
+     * Declares that this tool needs Node-only capabilities
+     * (`node:child_process`, the real filesystem, stdio-based MCP, etc.)
+     * When true AND the runtime can't support them, the engine replaces
+     * this tool with a capability stub (see `src/tools/capabilityStub.ts`)
+     * that returns a structured `isError` result instead of crashing.
+     *
+     * Leave undefined / false for tools that work anywhere (Read, Write,
+     * WebFetch, http-based MCP). Default: false.
+     */
+    readonly requiresNode?: boolean;
+    /**
+     * Internal marker set by `capabilityStub()` so the agent-loop's
+     * runner-handoff check (Plan 019 §4) can distinguish a stubbed tool
+     * from a real one without reflecting on the implementation.
+     * Do not set this manually.
+     */
+    readonly isCapabilityStub?: boolean;
     execute(input: z.infer<TSchema>, context: ToolContext): Promise<ToolResult>;
 }
 /**
@@ -848,6 +968,42 @@ interface ResolvedLoggingConfig {
     readonly level: LogLevel;
     readonly sink: LogSink;
 }
+/**
+ * Built-in ApiCall tool config (Plan 020).
+ *
+ * When `services` is non-empty, the engine auto-registers the
+ * `ApiCall` tool so the model can call tenant-configured external
+ * HTTP APIs without ever seeing credentials.
+ *
+ * `env`, `resolveAuth`, and the hook callbacks are INTENTIONALLY
+ * omitted from the Zod schema — they are runtime-only fields
+ * carried alongside ResolvedConfig. This structural split is the
+ * non-persistence guarantee: `JSON.stringify` of the schema-parsed
+ * config can never leak secrets.
+ */
+interface ResolvedApiConfig {
+    readonly services: readonly ApiServiceV1[];
+    readonly env?: Readonly<Record<string, string>> | undefined;
+    readonly resolveAuth?: ApiAuthResolverV1 | undefined;
+    readonly onRequest?: ((e: ApiRequestEventV1) => void | Promise<void>) | undefined;
+    readonly onResponse?: ((e: ApiResponseEventV1) => void | Promise<void>) | undefined;
+    readonly maxResponseBytes?: number | undefined;
+}
+/**
+ * Runner handoff config (Plan 019). When set, async runs on a
+ * restricted runtime (e.g. Cloudflare Workers) can hand off the run
+ * to a Node-side runner process via a single `POST { runId }` to
+ * `url`, authenticated with a bearer token (`secret`).
+ *
+ * Absent means no handoff ever happens — sync runs degrade via
+ * capability stubs, and async runs degrade the same way.
+ */
+interface ResolvedRunnerConfig {
+    /** Runner HTTP endpoint (e.g. `https://my-runner.example.com/continue`). */
+    readonly url: string;
+    /** Shared bearer token the engine sends in `Authorization: Bearer <secret>`. */
+    readonly secret: string;
+}
 interface ResolvedConfig {
     readonly model: ResolvedModelConfig;
     readonly storage: ResolvedStorageConfig;
@@ -864,6 +1020,15 @@ interface ResolvedConfig {
     readonly compaction: ResolvedCompactionConfig;
     readonly coordinator: ResolvedCoordinatorConfig;
     readonly orchestrator: ResolvedOrchestratorConfig;
+    /** Optional runner handoff config (Plan 019). Absent = no handoff. */
+    readonly runner?: ResolvedRunnerConfig | undefined;
+    /**
+     * Optional built-in ApiCall tool config (Plan 020). When set, the
+     * `ApiCall` tool is auto-registered. Env + callbacks are runtime-
+     * only fields — excluded from `ResolvedConfigSchema` to prevent
+     * secret serialization.
+     */
+    readonly api?: ResolvedApiConfig | undefined;
 }
 
 type DeepPartial<T> = T extends readonly unknown[] ? T : T extends object ? {
@@ -1650,6 +1815,20 @@ interface RunOptions {
      * by the `SkillPage` tool.
      */
     readonly skills?: ReadonlyArray<SkillOverride> | undefined;
+    /**
+     * Per-run ApiCall override (Plan 020). When any field is present,
+     * it overrides the matching field on `config.api`. Typical
+     * multi-tenant usage: one engine instance, each run passes its
+     * tenant's services + env via this field. Env + callbacks live
+     * here (runtime-only) and are never serialized.
+     */
+    readonly api?: {
+        readonly services?: ReadonlyArray<ApiServiceV1>;
+        readonly env?: Readonly<Record<string, string>>;
+        readonly resolveAuth?: ApiAuthResolverV1;
+        readonly onRequest?: (e: ApiRequestEventV1) => void | Promise<void>;
+        readonly onResponse?: (e: ApiResponseEventV1) => void | Promise<void>;
+    } | undefined;
 }
 interface TokenUsage {
     readonly input: number;
@@ -1674,7 +1853,7 @@ interface TokenUsage {
  * Kept in the union so the v0.2 change is backwards-compatible (no type
  * narrowing in callers that already switch on the full set).
  */
-type PauseReason = 'gate_required' | 'subagent_gate_required' | 'max_turns' | 'explicit' | 'timeout';
+type PauseReason = 'gate_required' | 'subagent_gate_required' | 'handoff_to_runner' | 'max_turns' | 'explicit' | 'timeout';
 interface RunSnapshot {
     readonly version: 1;
     readonly status: 'paused';
@@ -1744,6 +1923,18 @@ interface ResumeOptions {
      * consistent. Overrides are not persisted in the snapshot.
      */
     readonly skills?: ReadonlyArray<SkillOverride> | undefined;
+    /**
+     * Per-resume ApiCall override (Plan 020). Mirrors `RunOptions.api`.
+     * Pass the same env you used on start() — credentials are never
+     * persisted in the snapshot, so callers must re-supply them.
+     */
+    readonly api?: {
+        readonly services?: ReadonlyArray<ApiServiceV1>;
+        readonly env?: Readonly<Record<string, string>>;
+        readonly resolveAuth?: ApiAuthResolverV1;
+        readonly onRequest?: (e: ApiRequestEventV1) => void | Promise<void>;
+        readonly onResponse?: (e: ApiResponseEventV1) => void | Promise<void>;
+    } | undefined;
 }
 
 /**
@@ -1820,6 +2011,13 @@ interface ResponseMeta {
     readonly pendingToolCall?: RunSnapshot['pendingToolCall'];
     readonly pauseReason?: PauseReason;
     readonly transcript?: TranscriptLocation;
+    /**
+     * Plan 019 — names of tools whose capability-stub fired during this
+     * run (deduped). Callers can detect "this run ran against a runtime
+     * that couldn't execute these tools" and retry as async with a
+     * runner configured. Absent when no stub fired.
+     */
+    readonly capabilitiesMissing?: readonly string[];
     /** Additional context-specific fields (e.g., activity, lastTool, cancelled). */
     readonly [key: string]: unknown;
 }
@@ -1840,6 +2038,8 @@ declare function toResponse(result: RunResult, extra: {
     nodeId: string;
     durationMs: number;
     logPath?: string;
+    /** Plan 019 — capability-stub names observed during the run. */
+    capabilitiesMissing?: readonly string[];
 }): EngineResponse;
 
 /**
@@ -2044,8 +2244,20 @@ declare class Engine {
     private readonly backgroundExecutor;
     private readonly webhookDispatcher;
     constructor(config: ResolvedConfig, internals?: EngineInternals);
-    run(options: RunOptions): Promise<EngineResponse>;
-    resume(options: ResumeOptions): Promise<EngineResponse>;
+    /**
+     * Run a task synchronously to completion. The `_internal` parameter is
+     * reserved for the engine's own async wrappers (`start`, `resumeAsync`)
+     * to request runner handoff (Plan 019) — external callers must leave
+     * it unset. Sync callers never hand off; if they hit a Node-only tool
+     * on a restricted runtime, the capability stub returns an error and
+     * the model adapts.
+     */
+    run(options: RunOptions, _internal?: {
+        handoffToRunner?: boolean;
+    }): Promise<EngineResponse>;
+    resume(options: ResumeOptions, _internal?: {
+        handoffToRunner?: boolean;
+    }): Promise<EngineResponse>;
     /**
      * Load a paused snapshot from storage using runId (and optional nodeId).
      * If nodeId is not provided, finds the most recently paused node.
@@ -2105,6 +2317,18 @@ declare class Engine {
     recoverOrphanedRuns(opts?: {
         staleThresholdMs?: number;
     }): Promise<readonly RunState[]>;
+    /**
+     * When the response indicates the run paused for runner handoff, POST
+     * `{ runId }` to the configured runner URL. On success, return the
+     * response unchanged — state stays `paused` and the runner will flip
+     * it to `done` (or `failed`) on its side. On POST failure, convert
+     * the response to `failed` with `ERR_RUNNER_UNREACHABLE` so the
+     * caller sees a terminal state instead of a silent hang.
+     *
+     * Called only from `start()` / `resumeAsync()`. Sync `run()` never
+     * produces a `handoff_to_runner` pause (see `_internal.handoffToRunner`).
+     */
+    private maybeHandoffToRunner;
     private maybeFireWebhook;
     private dispatchWebhookWithRetries;
     /**
@@ -2185,6 +2409,17 @@ declare class Engine {
      *   - else → undefined (SkillPage tool not registered)
      */
     private resolveSkillSource;
+    /**
+     * Plan 020 — resolve the effective ApiCall config for a run.
+     *
+     * Precedence (each field independently):
+     *   RunOptions.api.X > config.api.X
+     *
+     * If neither side provides any services, returns undefined so the
+     * tool isn't registered at all. Env + resolveAuth + hooks flow
+     * through untouched — they never hit the Zod schema.
+     */
+    private resolveApiConfig;
     /**
      * Build a throttled heartbeat callback for agentLoop's `onProgress` hook.
      *
@@ -2450,6 +2685,37 @@ declare class RunTimeoutError extends EngineError {
     constructor(timeoutMs: number);
 }
 
+/**
+ * Capability stub — replaces a Node-only tool with a placeholder that
+ * returns a structured `isError` result when invoked in a runtime that
+ * can't execute it (e.g. Cloudflare Workers for Bash / stdio MCP).
+ *
+ * The stub preserves the original tool's name and description so the
+ * model still sees the tool in its toolset and can decide whether to
+ * call it. When called, the stub returns a clear message naming the
+ * tool and pointing at the runner-handoff escape hatch (Plan 019).
+ *
+ * In async runs with `config.runner` configured, the agent loop
+ * intercepts stub invocations BEFORE they execute and pauses the run
+ * with `pauseReason: 'handoff_to_runner'` so a Node-side runner can
+ * resume it. In sync runs (or async runs with no runner configured),
+ * the stub's `execute` actually runs and the model adapts its answer.
+ */
+
+/**
+ * Build a stub tool that mirrors `original.name` and `original.description`
+ * but returns an `isError` result when invoked. Used by the engine when
+ * a tool declares `requiresNode: true` and `canSpawnProcesses()` is false.
+ */
+declare function capabilityStub(original: Pick<Tool$1, 'name' | 'description'>): Tool$1;
+/**
+ * Convenience: given a tool, return the real tool when the runtime can
+ * execute it, otherwise a capability stub standing in for it. Callers
+ * that already know the spawn-availability flag (e.g. engine.ts which
+ * caches it) pass it directly instead of re-probing.
+ */
+declare function withCapabilityCheck(tool: Tool$1, spawnAvailable: boolean): Tool$1;
+
 /**
  * Structured JSON output — schema injection, parsing, validation.
  *
@@ -2947,6 +3213,43 @@ declare class InlineSkillSource implements SkillSource {
     private assertUrlAllowed;
 }
 
+/**
+ * ApiCall — built-in tool for calling tenant-configured external
+ * HTTP APIs without the model ever seeing credentials (Plan 020).
+ *
+ * The caller describes a set of `ApiServiceV1`s, supplies an `env`
+ * map of credential values (or a `resolveAuth` callback for dynamic
+ * auth), and this factory returns a `Tool` ready to register. The
+ * model picks a service from a closed-over enum + issues a request;
+ * the tool resolves auth, enforces per-service allowlists, fetches,
+ * and returns the response. Credentials live only in the closure —
+ * never in input, output, or any engine-persisted surface.
+ *
+ * Safety rails (all enforced per-call, first failure wins):
+ *   1. `service` must be in the closed enum.
+ *   2. Method must pass `allowedMethods` if set.
+ *   3. Path must match an `allowedPaths` entry if set.
+ *   4. Request body cannot exceed `maxBodyBytes` (default 256 KB).
+ *   5. Model-supplied headers cannot override auth headers (the
+ *      sanitizer strips case-insensitive collisions).
+ *
+ * Response body is size-capped at `maxResponseBytes` (default 100 KB)
+ * with a trailing truncation marker.
+ */
+
+interface CreateApiCallToolOptions {
+    readonly services: readonly ApiServiceV1[];
+    readonly env?: Readonly<Record<string, string>>;
+    readonly resolveAuth?: ApiAuthResolverV1;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly maxResponseBytes?: number;
+    readonly onRequest?: (e: ApiRequestEventV1) => void | Promise<void>;
+    readonly onResponse?: (e: ApiResponseEventV1) => void | Promise<void>;
+    readonly toolName?: string;
+    readonly toolDescription?: string;
+}
+declare function createApiCallTool(opts: CreateApiCallToolOptions): Tool$1;
+
 /**
  * Runtime detection — determines whether the engine is running in
  * Node.js or a restricted runtime (Cloudflare Workers, etc.)
@@ -3584,4 +3887,4 @@ declare const ENGINE_VERSION = "0.0.0";
  */
 declare function initEngine(user?: UserConfig): Engine;
 
-export { AISdkAdapter, type AgentDefinition, AnthropicAdapter, ApiError, AuthError, type BackgroundAgentResult, type BackgroundExecutor, BindingHttpTransport, type BuildSystemPromptOptions, ConfigError, DEFAULT_SAMPLING_MAX_DEPTH, ENGINE_VERSION, Engine, EngineError, type EngineInternals, type EngineResponse, type EngineStorage, type Engram, type EngramConfidence, type EngramKind, type EngramScope, type EngramSource, type Entry, type Episode, EpisodicMemory, type FileSnapshot, type FileStat, type FlushPolicy, type GateBeforeToolHook, type GateDecision$1 as GateDecision, Hippocampus, InlineSkillSource, type LoadedSkill, LocalStorageAdapter, type LogEntry, type LogLevel, type LogSink, type Logger, type LoopProgress, MAX_ATTEMPTS, type McpCallResult, McpClient, McpConnectionError, type McpInstructionDelta, McpManager, McpProtocolError, type McpServerState, McpTimeoutError, type McpToolDef, type MemoryMode, type MemoryScope, type ModelAdapter, type ModelMessage, type ModelProvider, type ModelToolDefinition, NodeBackgroundExecutor, type NormalizedEvent, NotImplementedError, type OrchestrateOptions, type OrchestratorResult, type PauseReason, type PermissionAction, type PermissionDecision, type PermissionMode, type PermissionPolicy, type PermissionRule, type Plan, PlanSchema, type PlanStep, PlanStepSchema, type PostRunEvent, type PostRunHook, type PostToolCallEvent$1 as PostToolCallEvent, type PostToolCallHook, type PostTurnEvent, type PostTurnHook, type PreRunEvent, type PreRunHook, type PreToolCallEvent$1 as PreToolCallEvent, type PreToolCallHook, type PreTurnEvent, type PreTurnHook, R2BindingStorageAdapter, type R2BucketBinding, type R2ClientConfig, R2StorageAdapter, RETRY_DELAYS_MS, RateLimitError, type ResolvedAgentsConfig, type ResolvedConfig, type ResolvedCoordinatorConfig, type ResolvedExecutionConfig, type ResolvedHooksConfig, type ResolvedLoggingConfig, type ResolvedMcpConfig, type ResolvedMcpHttpServerConfig, type ResolvedMcpServerConfig, type ResolvedMcpSseServerConfig, type ResolvedMcpStdioServerConfig, type ResolvedMemoryConfig, type ResolvedModelConfig, type ResolvedOrchestratorConfig, type ResolvedPermissionsConfig, type ResolvedR2Config, type ResolvedSkill, type ResolvedSkillsConfig, type ResolvedStorageConfig, type ResolvedToolsConfig, type ResolvedTranscriptConfig, type ResponseError, type ResponseMeta, type ResumeAsyncOptions, type ResumeOptions, type RetryPolicy, type RunOptions, type RunProgress, type RunResult, type RunSnapshot, type RunState, RunStateManager, type RunStatus, RunTimeoutError, type RuntimeKind, SAFE_TOOL_ALLOWLIST, type SamplingContext, type SamplingHandler, type SamplingMessage, type SamplingModelPreferences, type SamplingRequest, type SamplingResponse, type SamplingTextBlock, type SerializedAgent, type SkillOverride, type SkillPageOverride, type SkillSource, type SmartMemory, type SmartMemoryConfig, type SpawnResult, type StartOptions, type StepResult, type StepStatus, type StopHook, type StopHookEvent, type StopHookResult, type StorageAdapter, StorageError, type StorageProvider, StorageSkillSource, StreamIncompleteError, StreamParseError, type StreamRequest, StreamingToolExecutor, SubagentRegistry, type SubagentRegistryOptions, type TokenUsage, type Tool$1 as Tool, type ToolContext, ToolRegistry, type ToolResult, type TranscriptLocation, type TranscriptMeta, type TranscriptStatus, type UserConfig, type WaitForOptions, type WebhookConfig, type WebhookDelivery, WebhookDispatcher, type WebhookEvent, type WebhookOptions, adaptMcpTool, buildForkedMessages, buildPermissionPolicy, buildSchemaPrompt, buildSystemPrompt, buildWorkerAgent, canSpawnProcesses, createLogger, createModelAdapter, createSendMessageTool, createSkillPageTool, createSmartMemory, defaultSamplingHandler, defineTool, detectRuntime, getCoordinatorBasePrompt, getCoordinatorSystemPrompt, hasProcessLifecycle, initEngine, isCoordinatorMode, isInForkChild, isSafeTool, loadAgents, loadSkills, matchesRule, mcpToolName, orchestrate, parsePlan, parseRule, parseRules, partitionToolCalls, restoreSnapshot, runWithRetry, signPayload, snapshotFiles, synthesizeSpec, toResponse, tryParseJSON, validateOutput };
+export { AISdkAdapter, type AgentDefinition, AnthropicAdapter, type ApiAuthResolverV1, type ApiAuthV1, ApiError, type ApiHttpMethodV1, type ApiRequestEventV1, type ApiResolverCtxV1, type ApiResponseEventV1, type ApiServiceV1, AuthError, type BackgroundAgentResult, type BackgroundExecutor, BindingHttpTransport, type BuildSystemPromptOptions, ConfigError, type CreateApiCallToolOptions, DEFAULT_SAMPLING_MAX_DEPTH, ENGINE_VERSION, Engine, EngineError, type EngineInternals, type EngineResponse, type EngineStorage, type Engram, type EngramConfidence, type EngramKind, type EngramScope, type EngramSource, type Entry, type Episode, EpisodicMemory, type FileSnapshot, type FileStat, type FlushPolicy, type GateBeforeToolHook, type GateDecision$1 as GateDecision, Hippocampus, InlineSkillSource, type LoadedSkill, LocalStorageAdapter, type LogEntry, type LogLevel, type LogSink, type Logger, type LoopProgress, MAX_ATTEMPTS, type McpCallResult, McpClient, McpConnectionError, type McpInstructionDelta, McpManager, McpProtocolError, type McpServerState, McpTimeoutError, type McpToolDef, type MemoryMode, type MemoryScope, type ModelAdapter, type ModelMessage, type ModelProvider, type ModelToolDefinition, NodeBackgroundExecutor, type NormalizedEvent, NotImplementedError, type OrchestrateOptions, type OrchestratorResult, type PauseReason, type PermissionAction, type PermissionDecision, type PermissionMode, type PermissionPolicy, type PermissionRule, type Plan, PlanSchema, type PlanStep, PlanStepSchema, type PostRunEvent, type PostRunHook, type PostToolCallEvent$1 as PostToolCallEvent, type PostToolCallHook, type PostTurnEvent, type PostTurnHook, type PreRunEvent, type PreRunHook, type PreToolCallEvent$1 as PreToolCallEvent, type PreToolCallHook, type PreTurnEvent, type PreTurnHook, R2BindingStorageAdapter, type R2BucketBinding, type R2ClientConfig, R2StorageAdapter, RETRY_DELAYS_MS, RateLimitError, type ResolvedAgentsConfig, type ResolvedApiConfig, type ResolvedApiConfigV1, type ResolvedConfig, type ResolvedCoordinatorConfig, type ResolvedExecutionConfig, type ResolvedHooksConfig, type ResolvedLoggingConfig, type ResolvedMcpConfig, type ResolvedMcpHttpServerConfig, type ResolvedMcpServerConfig, type ResolvedMcpSseServerConfig, type ResolvedMcpStdioServerConfig, type ResolvedMemoryConfig, type ResolvedModelConfig, type ResolvedOrchestratorConfig, type ResolvedPermissionsConfig, type ResolvedR2Config, type ResolvedRunnerConfig, type ResolvedSkill, type ResolvedSkillsConfig, type ResolvedStorageConfig, type ResolvedToolsConfig, type ResolvedTranscriptConfig, type ResponseError, type ResponseMeta, type ResumeAsyncOptions, type ResumeOptions, type RetryPolicy, type RunOptions, type RunProgress, type RunResult, type RunSnapshot, type RunState, RunStateManager, type RunStatus, RunTimeoutError, type RuntimeKind, SAFE_TOOL_ALLOWLIST, type SamplingContext, type SamplingHandler, type SamplingMessage, type SamplingModelPreferences, type SamplingRequest, type SamplingResponse, type SamplingTextBlock, type SerializedAgent, type SkillOverride, type SkillPageOverride, type SkillSource, type SmartMemory, type SmartMemoryConfig, type SpawnResult, type StartOptions, type StepResult, type StepStatus, type StopHook, type StopHookEvent, type StopHookResult, type StorageAdapter, StorageError, type StorageProvider, StorageSkillSource, StreamIncompleteError, StreamParseError, type StreamRequest, StreamingToolExecutor, SubagentRegistry, type SubagentRegistryOptions, type TokenUsage, type Tool$1 as Tool, type ToolContext, ToolRegistry, type ToolResult, type TranscriptLocation, type TranscriptMeta, type TranscriptStatus, type UserConfig, type WaitForOptions, type WebhookConfig, type WebhookDelivery, WebhookDispatcher, type WebhookEvent, type WebhookOptions, adaptMcpTool, buildForkedMessages, buildPermissionPolicy, buildSchemaPrompt, buildSystemPrompt, buildWorkerAgent, canSpawnProcesses, capabilityStub, createApiCallTool, createLogger, createModelAdapter, createSendMessageTool, createSkillPageTool, createSmartMemory, defaultSamplingHandler, defineTool, detectRuntime, getCoordinatorBasePrompt, getCoordinatorSystemPrompt, hasProcessLifecycle, initEngine, isCoordinatorMode, isInForkChild, isSafeTool, loadAgents, loadSkills, matchesRule, mcpToolName, orchestrate, parsePlan, parseRule, parseRules, partitionToolCalls, restoreSnapshot, runWithRetry, signPayload, snapshotFiles, synthesizeSpec, toResponse, tryParseJSON, validateOutput, withCapabilityCheck };