eve 0.52.4 → 0.53.0

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

@@ -1,4 +1,4 @@
-import { SharedV4FileDataUrl, SharedV4FileDataReference, SharedV4FileDataText, SharedV4ProviderOptions, SharedV4ProviderReference, JSONValue, ImageModelV4File, LanguageModelV4ResponseMetadata, LanguageModelV4Usage, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, AISDKError, JSONSchema7, JSONParseError, TypeValidationError, APICallError, LanguageModelV4Prompt, LanguageModelV4CallOptions, SharedV4Warning, Experimental_BatchV4Status, JSONObject, LanguageModelV4FilePart, LanguageModelV4StreamPart, SharedV4ProviderMetadata, Experimental_TranscriptionModelV4StreamPart, TypeValidationContext } from '#compiled/@ai-sdk/provider/index.js';
+import { SharedV4FileDataUrl, SharedV4FileDataReference, SharedV4FileDataText, SharedV4ProviderOptions, SharedV4ProviderReference, JSONValue, ImageModelV4File, LanguageModelV4ResponseMetadata, LanguageModelV4Usage, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, JSONSchema7, JSONParseError, TypeValidationError, APICallError, AISDKError, LanguageModelV4Prompt, LanguageModelV4CallOptions, SharedV4Warning, Experimental_BatchV4Status, 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';
@@ -632,8 +632,14 @@ type InlineFileData = Extract<FilePart['data'], {
  * - `{ type: 'data', data: Uint8Array | Buffer }` → returned as-is
  * - `{ type: 'data', data: ArrayBuffer }` → wrapped in a `Uint8Array`
  * - `{ type: 'data', data: string }` → decoded as base64
+ *
+ * `{ type: 'stream' }` data is rejected: providers without streaming upload
+ * support funnel here and surface a clear `UnsupportedFunctionalityError`.
  */
-declare function convertInlineFileDataToUint8Array(data: InlineFileData): Uint8Array;
+declare function convertInlineFileDataToUint8Array(data: InlineFileData | {
+    type: 'stream';
+    stream: ReadableStream<Uint8Array>;
+}): Uint8Array;
 
 /**
  * Convert an ImageModelV4File to a URL or data URI string.
@@ -781,6 +787,178 @@ declare class DelayedPromise<T> {
     isPending(): boolean;
 }
 
+/**
+ * Fetch function type (standardizes the version of fetch used).
+ */
+type FetchFunction = typeof globalThis.fetch;
+
+/**
+ * Used to mark schemas so we can support both Zod and custom schemas.
+ */
+declare const schemaSymbol: unique symbol;
+type ValidationResult<OBJECT> = {
+    success: true;
+    value: OBJECT;
+} | {
+    success: false;
+    error: Error;
+};
+type Schema<OBJECT = unknown> = {
+    /**
+     * Used to mark schemas so we can support both Zod and custom schemas.
+     */
+    [schemaSymbol]: true;
+    /**
+     * Schema type for inference.
+     */
+    _type: OBJECT;
+    /**
+     * Optional. Validates that the structure of a value matches this schema,
+     * and returns a typed version of the value if it does.
+     */
+    readonly validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
+    /**
+     * The JSON Schema for the schema. It is passed to the providers.
+     */
+    readonly jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7>;
+};
+/**
+ * Creates a schema with deferred creation.
+ * This is important to reduce the startup time of the library
+ * and to avoid initializing unused validators.
+ *
+ * @param createValidator A function that creates a schema.
+ * @returns A function that returns a schema.
+ */
+declare function lazySchema<SCHEMA>(createSchema: () => Schema<SCHEMA>): LazySchema<SCHEMA>;
+type LazySchema<SCHEMA> = () => Schema<SCHEMA>;
+type ZodSchema<SCHEMA = any> = z3.Schema<SCHEMA, z3.ZodTypeDef, any> | $ZodType<SCHEMA, any>;
+type StandardSchema<SCHEMA = any> = StandardSchemaV1<unknown, SCHEMA> & {
+    readonly '~standard': StandardSchemaV1.Props<unknown, SCHEMA> & {
+        readonly jsonSchema?: StandardJSONSchemaV1.Converter;
+    };
+};
+type FlexibleSchema<SCHEMA = any> = Schema<SCHEMA> | LazySchema<SCHEMA> | ZodSchema<SCHEMA> | StandardSchema<SCHEMA>;
+type InferSchema<SCHEMA> = SCHEMA extends ZodSchema<infer T> ? T : SCHEMA extends StandardSchema<infer T> ? T : SCHEMA extends LazySchema<infer T> ? T : SCHEMA extends Schema<infer T> ? T : never;
+/**
+ * Create a schema using a JSON Schema.
+ *
+ * @param jsonSchema The JSON Schema for the schema.
+ * @param options.validate Optional. A validation function for the schema.
+ */
+declare function jsonSchema<OBJECT = unknown>(jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7> | (() => JSONSchema7 | PromiseLike<JSONSchema7>), { validate, }?: {
+    validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
+}): Schema<OBJECT>;
+declare function asSchema<OBJECT>(schema: FlexibleSchema<OBJECT> | undefined): Schema<OBJECT>;
+declare function zodSchema<OBJECT>(zodSchema: $ZodType<OBJECT, any> | z3.Schema<OBJECT, z3.ZodTypeDef, any>, options?: {
+    /**
+     * Enables support for references in the schema.
+     * This is required for recursive schemas, e.g. with `z.lazy`.
+     * However, not all language models and providers support such references.
+     * Defaults to `false`.
+     */
+    useReferences?: boolean;
+}): Schema<OBJECT>;
+
+/**
+ * Parses a JSON string into an unknown object.
+ *
+ * @param text - The JSON string to parse.
+ * @returns {JSONValue} - The parsed JSON object.
+ */
+declare function parseJSON(options: {
+    text: string;
+    schema?: undefined;
+}): Promise<JSONValue>;
+/**
+ * Parses a JSON string into a strongly-typed object using the provided schema.
+ *
+ * @template T - The type of the object to parse the JSON into.
+ * @param {string} text - The JSON string to parse.
+ * @param {Validator<T>} schema - The schema to use for parsing the JSON.
+ * @returns {Promise<T>} - The parsed object.
+ */
+declare function parseJSON<T>(options: {
+    text: string;
+    schema: FlexibleSchema<T>;
+}): Promise<T>;
+type ParseResult<T> = {
+    success: true;
+    value: T;
+    rawValue: unknown;
+} | {
+    success: false;
+    error: JSONParseError | TypeValidationError;
+    rawValue: unknown;
+};
+/**
+ * Safely parses a JSON string and returns the result as an object of type `unknown`.
+ *
+ * @param text - The JSON string to parse.
+ * @returns {Promise<object>} Either an object with `success: true` and the parsed data, or an object with `success: false` and the error that occurred.
+ */
+declare function safeParseJSON(options: {
+    text: string;
+    schema?: undefined;
+}): Promise<ParseResult<JSONValue>>;
+/**
+ * Safely parses a JSON string into a strongly-typed object, using a provided schema to validate the object.
+ *
+ * @template T - The type of the object to parse the JSON into.
+ * @param {string} text - The JSON string to parse.
+ * @param {Validator<T>} schema - The schema to use for parsing the JSON.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+declare function safeParseJSON<T>(options: {
+    text: string;
+    schema: FlexibleSchema<T>;
+}): Promise<ParseResult<T>>;
+declare function isParsableJson(input: string): boolean;
+
+type ResponseHandler<RETURN_TYPE> = (options: {
+    url: string;
+    requestBodyValues: unknown;
+    response: Response;
+}) => PromiseLike<{
+    value: RETURN_TYPE;
+    rawValue?: unknown;
+    responseHeaders?: Record<string, string>;
+}>;
+declare const createJsonErrorResponseHandler: <T>({ errorSchema, errorToMessage, isRetryable, }: {
+    errorSchema: FlexibleSchema<T>;
+    errorToMessage: (error: T) => string;
+    isRetryable?: (response: Response, error?: T) => boolean;
+}) => ResponseHandler<APICallError>;
+declare const createEventSourceResponseHandler: <T>(chunkSchema: FlexibleSchema<T>) => ResponseHandler<ReadableStream<ParseResult<T>>>;
+declare const createJsonResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<T>;
+declare const createJsonLinesResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<AsyncGenerator<T>>;
+declare const createBinaryResponseHandler: () => ResponseHandler<Uint8Array>;
+/**
+ * Passes the response body through as a `ReadableStream<Uint8Array>` without
+ * buffering it (unlike `createBinaryResponseHandler`). The consumer is
+ * responsible for draining or cancelling the stream.
+ */
+declare const createBinaryStreamResponseHandler: () => ResponseHandler<ReadableStream<Uint8Array>>;
+declare const createStatusCodeErrorResponseHandler: () => ResponseHandler<APICallError>;
+
+/**
+ * Sends a DELETE request. For URLs built from developer-configured endpoints
+ * only — there is no untrusted-URL validation path (use `getFromApi` with
+ * `validateUrl` for response-supplied URLs).
+ */
+declare const deleteFromApi: <T>({ url, headers, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
+    url: string;
+    headers?: Record<string, string | undefined>;
+    failedResponseHandler: ResponseHandler<Error>;
+    successfulResponseHandler: ResponseHandler<T>;
+    abortSignal?: AbortSignal;
+    fetch?: FetchFunction;
+}) => Promise<{
+    value: T;
+    rawValue?: unknown;
+    responseHeaders?: Record<string, string>;
+}>;
+
 /**
  * Detect the IANA media type of a file from its raw bytes or base64 string.
  *
@@ -861,11 +1039,6 @@ declare class DownloadError extends AISDKError {
  */
 declare const EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL: unique symbol;
 
-/**
- * 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.
  *
@@ -982,149 +1155,6 @@ type IdGenerator = () => string;
  */
 declare const generateId: IdGenerator;
 
-/**
- * Used to mark schemas so we can support both Zod and custom schemas.
- */
-declare const schemaSymbol: unique symbol;
-type ValidationResult<OBJECT> = {
-    success: true;
-    value: OBJECT;
-} | {
-    success: false;
-    error: Error;
-};
-type Schema<OBJECT = unknown> = {
-    /**
-     * Used to mark schemas so we can support both Zod and custom schemas.
-     */
-    [schemaSymbol]: true;
-    /**
-     * Schema type for inference.
-     */
-    _type: OBJECT;
-    /**
-     * Optional. Validates that the structure of a value matches this schema,
-     * and returns a typed version of the value if it does.
-     */
-    readonly validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
-    /**
-     * The JSON Schema for the schema. It is passed to the providers.
-     */
-    readonly jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7>;
-};
-/**
- * Creates a schema with deferred creation.
- * This is important to reduce the startup time of the library
- * and to avoid initializing unused validators.
- *
- * @param createValidator A function that creates a schema.
- * @returns A function that returns a schema.
- */
-declare function lazySchema<SCHEMA>(createSchema: () => Schema<SCHEMA>): LazySchema<SCHEMA>;
-type LazySchema<SCHEMA> = () => Schema<SCHEMA>;
-type ZodSchema<SCHEMA = any> = z3.Schema<SCHEMA, z3.ZodTypeDef, any> | $ZodType<SCHEMA, any>;
-type StandardSchema<SCHEMA = any> = StandardSchemaV1<unknown, SCHEMA> & {
-    readonly '~standard': StandardSchemaV1.Props<unknown, SCHEMA> & {
-        readonly jsonSchema?: StandardJSONSchemaV1.Converter;
-    };
-};
-type FlexibleSchema<SCHEMA = any> = Schema<SCHEMA> | LazySchema<SCHEMA> | ZodSchema<SCHEMA> | StandardSchema<SCHEMA>;
-type InferSchema<SCHEMA> = SCHEMA extends ZodSchema<infer T> ? T : SCHEMA extends StandardSchema<infer T> ? T : SCHEMA extends LazySchema<infer T> ? T : SCHEMA extends Schema<infer T> ? T : never;
-/**
- * Create a schema using a JSON Schema.
- *
- * @param jsonSchema The JSON Schema for the schema.
- * @param options.validate Optional. A validation function for the schema.
- */
-declare function jsonSchema<OBJECT = unknown>(jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7> | (() => JSONSchema7 | PromiseLike<JSONSchema7>), { validate, }?: {
-    validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
-}): Schema<OBJECT>;
-declare function asSchema<OBJECT>(schema: FlexibleSchema<OBJECT> | undefined): Schema<OBJECT>;
-declare function zodSchema<OBJECT>(zodSchema: $ZodType<OBJECT, any> | z3.Schema<OBJECT, z3.ZodTypeDef, any>, options?: {
-    /**
-     * Enables support for references in the schema.
-     * This is required for recursive schemas, e.g. with `z.lazy`.
-     * However, not all language models and providers support such references.
-     * Defaults to `false`.
-     */
-    useReferences?: boolean;
-}): Schema<OBJECT>;
-
-/**
- * Parses a JSON string into an unknown object.
- *
- * @param text - The JSON string to parse.
- * @returns {JSONValue} - The parsed JSON object.
- */
-declare function parseJSON(options: {
-    text: string;
-    schema?: undefined;
-}): Promise<JSONValue>;
-/**
- * Parses a JSON string into a strongly-typed object using the provided schema.
- *
- * @template T - The type of the object to parse the JSON into.
- * @param {string} text - The JSON string to parse.
- * @param {Validator<T>} schema - The schema to use for parsing the JSON.
- * @returns {Promise<T>} - The parsed object.
- */
-declare function parseJSON<T>(options: {
-    text: string;
-    schema: FlexibleSchema<T>;
-}): Promise<T>;
-type ParseResult<T> = {
-    success: true;
-    value: T;
-    rawValue: unknown;
-} | {
-    success: false;
-    error: JSONParseError | TypeValidationError;
-    rawValue: unknown;
-};
-/**
- * Safely parses a JSON string and returns the result as an object of type `unknown`.
- *
- * @param text - The JSON string to parse.
- * @returns {Promise<object>} Either an object with `success: true` and the parsed data, or an object with `success: false` and the error that occurred.
- */
-declare function safeParseJSON(options: {
-    text: string;
-    schema?: undefined;
-}): Promise<ParseResult<JSONValue>>;
-/**
- * Safely parses a JSON string into a strongly-typed object, using a provided schema to validate the object.
- *
- * @template T - The type of the object to parse the JSON into.
- * @param {string} text - The JSON string to parse.
- * @param {Validator<T>} schema - The schema to use for parsing the JSON.
- * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
- */
-declare function safeParseJSON<T>(options: {
-    text: string;
-    schema: FlexibleSchema<T>;
-}): Promise<ParseResult<T>>;
-declare function isParsableJson(input: string): boolean;
-
-type ResponseHandler<RETURN_TYPE> = (options: {
-    url: string;
-    requestBodyValues: unknown;
-    response: Response;
-}) => PromiseLike<{
-    value: RETURN_TYPE;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
-}>;
-declare const createJsonErrorResponseHandler: <T>({ errorSchema, errorToMessage, isRetryable, }: {
-    errorSchema: FlexibleSchema<T>;
-    errorToMessage: (error: T) => string;
-    isRetryable?: (response: Response, error?: T) => boolean;
-}) => ResponseHandler<APICallError>;
-declare const createEventSourceResponseHandler: <T>(chunkSchema: FlexibleSchema<T>) => ResponseHandler<ReadableStream<ParseResult<T>>>;
-declare const createJsonResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<T>;
-declare const createJsonLinesResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<AsyncGenerator<T>>;
-declare const createBinaryResponseHandler: () => ResponseHandler<Uint8Array>;
-declare const createStatusCodeErrorResponseHandler: () => ResponseHandler<APICallError>;
-
 declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, validateUrl, credentialedOrigin, trustedOrigin, }: {
     url: string;
     headers?: Record<string, string | undefined>;
@@ -1383,6 +1413,45 @@ declare function parseProviderOptions<OPTIONS>({ provider, providerOptions, sche
     schema: FlexibleSchema<OPTIONS>;
 }): Promise<OPTIONS | undefined>;
 
+/**
+ * A part of a streaming multipart/form-data request body.
+ *
+ * Parts are emitted in array order, which providers may depend on
+ * (e.g. xAI requires expiry fields to precede the file part).
+ */
+type MultipartStreamPart = {
+    type: 'field';
+    name: string;
+    value: string;
+} | {
+    type: 'file';
+    name: string;
+    filename?: string;
+    mediaType?: string;
+    content: ReadableStream<Uint8Array> | Uint8Array;
+};
+/**
+ * POSTs a multipart/form-data body as a request stream, so file parts backed
+ * by a `ReadableStream` are sent without buffering the full file in memory.
+ *
+ * Requires a fetch implementation that supports streaming request bodies
+ * (`duplex: 'half'`). Callers with fully buffered payloads can keep using
+ * `postFormDataToApi`.
+ */
+declare const postMultipartStreamToApi: <T>({ url, headers, parts, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
+    url: string;
+    headers?: Record<string, string | undefined>;
+    parts: Array<MultipartStreamPart>;
+    failedResponseHandler: ResponseHandler<Error>;
+    successfulResponseHandler: ResponseHandler<T>;
+    abortSignal?: AbortSignal;
+    fetch?: FetchFunction;
+}) => Promise<{
+    value: T;
+    rawValue?: unknown;
+    responseHeaders?: Record<string, string>;
+}>;
+
 declare const postJsonToApi: <T>({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
     url: string;
     headers?: Record<string, string | undefined>;
@@ -2719,4 +2788,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, EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, 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 ToolCallerDefinition as Experimental_ToolCallerDefinition, type ToolCallerTool as Experimental_ToolCallerTool, 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 ProviderStreamError, type ReasoningFilePart, type ReasoningPart, type Resolvable, type ResponseHandler, type RetryDelayProvider, type RetryErrorFactory, type RetryErrorReason, type RetryFunction, type Schema, SerializationError, 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, createJsonLinesResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createProviderStreamError, createStatusCodeErrorResponseHandler, createToolNameMapping, delay, detectMediaType, downloadBlob, dynamicTool, executeTool, getToolCaller as experimental_getToolCaller, parseTranscriptionStreamClientFrame as experimental_parseTranscriptionStreamClientFrame, parseTranscriptionStreamPart as experimental_parseTranscriptionStreamPart, serializeTranscriptionStreamPart as experimental_serializeTranscriptionStreamPart, toolCaller as experimental_toolCaller, extractLines, extractResponseHeaders, fetchWithValidatedRedirects, filterNullable, generateId, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, getWebSocketConstructor, injectJsonInstructionIntoMessages, isAbortError, isBrowserRuntime, isBuffer, isCustomReasoning, isExecutableTool, isFullMediaType, isNonNullable, isParsableJson, isProviderReference, isProviderStreamError, isRecord, isSameOrigin, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeBatchRequestCounts, 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 };
+export { type Arrayable, type AssistantContent, type AssistantModelMessage, type Context, type CustomPart, DEFAULT_MAX_DOWNLOAD_SIZE, type DataContent, DelayedPromise, DownloadError, type DynamicTool, EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, 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 ToolCallerDefinition as Experimental_ToolCallerDefinition, type ToolCallerTool as Experimental_ToolCallerTool, 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 MultipartStreamPart, type ParseResult, type ProviderDefinedTool, type ProviderDefinedToolFactory, type ProviderDefinedToolFactoryWithOutputSchema, type ProviderExecutedTool, type ProviderExecutedToolFactory, type ProviderOptions, type ProviderReference, type ProviderStreamError, type ReasoningFilePart, type ReasoningPart, type Resolvable, type ResponseHandler, type RetryDelayProvider, type RetryErrorFactory, type RetryErrorReason, type RetryFunction, type Schema, SerializationError, 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, createBinaryStreamResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createProviderStreamError, createStatusCodeErrorResponseHandler, createToolNameMapping, delay, deleteFromApi, detectMediaType, downloadBlob, dynamicTool, executeTool, getToolCaller as experimental_getToolCaller, parseTranscriptionStreamClientFrame as experimental_parseTranscriptionStreamClientFrame, parseTranscriptionStreamPart as experimental_parseTranscriptionStreamPart, serializeTranscriptionStreamPart as experimental_serializeTranscriptionStreamPart, toolCaller as experimental_toolCaller, extractLines, extractResponseHeaders, fetchWithValidatedRedirects, filterNullable, generateId, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, getWebSocketConstructor, injectJsonInstructionIntoMessages, isAbortError, isBrowserRuntime, isBuffer, isCustomReasoning, isExecutableTool, isFullMediaType, isNonNullable, isParsableJson, isProviderReference, isProviderStreamError, isRecord, isSameOrigin, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeBatchRequestCounts, normalizeHeaders, parseJSON, parseJsonEventStream, parseProviderOptions, postFormDataToApi, postJsonToApi, postMultipartStreamToApi, 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/create-hook.d.ts

@@ -163,6 +163,9 @@ export interface HookOptions {
     /**
      * Additional user-defined data to include with the hook payload.
      *
+     * Read it back outside the workflow with `getHookByToken()`, where
+     * `hook.metadata` is a Promise: `await hook.metadata`.
+     *
      * @example
      *
      * ```ts

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

@@ -1,2 +1,2 @@
-import"../../_chunks/workflow/dist-veFIAdWV.js";import{$n as e,Ar as t,F as n,Mr as r,N as i,T as a,X as o,Y as s,br as c,cr as l,dr as u,hr as d,jr as f,mr as p,pr as m,t as h,vr as g,xr as _,yr as v}from"../../_chunks/workflow/attribute-changes-DpruylJZ.js";import{i as y,u as b}from"../../_chunks/workflow/dist-BIO9Inoc.js";import{n as x}from"../../_chunks/workflow/resume-hook-DWDi_wCN.js";import{t as S}from"../../_chunks/workflow/sleep-BKxoNDRv.js";function C(e){f(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,C)}function w(e){f(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,w)}function T({schema:e}={}){function t(e){f(`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 x(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 x(t,r.value)}}}async function E(e,t={}){let n=o.getStore(),r=n?.workflowMetadata?.workflowRunId;if(!r)throw new y(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let i=h(e,t);if(i.length!==0){if(n.runReadyBarrier)try{await n.runReadyBarrier}catch{}await(await u()).events.create(r,{eventType:`attr_set`,specVersion:7,eventData:{changes:i,writer:{type:`step`,stepId:n.stepMetadata.stepId,attempt:n.stepMetadata.attempt},...t.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function D(){let e=o.getStore();return e||t(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,D),e.stepMetadata}function O(){let e=o.getStore();return e||r(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,O),e.workflowMetadata}function k(t={}){let u=o.getStore();u||r(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,k);let{namespace:f}=t,h=u.workflowMetadata.workflowRunId,y=s(h,f);u.writables??=new Map;let b=u.writables,x=b.get(y);if(x)return x.writable;let S=n(i(globalThis,u.ops,h,u.encryptionKey,!0,u.runReadyBarrier),u.encryptionKey),C=new a(h,y,u.runReadyBarrier),w=m();return u.ops.push(w.promise),p(S.readable,C,w).catch(()=>{}),d(S.writable,w),Object.defineProperty(S.writable,g,{value:y,writable:!1}),Object.defineProperty(S.writable,_,{value:h,writable:!1}),u.workflowDeploymentId&&Object.defineProperty(S.writable,v,{value:u.workflowDeploymentId,writable:!1}),e(u.encryptionKey)&&Object.defineProperty(S.writable,c,{value:l(u.encryptionKey.keyPair.publicKey),writable:!1}),b.set(y,{writable:S.writable,state:w}),S.writable}export{y as FatalError,b as RetryableError,C as createHook,w as createWebhook,T as defineHook,D as getStepMetadata,O as getWorkflowMetadata,k as getWritable,E as setAttributes,S as sleep};
+import"../../_chunks/workflow/dist-DDeH-1ER.js";import{$ as e,Cr as t,Fr as n,L as r,Nr as i,P as a,Pr as o,Q as s,Sr as c,T as l,_r as u,dr as d,gr as f,mr as p,nr as m,t as h,vr as g,wr as _,xr as v}from"../../_chunks/workflow/attribute-changes-C6H-fRVP.js";import{i as y,u as b}from"../../_chunks/workflow/dist-xTushGCp.js";import{n as x}from"../../_chunks/workflow/resume-hook-BRDLAb67.js";import{t as S}from"../../_chunks/workflow/sleep-6cG0F99-.js";function C(e){o(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,C)}function w(e){o(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,w)}function T({schema:e}={}){function t(e){o(`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 x(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 x(t,r.value)}}}async function E(t,n={}){let r=e.getStore(),i=r?.workflowMetadata?.workflowRunId;if(!i)throw new y(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let a=h(t,n);if(a.length!==0){if(r.runReadyBarrier)try{await r.runReadyBarrier}catch{}await(await p()).events.create(i,{eventType:`attr_set`,specVersion:7,eventData:{changes:a,writer:{type:`step`,stepId:r.stepMetadata.stepId,attempt:r.stepMetadata.attempt},...n.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function D(){let t=e.getStore();return t||i(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,D),t.stepMetadata}function O(){let t=e.getStore();return t||n(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,O),t.workflowMetadata}function k(i={}){let o=e.getStore();o||n(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,k);let{namespace:p}=i,h=o.workflowMetadata.workflowRunId,y=s(h,p);o.writables??=new Map;let b=o.writables,x=b.get(y);if(x)return x.writable;let S=r(a(globalThis,o.ops,h,o.encryptionKey,!0,o.runReadyBarrier),o.encryptionKey),C=new l(h,y,o.runReadyBarrier),w=f();return o.ops.push(w.promise),u(S.readable,C,w).catch(()=>{}),g(S.writable,w),Object.defineProperty(S.writable,v,{value:y,writable:!1}),Object.defineProperty(S.writable,_,{value:h,writable:!1}),o.workflowDeploymentId&&Object.defineProperty(S.writable,c,{value:o.workflowDeploymentId,writable:!1}),m(o.encryptionKey)&&Object.defineProperty(S.writable,t,{value:d(o.encryptionKey.keyPair.publicKey),writable:!1}),b.set(y,{writable:S.writable,state:w}),S.writable}export{y as FatalError,b as RetryableError,C as createHook,w as createWebhook,T as defineHook,D as getStepMetadata,O as getWorkflowMetadata,k as getWritable,E as setAttributes,S as sleep};

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

@@ -1 +1 @@
-import{a as e,c as t,i as n,n as r,o as i,r as a,s as o,t as s}from"../../_chunks/workflow/private-aXEeo0fU.js";export{s as awaitEarlierDeliveries,r as getStepFunction,a as hasParkedCommittedDelivery,n as isDeliveryIdle,e as registerDeliveryBarrier,i as registerStepFunction,o as scheduleWhenIdle,t as scheduleWorkflowSuspension};
+import{a as e,c as t,i as n,n as r,o as i,r as a,s as o,t as s}from"../../_chunks/workflow/private-CFJkQA7R.js";export{s as awaitEarlierDeliveries,r as getStepFunction,a as hasParkedCommittedDelivery,n as isDeliveryIdle,e as registerDeliveryBarrier,i as registerStepFunction,o as scheduleWhenIdle,t as scheduleWorkflowSuspension};

package/dist/src/compiled/@workflow/core/runtime/resume-hook.d.ts

@@ -1,9 +1,60 @@
-import { type Hook } from '#compiled/@workflow/world/index.js';
+import { type Hook as WorldHook } from '#compiled/@workflow/world/index.js';
 import { type PayloadKey } from '../serialization.js';
 /**
- * Get the hook by token to find the associated workflow run,
- * and hydrate the `metadata` property if it was set from within
- * the workflow run.
+ * A hook record with its serialized `metadata` omitted: everything a resume
+ * actually reads. Resuming never looks at metadata, so the resume path accepts
+ * both a raw {@link WorldHook} straight out of a World and a {@link Hook}
+ * whose `metadata` is a Promise.
+ */
+type ResumableHook = Omit<WorldHook, 'metadata'>;
+/**
+ * A hook as returned by {@link getHookByToken} and {@link resumeHook}: the
+ * World's {@link WorldHook} record with its user-defined `metadata` hydrated
+ * lazily.
+ *
+ * `metadata` is a getter that returns a Promise — the same shape as
+ * `Run.returnValue` — so looking a hook up by token costs exactly one read.
+ * Hydrating metadata is a decrypting READ that needs the owning run's payload
+ * keys, and resolving those can cost a run fetch plus a `run-key` API round
+ * trip (~350ms). Deferring that to first access keeps the lookup fast for the
+ * many callers that only need `runId`/`token` — most importantly hook
+ * resumption, which never reads metadata at all.
+ *
+ * The promise is memoized: hydration (and the key resolution behind it) runs at
+ * most once per hook object. Awaiting it on a hook that stored no metadata
+ * resolves `undefined` and performs no I/O.
+ *
+ * Like `Run.returnValue`, the accessor is non-enumerable, so it is absent from
+ * `{ ...hook }` and `JSON.stringify(hook)` — read it explicitly and include the
+ * awaited value if you need to forward it.
+ *
+ * @example
+ *
+ * ```ts
+ * const hook = await getHookByToken(token);
+ * console.log(hook.runId); // no metadata work
+ * const metadata = (await hook.metadata) as { allowedUserId?: string } | undefined;
+ * ```
+ */
+export interface Hook extends ResumableHook {
+    /**
+     * The hook's user-defined metadata, hydrated on first access and memoized.
+     * Resolves `undefined` when the hook carries no metadata.
+     */
+    readonly metadata: Promise<unknown>;
+}
+/**
+ * Get the hook by token to find the associated workflow run.
+ *
+ * This is a single read. The returned hook's `metadata` is a getter that
+ * resolves a Promise (see {@link Hook}), so the run fetch and
+ * `run-key` round trip that hydrating it can require are only paid by callers
+ * that actually await it:
+ *
+ * ```ts
+ * const hook = await getHookByToken(token);
+ * const metadata = await hook.metadata;
+ * ```
  *
  * A Hook kept by minimum retention remains available here after its run ends,
  * but cannot be resumed.
@@ -12,8 +63,8 @@ import { type PayloadKey } from '../serialization.js';
  */
 export declare function getHookByToken(token: string): Promise<Hook>;
 /**
- * The result of {@link resumeHook}: a {@link Hook} augmented with an optional
- * resilience signal.
+ * The result of {@link resumeHook}: a {@link Hook} augmented
+ * with an optional resilience signal.
  *
  * `resilientResume` is retained for source compatibility and is never set.
  * `resumeHook()` now requires the durable `hook_received` write and workflow
@@ -68,7 +119,7 @@ export type ResumedHook = Hook & {
  * }
  * ```
  */
-export declare function resumeHook<T = any>(tokenOrHook: string | Hook, payload: T, encryptionKeyOverride?: PayloadKey): Promise<ResumedHook>;
+export declare function resumeHook<T = any>(tokenOrHook: string | ResumableHook, payload: T, encryptionKeyOverride?: PayloadKey): Promise<ResumedHook>;
 /**
  * Resumes a webhook by sending a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request}
  * object to a hook identified by its token.
@@ -105,4 +156,5 @@ export declare function resumeHook<T = any>(tokenOrHook: string | Hook, payload:
  * ```
  */
 export declare function resumeWebhook(token: string, request: Request): Promise<Response>;
+export {};
 //# sourceMappingURL=resume-hook.d.ts.map

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

@@ -61,6 +61,32 @@ export interface WorkflowReadableStreamOptions {
      */
     global?: Record<string, any>;
 }
+/**
+ * Options for configuring a writable onto a workflow run's stream.
+ */
+export interface WorkflowRunWritableStreamOptions {
+    /**
+     * An optional namespace to distinguish between multiple streams associated
+     * with the same workflow run.
+     */
+    namespace?: string;
+    /**
+     * Any asynchronous operations to complete before pausing or terminating the
+     * execution environment
+     * (i.e. using [`waitUntil()`](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) or similar).
+     *
+     * Writes are acknowledged on buffer entry, so a caller that needs them
+     * durable before the environment goes away should pass an array here and
+     * await it after releasing the writer lock.
+     */
+    ops?: Promise<any>[];
+    /**
+     * The global object to use for reducing types from the global scope.
+     *
+     * Defaults to {@link [`globalThis`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/globalThis)}.
+     */
+    global?: Record<string, any>;
+}
 /**
  * A handler class for a workflow run.
  */
@@ -145,6 +171,22 @@ export declare class Run<TResult> {
      * @returns A `WorkflowReadableStream` for the workflow run.
      */
     getReadable<R = any>(options?: WorkflowReadableStreamOptions): WorkflowReadableStream<R>;
+    /** The writable stream of the workflow run. */
+    get writable(): WritableStream;
+    /**
+     * Returns a writable that appends to this run's stream.
+     *
+     * Initialization is deferred until the first write. The run must already
+     * exist. The writable may be forwarded through `start()` and into steps, but
+     * grants no read access or additional authorization.
+     *
+     * @remarks
+     * `writer.close()` closes the shared stream. Contributors should call
+     * `releaseLock()`, which also drains pending writes.
+     *
+     * @param options - The writable stream options.
+     */
+    getWritable<W = any>(options?: WorkflowRunWritableStreamOptions): WritableStream<W>;
 }
 /**
  * Retrieves a `Run` object for a given run ID.

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

@@ -1,4 +1,4 @@
-import type { World } from '#compiled/@workflow/world/index.js';
+import type { RunRetention, World } from '#compiled/@workflow/world/index.js';
 import { Run } from './run.js';
 /**
  * Reset the `deploymentId: 'latest'` no-op warn-once guard. Test-only,
@@ -48,6 +48,36 @@ export interface StartOptionsBase {
      * the `setAttributes` option of the same name.
      */
     allowReservedAttributes?: boolean;
+    /**
+     * Set a preference for data retention after run completion.
+     *
+     * **Experimental.** Both the unit and the set of accepted values are expected
+     * to change.
+     *
+     * Worlds control the retention of user data (event payloads and stream
+     * chunks), the event log, and any analytics data. Options are:
+     * - `'default'`: same as omission, the World will decide. On Vercel, this
+     *   is based on your team's plan.
+     * - `0`: data is deleted as soon as your run completes or fails. On
+     *   Vercel, user data is deleted, but metadata may persist for your plan's
+     *   default retention period.
+     *
+     * The value is a duration, with zero being the only valid option currently.
+     *
+     * **Known limitation at `0`.** The purge races your own read of the run's
+     * result and generally wins, so `await run.returnValue` on a
+     * `experimental_retention: 0` run usually throws `RunExpiredError` rather
+     * than resolving. If you need the result, return it through a channel you
+     * control, e.g. a step that writes it to external storage.
+     *
+     * Recorded on the run as the reserved `$retention` attribute, so it
+     * requires a World implementing spec version 4 or later. `'default'` is
+     * not written at all, keeping it exactly equivalent to omitting the
+     * option. Retention is enforced by the World: the first-party Worlds
+     * (Vercel, Local, Postgres) implement it, and a World that does not
+     * recognize the value keeps the data.
+     */
+    experimental_retention?: RunRetention;
     /**
      * The ID of an existing run this run is being replayed from, if any.
      *