eve 0.24.0 → 0.24.2

package/dist/src/compiled/@ai-sdk/provider-utils/index.d.ts

@@ -1,4 +1,4 @@
-import { SharedV4FileDataUrl, SharedV4FileDataReference, SharedV4FileDataText, SharedV4ProviderOptions, SharedV4ProviderReference, JSONValue, ImageModelV4File, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, AISDKError, JSONSchema7, JSONParseError, TypeValidationError, APICallError, LanguageModelV4Prompt, LanguageModelV4CallOptions, SharedV4Warning, JSONObject, LanguageModelV4FilePart, LanguageModelV4StreamPart, SharedV4ProviderMetadata, TypeValidationContext } from '#compiled/@ai-sdk/provider/index.js';
+import { SharedV4FileDataUrl, SharedV4FileDataReference, SharedV4FileDataText, SharedV4ProviderOptions, SharedV4ProviderReference, JSONValue, ImageModelV4File, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, AISDKError, JSONSchema7, JSONParseError, TypeValidationError, APICallError, LanguageModelV4Prompt, LanguageModelV4CallOptions, SharedV4Warning, JSONObject, LanguageModelV4FilePart, LanguageModelV4StreamPart, SharedV4ProviderMetadata, Experimental_TranscriptionModelV4StreamPart, TypeValidationContext } from '#compiled/@ai-sdk/provider/index.js';
 export { getErrorMessage } from '#compiled/@ai-sdk/provider/index.js';
 import { StandardSchemaV1, StandardJSONSchemaV1 } from '#compiled/@standard-schema/spec/index.js';
 export * from '#compiled/@standard-schema/spec/index.js';
@@ -19,6 +19,77 @@ declare function asArray<T>(value: Arrayable<T>): T[];
 
 declare function combineHeaders(...headers: Array<Record<string, string | undefined> | undefined>): Record<string, string | undefined>;
 
+type WebSocketLike = {
+    readyState: number;
+    /** Bytes queued by `send` but not yet transmitted (native + `ws`). */
+    readonly bufferedAmount?: number;
+    send(data: string | Uint8Array | ArrayBuffer): void;
+    close(code?: number, reason?: string): void;
+    onopen: ((event: unknown) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    onclose: ((event: unknown) => void) | null;
+};
+type WebSocketConstructor = new (url: string | URL, protocols?: string | string[], options?: {
+    headers?: Record<string, string | undefined>;
+}) => WebSocketLike;
+declare function getWebSocketConstructor(webSocket: WebSocketConstructor | undefined): WebSocketConstructor;
+/**
+ * Converts an http(s) URL to the corresponding ws(s) URL.
+ */
+declare function toWebSocketUrl(url: string | URL): URL;
+/**
+ * Reads WebSocket message data as text, handling string, binary,
+ * and Blob payloads.
+ */
+declare function readWebSocketMessageText(data: unknown): Promise<string>;
+/**
+ * Waits until the socket's send buffer drains below `highWaterMark` bytes.
+ * No-op for implementations that do not expose `bufferedAmount`. There is no
+ * portable drain event, so this polls. Returns as soon as the socket is no
+ * longer open or the signal aborts — `bufferedAmount` never drains on a
+ * closed socket, so waiting on would poll forever.
+ */
+declare function waitForWebSocketBufferDrain(socket: WebSocketLike, { highWaterMark, pollIntervalMs, abortSignal, }?: {
+    highWaterMark?: number;
+    pollIntervalMs?: number;
+    abortSignal?: AbortSignal;
+}): Promise<void>;
+
+interface WebSocketConnection {
+    /** Undefined when the constructor threw or the signal was already aborted. */
+    socket: WebSocketLike | undefined;
+    /**
+     * Unregisters the abort listener and closes the socket. Never throws.
+     * Handlers stay attached; callers guard their own terminal state.
+     */
+    close: (code?: number) => void;
+}
+/**
+ * Opens a WebSocket for a provider model, owning the transport-generic layer
+ * (analogous to `postToApi` for HTTP): constructor resolution, header hygiene,
+ * abort wiring, and message decoding. Callers own the URL, the auth channel
+ * (subprotocols vs headers), and the wire protocol.
+ */
+declare function connectToWebSocket({ url, protocols, headers, webSocket, abortSignal, onOpen, onMessageText, onProcessingError, onSocketError, onClose, onAbort, }: {
+    url: string | URL;
+    protocols?: string | string[];
+    headers?: Record<string, string | undefined>;
+    webSocket?: WebSocketConstructor;
+    abortSignal?: AbortSignal;
+    onOpen?: (socket: WebSocketLike) => void;
+    /** One decoded message. Throws and rejections go to `onProcessingError`. */
+    onMessageText: (text: string) => void | PromiseLike<void>;
+    /** Constructor throws and message decoding/processing failures. */
+    onProcessingError: (error: unknown) => void;
+    onSocketError?: () => void;
+    onClose?: () => void;
+    /** Also called (without opening a socket) when the signal is already aborted. */
+    onAbort?: (reason: unknown) => void;
+}): WebSocketConnection;
+
 /**
  * Converts an AsyncIterator to a ReadableStream.
  *
@@ -739,33 +810,67 @@ declare class DownloadError extends AISDKError {
 }
 
 /**
- * Fetches a URL while enforcing the SSRF download guard on every hop.
+ * Fetch function type (standardizes the version of fetch used).
+ */
+type FetchFunction = typeof globalThis.fetch;
+
+/**
+ * Fetches a URL while enforcing the download guard on every hop.
  *
  * Redirects are followed manually (`redirect: 'manual'`) so each hop is
  * validated with {@link validateDownloadUrl} *before* it is requested. Relying
  * on the default `redirect: 'follow'` would issue the request to a redirect
  * target (e.g. an internal address) before we ever see its URL, defeating the
- * SSRF guard.
+ * guard.
+ *
+ * Request headers are also protected: {@link sanitizeRequestHeaders} strips
+ * proxy/metadata/cookie/hop-by-hop headers before the first request, and all
+ * caller headers except `User-Agent` are dropped on a cross-origin redirect.
+ * The fetch spec only strips `Authorization` on cross-origin redirects because
+ * in a browser, CORS preflighting protects custom headers; there is no CORS on
+ * the server, so provider API keys carried in custom headers (e.g. `x-key`)
+ * must be dropped here as well.
  *
  * A `redirect: 'manual'` request yields an unreadable opaque response in the
  * browser (and in other spec-compliant fetch implementations), so the redirect
  * target cannot be validated here. In a real browser this is safe to follow
- * natively because SSRF is not reachable (fetch is constrained by CORS and
- * cannot reach a server's internal network or cloud-metadata). On any other
- * runtime we cannot validate the hop, so we fail closed rather than follow it
- * blindly and bypass the SSRF guard.
+ * natively because reaching an internal network is not possible (fetch is
+ * constrained by CORS and cannot reach a server's internal network or
+ * cloud-metadata). On any other runtime we cannot validate the hop, so we fail
+ * closed rather than follow it blindly and bypass the guard.
+ *
+ * A hop that is same-origin with `trustedOrigin` (the developer-configured
+ * provider endpoint) skips target validation: that origin is exactly what an
+ * unvalidated, config-derived request would fetch anyway, and validating it
+ * would break legitimate self-hosted / localhost deployments whose response
+ * URLs point back at the configured host. Hops on any other origin are always
+ * validated.
  *
  * The returned response is the final (non-redirect) response. The caller is
  * responsible for checking `response.ok` and reading the body.
  *
+ * Not solved here: this does string/literal checks only and does not resolve
+ * DNS, so a hostname that *resolves* to a private address, and DNS rebinding
+ * (the resolved IP flipping between validation and connect), are not blocked.
+ * Server deployments fetching untrusted URLs should constrain egress at the
+ * network layer or inject a Node `fetch` that pins the resolved IP at connect
+ * time — those need DNS/socket APIs not available on all target runtimes
+ * (edge, browser, Bun), so they are intentionally not built in.
+ *
  * @throws DownloadError if a hop is unsafe, the redirect limit is exceeded, or
  * a redirect cannot be validated on a non-browser runtime.
  */
-declare function fetchWithValidatedRedirects({ url, headers, abortSignal, maxRedirects, }: {
+declare function fetchWithValidatedRedirects({ url, headers, abortSignal, maxRedirects, fetch, trustedOrigin, }: {
     url: string;
     headers?: HeadersInit;
     abortSignal?: AbortSignal;
     maxRedirects?: number;
+    fetch?: FetchFunction;
+    /**
+     * A developer-configured origin (e.g. the provider's `baseURL`) whose hops
+     * skip target validation. Must never be derived from response data.
+     */
+    trustedOrigin?: string;
 }): Promise<Response>;
 
 /**
@@ -793,11 +898,6 @@ declare function extractResponseHeaders(response: Response): {
     [k: string]: string;
 };
 
-/**
- * Fetch function type (standardizes the version of fetch used).
- */
-type FetchFunction = typeof globalThis.fetch;
-
 /**
  * Filters `null` and `undefined` values out of a list of values.
  *
@@ -970,13 +1070,46 @@ declare const createJsonResponseHandler: <T>(responseSchema: FlexibleSchema<T>)
 declare const createBinaryResponseHandler: () => ResponseHandler<Uint8Array>;
 declare const createStatusCodeErrorResponseHandler: () => ResponseHandler<APICallError>;
 
-declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, }: {
+declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, validateUrl, credentialedOrigin, trustedOrigin, }: {
     url: string;
     headers?: Record<string, string | undefined>;
     failedResponseHandler: ResponseHandler<Error>;
     successfulResponseHandler: ResponseHandler<T>;
     abortSignal?: AbortSignal;
     fetch?: FetchFunction;
+    /**
+     * Set `true` when `url` is untrusted (e.g. taken from a provider response
+     * body): it is routed through {@link fetchWithValidatedRedirects}, which
+     * rejects private/loopback/link-local targets and re-validates redirect
+     * hops; blocked URLs throw `DownloadError`. Set `false` only for URLs built
+     * from a developer-configured endpoint.
+     *
+     * Optional for backwards compatibility with existing callers; omitting it
+     * behaves like `false` (no validation). Provider code in this repository
+     * must always pass it explicitly so every call site makes a visible trust
+     * decision — see `contributing/secure-url-handling.md`.
+     */
+    validateUrl?: boolean;
+    /**
+     * When set, `headers` are sent only if `url` is same-origin with this origin
+     * (the user-agent suffix is always kept). Pass the provider's configured
+     * base URL alongside `validateUrl: true` so credentials never ride a request
+     * to a response-supplied host on a different origin (e.g. a CDN). Redirects
+     * that later cross origin drop all caller headers regardless (see
+     * {@link fetchWithValidatedRedirects}).
+     */
+    credentialedOrigin?: string;
+    /**
+     * A developer-configured origin (e.g. the provider's `baseURL`) that is
+     * exempt from URL validation when `validateUrl` is `true`. A response URL
+     * (or redirect hop) that is same-origin with it is fetched without target
+     * validation — it points at exactly the host a config-derived
+     * `validateUrl: false` request would fetch anyway, so blocking it would
+     * only break legitimate self-hosted / localhost deployments whose response
+     * URLs point back at the configured host. Hops on any other origin are
+     * still validated. Must never be derived from response data.
+     */
+    trustedOrigin?: string;
 }) => Promise<{
     value: T;
     rawValue?: unknown;
@@ -2024,6 +2157,31 @@ declare function resolveProviderReference({ reference, provider, }: {
     provider: string;
 }): string;
 
+type RetryFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;
+type RetryErrorReason = 'maxRetriesExceeded' | 'errorNotRetryable';
+type RetryErrorFactory = ({ message, reason, errors, }: {
+    message: string;
+    reason: RetryErrorReason;
+    errors: Array<unknown>;
+}) => unknown;
+type RetryDelayProvider = ({ error, exponentialBackoffDelay, }: {
+    error: unknown;
+    exponentialBackoffDelay: number;
+}) => number;
+type ShouldRetryFunction = (error: unknown) => boolean | Promise<boolean>;
+/**
+ * Retries a failed operation with exponential backoff.
+ */
+declare const retryWithExponentialBackoff: ({ maxRetries, initialDelayInMs, backoffFactor, abortSignal, shouldRetry, getDelayInMs, createRetryError, }: {
+    maxRetries?: number;
+    initialDelayInMs?: number;
+    backoffFactor?: number;
+    abortSignal?: AbortSignal;
+    shouldRetry: ShouldRetryFunction;
+    getDelayInMs?: RetryDelayProvider;
+    createRetryError?: RetryErrorFactory;
+}) => RetryFunction;
+
 /**
  * Serializes a model instance for workflow step boundaries.
  * Returns the `modelId` plus the JSON-serializable config properties.
@@ -2054,6 +2212,8 @@ declare function serializeModelOptions<CONFIG extends {
     config: JSONObject;
 };
 
+declare function secureJsonParse(text: string): any;
+
 /**
  * Minimal interface for a streaming tool call delta from an OpenAI-compatible API.
  */
@@ -2136,10 +2296,108 @@ declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = St
  */
 declare function stripFileExtension(filename: string): string;
 
+/**
+ * Experimental transcription-stream WebSocket envelope (v1): the standard
+ * serialization of `TranscriptionModelV4.doStream` over a WebSocket. Clients
+ * (e.g. the `@ai-sdk/gateway` provider) encode with this module and servers
+ * (e.g. AI Gateway) decode with it, so the two sides cannot drift.
+ *
+ * Envelope rules:
+ *
+ * 1. The client sends exactly one `transcription-stream.start` TEXT frame
+ *    first.
+ * 2. Audio rides BINARY frames containing raw bytes in the declared
+ *    `inputAudioFormat` (base64 string chunks are decoded before sending).
+ * 3. The client signals end of audio with the
+ *    `transcription-stream.audio-done` TEXT frame; a plain close without it
+ *    is an abort.
+ * 4. Every server→client TEXT frame is one JSON-serialized
+ *    `TranscriptionModelV4StreamPart` (flattened, no wrapper). Payloads must
+ *    be JSON-serializable. `Date` values (`response-metadata.timestamp`)
+ *    serialize to ISO 8601 strings and are revived by
+ *    `parseTranscriptionStreamPart`. `Error` payloads in `error` parts
+ *    serialize as `{ name, message }`.
+ * 5. The server closes with code 1000 after the `finish` part; on failure it
+ *    sends an `error` part and closes non-1000. A close without a prior
+ *    `finish` is an error.
+ * 6. Unknown frame/part types are ignored in both directions (forward
+ *    compatibility).
+ * 7. Servers may enforce a maximum frame size (the AI Gateway rejects frames
+ *    over 256 KiB); clients should split audio into frames of at most
+ *    64 KiB.
+ * 8. Connection establishment (URL, auth) is transport-specific and out of
+ *    scope.
+ *
+ * The envelope validates frame shape only; server policy (accepted audio
+ * formats, required `rate`, size limits) layers on top. Both parsers use
+ * `secureJsonParse`, so frames carrying `__proto__` / `constructor.prototype`
+ * keys are rejected (prototype-pollution protection) rather than parsed.
+ */
+/** Type of the first client TEXT frame. */
+declare const TRANSCRIPTION_STREAM_START_FRAME_TYPE = "transcription-stream.start";
+/** Type of the client TEXT frame that signals the end of the audio input. */
+declare const TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE = "transcription-stream.audio-done";
+/**
+ * The client's session start frame. Optional keys are omitted when undefined.
+ */
+type TranscriptionStreamStartFrame = {
+    type: typeof TRANSCRIPTION_STREAM_START_FRAME_TYPE;
+    /** Audio format of the binary audio frames, e.g. `{ type: 'audio/pcm', rate: 16000 }`. */
+    inputAudioFormat: {
+        type: string;
+        rate?: number;
+    };
+    /** Provider-specific options, passed through verbatim. */
+    providerOptions?: Record<string, JSONObject>;
+    /** When true, the server should include `raw` parts in the stream. */
+    includeRawChunks?: boolean;
+};
+/** Server-side classification of a client TEXT frame. */
+type TranscriptionStreamClientFrame = {
+    type: 'start';
+    frame: TranscriptionStreamStartFrame;
+} | {
+    type: 'audio-done';
+} | {
+    /** Malformed JSON or a recognized frame with an invalid shape. */
+    type: 'invalid';
+    message: string;
+} | {
+    /** Unrecognized frame type; ignore for forward compatibility. */
+    type: 'unknown';
+};
+/**
+ * Server-side: parse a client TEXT frame. Validates envelope shape only and
+ * rejects prototype-pollution payloads (parsed with `secureJsonParse`). Never
+ * throws.
+ */
+declare function parseTranscriptionStreamClientFrame(text: string): TranscriptionStreamClientFrame;
+/**
+ * Server-side: serialize a transcription stream part as one TEXT frame.
+ * `Error` payloads in `error` parts serialize as `{ name, message }` —
+ * `Error` properties are non-enumerable, so a plain `JSON.stringify` would
+ * serialize them to `{}` and lose the message end-to-end. Returns
+ * `undefined` for payloads that are not JSON-serializable (envelope rule 4,
+ * e.g. bigint or cyclic values); callers drop the frame.
+ */
+declare function serializeTranscriptionStreamPart(part: Experimental_TranscriptionModelV4StreamPart): string | undefined;
+/**
+ * Client-side: parse a server TEXT frame into a transcription stream part.
+ * Returns `undefined` for malformed or unsafe (prototype-polluting) JSON
+ * (parsed with `secureJsonParse`), unknown part types, and known part types
+ * whose required or optional fields are missing or mistyped (including
+ * warning and segment elements) — downstream SDK code dereferences those
+ * fields, so a drifted server must not crash or pollute the stream.
+ * Revives `response-metadata.timestamp` to a `Date`.
+ */
+declare function parseTranscriptionStreamPart(text: string): Experimental_TranscriptionModelV4StreamPart | undefined;
+
 declare function convertBase64ToUint8Array(base64String: string): Uint8Array<ArrayBuffer>;
 declare function convertUint8ArrayToBase64(array: Uint8Array): string;
 declare function convertToBase64(value: string | Uint8Array): string;
 
+declare function validateBaseURL(baseURL: string | undefined): string | undefined;
+
 /**
  * Validates that a URL is safe to download from, blocking private/internal addresses
  * to prevent SSRF attacks.
@@ -2359,4 +2617,4 @@ interface ToolResult<NAME extends string, INPUT, OUTPUT> {
     dynamic?: boolean;
 }
 
-export { type Arrayable, type AssistantContent, type AssistantModelMessage, type Context, type CustomPart, DEFAULT_MAX_DOWNLOAD_SIZE, type DataContent, DelayedPromise, DownloadError, type DynamicTool, type ExecutableTool, type SandboxProcess as Experimental_SandboxProcess, type SandboxSession as Experimental_SandboxSession, type FetchFunction, type FileData, type FileDataData, type FileDataReference, type FileDataText, type FileDataUrl, type FilePart, type FlexibleSchema, type FunctionTool, type HasRequiredKey, type IdGenerator, type ImagePart, type InferSchema, type InferToolContext, type InferToolInput, type InferToolOutput, type InferToolSetContext, type LazySchema, type MaybePromiseLike, type ModelMessage, type ParseResult, type ProviderDefinedTool, type ProviderDefinedToolFactory, type ProviderDefinedToolFactoryWithOutputSchema, type ProviderExecutedTool, type ProviderExecutedToolFactory, type ProviderOptions, type ProviderReference, type ReasoningFilePart, type ReasoningPart, type Resolvable, type ResponseHandler, type Schema, type StreamingToolCallDelta, StreamingToolCallTracker, type StreamingToolCallTrackerOptions, type SystemModelMessage, type TextPart, type Tool, type ToolApprovalRequest, type ToolApprovalResponse, type ToolCall, type ToolCallPart, type ToolContent, type ToolExecuteFunction, type ToolExecutionOptions, type ToolModelMessage, type ToolNameMapping, type ToolNeedsApprovalFunction, type ToolResult, type ToolResultOutput, type ToolResultPart, type ToolSet, type UserContent, type UserModelMessage, VERSION, type ValidationResult, asArray, asSchema, cancelResponseBody, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertImageModelFileToDataUri, convertInlineFileDataToUint8Array, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createStatusCodeErrorResponseHandler, createToolNameMapping, delay, detectMediaType, downloadBlob, dynamicTool, executeTool, extractLines, extractResponseHeaders, fetchWithValidatedRedirects, filterNullable, generateId, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, injectJsonInstructionIntoMessages, isAbortError, isBrowserRuntime, isBuffer, isCustomReasoning, isExecutableTool, isFullMediaType, isNonNullable, isParsableJson, isProviderReference, isSameOrigin, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeHeaders, parseJSON, parseJsonEventStream, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, readResponseWithSizeLimit, removeUndefinedEntries, resolve, resolveFullMediaType, resolveProviderReference, safeParseJSON, safeValidateTypes, serializeModelOptions, stripFileExtension, tool, validateDownloadUrl, validateTypes, withUserAgentSuffix, withoutTrailingSlash, zodSchema };
+export { type Arrayable, type AssistantContent, type AssistantModelMessage, type Context, type CustomPart, DEFAULT_MAX_DOWNLOAD_SIZE, type DataContent, DelayedPromise, DownloadError, type DynamicTool, TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE, TRANSCRIPTION_STREAM_START_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_START_FRAME_TYPE, type ExecutableTool, type SandboxProcess as Experimental_SandboxProcess, type SandboxSession as Experimental_SandboxSession, type TranscriptionStreamClientFrame as Experimental_TranscriptionStreamClientFrame, type TranscriptionStreamStartFrame as Experimental_TranscriptionStreamStartFrame, type FetchFunction, type FileData, type FileDataData, type FileDataReference, type FileDataText, type FileDataUrl, type FilePart, type FlexibleSchema, type FunctionTool, type HasRequiredKey, type IdGenerator, type ImagePart, type InferSchema, type InferToolContext, type InferToolInput, type InferToolOutput, type InferToolSetContext, type LazySchema, type MaybePromiseLike, type ModelMessage, type ParseResult, type ProviderDefinedTool, type ProviderDefinedToolFactory, type ProviderDefinedToolFactoryWithOutputSchema, type ProviderExecutedTool, type ProviderExecutedToolFactory, type ProviderOptions, type ProviderReference, type ReasoningFilePart, type ReasoningPart, type Resolvable, type ResponseHandler, type RetryDelayProvider, type RetryErrorFactory, type RetryErrorReason, type RetryFunction, type Schema, type ShouldRetryFunction, type StreamingToolCallDelta, StreamingToolCallTracker, type StreamingToolCallTrackerOptions, type SystemModelMessage, type TextPart, type Tool, type ToolApprovalRequest, type ToolApprovalResponse, type ToolCall, type ToolCallPart, type ToolContent, type ToolExecuteFunction, type ToolExecutionOptions, type ToolModelMessage, type ToolNameMapping, type ToolNeedsApprovalFunction, type ToolResult, type ToolResultOutput, type ToolResultPart, type ToolSet, type UserContent, type UserModelMessage, VERSION, type ValidationResult, type WebSocketConnection, type WebSocketConstructor, type WebSocketLike, asArray, asSchema, cancelResponseBody, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertImageModelFileToDataUri, convertInlineFileDataToUint8Array, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createStatusCodeErrorResponseHandler, createToolNameMapping, delay, detectMediaType, downloadBlob, dynamicTool, executeTool, parseTranscriptionStreamClientFrame as experimental_parseTranscriptionStreamClientFrame, parseTranscriptionStreamPart as experimental_parseTranscriptionStreamPart, serializeTranscriptionStreamPart as experimental_serializeTranscriptionStreamPart, extractLines, extractResponseHeaders, fetchWithValidatedRedirects, filterNullable, generateId, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, getWebSocketConstructor, injectJsonInstructionIntoMessages, isAbortError, isBrowserRuntime, isBuffer, isCustomReasoning, isExecutableTool, isFullMediaType, isNonNullable, isParsableJson, isProviderReference, isSameOrigin, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeHeaders, parseJSON, parseJsonEventStream, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, readResponseWithSizeLimit, readWebSocketMessageText, removeUndefinedEntries, resolve, resolveFullMediaType, resolveProviderReference, retryWithExponentialBackoff, safeParseJSON, safeValidateTypes, secureJsonParse, serializeModelOptions, stripFileExtension, toWebSocketUrl, tool, validateBaseURL, validateDownloadUrl, validateTypes, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema };

package/dist/src/compiled/@workflow/core/index.js

@@ -1,2 +1,2 @@
-import{c as e,i as t}from"../../_chunks/workflow/dist-DpDDcpTl.js";import{An as n,C as r,Cn as i,Dn as a,En as o,Mn as s,R as c,T as l,Tn as u,fn as d,h as f,jn as p,mn as m,pn as h,t as g,z as _}from"../../_chunks/workflow/attribute-changes-Dmf_myUv.js";import"../../_chunks/workflow/dist-CQenixFf.js";import{n as v}from"../../_chunks/workflow/resume-hook-BH01MfRF.js";import{t as y}from"../../_chunks/workflow/sleep-BkAHCD_s.js";function b(e){p(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,b)}function x(e){p(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,x)}function S({schema:e}={}){function t(e){p(`defineHook().create()`,`https://workflow-sdk.dev/docs/api-reference/workflow/define-hook`,t)}return{create:t,async resume(t,n){if(!e?.[`~standard`])return await v(t,n);let r=e[`~standard`].validate(n);if(r instanceof Promise&&(r=await r),r.issues){let e=r.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`&&e?e.key:e)).join(`.`);return t?`  at "${t}": ${e.message}`:`  ${e.message}`});throw Error(`Hook payload did not match the defined schema:\n${e.join(`
+import{c as e,i as t}from"../../_chunks/workflow/dist-DpDDcpTl.js";import{An as n,C as r,Cn as i,Dn as a,En as o,Mn as s,R as c,T as l,Tn as u,fn as d,h as f,jn as p,mn as m,pn as h,t as g,z as _}from"../../_chunks/workflow/attribute-changes-MGTOG_uX.js";import"../../_chunks/workflow/dist-Blxnyb7-.js";import{n as v}from"../../_chunks/workflow/resume-hook-DHP5ql3-.js";import{t as y}from"../../_chunks/workflow/sleep-uA9pS-PT.js";function b(e){p(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,b)}function x(e){p(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,x)}function S({schema:e}={}){function t(e){p(`defineHook().create()`,`https://workflow-sdk.dev/docs/api-reference/workflow/define-hook`,t)}return{create:t,async resume(t,n){if(!e?.[`~standard`])return await v(t,n);let r=e[`~standard`].validate(n);if(r instanceof Promise&&(r=await r),r.issues){let e=r.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`&&e?e.key:e)).join(`.`);return t?`  at "${t}": ${e.message}`:`  ${e.message}`});throw Error(`Hook payload did not match the defined schema:\n${e.join(`
 `)}`)}return await v(t,r.value)}}}async function C(e,n={}){let r=_.getStore(),a=r?.workflowMetadata?.workflowRunId;if(!a)throw new t(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let o=g(e,n);if(o.length!==0){if(r.runReadyBarrier)try{await r.runReadyBarrier}catch{}await(await i()).events.create(a,{eventType:`attr_set`,specVersion:5,eventData:{changes:o,writer:{type:`step`,stepId:r.stepMetadata.stepId,attempt:r.stepMetadata.attempt},...n.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}const w=C;function T(){let e=_.getStore();return e||n(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,T),e.stepMetadata}function E(){let e=_.getStore();return e||s(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,E),e.workflowMetadata}function D(e={}){let t=_.getStore();t||s(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,D);let{namespace:n}=e,i=t.workflowMetadata.workflowRunId,p=c(i,n),g=t.writables??=new Map,v=g.get(p);if(v)return v.writable;let y=l(r(globalThis,t.ops,i,t.encryptionKey,!0,t.runReadyBarrier),t.encryptionKey),b=new f(i,p,t.runReadyBarrier),x=u();return t.ops.push(x.promise),o(y.readable,b,x).catch(()=>{}),a(y.writable,x),Object.defineProperty(y.writable,d,{value:p,writable:!1}),Object.defineProperty(y.writable,m,{value:i,writable:!1}),t.workflowDeploymentId&&Object.defineProperty(y.writable,h,{value:t.workflowDeploymentId,writable:!1}),g.set(p,{writable:y.writable,state:x}),y.writable}export{t as FatalError,e as RetryableError,b as createHook,x as createWebhook,S as defineHook,w as experimental_setAttributes,T as getStepMetadata,E as getWorkflowMetadata,D as getWritable,C as setAttributes,y as sleep};

package/dist/src/compiled/@workflow/core/runtime/start.d.ts

@@ -17,6 +17,18 @@ export interface StartOptionsBase {
      * The spec version to use for the workflow run. Defaults to the latest version.
      */
     specVersion?: number;
+    /**
+     * Optional region identifier for the new run. Currently consumed only
+     * by `@workflow/world-vercel`, which embeds the region into the tagged
+     * run ID and routes the initial workflow message to the matching
+     * regional queue. When omitted, the world falls back to its own
+     * default (for `world-vercel`: the `VERCEL_REGION` environment
+     * variable, then the server-side default region `iad1` — a concrete,
+     * routable region is always chosen).
+     *
+     * Worlds without a regional dimension ignore this field.
+     */
+    region?: string;
     /**
      * Plaintext attributes to seed on the run as it is created.
      *