experimental-ash 0.58.0 → 0.59.0

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

@@ -0,0 +1,32 @@
+import type { ModelMessage } from "ai";
+import type { CodeModeInterrupt, CodeModeInterruptPayload, CodeModeOptions, CodeModeToolExecutionOptions, CodeModeToolSet, CodeModeUnwrappedResult } from "./types.js";
+/**
+ * Returns true when a value is a generic code-mode host interruption.
+ */
+export declare function isCodeModeInterrupt(value: unknown): value is CodeModeInterrupt;
+/**
+ * Continues a code-mode invocation that previously returned a generic
+ * interruption.
+ */
+export declare function continueCodeModeInterrupt<TPayload extends CodeModeInterruptPayload = CodeModeInterruptPayload, TResolution = unknown>({ interrupt, resolution, tools, options, toolExecutionOptions, }: {
+    interrupt: CodeModeInterrupt<TPayload>;
+    resolution: TResolution;
+    tools: CodeModeToolSet;
+    options?: CodeModeOptions;
+    toolExecutionOptions?: Partial<CodeModeToolExecutionOptions>;
+}): Promise<unknown>;
+/**
+ * Finds a code-mode interruption in a result-like object.
+ */
+export declare function getCodeModeInterrupt(result: unknown): CodeModeInterrupt | undefined;
+/**
+ * Normalizes a direct or AI SDK result-like value into completed/interrupted
+ * status.
+ */
+export declare function unwrapCodeModeResult(result: unknown): CodeModeUnwrappedResult;
+/**
+ * Replaces a stored outer `code_mode` interruption result in model history with
+ * the final continuation output.
+ */
+export declare function replaceCodeModeInterruptResult(messages: ModelMessage[], interrupt: CodeModeInterrupt, finalOutput: unknown): ModelMessage[];
+//# sourceMappingURL=interrupt-continuation.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { CodeModeOptions, NormalizedCodeModeOptions } from "./types.js";
+export declare function normalizeOptions(options?: CodeModeOptions): NormalizedCodeModeOptions;
+//# sourceMappingURL=options.d.ts.map

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

@@ -0,0 +1,12 @@
+import type { RunCodeModeInput } from "./types.js";
+/**
+ * Runs one code-mode invocation directly without wrapping it as an AI SDK tool.
+ *
+ * The source is executed in a fresh QuickJS context with the provided host tools,
+ * execution limits, fetch policy, and approval policy.
+ *
+ * @param input - Source code, host tools, forwarded tool execution options, and code-mode options.
+ * @returns The JSON-serializable value returned by the sandboxed program.
+ */
+export declare function runCodeMode(input: RunCodeModeInput): Promise<unknown>;
+//# sourceMappingURL=run-code-mode.d.ts.map

package/dist/src/compiled/experimental-ai-sdk-code-mode/runtime/guest-sources.d.ts

@@ -0,0 +1,3 @@
+export declare function buildGuestRuntimeSetupSource(fetchEnabled: boolean): string;
+export declare function wrapUserCode(js: string): string;
+//# sourceMappingURL=guest-sources.d.ts.map

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

@@ -0,0 +1,22 @@
+import type { CodeModeWorkerUrl, RunCodeModeInput } from "../types.js";
+/**
+ * Sets the process-global worker script URL used for new code-mode workers.
+ *
+ * This is intended for advanced integrations that provide a custom,
+ * self-contained worker. Call this before starting invocations.
+ * Active workers keep running; idle workers are retired so future invocations
+ * use the new location.
+ *
+ * @param workerUrl - Node.js worker path or URL, or `undefined` to reset.
+ */
+export declare function setCodeModeWorkerUrl(workerUrl?: CodeModeWorkerUrl): void;
+/**
+ * Returns the worker script URL currently used for new code-mode workers.
+ */
+export declare function getCodeModeWorkerUrl(): CodeModeWorkerUrl;
+/**
+ * Returns the package default worker script URL.
+ */
+export declare function getDefaultCodeModeWorkerUrl(): URL;
+export declare function runManagedCodeMode(input: RunCodeModeInput): Promise<unknown>;
+//# sourceMappingURL=manager.d.ts.map

package/dist/src/compiled/experimental-ai-sdk-code-mode/runtime/max-workers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Sets the process-global maximum number of active code-mode workers.
+ *
+ * Pass `undefined` or call without an argument to restore the dynamic
+ * memory-based default. The default admits at least one invocation and admits
+ * additional workers only when available memory can cover another worker.
+ *
+ * @param maxWorkers - Positive integer worker cap, or `undefined` to reset.
+ */
+export declare function setMaxWorkers(maxWorkers?: number): void;
+/**
+ * Returns the currently effective worker cap.
+ *
+ * @internal
+ */
+export declare function getMaxWorkers({ memoryLimitBytes, activeWorkers, }: {
+    memoryLimitBytes: number;
+    activeWorkers: number;
+}): number;
+//# sourceMappingURL=max-workers.d.ts.map

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

@@ -0,0 +1,49 @@
+import type { CodeModeDeterminismState, NormalizedCodeModeOptions, SerializableError } from "../types.js";
+export interface WorkerRunMessage {
+    type: "run";
+    invocationId: string;
+    js: string;
+    determinism: CodeModeDeterminismState;
+    options: Pick<NormalizedCodeModeOptions, "timeoutMs" | "memoryLimitBytes" | "maxStackSizeBytes" | "maxResultBytes" | "fetchEnabled">;
+}
+export interface WorkerToolRequest {
+    type: "tool-request";
+    invocationId: string;
+    requestId: string;
+    toolName: string;
+    inputJson: string;
+}
+export interface WorkerFetchRequest {
+    type: "fetch-request";
+    invocationId: string;
+    requestId: string;
+    request: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: string;
+    };
+}
+export interface WorkerBridgeResponse {
+    type: "bridge-response";
+    invocationId: string;
+    requestId: string;
+    success: boolean;
+    dateNowMs: number;
+    valueJson?: string;
+    error?: SerializableError;
+}
+export interface WorkerResultMessage {
+    type: "result";
+    invocationId: string;
+    success: boolean;
+    valueJson?: string;
+    error?: SerializableError;
+}
+export interface WorkerReadyMessage {
+    type: "ready";
+    invocationId: string;
+}
+export type WorkerToMainMessage = WorkerToolRequest | WorkerFetchRequest | WorkerResultMessage | WorkerReadyMessage;
+export type MainToWorkerMessage = WorkerRunMessage | WorkerBridgeResponse;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/src/compiled/experimental-ai-sdk-code-mode/runtime/worker-source.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Inline worker source generated into `dist/runtime/worker-source.js` during
+ * package builds.
+ *
+ * The source placeholder is intentionally unusable before the build step so a
+ * broken package build fails loudly instead of trying to run an empty worker.
+ *
+ * @internal
+ */
+export declare const INLINE_CODE_MODE_WORKER_SOURCE = "throw new Error(\"Code mode inline worker source was not generated.\");";
+//# sourceMappingURL=worker-source.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function assertJsonSerializable(value: unknown, maxBytes: number, label: string): void;
+export declare function toJsonPayload(value: unknown, maxBytes: number, label: string): string;
+export declare function toStrictJsonPayload(value: unknown, maxBytes: number, label: string): string;
+export declare function assertJsonPayloadSize(valueJson: string, maxBytes: number, label: string): void;
+//# sourceMappingURL=serialization.d.ts.map

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

@@ -0,0 +1,11 @@
+export declare function assertSourceSize(source: string, maxSourceBytes: number): void;
+export declare function transformSource(source: string): string;
+export declare function getTransformedSourceCacheStats(): {
+    entries: number;
+    bytes: number;
+    maxEntries: number;
+    maxBytes: number;
+    maxEntryBytes: number;
+};
+export declare function clearTransformedSourceCache(): void;
+//# sourceMappingURL=source-cache.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { CodeModeTelemetryOptions } from "./types.js";
+type AttributeValue = string | number | boolean | Array<string | number | boolean>;
+type Attributes = Record<string, AttributeValue>;
+interface TelemetrySpan {
+    setAttribute?: (key: string, value: AttributeValue) => void;
+    setAttributes?: (attributes: Attributes) => void;
+    addEvent?: (name: string, attributes?: Attributes) => void;
+    recordException?: (exception: Error | string | unknown) => void;
+    setStatus?: (status: {
+        code: number;
+        message?: string;
+    }) => void;
+    end?: () => void;
+}
+export declare function startTelemetrySpan(telemetry: CodeModeTelemetryOptions | undefined, name: string, attributes: Record<string, unknown>): TelemetrySpan | undefined;
+export declare function addTelemetryEvent(span: TelemetrySpan | undefined, name: string, attributes?: Record<string, unknown>): void;
+export declare function recordTelemetryError(span: TelemetrySpan | undefined, error: unknown): void;
+export declare function endTelemetrySpan(span: TelemetrySpan | undefined): void;
+export {};
+//# sourceMappingURL=telemetry.d.ts.map

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

@@ -0,0 +1,24 @@
+import type { CodeModeInterruptExecutionContext, CodeModeInterruptPayload, CodeModeOptions, CodeModeToolExecutionOptions, CodeModeToolSet } from "./types.js";
+export type HostToolInvocationResult = {
+    type: "success";
+    valueJson: string;
+} | {
+    type: "interrupted";
+    toolName: string;
+    input: unknown;
+    toolCallId: string;
+    payload: CodeModeInterruptPayload;
+};
+export declare function invokeHostTool({ toolName, inputJson, tools, baseExecutionOptions, codeModeOptions, maxToolInputBytes, maxToolOutputBytes, toolCallId, codeModeInterrupt, skipApproval, }: {
+    toolName: string;
+    inputJson: string;
+    tools: CodeModeToolSet;
+    baseExecutionOptions: CodeModeToolExecutionOptions;
+    codeModeOptions: CodeModeOptions;
+    maxToolInputBytes: number;
+    maxToolOutputBytes: number;
+    toolCallId: string;
+    codeModeInterrupt?: CodeModeInterruptExecutionContext;
+    skipApproval?: boolean;
+}): Promise<HostToolInvocationResult>;
+//# sourceMappingURL=tool-invocation.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { CodeModeOptions, CodeModeToolSet } from "./types.js";
+export declare function buildCodeModeToolDescription(tools: CodeModeToolSet, options?: CodeModeOptions): string;
+//# sourceMappingURL=tool-prompt.d.ts.map