experimental-ash 0.58.1 → 0.59.0

package/dist/src/compiled/experimental-ai-sdk-code-mode/errors.d.ts

@@ -0,0 +1,114 @@
+import type { SerializableError } from "./types.js";
+/**
+ * Base class for errors raised by code mode.
+ *
+ * All package-specific errors include a stable `code` string and may include
+ * structured `details` for diagnostics.
+ */
+export declare class CodeModeError extends Error {
+    /**
+     * Stable machine-readable error code.
+     */
+    code: string;
+    /**
+     * Optional structured diagnostic details.
+     */
+    readonly details?: unknown;
+    constructor(message: string, code?: string, details?: unknown);
+}
+/**
+ * Raised when a sandbox invocation exceeds its timeout.
+ */
+export declare class CodeModeTimeoutError extends CodeModeError {
+    constructor(timeoutMs: number);
+}
+/**
+ * Raised when the outer AI SDK abort signal aborts a code-mode invocation.
+ */
+export declare class CodeModeAbortedError extends CodeModeError {
+    constructor();
+}
+/**
+ * Raised when the process-global worker cap has been reached.
+ *
+ * Configure the cap with `setMaxWorkers`.
+ */
+export declare class CodeModeConcurrencyError extends CodeModeError {
+    constructor(maxWorkers: number);
+}
+/**
+ * Raised when the provided source exceeds `executionPolicy.maxSourceBytes`.
+ */
+export declare class CodeModeSourceTooLargeError extends CodeModeError {
+    constructor(bytes: number, maxBytes: number);
+}
+/**
+ * Raised when sandboxed code exceeds bridge request limits.
+ *
+ * Bridge requests include host tool calls and sandbox fetch calls.
+ */
+export declare class CodeModeBridgeLimitError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Raised when sandboxed code starts host bridge work and returns without
+ * awaiting or otherwise observing it.
+ */
+export declare class CodeModeDetachedBridgeRequestError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Raised when the main thread and worker protocol observes an invalid or
+ * mismatched message.
+ */
+export declare class CodeModeProtocolError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Base class for failures caused by nested host tool execution.
+ */
+export declare class CodeModeToolError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Raised when sandboxed code requests a tool that requires approval and no
+ * approval callback approves it.
+ */
+export declare class CodeModeToolApprovalRequiredError extends CodeModeToolError {
+    constructor(toolName: string, input: unknown, toolCallId: string);
+}
+/**
+ * Raised when `approval.onApprovalRequired` denies a requested host tool call.
+ */
+export declare class CodeModeToolApprovalDeniedError extends CodeModeToolError {
+    constructor(toolName: string, input: unknown, toolCallId: string, reason?: string);
+}
+/**
+ * Raised when sandboxed `fetch` is unavailable, disallowed by policy, aborted,
+ * too large, or otherwise fails during host fetch handling.
+ */
+export declare class CodeModeFetchError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Converts an unknown thrown value into a worker-safe serializable shape.
+ *
+ * @internal
+ */
+export declare function serializeError(error: unknown): SerializableError;
+/**
+ * Converts host bridge failures into a sandbox-visible sanitized shape.
+ *
+ * This intentionally omits stack traces and diagnostic details. Full host
+ * diagnostics should use `serializeError` through lifecycle hooks or telemetry.
+ *
+ * @internal
+ */
+export declare function serializeBridgeErrorForGuest(error: unknown, context: "tool" | "fetch" | "bridge"): SerializableError;
+/**
+ * Rehydrates a serialized worker error into an Error instance.
+ *
+ * @internal
+ */
+export declare function deserializeError(error: SerializableError): Error;
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/compiled/experimental-ai-sdk-code-mode/fetch-policy.d.ts

@@ -0,0 +1,21 @@
+import type { CodeModeFetchPolicy } from "./types.js";
+export interface HostFetchRequest {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}
+export interface HostFetchResponse {
+    url: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+}
+export declare function executeHostFetch({ request, fetch, policy, signal, }: {
+    request: HostFetchRequest;
+    fetch: typeof globalThis.fetch | undefined | false;
+    policy: CodeModeFetchPolicy;
+    signal?: AbortSignal;
+}): Promise<HostFetchResponse>;
+//# sourceMappingURL=fetch-policy.d.ts.map

package/dist/src/compiled/experimental-ai-sdk-code-mode/host-interrupt.d.ts

@@ -0,0 +1,25 @@
+import type { CodeModeInterruptPayload } from "./types.js";
+declare const CODE_MODE_HOST_INTERRUPT_SIGNAL: unique symbol;
+interface CodeModeHostInterruptSignal extends Error {
+    readonly [CODE_MODE_HOST_INTERRUPT_SIGNAL]: true;
+    readonly payload: CodeModeInterruptPayload;
+}
+/**
+ * Interrupts the current nested host tool call and returns control to the host.
+ *
+ * Host tools can call this when they need an external pause, such as connection
+ * OAuth. Code mode returns a serializable `CodeModeInterrupt` with an opaque
+ * continuation instead of treating the pause as a tool failure.
+ *
+ * @param payload - JSON-serializable interruption payload with a stable `kind`.
+ */
+export declare function requestCodeModeInterrupt<TPayload extends CodeModeInterruptPayload>(payload: TPayload): never;
+/**
+ * Returns true when an unknown thrown value is the internal host-interrupt
+ * signal thrown by `requestCodeModeInterrupt`.
+ *
+ * @internal
+ */
+export declare function isCodeModeHostInterruptSignal(value: unknown): value is CodeModeHostInterruptSignal;
+export {};
+//# sourceMappingURL=host-interrupt.d.ts.map

package/dist/src/compiled/experimental-ai-sdk-code-mode/index.d.ts

@@ -1,144 +1,11 @@
-import type { ModelMessage, ToolSet } from "ai";
-
-export interface CodeModeInterruptPayload {
-  readonly kind?: string;
-  readonly [key: string]: unknown;
-}
-
-export interface CodeModeContinuation {
-  readonly outerToolCallId: string;
-  readonly [key: string]: unknown;
-}
-
-export interface CodeModePendingContinuation<
-  Payload extends CodeModeInterruptPayload = CodeModeInterruptPayload,
-> {
-  readonly continuation: CodeModeContinuation;
-  readonly interrupt: CodeModeInterruptCore<Payload>;
-  readonly type: "code-mode-pending-continuation";
-  readonly [key: string]: unknown;
-}
-
-export interface CodeModeInterruptCore<
-  Payload extends CodeModeInterruptPayload = CodeModeInterruptPayload,
-> {
-  readonly continuation: CodeModeContinuation;
-  readonly interruptId: string;
-  readonly payload: Payload;
-  readonly type: "code-mode-interrupt";
-}
-
-export interface CodeModeInterrupt<
-  Payload extends CodeModeInterruptPayload = CodeModeInterruptPayload,
-> extends CodeModeInterruptCore<Payload> {
-  readonly pendingContinuation: CodeModePendingContinuation<Payload>;
-}
-
-export interface CodeModeApprovalInterrupt {
-  readonly approvalId: string;
-  readonly continuation: CodeModeContinuation;
-  readonly toolCallId: string;
-  readonly toolName: string;
-  readonly type: "code-mode-approval-required";
-}
-
-export interface CodeModeInterruptExecutionContext<
-  Payload extends CodeModeInterruptPayload = CodeModeInterruptPayload,
-  Resolution = unknown,
-> {
-  readonly interruptId: string;
-  readonly payload: Payload;
-  readonly resolution: Resolution;
-}
-
-export interface CodeModeNestedToolCallEvent {
-  readonly bridgeIndex: number;
-  readonly input: unknown;
-  readonly inputBytes: number;
-  readonly invocationId: string;
-  readonly outerToolCallId: string;
-  readonly replayed?: boolean;
-  readonly startedAtMs: number;
-  readonly toolCallId: string;
-  readonly toolName: string;
-}
-
-export interface CodeModeNestedToolResultEvent {
-  readonly bridgeIndex: number;
-  readonly completedAtMs: number;
-  readonly durationMs: number;
-  readonly error?: unknown;
-  readonly input: unknown;
-  readonly inputBytes: number;
-  readonly invocationId: string;
-  readonly outerToolCallId: string;
-  readonly output?: unknown;
-  readonly outputBytes?: number;
-  readonly replayed?: boolean;
-  readonly startedAtMs: number;
-  readonly status: "fulfilled" | "rejected" | "interrupted" | "approval-required";
-  readonly toolCallId: string;
-  readonly toolName: string;
-}
-
-export interface CodeModeLifecycleHookErrorEvent {
-  readonly event: unknown;
-  readonly hook: string;
-}
-
-export interface CodeModeOptions {
-  readonly approval?: {
-    readonly mode: "interrupt";
-  };
-  readonly lifecycle?: {
-    readonly onHookError?: (
-      error: unknown,
-      event: CodeModeLifecycleHookErrorEvent,
-    ) => void | Promise<void>;
-    readonly onInterrupt?: (event: unknown) => void | Promise<void>;
-    readonly onNestedToolCall?: (event: CodeModeNestedToolCallEvent) => void | Promise<void>;
-    readonly onNestedToolResult?: (event: CodeModeNestedToolResultEvent) => void | Promise<void>;
-  };
-}
-
-export interface CodeModeUnwrappedResult {
-  readonly interrupt?: CodeModeInterrupt | CodeModeApprovalInterrupt;
-  readonly output?: unknown;
-  readonly status: "completed" | "interrupted";
-}
-
-export class CodeModeProtocolError extends Error {
-  readonly code: "CODE_MODE_PROTOCOL_ERROR";
-  readonly details?: unknown;
-  constructor(message: string, details?: unknown);
-}
-
-export function createCodeModeTool(tools: ToolSet, options?: CodeModeOptions): unknown;
-export function continueCodeModeApproval(input: {
-  readonly approvalResponse: unknown;
-  readonly interrupt: CodeModeApprovalInterrupt;
-  readonly options?: CodeModeOptions;
-  readonly tools: ToolSet;
-}): Promise<unknown>;
-export function continueCodeModeInterrupt(input: {
-  readonly interrupt: CodeModeInterrupt;
-  readonly resolution: unknown;
-  readonly options?: CodeModeOptions;
-  readonly tools: ToolSet;
-}): Promise<unknown>;
-export function getCodeModeApprovalResponse(
-  messages: readonly ModelMessage[],
-  interrupt: CodeModeApprovalInterrupt,
-): unknown | undefined;
-export function getCodeModeInterrupt(value: unknown): CodeModeInterrupt | undefined;
-export function isCodeModeApprovalInterrupt(value: unknown): value is CodeModeApprovalInterrupt;
-export function replaceCodeModeInterruptResult(
-  messages: readonly ModelMessage[],
-  pending: CodeModePendingContinuation,
-  finalOutput: unknown,
-): ModelMessage[];
-export function requestCodeModeInterrupt(payload: CodeModeInterruptPayload): never;
-export function toCodeModeApprovalMessages(
-  interrupt: CodeModeApprovalInterrupt,
-): readonly ModelMessage[];
-export function unwrapCodeModeResult(value: unknown): CodeModeUnwrappedResult;
+export { attachCodeModeApprovalResult, continueCodeModeApproval, generateTextWithCodeModeApprovals, getCodeModeApprovalInterrupt, getCodeModeApprovalResponse, isCodeModeApprovalInterrupt, streamTextWithCodeModeApprovals, toCodeModeApprovalMessages, wrapToolLoopAgentForCodeModeApprovals, } from "./approval-continuation.js";
+export { createCodeModeTool } from "./code-mode-tool.js";
+export { setCodeModeContinuationSigningKey } from "./continuation-capability.js";
+export { CodeModeAbortedError, CodeModeBridgeLimitError, CodeModeConcurrencyError, CodeModeDetachedBridgeRequestError, CodeModeError, CodeModeFetchError, CodeModeProtocolError, CodeModeSourceTooLargeError, CodeModeTimeoutError, CodeModeToolApprovalDeniedError, CodeModeToolApprovalRequiredError, CodeModeToolError, } from "./errors.js";
+export { requestCodeModeInterrupt } from "./host-interrupt.js";
+export { continueCodeModeInterrupt, getCodeModeInterrupt, isCodeModeInterrupt, replaceCodeModeInterruptResult, unwrapCodeModeResult, } from "./interrupt-continuation.js";
+export { runCodeMode } from "./run-code-mode.js";
+export { getCodeModeWorkerUrl, getDefaultCodeModeWorkerUrl, setCodeModeWorkerUrl, } from "./runtime/manager.js";
+export { setMaxWorkers } from "./runtime/max-workers.js";
+export type { ApprovalDecision, CodeModeApprovalInterrupt, CodeModeApprovalInterruptPayload, CodeModeApprovalRequest, CodeModeApprovalResolution, CodeModeApprovalResponse, CodeModeContinuation, CodeModeContinuationAuth, CodeModeContinuationLedgerEntry, CodeModeDeterminismState, CodeModeExecutionPolicy, CodeModeFetchPolicy, CodeModeFetchRequestEvent, CodeModeFetchResultEvent, CodeModeInterrupt, CodeModeInterruptEvent, CodeModeInterruptExecutionContext, CodeModeInterruptPayload, CodeModeInterruptResolution, CodeModeLifecycleHookErrorEvent, CodeModeModelOutput, CodeModeModelOutputOptions, CodeModeModelVisibleBridgeSummary, CodeModeNestedToolCallEvent, CodeModeNestedToolResultEvent, CodeModeOptions, CodeModeTelemetryOptions, CodeModeToolExecutionOptions, CodeModeToolInput, CodeModeToolSet, CodeModeTrace, CodeModeTraceEntry, CodeModeUnwrappedResult, CodeModeWorkerUrl, RunCodeModeInput, UnsignedCodeModeContinuation, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map