ai 5.0.0-canary.18 → 5.0.0-canary.19

package/dist/internal/index.d.mts

@@ -1,7 +1,13 @@
+import { SharedV2ProviderOptions, JSONValue, LanguageModelV2Source, JSONObject, LanguageModelV2Prompt, LanguageModelV2FunctionTool, LanguageModelV2ProviderDefinedTool, LanguageModelV2ToolChoice } from '@ai-sdk/provider';
 import { ToolResultContent, ToolCall, ToolResult, Schema } from '@ai-sdk/provider-utils';
 import { z } from 'zod';
-import * as _ai_sdk_provider from '@ai-sdk/provider';
-import { SharedV2ProviderOptions, JSONValue as JSONValue$1, LanguageModelV2Source, LanguageModelV2FinishReason, LanguageModelV2Usage, JSONObject, LanguageModelV2FunctionTool, LanguageModelV2ProviderDefinedTool, LanguageModelV2ToolChoice, LanguageModelV2Prompt } from '@ai-sdk/provider';
+
+declare function download({ url }: {
+    url: URL;
+}): Promise<{
+    data: Uint8Array;
+    mediaType: string | undefined;
+}>;
 
 /**
 Additional provider-specific options.
@@ -234,12 +240,6 @@ It can be a user message, an assistant message, or a tool message.
  */
 type ModelMessage = SystemModelMessage | UserModelMessage | AssistantModelMessage | ToolModelMessage;
 
-type JSONValue = JSONValue$1;
-
-/**
-A source that has been used as input to generate the response.
-*/
-type Source = LanguageModelV2Source;
 /**
 Tool choice for the generation. It supports the following settings:
 
@@ -285,17 +285,13 @@ interface UIMessage {
      */
     createdAt?: Date;
     /**
-  Text content of the message. Use parts when possible.
-     */
-    content: string;
-    /**
   The role of the message.
      */
     role: 'system' | 'user' | 'assistant';
     /**
   Additional message-specific information added on the server via StreamData
      */
-    annotations?: JSONValue$1[] | undefined;
+    annotations?: JSONValue[] | undefined;
     /**
   The parts of the message. Use this for rendering the message in the UI.
   
@@ -381,75 +377,6 @@ type StepStartUIPart = {
     type: 'step-start';
 };
 
-type DataStreamString = `${(typeof DataStreamStringPrefixes)[keyof typeof DataStreamStringPrefixes]}:${string}\n`;
-interface DataStreamPart<CODE extends string, NAME extends string, TYPE> {
-    code: CODE;
-    name: NAME;
-    parse: (value: JSONValue) => {
-        type: NAME;
-        value: TYPE;
-    };
-}
-declare const dataStreamParts: readonly [DataStreamPart<"0", "text", string>, DataStreamPart<"2", "data", _ai_sdk_provider.JSONValue[]>, DataStreamPart<"3", "error", string>, DataStreamPart<"8", "message_annotations", _ai_sdk_provider.JSONValue[]>, DataStreamPart<"9", "tool_call", ToolCall<string, any>>, DataStreamPart<"a", "tool_result", Omit<ToolResult<string, any, any>, "toolName" | "args">>, DataStreamPart<"b", "tool_call_streaming_start", {
-    toolCallId: string;
-    toolName: string;
-}>, DataStreamPart<"c", "tool_call_delta", {
-    toolCallId: string;
-    argsTextDelta: string;
-}>, DataStreamPart<"d", "finish_message", {
-    finishReason: LanguageModelV2FinishReason;
-    usage?: LanguageModelV2Usage;
-}>, DataStreamPart<"e", "finish_step", {
-    isContinued: boolean;
-    finishReason: LanguageModelV2FinishReason;
-    usage?: LanguageModelV2Usage;
-}>, DataStreamPart<"f", "start_step", {
-    messageId: string;
-}>, DataStreamPart<"g", "reasoning", {
-    text: string;
-    providerMetadata?: Record<string, any> | undefined;
-}>, DataStreamPart<"h", "source", LanguageModelV2Source>, DataStreamPart<"l", "reasoning_part_finish", {}>, DataStreamPart<"k", "file", {
-    url: string;
-    mediaType: string;
-}>];
-type DataStreamParts = (typeof dataStreamParts)[number];
-/**
- * Maps the type of a stream part to its value type.
- */
-type DataStreamPartValueType = {
-    [P in DataStreamParts as P['name']]: ReturnType<P['parse']>['value'];
-};
-/**
- * The map of prefixes for data in the stream
- *
- * - 0: Text from the LLM response
- * - 1: (OpenAI) function_call responses
- * - 2: custom JSON added by the user using `Data`
- * - 6: (OpenAI) tool_call responses
- *
- * Example:
- * ```
- * 0:Vercel
- * 0:'s
- * 0: AI
- * 0: AI
- * 0: SDK
- * 0: is great
- * 0:!
- * 2: { "someJson": "value" }
- * 1: {"function_call": {"name": "get_current_weather", "arguments": "{\\n\\"location\\": \\"Charlottesville, Virginia\\",\\n\\"format\\": \\"celsius\\"\\n}"}}
- * 6: {"tool_call": {"id": "tool_0", "type": "function", "function": {"name": "get_current_weather", "arguments": "{\\n\\"location\\": \\"Charlottesville, Virginia\\",\\n\\"format\\": \\"celsius\\"\\n}"}}}
- *```
- */
-declare const DataStreamStringPrefixes: { [K in DataStreamParts["name"]]: (typeof dataStreamParts)[number]["code"]; };
-/**
-Prepends a string with a prefix from the `StreamChunkPrefixes`, converts it to JSON,
-and appends a new line.
-
-It ensures type-safety for the part type and value.
- */
-declare function formatDataStreamPart<T extends keyof DataStreamPartValueType>(type: T, value: DataStreamPartValueType[T]): DataStreamString;
-
 type ToolParameters<T = JSONObject> = z.Schema<T> | Schema<T>;
 interface ToolExecutionOptions {
     /**
@@ -473,7 +400,7 @@ This enables the language model to generate the input.
 
 The tool can also contain an optional execute function for the actual execution function of the tool.
  */
-type Tool<PARAMETERS extends JSONValue$1 | unknown | never = any, RESULT = any> = {
+type Tool<PARAMETERS extends JSONValue | unknown | never = any, RESULT = any> = {
     /**
   An optional description of what the tool does.
   Will be used by the language model to decide whether to use the tool.
@@ -556,6 +483,12 @@ declare function standardizePrompt<TOOLS extends ToolSet>({ prompt, tools, }: {
     tools: undefined | TOOLS;
 }): Promise<StandardizedPrompt>;
 
+declare function convertToLanguageModelPrompt({ prompt, supportedUrls, downloadImplementation, }: {
+    prompt: StandardizedPrompt;
+    supportedUrls: Record<string, RegExp[]>;
+    downloadImplementation?: typeof download;
+}): Promise<LanguageModelV2Prompt>;
+
 type CallSettings = {
     /**
   Maximum number of tokens to generate.
@@ -631,27 +564,436 @@ type CallSettings = {
     headers?: Record<string, string | undefined>;
 };
 
+/**
+ * Validates call settings and sets default values.
+ */
+declare function prepareCallSettings({ maxOutputTokens, temperature, topP, topK, presencePenalty, frequencyPenalty, stopSequences, seed, }: Omit<CallSettings, 'abortSignal' | 'headers' | 'maxRetries'>): Omit<CallSettings, 'abortSignal' | 'headers' | 'maxRetries' | 'temperature'> & {
+    temperature?: number;
+};
+
+type RetryFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;
+
+/**
+ * Validate and prepare retries.
+ */
+declare function prepareRetries({ maxRetries, }: {
+    maxRetries: number | undefined;
+}): {
+    maxRetries: number;
+    retry: RetryFunction;
+};
+
+declare const dataStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "text";
+}, {
+    value: string;
+    type: "text";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"data">;
+    value: z.ZodArray<z.ZodAny, "many">;
+}, "strip", z.ZodTypeAny, {
+    value: any[];
+    type: "data";
+}, {
+    value: any[];
+    type: "data";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "error";
+}, {
+    value: string;
+    type: "error";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"message-annotations">;
+    value: z.ZodArray<z.ZodAny, "many">;
+}, "strip", z.ZodTypeAny, {
+    value: any[];
+    type: "message-annotations";
+}, {
+    value: any[];
+    type: "message-annotations";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-call">;
+    value: z.ZodObject<{
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+        args: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        toolCallId: string;
+        toolName: string;
+        args?: unknown;
+    }, {
+        toolCallId: string;
+        toolName: string;
+        args?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        toolCallId: string;
+        toolName: string;
+        args?: unknown;
+    };
+    type: "tool-call";
+}, {
+    value: {
+        toolCallId: string;
+        toolName: string;
+        args?: unknown;
+    };
+    type: "tool-call";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-result">;
+    value: z.ZodObject<{
+        toolCallId: z.ZodString;
+        result: z.ZodUnknown;
+        providerMetadata: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        toolCallId: string;
+        result?: unknown;
+        providerMetadata?: any;
+    }, {
+        toolCallId: string;
+        result?: unknown;
+        providerMetadata?: any;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        toolCallId: string;
+        result?: unknown;
+        providerMetadata?: any;
+    };
+    type: "tool-result";
+}, {
+    value: {
+        toolCallId: string;
+        result?: unknown;
+        providerMetadata?: any;
+    };
+    type: "tool-result";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-call-streaming-start">;
+    value: z.ZodObject<{
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        toolCallId: string;
+        toolName: string;
+    }, {
+        toolCallId: string;
+        toolName: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        toolCallId: string;
+        toolName: string;
+    };
+    type: "tool-call-streaming-start";
+}, {
+    value: {
+        toolCallId: string;
+        toolName: string;
+    };
+    type: "tool-call-streaming-start";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-call-delta">;
+    value: z.ZodObject<{
+        toolCallId: z.ZodString;
+        argsTextDelta: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        toolCallId: string;
+        argsTextDelta: string;
+    }, {
+        toolCallId: string;
+        argsTextDelta: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        toolCallId: string;
+        argsTextDelta: string;
+    };
+    type: "tool-call-delta";
+}, {
+    value: {
+        toolCallId: string;
+        argsTextDelta: string;
+    };
+    type: "tool-call-delta";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"finish-message">;
+    value: z.ZodObject<{
+        finishReason: z.ZodEnum<["stop", "length", "tool-calls", "content-filter", "other", "error", "unknown"]>;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodOptional<z.ZodNumber>;
+            outputTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            reasoningTokens: z.ZodOptional<z.ZodNumber>;
+            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        }, {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        finishReason: "length" | "unknown" | "stop" | "content-filter" | "tool-calls" | "error" | "other";
+        usage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    }, {
+        finishReason: "length" | "unknown" | "stop" | "content-filter" | "tool-calls" | "error" | "other";
+        usage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        finishReason: "length" | "unknown" | "stop" | "content-filter" | "tool-calls" | "error" | "other";
+        usage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    };
+    type: "finish-message";
+}, {
+    value: {
+        finishReason: "length" | "unknown" | "stop" | "content-filter" | "tool-calls" | "error" | "other";
+        usage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    };
+    type: "finish-message";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"finish-step">;
+    value: z.ZodObject<{
+        isContinued: z.ZodBoolean;
+        finishReason: z.ZodEnum<["stop", "length", "tool-calls", "content-filter", "other", "error", "unknown"]>;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodOptional<z.ZodNumber>;
+            outputTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            reasoningTokens: z.ZodOptional<z.ZodNumber>;
+            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        }, {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        finishReason: "length" | "unknown" | "stop" | "content-filter" | "tool-calls" | "error" | "other";
+        isContinued: boolean;
+        usage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    }, {
+        finishReason: "length" | "unknown" | "stop" | "content-filter" | "tool-calls" | "error" | "other";
+        isContinued: boolean;
+        usage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        finishReason: "length" | "unknown" | "stop" | "content-filter" | "tool-calls" | "error" | "other";
+        isContinued: boolean;
+        usage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    };
+    type: "finish-step";
+}, {
+    value: {
+        finishReason: "length" | "unknown" | "stop" | "content-filter" | "tool-calls" | "error" | "other";
+        isContinued: boolean;
+        usage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    };
+    type: "finish-step";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"start-step">;
+    value: z.ZodObject<{
+        messageId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        messageId: string;
+    }, {
+        messageId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        messageId: string;
+    };
+    type: "start-step";
+}, {
+    value: {
+        messageId: string;
+    };
+    type: "start-step";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning">;
+    value: z.ZodObject<{
+        text: z.ZodString;
+        providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        providerMetadata?: Record<string, any> | undefined;
+    }, {
+        text: string;
+        providerMetadata?: Record<string, any> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        text: string;
+        providerMetadata?: Record<string, any> | undefined;
+    };
+    type: "reasoning";
+}, {
+    value: {
+        text: string;
+        providerMetadata?: Record<string, any> | undefined;
+    };
+    type: "reasoning";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"source">;
+    value: z.ZodObject<{
+        type: z.ZodLiteral<"source">;
+        sourceType: z.ZodLiteral<"url">;
+        id: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        type: "source";
+        id: string;
+        sourceType: "url";
+        providerMetadata?: any;
+        title?: string | undefined;
+    }, {
+        url: string;
+        type: "source";
+        id: string;
+        sourceType: "url";
+        providerMetadata?: any;
+        title?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        url: string;
+        type: "source";
+        id: string;
+        sourceType: "url";
+        providerMetadata?: any;
+        title?: string | undefined;
+    };
+    type: "source";
+}, {
+    value: {
+        url: string;
+        type: "source";
+        id: string;
+        sourceType: "url";
+        providerMetadata?: any;
+        title?: string | undefined;
+    };
+    type: "source";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    value: z.ZodObject<{
+        url: z.ZodString;
+        mediaType: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        mediaType: string;
+    }, {
+        url: string;
+        mediaType: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        url: string;
+        mediaType: string;
+    };
+    type: "file";
+}, {
+    value: {
+        url: string;
+        mediaType: string;
+    };
+    type: "file";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning-part-finish">;
+    value: z.ZodNull;
+}, "strip", z.ZodTypeAny, {
+    value: null;
+    type: "reasoning-part-finish";
+}, {
+    value: null;
+    type: "reasoning-part-finish";
+}>]>;
+type DataStreamPart = z.infer<typeof dataStreamPartSchema>;
+
 interface DataStreamWriter {
     /**
-     * Appends a data part to the stream.
-     */
-    write(data: DataStreamString): void;
-    /**
-     * Appends a data part to the stream.
-     */
-    writeData(value: JSONValue$1): void;
-    /**
-     * Appends a message annotation to the stream.
+     * Appends a data stream part to the stream.
      */
-    writeMessageAnnotation(value: JSONValue$1): void;
-    /**
-     * Appends a source part to the stream.
-     */
-    writeSource(source: Source): void;
+    write(part: DataStreamPart): void;
     /**
      * Merges the contents of another stream to this stream.
      */
-    merge(stream: ReadableStream<DataStreamString>): void;
+    merge(stream: ReadableStream<DataStreamPart>): void;
     /**
      * Error handler that is used by the data stream writer.
      * This is intended for forwarding when merging streams
@@ -660,23 +1002,6 @@ interface DataStreamWriter {
     onError: ((error: unknown) => string) | undefined;
 }
 
-/**
- * A stream wrapper to send custom JSON-encoded data back to the client.
- *
- * @deprecated Please use `createDataStream`, `createDataStreamResponse`, and `pipeDataStreamToResponse` instead.
- */
-declare class StreamData {
-    private encoder;
-    private controller;
-    stream: ReadableStream<Uint8Array>;
-    private isClosed;
-    private warningTimeout;
-    constructor();
-    close(): Promise<void>;
-    append(value: JSONValue): void;
-    appendMessageAnnotation(value: JSONValue): void;
-}
-
 declare function prepareToolsAndToolChoice<TOOLS extends ToolSet>({ tools, toolChoice, activeTools, }: {
     tools: TOOLS | undefined;
     toolChoice: ToolChoice<TOOLS> | undefined;
@@ -686,70 +1011,12 @@ declare function prepareToolsAndToolChoice<TOOLS extends ToolSet>({ tools, toolC
     toolChoice: LanguageModelV2ToolChoice | undefined;
 };
 
-type RetryFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;
-
-/**
- * Validate and prepare retries.
- */
-declare function prepareRetries({ maxRetries, }: {
-    maxRetries: number | undefined;
-}): {
-    maxRetries: number;
-    retry: RetryFunction;
-};
-
-/**
- * Validates call settings and sets default values.
- */
-declare function prepareCallSettings({ maxOutputTokens, temperature, topP, topK, presencePenalty, frequencyPenalty, stopSequences, seed, }: Omit<CallSettings, 'abortSignal' | 'headers' | 'maxRetries'>): Omit<CallSettings, 'abortSignal' | 'headers' | 'maxRetries' | 'temperature'> & {
-    temperature?: number;
-};
-
-declare function download({ url }: {
-    url: URL;
-}): Promise<{
-    data: Uint8Array;
-    mediaType: string | undefined;
-}>;
-
-declare function convertToLanguageModelPrompt({ prompt, supportedUrls, downloadImplementation, }: {
-    prompt: StandardizedPrompt;
-    supportedUrls: Record<string, RegExp[]>;
-    downloadImplementation?: typeof download;
-}): Promise<LanguageModelV2Prompt>;
-
-/**
- * Merges two readable streams into a single readable stream, emitting values
- * from each stream as they become available.
- *
- * The first stream is prioritized over the second stream. If both streams have
- * values available, the first stream's value is emitted first.
- *
- * @template VALUE1 - The type of values emitted by the first stream.
- * @template VALUE2 - The type of values emitted by the second stream.
- * @param {ReadableStream<VALUE1>} stream1 - The first readable stream.
- * @param {ReadableStream<VALUE2>} stream2 - The second readable stream.
- * @returns {ReadableStream<VALUE1 | VALUE2>} A new readable stream that emits values from both input streams.
- */
-declare function mergeStreams<VALUE1, VALUE2>(stream1: ReadableStream<VALUE1>, stream2: ReadableStream<VALUE2>): ReadableStream<VALUE1 | VALUE2>;
-
-declare function prepareResponseHeaders(headers: HeadersInit | undefined, { contentType, dataStreamVersion, }: {
-    contentType: string;
-    dataStreamVersion?: 'v1' | undefined;
-}): Headers;
-
 /**
  * Configuration options and helper callback methods for stream lifecycle events.
  */
 interface StreamCallbacks {
     /** `onStart`: Called once when the stream is initialized. */
     onStart?: () => Promise<void> | void;
-    /**
-     * `onCompletion`: Called for each tokenized message.
-     *
-     * @deprecated Use `onFinal` instead.
-     */
-    onCompletion?: (completion: string) => Promise<void> | void;
     /** `onFinal`: Called once when the stream is closed with the final completion message. */
     onFinal?: (completion: string) => Promise<void> | void;
     /** `onToken`: Called for each tokenized message. */
@@ -762,7 +1029,6 @@ interface StreamCallbacks {
  * The transform stream uses the provided callbacks to execute custom logic at different stages of the stream's lifecycle.
  * - `onStart`: Called once when the stream is initialized.
  * - `onToken`: Called for each tokenized message.
- * - `onCompletion`: Called every time a completion message is received. This can occur multiple times when using e.g. OpenAI functions
  * - `onFinal`: Called once when the stream is closed with the final completion message.
  *
  * This function is useful when you want to process a stream of messages and perform specific actions during the stream's lifecycle.
@@ -774,12 +1040,11 @@ interface StreamCallbacks {
  * const callbacks = {
  *   onStart: async () => console.log('Stream started'),
  *   onToken: async (token) => console.log(`Token: ${token}`),
- *   onCompletion: async (completion) => console.log(`Completion: ${completion}`)
  *   onFinal: async () => data.close()
  * };
  * const transformer = createCallbacksTransformer(callbacks);
  */
-declare function createCallbacksTransformer(callbacks?: StreamCallbacks | undefined): TransformStream<string, Uint8Array>;
+declare function createCallbacksTransformer(callbacks?: StreamCallbacks | undefined): TransformStream<string, string>;
 
 /**
  * Warning time for notifying developers that a stream is hanging in dev mode
@@ -787,4 +1052,4 @@ declare function createCallbacksTransformer(callbacks?: StreamCallbacks | undefi
  */
 declare const HANGING_STREAM_WARNING_TIME_MS: number;
 
-export { DataStreamWriter, HANGING_STREAM_WARNING_TIME_MS, StreamCallbacks, StreamData, convertToLanguageModelPrompt, createCallbacksTransformer, formatDataStreamPart, mergeStreams, prepareCallSettings, prepareResponseHeaders, prepareRetries, prepareToolsAndToolChoice, standardizePrompt };
+export { DataStreamWriter, HANGING_STREAM_WARNING_TIME_MS, StreamCallbacks, convertToLanguageModelPrompt, createCallbacksTransformer, prepareCallSettings, prepareRetries, prepareToolsAndToolChoice, standardizePrompt };