@ai-sdk/provider-utils 5.0.6 → 5.0.9

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @ai-sdk/provider-utils
 
+## 5.0.9
+
+### Patch Changes
+
+- 4be62c1: fix(provider-utils): validate provider-response URLs in `getFromApi`
+
+  `getFromApi` now has a `validateUrl` flag. It is optional so existing callers keep compiling (omitting it behaves like `false`, i.e. no validation), but all AI SDK provider packages set it explicitly at every call site so each one makes a visible trust decision. When `true`, the URL is routed through `fetchWithValidatedRedirects` — the same guard used by `downloadBlob` — which rejects private/loopback/link-local targets, re-validates every redirect hop, strips proxy/metadata/cookie request headers, and drops all caller headers except the user-agent on cross-origin redirects (custom API-key headers must not follow a redirect off-origin any more than `Authorization` may); blocked URLs throw `DownloadError`. It is enabled at the image/video/audio download and polling call sites where the URL comes from a provider response body; URLs built from developer-configured endpoints pass `validateUrl: false` and are unaffected.
+
+  A new optional `credentialedOrigin` withholds caller headers unless the URL is same-origin with it, so the API key is not sent to a response-supplied host on a different origin.
+
+  A new optional `trustedOrigin` exempts URLs (and redirect hops) that are same-origin with the developer-configured provider endpoint from target validation, so self-hosted and localhost deployments whose response URLs point back at the configured host keep working; all other hops are still validated.
+
+  Also closes range gaps in `validateDownloadUrl` (IPv4 `224.0.0.0/4` multicast and the TEST-NET documentation ranges `192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`; IPv6 documentation ranges `2001:db8::/32` and `3fff::/20`), and follows only the fetch-spec redirect status codes (301/302/303/307/308) — a `Location` header on any other status is not followed. This guard performs string/literal checks only and does not resolve DNS; hostnames that resolve to private addresses and DNS rebinding remain out of scope and must be constrained at the network layer (or by injecting a Node `fetch` that pins the resolved IP at connect time) for server deployments handling untrusted URLs. See `contributing/secure-url-handling.md`.
+
+- 7805e4a: Add experimental transcription-stream WebSocket envelope (standard doStream-over-WebSocket serialization): frame type constants, `experimental_parseTranscriptionStreamClientFrame`, `experimental_serializeTranscriptionStreamPart`, and `experimental_parseTranscriptionStreamPart` (all APIs are exported with experimental prefixes). `serializeTranscriptionStreamPart` returns `undefined` for payloads that are not JSON-serializable (callers drop the frame) and serializes cross-realm `Error` payloads by brand check.
+- cd12954: Reject empty OpenAI, Anthropic, and Replicate base URLs with a helpful AI SDK
+  invalid argument error.
+
+## 5.0.8
+
+### Patch Changes
+
+- e193290: Add `connectToWebSocket` to `@ai-sdk/provider-utils`: a shared WebSocket connect layer (constructor resolution, header hygiene, abort wiring, message decoding) analogous to `postToApi` for HTTP. The openai and xai streaming transcription models now use it instead of hand-rolled connects. For openai and xai this also means WebSocket constructor failures now surface as stream errors instead of throwing synchronously from `doStream`, an already-aborted signal no longer constructs a socket, and the caller's audio stream is cancelled on pre-open failures. Messages are processed in order with close handling deferred behind pending frames, audio send loops apply backpressure via the socket's bufferedAmount, and failed sends cancel the caller's audio stream.
+
+## 5.0.7
+
+### Patch Changes
+
+- Updated dependencies [0f93c57]
+  - @ai-sdk/provider@4.0.3
+
 ## 5.0.6
 
 ### Patch Changes

package/dist/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 '@ai-sdk/provider';
+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 '@ai-sdk/provider';
 export { getErrorMessage } from '@ai-sdk/provider';
 import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
 export * from '@standard-schema/spec';
@@ -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;
@@ -2163,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.
@@ -2221,31 +2452,6 @@ declare function safeValidateTypes<OBJECT>({ value, schema, context, }: {
 
 declare const VERSION: string;
 
-type WebSocketLike = {
-    readyState: 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>;
-
 /**
  * Appends suffix parts to the `user-agent` header.
  * If a `user-agent` header already exists, the suffix parts are appended to it.
@@ -2411,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 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 WebSocketConstructor, type WebSocketLike, 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, 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, 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 };