@agentfield/sdk 0.1.101 → 0.1.102-rc.2

package/dist/index.d.ts

@@ -7,6 +7,112 @@ import { WriteStream } from 'node:tty';
 import { ToolSet } from 'ai';
 import { JWK } from 'jose';
 
+type PauseLogger = {
+    info(message: string, meta?: Record<string, unknown>): void;
+};
+/** Canonical human-decision values carried on an {@link ApprovalResult}. */
+type ApprovalDecision = 'approved' | 'rejected' | 'request_changes' | 'expired' | 'error' | 'cancelled' | (string & {});
+/**
+ * The outcome of a paused execution once a human (or upstream service)
+ * resolves it. Mirrors the Python SDK's `ApprovalResult` dataclass so a
+ * reasoner authored against either SDK reads the same fields.
+ */
+declare class ApprovalResult {
+    readonly decision: ApprovalDecision;
+    readonly feedback: string;
+    readonly executionId: string;
+    readonly approvalRequestId: string;
+    readonly rawResponse?: Record<string, any>;
+    constructor(params: {
+        decision: ApprovalDecision;
+        feedback?: string;
+        executionId?: string;
+        approvalRequestId?: string;
+        rawResponse?: Record<string, any>;
+    });
+    /** True when the human approved the request. */
+    get approved(): boolean;
+    /** True when the human asked for changes rather than approving/rejecting. */
+    get changesRequested(): boolean;
+}
+/**
+ * Tracks how long a single execution has spent inside `ctx.pause()`.
+ *
+ * The async-execution watchdog (see Agent.runReasonerAsync) must not count
+ * time spent waiting for an external approval against the reasoner's active
+ * wall-clock budget — otherwise `expiresInHours` on a pause would be silently
+ * capped at the reasoner timeout. The watchdog reads `totalPaused()` and
+ * subtracts it from elapsed wall-clock. On the awaiter side, the same clock
+ * is used so a parent that is blocked waiting on a paused descendant does not
+ * burn its own budget.
+ *
+ * A reasoner runs as a single async chain, so pause intervals cannot overlap
+ * on one clock; no locking is needed. All values are milliseconds.
+ */
+declare class PauseClock {
+    private totalPausedMs;
+    private pauseStartedAt;
+    /**
+     * Set by the watchdog when it aborts the reasoner for exceeding the active
+     * budget. Distinguishes a budget-timeout abort from an external cooperative
+     * cancel arriving via the cancel dispatcher.
+     */
+    timedOut: boolean;
+    startPause(): void;
+    endPause(): void;
+    /** Cumulative paused milliseconds, including any in-progress pause. */
+    totalPaused(): number;
+}
+/**
+ * Registry of pending execution-pause promises resolved via webhook callback.
+ *
+ * Each `ctx.pause()` call registers a promise keyed by `approvalRequestId`.
+ * When the control plane POSTs a resolution to the agent's
+ * `/webhooks/approval` route, the matching promise is resolved and the paused
+ * reasoner unblocks. Mirrors the Python SDK's `_PauseManager`.
+ */
+declare class PauseManager {
+    private readonly pending;
+    /** execution_id -> approval_request_id, for fallback resolution. */
+    private readonly execToRequest;
+    /**
+     * Register a new pending pause and return the promise to await. Idempotent:
+     * a second register() for the same `approvalRequestId` returns the existing
+     * promise rather than replacing it.
+     */
+    register(approvalRequestId: string, executionId?: string): Promise<ApprovalResult>;
+    /**
+     * Resolve a pending pause by `approvalRequestId`. Returns true if a waiter
+     * was found and resolved, false otherwise.
+     */
+    resolve(approvalRequestId: string, result: ApprovalResult): boolean;
+    /**
+     * Fallback: resolve by `executionId` when the callback omits the
+     * `approvalRequestId`. Returns true if a waiter was found.
+     */
+    resolveByExecutionId(executionId: string, result: ApprovalResult): boolean;
+    /**
+     * Resolve every pending pause with a `cancelled` result. Used on shutdown so
+     * a reasoner blocked in `ctx.pause()` doesn't hang the process forever.
+     */
+    cancelAll(): void;
+    /** Number of currently-pending pauses. Useful for tests. */
+    pendingCount(): number;
+}
+/**
+ * Install the `POST /webhooks/approval` route on the agent's Express app.
+ *
+ * The control plane POSTs here (via the `callback_url` registered when the
+ * execution paused) once a human resolves the approval. The body carries
+ * `{ execution_id, decision, feedback, approval_request_id, response }`. We
+ * resolve the matching pending pause — first by `approval_request_id`, then by
+ * `execution_id` as a fallback — and reply `{ status, resolved }`.
+ *
+ * Always installed so the control plane reaches the worker regardless of which
+ * routes the user registered first (same rationale as installCancelRoute).
+ */
+declare function installApprovalWebhookRoute(app: express.Express, manager: PauseManager, logger?: PauseLogger): void;
+
 type ZodSchema<T> = z.Schema<T, z.ZodTypeDef, any>;
 interface AIRequestOptions {
     system?: string;
@@ -274,6 +380,51 @@ interface ExecutionStatusUpdate {
     progress?: number;
     statusReason?: string;
 }
+/** Metadata forwarded as `X-*` headers on execute / executeAsync dispatch. */
+interface ExecuteMetadata {
+    runId?: string;
+    workflowId?: string;
+    rootWorkflowId?: string;
+    parentExecutionId?: string;
+    reasonerId?: string;
+    sessionId?: string;
+    actorId?: string;
+    callerDid?: string;
+    targetDid?: string;
+    agentNodeDid?: string;
+    agentNodeId?: string;
+    replaySourceRunId?: string;
+    replayBeforeExecutionId?: string;
+    replayMode?: string;
+}
+/** Terminal (or in-flight) status snapshot from `GET /executions/{id}`. */
+interface ExecutionStatusSnapshot {
+    executionId: string;
+    status: string;
+    statusReason?: string;
+    result?: any;
+    error?: string;
+    errorDetails?: unknown;
+    durationMs?: number;
+}
+/** Options for {@link AgentFieldClient.waitForExecutionResult}. */
+interface WaitForExecutionOptions {
+    /** Total timeout in milliseconds. Omit for no wall-clock cap. */
+    timeoutMs?: number;
+    /** Initial poll interval in milliseconds (default: 1000). */
+    pollIntervalMs?: number;
+    /** Maximum poll interval in milliseconds (default: 5000). */
+    maxIntervalMs?: number;
+    /**
+     * Pause-clock whose paused time is excluded from the wall-clock timeout, so
+     * a parent awaiting a paused descendant does not spuriously time out.
+     */
+    pauseClock?: PauseClock;
+    /** Fired once when the awaited child transitions into `waiting`. */
+    onChildWaiting?: () => void | Promise<void>;
+    /** Fired once when the awaited child leaves `waiting` (back to running). */
+    onChildRunning?: () => void | Promise<void>;
+}
 interface RestartExecutionOptions {
     scope?: 'workflow' | 'execution';
     reuse?: 'succeeded-before' | 'all-succeeded' | 'none';
@@ -326,6 +477,61 @@ declare class AgentFieldClient {
     }): Promise<void>;
     publishExecutionLogs(payload: ExecutionLogTransportPayload): void;
     updateExecutionStatus(executionId: string, update: ExecutionStatusUpdate): Promise<void>;
+    /** Build the `X-*` dispatch headers shared by execute / executeAsync. */
+    private buildExecuteHeaders;
+    /**
+     * Submit an async execution and return its `execution_id`.
+     *
+     * POSTs to `/api/v1/execute/async/{target}`, which enqueues the execution
+     * and responds `202 Accepted` immediately (the control plane runs it and
+     * tracks status out-of-band). Use with {@link waitForExecutionResult} to
+     * poll for the terminal result without holding a synchronous connection —
+     * this is what lets a parent await a descendant that legitimately pauses
+     * (WAITING) for a long time without hitting the dispatch ceiling.
+     */
+    executeAsync(target: string, input: any, metadata?: ExecuteMetadata): Promise<string>;
+    /** Fetch the current status snapshot for an execution. */
+    getExecutionStatus(executionId: string): Promise<ExecutionStatusSnapshot>;
+    /**
+     * Poll an async execution until it reaches a terminal status, returning its
+     * result (or throwing on failure/cancellation/timeout).
+     *
+     * While polling, this observes the child's status transitions: when the
+     * child enters `waiting` it starts the supplied pause-clock and fires
+     * `onChildWaiting`; when the child leaves `waiting` it stops the clock and
+     * fires `onChildRunning`. Paused time is excluded from `timeoutMs`, so a
+     * parent awaiting a paused descendant does not time out while the descendant
+     * legitimately waits. Mirrors the Python SDK's `wait_for_execution_result`.
+     */
+    waitForExecutionResult<T = any>(executionId: string, opts?: WaitForExecutionOptions): Promise<T>;
+    /**
+     * Notify the control plane that THIS execution is now `waiting` or `running`
+     * because of its awaited child's state — the multi-hop pause propagation
+     * hook. Distinct from request-approval: no approval id, no webhook, no human.
+     * It exists purely so ancestors watching this execution see WAITING
+     * transitively while a descendant is paused, and stop counting wall-clock.
+     *
+     * POSTs to `/api/v1/agents/{node}/executions/{id}/awaiter-status`.
+     */
+    notifyAwaiterStatus(executionId: string, status: 'waiting' | 'running', reason?: string): Promise<void>;
+    /**
+     * Deliver a terminal execution result to the control plane, with retries.
+     *
+     * This is the out-of-band completion callback used by async-execution
+     * dispatch: after a reasoner has been 202-acked and run detached, its final
+     * status (`succeeded` / `failed` / `cancelled`) is POSTed to
+     * `/api/v1/executions/{id}/status`. Retries with exponential backoff because
+     * a dropped terminal callback would leave the execution stuck forever.
+     */
+    reportExecutionResult(executionId: string, payload: {
+        status: string;
+        result?: any;
+        error?: string;
+        errorDetails?: unknown;
+        durationMs?: number;
+        completedAt?: string;
+        reasoner?: string;
+    }, maxRetries?: number): Promise<boolean>;
     discoverCapabilities(options?: DiscoveryOptions): Promise<DiscoveryResult>;
     private mapDiscoveryResponse;
     private mapCompactDiscovery;
@@ -708,6 +914,22 @@ declare class ReasonerContext<TInput = any> {
     }>;
     aiStream(prompt: string, options?: AIRequestOptions): Promise<AIStream>;
     call(target: string, input: any): Promise<any>;
+    /**
+     * Pause this execution for external approval / resumption.
+     *
+     * Transitions the execution to `waiting` on the control plane and blocks
+     * until a decision arrives via the agent's approval webhook, or the timeout
+     * elapses (returning `{ decision: 'expired' }`). The caller creates the
+     * approval request on an external service first and passes its
+     * `approvalRequestId`. Delegates to {@link Agent.pause}. See its docs for the
+     * async-execution requirement that lets a pause outlive the dispatch ceiling.
+     */
+    pause(opts: {
+        approvalRequestId: string;
+        approvalRequestUrl?: string;
+        expiresInHours?: number;
+        timeoutMs?: number;
+    }): Promise<ApprovalResult>;
     discover(options?: DiscoveryOptions): Promise<DiscoveryResult>;
     note(message: string, tags?: string[]): void;
 }
@@ -879,6 +1101,25 @@ interface AgentConfig {
     verificationRefreshInterval?: number;
     /** Agent-level tags for tag-based authorization policies. */
     tags?: string[];
+    /**
+     * Enable async-execution dispatch (default: true). When enabled, a reasoner
+     * invoked by the control plane (i.e. carrying an `X-Execution-ID` header) is
+     * acknowledged immediately with `202 Accepted` and run detached; its terminal
+     * result is delivered out-of-band via `POST /executions/{id}/status`. This is
+     * what lets a reasoner call `ctx.pause()` and wait far longer than the
+     * control plane's synchronous dispatch ceiling. Set to `false` to keep the
+     * legacy behaviour of holding the HTTP connection open until the reasoner
+     * returns (in which case `ctx.pause()` is bounded by that ceiling).
+     */
+    asyncExecution?: boolean;
+    /**
+     * Active-time wall-clock budget for a detached reasoner, in milliseconds
+     * (default: 7_200_000 = 2h). Time spent inside `ctx.pause()` (and waiting on
+     * a paused descendant) is excluded from this budget. When active time exceeds
+     * it, the reasoner is aborted and reported as failed with reason
+     * `reasoner_timeout`. Only applies when `asyncExecution` is enabled.
+     */
+    executionBudgetMs?: number;
 }
 interface AIConfig {
     provider?: 'openai' | 'anthropic' | 'google' | 'mistral' | 'groq' | 'xai' | 'deepseek' | 'cohere' | 'openrouter' | 'ollama';
@@ -1164,7 +1405,26 @@ declare class Agent {
      *  code that respects `signal.aborted` (fetch, anthropic SDK, openai
      *  SDK, etc.). See ./cancel.ts. */
     private readonly cancelRegistry;
+    /** Registry of pending `ctx.pause()` promises, resolved by the
+     *  `/webhooks/approval` route when the control plane delivers a decision.
+     *  See ./pause.ts. */
+    private readonly pauseManager;
+    /** Per-execution pause clocks, keyed by execution_id. Present only for
+     *  detached (async-execution) reasoners; used to exclude pause/await time
+     *  from the reasoner's active wall-clock budget and from an awaiter's wait
+     *  timeout. See ./pause.ts. */
+    private readonly pauseClocks;
+    /** Execution-scoped approval client used by `Agent.pause()`. */
+    private readonly approvalClient;
     constructor(config: AgentConfig);
+    /** Coerce the loosely-typed `defaultHeaders` config into string headers. */
+    private sanitizeDefaultHeaders;
+    /**
+     * Resolve the externally-reachable base URL for this agent — the URL the
+     * control plane uses to call back (approval webhook, cancel). Mirrors the
+     * value published at registration time.
+     */
+    private resolvePublicUrl;
     reasoner<TInput = any, TOutput = any>(name: string, handler: ReasonerHandler<TInput, TOutput>, options?: ReasonerOptions): this;
     skill<TInput = any, TOutput = any>(name: string, handler: SkillHandler<TInput, TOutput>, options?: SkillOptions): this;
     includeRouter(router: AgentRouter): void;
@@ -1184,10 +1444,48 @@ declare class Agent {
     getWorkflowReporter(metadata: ExecutionMetadata): WorkflowReporter;
     getDidInterface(metadata: ExecutionMetadata, defaultInput?: any, targetName?: string): DidInterface;
     note(message: string, tags?: string[], metadata?: ExecutionMetadata): void;
+    /**
+     * Pause the current execution for external approval / resumption.
+     *
+     * Transitions the execution to `waiting` on the control plane, then blocks
+     * until the approval webhook callback resolves it or the timeout elapses.
+     * The caller is responsible for creating the approval request on an external
+     * service (e.g. hax-sdk) *before* calling this and passing the resulting
+     * `approvalRequestId`.
+     *
+     * Requires the agent to be serving (a reachable callback URL) and, to survive
+     * past the control plane's synchronous dispatch ceiling, requires
+     * async-execution dispatch to be enabled (the default). When async dispatch
+     * is disabled the pause still works but is bounded by that ceiling.
+     *
+     * Returns an {@link ApprovalResult}. On timeout it returns
+     * `{ decision: 'expired' }` rather than throwing. Mirrors the Python SDK's
+     * `Agent.pause()`.
+     */
+    pause(opts: {
+        approvalRequestId: string;
+        approvalRequestUrl?: string;
+        expiresInHours?: number;
+        timeoutMs?: number;
+        executionId?: string;
+    }): Promise<ApprovalResult>;
     private buildExecutionLogContext;
     serve(): Promise<void>;
     shutdown(): Promise<void>;
     call(target: string, input: any): Promise<any>;
+    /**
+     * Remote call variant that submits the execution asynchronously and polls for
+     * its result, instead of holding a synchronous connection open. This lets a
+     * caller await a descendant that legitimately pauses (WAITING) for a long
+     * time without tripping the control plane's synchronous dispatch ceiling.
+     *
+     * Multi-hop pause propagation: if the caller itself is a detached reasoner
+     * (has a registered pause-clock), then when the awaited child enters WAITING
+     * we push the caller's own execution to WAITING via awaiter-status — so any
+     * ancestor awaiting the caller transitively sees WAITING too and doesn't time
+     * out. Mirrors the propagation wiring in the Python SDK's `Agent.call`.
+     */
+    private callRemoteAsync;
     private registerDefaultRoutes;
     private executeReasoner;
     private executeSkill;
@@ -1207,6 +1505,35 @@ declare class Agent {
     private skillDefinitions;
     private discoveryPayload;
     private executeInvocation;
+    /**
+     * True when an incoming reasoner dispatch should run detached (202-ack).
+     *
+     * Requires async execution to be enabled AND the request to carry BOTH
+     * `X-Execution-ID` and `X-Run-ID`. The `X-Run-ID` header is the marker that
+     * the control plane dispatched this via an async-aware path — the workflow
+     * execute paths (`/execute`, `/execute/async`, agent-to-agent calls, triggers)
+     * always set it (see control-plane callAgent), and those paths wait for the
+     * out-of-band `/status` result. The legacy synchronous invoke endpoint
+     * (`POST /api/v1/reasoners/{node}.{reasoner}`) omits `X-Run-ID` for
+     * long-running agents and forwards the agent's HTTP response verbatim; it
+     * cannot handle a 202, so we must run synchronously there and return the
+     * result inline. Direct HTTP callers / tests without these headers likewise
+     * keep the synchronous request/response contract.
+     */
+    private shouldRunAsync;
+    /** True when the request carries a non-empty value for the given header. */
+    private hasHeader;
+    /**
+     * Run a reasoner detached after its dispatch was 202-acked, delivering the
+     * terminal status out-of-band via `POST /executions/{id}/status`.
+     *
+     * A pause-clock is registered for the execution so `ctx.pause()` (and any
+     * awaited paused descendant) can exclude its wait from the active wall-clock
+     * budget. A watchdog aborts the reasoner if active time exceeds the budget,
+     * guaranteeing the control plane always sees a terminal status even if the
+     * reasoner hangs. Mirrors the Python SDK's `_execute_async_with_callback`.
+     */
+    private runReasonerAsync;
     private runReasoner;
     private runSkill;
     private registerWithControlPlane;
@@ -2067,4 +2394,4 @@ declare class SessionTransportError extends Error {
 declare function normalizeSessionTransportValue(value: string): string;
 declare function validateSessionTransport(provider: string, transport: string): SessionTransportCapability;
 
-export { ACTIVE_STATUSES, AIClient, type AIConfig, type AIEmbeddingOptions, type AIRequestOptions, type AIStream, type AIToolRequestOptions, Agent, type AgentCapability, type AgentConfig, type AgentHandler, AgentRouter, type AgentRouterOptions, type AgentState, ApprovalClient, type ApprovalRequestResponse, type ApprovalStatusResponse, Audio, type AudioOutput, type AudioRequest, type AuditTrailExport, type AuditTrailFilters, type Awaitable, CANONICAL_STATUSES, type CompactCapability, type CompactDiscoveryResponse, DIDAuthenticator, type DIDIdentity, type DIDIdentityPackage, type DIDRegistrationRequest, type DIDRegistrationResponse, type DeploymentType, DidClient, DidInterface, DidManager, type DidResolver, type DiscoveryFormat, type DiscoveryOptions, type DiscoveryPagination, type DiscoveryResponse, type DiscoveryResult, ExecutionContext, type ExecutionCredential, type ExecutionLogAttributes, type ExecutionLogBatchPayload, type ExecutionLogContext, type ExecutionLogEmitOptions, type ExecutionLogEntry, type ExecutionLogLevel, type ExecutionLogTransport, type ExecutionLogTransportPayload, type ExecutionLogWireEntry, ExecutionLogger, type ExecutionLoggerOptions, type ExecutionMetadata, ExecutionStatus, type ExecutionStatusValue, File, type FileOutput, type GenerateCredentialOptions, type GenerateCredentialParams, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, type HarnessConfig, type HarnessOptions, type HarnessProvider, type HarnessResult, HarnessRunner, type HealthStatus, Image, type ImageOutput, type ImageRequest, JWE_ALG, JWE_ENC, KEY_AGREEMENT_TYPE, type MediaProvider, MediaProviderError, type MediaResponse, MediaRouter, type MemoryChangeEvent, MemoryClient, MemoryClientBase, type MemoryConfig, MemoryEventClient, type MemoryEventHandler, type MemoryEventHistoryOptions, MemoryInterface, type MemoryRequestMetadata, type MemoryRequestOptions, type MemoryScope, type MemoryWatchHandler, type Metrics, type MultimodalContent, MultimodalResponse, OpenRouterMediaProvider, type OpenRouterMediaProviderOptions, type Payload, PayloadEncryptionError, RateLimitError, type RateLimiterOptions, type RawExecutionContext, type RawResult, RealtimeSession, type ReasonerCapability, ReasonerContext, type ReasonerDefinition, type ReasonerHandler, type ReasonerOptions, type RequestApprovalPayload, SUPPORTED_PROVIDERS, SUPPORTED_SESSION_TRANSPORTS, type ServerlessAdapter, type ServerlessEvent, type ServerlessResponse, type SessionDefinition, type SessionOptions, type SessionProvider, type SessionTransport, type SessionTransportCapability, SessionTransportError, type SessionTurn, type SkillCapability, SkillContext, type SkillDefinition, type SkillHandler, type SkillOptions, StatelessRateLimiter, TERMINAL_STATUSES, Text, type ToolCallConfig, type ToolCallRecord, type ToolCallTrace, type ToolsOption, type VectorSearchOptions, type VectorSearchResult, Video, type VideoFrameImage, type VideoInputReference, type VideoRequest, type WaitForApprovalOptions, type WorkflowCredential, type WorkflowMetadata, type WorkflowProgressOptions, WorkflowReporter, type ZodSchema, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildSessionDefinition, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, decrypt, decryptToString, encryptForDid, encryptToJwk, executeToolCallLoop, extractKeyAgreementJwk, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, generateX25519KeyPair, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeSessionTransportValue, normalizeStatus, serializeExecutionLogEntry, text, validateSessionTransport, videoFromBase64, videoFromBuffer, videoFromFile, videoFromUrl };
+export { ACTIVE_STATUSES, AIClient, type AIConfig, type AIEmbeddingOptions, type AIRequestOptions, type AIStream, type AIToolRequestOptions, Agent, type AgentCapability, type AgentConfig, type AgentHandler, AgentRouter, type AgentRouterOptions, type AgentState, ApprovalClient, type ApprovalDecision, type ApprovalRequestResponse, ApprovalResult, type ApprovalStatusResponse, Audio, type AudioOutput, type AudioRequest, type AuditTrailExport, type AuditTrailFilters, type Awaitable, CANONICAL_STATUSES, type CompactCapability, type CompactDiscoveryResponse, DIDAuthenticator, type DIDIdentity, type DIDIdentityPackage, type DIDRegistrationRequest, type DIDRegistrationResponse, type DeploymentType, DidClient, DidInterface, DidManager, type DidResolver, type DiscoveryFormat, type DiscoveryOptions, type DiscoveryPagination, type DiscoveryResponse, type DiscoveryResult, ExecutionContext, type ExecutionCredential, type ExecutionLogAttributes, type ExecutionLogBatchPayload, type ExecutionLogContext, type ExecutionLogEmitOptions, type ExecutionLogEntry, type ExecutionLogLevel, type ExecutionLogTransport, type ExecutionLogTransportPayload, type ExecutionLogWireEntry, ExecutionLogger, type ExecutionLoggerOptions, type ExecutionMetadata, ExecutionStatus, type ExecutionStatusValue, File, type FileOutput, type GenerateCredentialOptions, type GenerateCredentialParams, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, type HarnessConfig, type HarnessOptions, type HarnessProvider, type HarnessResult, HarnessRunner, type HealthStatus, Image, type ImageOutput, type ImageRequest, JWE_ALG, JWE_ENC, KEY_AGREEMENT_TYPE, type MediaProvider, MediaProviderError, type MediaResponse, MediaRouter, type MemoryChangeEvent, MemoryClient, MemoryClientBase, type MemoryConfig, MemoryEventClient, type MemoryEventHandler, type MemoryEventHistoryOptions, MemoryInterface, type MemoryRequestMetadata, type MemoryRequestOptions, type MemoryScope, type MemoryWatchHandler, type Metrics, type MultimodalContent, MultimodalResponse, OpenRouterMediaProvider, type OpenRouterMediaProviderOptions, PauseClock, PauseManager, type Payload, PayloadEncryptionError, RateLimitError, type RateLimiterOptions, type RawExecutionContext, type RawResult, RealtimeSession, type ReasonerCapability, ReasonerContext, type ReasonerDefinition, type ReasonerHandler, type ReasonerOptions, type RequestApprovalPayload, SUPPORTED_PROVIDERS, SUPPORTED_SESSION_TRANSPORTS, type ServerlessAdapter, type ServerlessEvent, type ServerlessResponse, type SessionDefinition, type SessionOptions, type SessionProvider, type SessionTransport, type SessionTransportCapability, SessionTransportError, type SessionTurn, type SkillCapability, SkillContext, type SkillDefinition, type SkillHandler, type SkillOptions, StatelessRateLimiter, TERMINAL_STATUSES, Text, type ToolCallConfig, type ToolCallRecord, type ToolCallTrace, type ToolsOption, type VectorSearchOptions, type VectorSearchResult, Video, type VideoFrameImage, type VideoInputReference, type VideoRequest, type WaitForApprovalOptions, type WorkflowCredential, type WorkflowMetadata, type WorkflowProgressOptions, WorkflowReporter, type ZodSchema, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildSessionDefinition, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, decrypt, decryptToString, encryptForDid, encryptToJwk, executeToolCallLoop, extractKeyAgreementJwk, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, generateX25519KeyPair, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, installApprovalWebhookRoute, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeSessionTransportValue, normalizeStatus, serializeExecutionLogEntry, text, validateSessionTransport, videoFromBase64, videoFromBuffer, videoFromFile, videoFromUrl };