@fairyhunter13/ai-sdk 6.0.116-fork.1

package/src/types/provider.ts

@@ -0,0 +1,55 @@
+import { EmbeddingModel } from './embedding-model';
+import { LanguageModel } from './language-model';
+import { ImageModel } from './image-model';
+import { RerankingModel } from './reranking-model';
+
+/**
+ * Provider for language, text embedding, and image models.
+ */
+export type Provider = {
+  /**
+   * Returns the language model with the given id.
+   * The model id is then passed to the provider function to get the model.
+   *
+   * @param {string} modelId - The id of the model to return.
+   *
+   * @returns {LanguageModel} The language model associated with the id
+   *
+   * @throws {NoSuchModelError} If no such model exists.
+   */
+  languageModel(modelId: string): LanguageModel;
+
+  /**
+   * Returns the text embedding model with the given id.
+   * The model id is then passed to the provider function to get the model.
+   *
+   * @param {string} modelId - The id of the model to return.
+   *
+   * @returns {EmbeddingModel} The embedding model associated with the id
+   *
+   * @throws {NoSuchModelError} If no such model exists.
+   */
+  embeddingModel(modelId: string): EmbeddingModel;
+
+  /**
+   * Returns the image model with the given id.
+   * The model id is then passed to the provider function to get the model.
+   *
+   * @param {string} modelId - The id of the model to return.
+   *
+   * @returns {ImageModel} The image model associated with the id
+   */
+  imageModel(modelId: string): ImageModel;
+
+  /**
+   * Returns the reranking model with the given id.
+   * The model id is then passed to the provider function to get the model.
+   *
+   * @param {string} modelId - The id of the model to return.
+   *
+   * @returns {RerankingModel} The reranking model associated with the id
+   *
+   * @throws {NoSuchModelError} If no such model exists.
+   */
+  rerankingModel(modelId: string): RerankingModel;
+};

package/src/types/reranking-model.ts

@@ -0,0 +1,6 @@
+import { RerankingModelV3, RerankingModelV4 } from '@ai-sdk/provider';
+
+/**
+ * Reranking model that is used by the AI SDK.
+ */
+export type RerankingModel = RerankingModelV4 | RerankingModelV3;

package/src/types/speech-model-response-metadata.ts

@@ -0,0 +1,21 @@
+export type SpeechModelResponseMetadata = {
+  /**
+   * Timestamp for the start of the generated response.
+   */
+  timestamp: Date;
+
+  /**
+   * The ID of the response model that was used to generate the response.
+   */
+  modelId: string;
+
+  /**
+   * Response headers.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Response body.
+   */
+  body?: unknown;
+};

package/src/types/speech-model.ts

@@ -0,0 +1,10 @@
+import { SpeechModelV2, SpeechModelV3, SpeechModelV4 } from '@ai-sdk/provider';
+
+/**
+ * Speech model that is used by the AI SDK.
+ */
+export type SpeechModel =
+  | string
+  | SpeechModelV4
+  | SpeechModelV3
+  | SpeechModelV2;

package/src/types/transcription-model-response-metadata.ts

@@ -0,0 +1,16 @@
+export type TranscriptionModelResponseMetadata = {
+  /**
+   * Timestamp for the start of the generated response.
+   */
+  timestamp: Date;
+
+  /**
+   * The ID of the response model that was used to generate the response.
+   */
+  modelId: string;
+
+  /**
+   * Response headers.
+   */
+  headers?: Record<string, string>;
+};

package/src/types/transcription-model.ts

@@ -0,0 +1,14 @@
+import {
+  TranscriptionModelV2,
+  TranscriptionModelV3,
+  TranscriptionModelV4,
+} from '@ai-sdk/provider';
+
+/**
+ * Transcription model that is used by the AI SDK.
+ */
+export type TranscriptionModel =
+  | string
+  | TranscriptionModelV4
+  | TranscriptionModelV3
+  | TranscriptionModelV2;

package/src/types/usage.ts

@@ -0,0 +1,200 @@
+import {
+  ImageModelV4Usage,
+  JSONObject,
+  LanguageModelV4Usage,
+} from '@ai-sdk/provider';
+
+/**
+ * Represents the number of tokens used in a prompt and completion.
+ */
+export type LanguageModelUsage = {
+  /**
+   * The total number of input (prompt) tokens used.
+   */
+  inputTokens: number | undefined;
+
+  /**
+   * Detailed information about the input tokens.
+   */
+  inputTokenDetails: {
+    /**
+     * The number of non-cached input (prompt) tokens used.
+     */
+    noCacheTokens: number | undefined;
+
+    /**
+     * The number of cached input (prompt) tokens read.
+     */
+    cacheReadTokens: number | undefined;
+
+    /**
+     * The number of cached input (prompt) tokens written.
+     */
+    cacheWriteTokens: number | undefined;
+  };
+
+  /**
+   * The number of total output (completion) tokens used.
+   */
+  outputTokens: number | undefined;
+
+  /**
+   * Detailed information about the output tokens.
+   */
+  outputTokenDetails: {
+    /**
+     * The number of text tokens used.
+     */
+    textTokens: number | undefined;
+
+    /**
+     * The number of reasoning tokens used.
+     */
+    reasoningTokens: number | undefined;
+  };
+
+  /**
+   * The total number of tokens used.
+   */
+  totalTokens: number | undefined;
+
+  /**
+   * @deprecated Use outputTokenDetails.reasoningTokens instead.
+   */
+  reasoningTokens?: number | undefined;
+
+  /**
+   * @deprecated Use inputTokenDetails.cacheReadTokens instead.
+   */
+  cachedInputTokens?: number | undefined;
+
+  /**
+   * Raw usage information from the provider.
+   *
+   * This is the usage information in the shape that the provider returns.
+   * It can include additional information that is not part of the standard usage information.
+   */
+  raw?: JSONObject;
+};
+
+/**
+ * Represents the number of tokens used in an embedding.
+ */
+// TODO replace with EmbeddingModelV4Usage once available in @ai-sdk/provider
+export type EmbeddingModelUsage = {
+  /**
+   * The number of tokens used in the embedding.
+   */
+  tokens: number;
+};
+
+export function asLanguageModelUsage(
+  usage: LanguageModelV4Usage,
+): LanguageModelUsage {
+  return {
+    inputTokens: usage.inputTokens.total,
+    inputTokenDetails: {
+      noCacheTokens: usage.inputTokens.noCache,
+      cacheReadTokens: usage.inputTokens.cacheRead,
+      cacheWriteTokens: usage.inputTokens.cacheWrite,
+    },
+    outputTokens: usage.outputTokens.total,
+    outputTokenDetails: {
+      textTokens: usage.outputTokens.text,
+      reasoningTokens: usage.outputTokens.reasoning,
+    },
+    totalTokens: addTokenCounts(
+      usage.inputTokens.total,
+      usage.outputTokens.total,
+    ),
+    raw: usage.raw,
+    reasoningTokens: usage.outputTokens.reasoning,
+    cachedInputTokens: usage.inputTokens.cacheRead,
+  };
+}
+
+export function createNullLanguageModelUsage(): LanguageModelUsage {
+  return {
+    inputTokens: undefined,
+    inputTokenDetails: {
+      noCacheTokens: undefined,
+      cacheReadTokens: undefined,
+      cacheWriteTokens: undefined,
+    },
+    outputTokens: undefined,
+    outputTokenDetails: {
+      textTokens: undefined,
+      reasoningTokens: undefined,
+    },
+    totalTokens: undefined,
+    raw: undefined,
+  };
+}
+
+export function addLanguageModelUsage(
+  usage1: LanguageModelUsage,
+  usage2: LanguageModelUsage,
+): LanguageModelUsage {
+  return {
+    inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
+    inputTokenDetails: {
+      noCacheTokens: addTokenCounts(
+        usage1.inputTokenDetails?.noCacheTokens,
+        usage2.inputTokenDetails?.noCacheTokens,
+      ),
+      cacheReadTokens: addTokenCounts(
+        usage1.inputTokenDetails?.cacheReadTokens,
+        usage2.inputTokenDetails?.cacheReadTokens,
+      ),
+      cacheWriteTokens: addTokenCounts(
+        usage1.inputTokenDetails?.cacheWriteTokens,
+        usage2.inputTokenDetails?.cacheWriteTokens,
+      ),
+    },
+    outputTokens: addTokenCounts(usage1.outputTokens, usage2.outputTokens),
+    outputTokenDetails: {
+      textTokens: addTokenCounts(
+        usage1.outputTokenDetails?.textTokens,
+        usage2.outputTokenDetails?.textTokens,
+      ),
+      reasoningTokens: addTokenCounts(
+        usage1.outputTokenDetails?.reasoningTokens,
+        usage2.outputTokenDetails?.reasoningTokens,
+      ),
+    },
+    totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
+    reasoningTokens: addTokenCounts(
+      usage1.reasoningTokens,
+      usage2.reasoningTokens,
+    ),
+    cachedInputTokens: addTokenCounts(
+      usage1.cachedInputTokens,
+      usage2.cachedInputTokens,
+    ),
+  };
+}
+
+function addTokenCounts(
+  tokenCount1: number | undefined,
+  tokenCount2: number | undefined,
+): number | undefined {
+  return tokenCount1 == null && tokenCount2 == null
+    ? undefined
+    : (tokenCount1 ?? 0) + (tokenCount2 ?? 0);
+}
+
+/**
+ * Usage information for an image model call.
+ */
+export type ImageModelUsage = ImageModelV4Usage;
+
+export function addImageModelUsage(
+  usage1: ImageModelUsage,
+  usage2: ImageModelUsage,
+): ImageModelUsage {
+  return {
+    inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
+    outputTokens: addTokenCounts(usage1.outputTokens, usage2.outputTokens),
+    totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
+  };
+}

package/src/types/video-model-response-metadata.ts

@@ -0,0 +1,28 @@
+import type { SharedV4ProviderMetadata } from '@ai-sdk/provider';
+
+/**
+ * Response metadata for a video model call.
+ */
+export type VideoModelResponseMetadata = {
+  /**
+   * Timestamp for the start of the generated response.
+   */
+  timestamp: Date;
+
+  /**
+   * The ID of the response model that was used to generate the response.
+   */
+  modelId: string;
+
+  /**
+   * Response headers.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Provider-specific metadata for this call.
+   * When multiple calls are made (n > maxVideosPerCall), each response
+   * contains its own providerMetadata, allowing lossless per-call access.
+   */
+  providerMetadata?: SharedV4ProviderMetadata;
+};

package/src/types/video-model.ts

@@ -0,0 +1,15 @@
+import {
+  Experimental_VideoModelV3,
+  Experimental_VideoModelV4,
+  SharedV4ProviderMetadata,
+} from '@ai-sdk/provider';
+
+/**
+ * A video model can be a string (model ID) or a video model object.
+ */
+export type VideoModel =
+  | string
+  | Experimental_VideoModelV4
+  | Experimental_VideoModelV3;
+
+export type VideoModelProviderMetadata = SharedV4ProviderMetadata;

package/src/types/warning.ts

@@ -0,0 +1,7 @@
+import { SharedV4Warning } from '@ai-sdk/provider';
+
+/**
+ * Warning from the model provider for this call. The call will proceed, but e.g.
+ * some settings might not be supported, which can lead to suboptimal results.
+ */
+export type Warning = SharedV4Warning;

package/src/ui/call-completion-api.ts

@@ -0,0 +1,157 @@
+import {
+  parseJsonEventStream,
+  ParseResult,
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent,
+} from '@ai-sdk/provider-utils';
+import {
+  UIMessageChunk,
+  uiMessageChunkSchema,
+} from '../ui-message-stream/ui-message-chunks';
+import { consumeStream } from '../util/consume-stream';
+import { processTextStream } from './process-text-stream';
+import { VERSION } from '../version';
+
+// use function to allow for mocking in tests:
+const getOriginalFetch = () => fetch;
+
+export async function callCompletionApi({
+  api,
+  prompt,
+  credentials,
+  headers,
+  body,
+  streamProtocol = 'data',
+  setCompletion,
+  setLoading,
+  setError,
+  setAbortController,
+  onFinish,
+  onError,
+  fetch = getOriginalFetch(),
+}: {
+  api: string;
+  prompt: string;
+  credentials: RequestCredentials | undefined;
+  headers: HeadersInit | undefined;
+  body: Record<string, any>;
+  streamProtocol: 'data' | 'text' | undefined;
+  setCompletion: (completion: string) => void;
+  setLoading: (loading: boolean) => void;
+  setError: (error: Error | undefined) => void;
+  setAbortController: (abortController: AbortController | null) => void;
+  onFinish: ((prompt: string, completion: string) => void) | undefined;
+  onError: ((error: Error) => void) | undefined;
+  fetch: ReturnType<typeof getOriginalFetch> | undefined;
+}) {
+  try {
+    setLoading(true);
+    setError(undefined);
+
+    const abortController = new AbortController();
+    setAbortController(abortController);
+
+    // Empty the completion immediately.
+    setCompletion('');
+
+    const response = await fetch(api, {
+      method: 'POST',
+      body: JSON.stringify({
+        prompt,
+        ...body,
+      }),
+      credentials,
+      headers: withUserAgentSuffix(
+        {
+          'Content-Type': 'application/json',
+          ...headers,
+        },
+        `ai-sdk/${VERSION}`,
+        getRuntimeEnvironmentUserAgent(),
+      ),
+      signal: abortController.signal,
+    }).catch(err => {
+      throw err;
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        (await response.text()) ?? 'Failed to fetch the chat response.',
+      );
+    }
+
+    if (!response.body) {
+      throw new Error('The response body is empty.');
+    }
+
+    let result = '';
+
+    switch (streamProtocol) {
+      case 'text': {
+        await processTextStream({
+          stream: response.body,
+          onTextPart: chunk => {
+            result += chunk;
+            setCompletion(result);
+          },
+        });
+        break;
+      }
+      case 'data': {
+        await consumeStream({
+          stream: parseJsonEventStream({
+            stream: response.body,
+            schema: uiMessageChunkSchema,
+          }).pipeThrough(
+            new TransformStream<ParseResult<UIMessageChunk>, UIMessageChunk>({
+              async transform(part) {
+                if (!part.success) {
+                  throw part.error;
+                }
+
+                const streamPart = part.value;
+                if (streamPart.type === 'text-delta') {
+                  result += streamPart.delta;
+                  setCompletion(result);
+                } else if (streamPart.type === 'error') {
+                  throw new Error(streamPart.errorText);
+                }
+              },
+            }),
+          ),
+          onError: error => {
+            throw error;
+          },
+        });
+        break;
+      }
+      default: {
+        const exhaustiveCheck: never = streamProtocol;
+        throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
+      }
+    }
+
+    if (onFinish) {
+      onFinish(prompt, result);
+    }
+
+    setAbortController(null);
+    return result;
+  } catch (err) {
+    // Ignore abort errors as they are expected.
+    if ((err as any).name === 'AbortError') {
+      setAbortController(null);
+      return null;
+    }
+
+    if (err instanceof Error) {
+      if (onError) {
+        onError(err);
+      }
+    }
+
+    setError(err as Error);
+  } finally {
+    setLoading(false);
+  }
+}

package/src/ui/chat-transport.ts

@@ -0,0 +1,83 @@
+import { UIMessageChunk } from '../ui-message-stream';
+import { ChatRequestOptions } from './chat';
+import { UIMessage } from './ui-messages';
+
+/**
+ * Transport interface for handling chat message communication and streaming.
+ *
+ * The `ChatTransport` interface provides fine-grained control over how messages
+ * are sent to API endpoints and how responses are processed. This enables
+ * alternative communication protocols like WebSockets, custom authentication
+ * patterns, or specialized backend integrations.
+ *
+ * @template UI_MESSAGE - The UI message type extending UIMessage
+ */
+export interface ChatTransport<UI_MESSAGE extends UIMessage> {
+  /**
+   * Sends messages to the chat API endpoint and returns a streaming response.
+   *
+   * This method handles both new message submission and message regeneration.
+   * It supports real-time streaming of responses through UIMessageChunk events.
+   *
+   * @param options - Configuration object containing:
+   * @param options.trigger - The type of message submission:
+   *   - `'submit-message'`: Submitting a new user message
+   *   - `'regenerate-message'`: Regenerating an assistant response
+   * @param options.chatId - Unique identifier for the chat session
+   * @param options.messageId - ID of the message to regenerate (for regenerate-message trigger) or undefined for new messages
+   * @param options.messages - Array of UI messages representing the conversation history
+   * @param options.abortSignal - Signal to abort the request if needed
+   * @param options.headers - Additional HTTP headers to include in the request
+   * @param options.body - Additional JSON properties to include in the request body
+   * @param options.metadata - Custom metadata to attach to the request
+   *
+   * @returns Promise resolving to a ReadableStream of UIMessageChunk objects.
+   *   The stream emits various chunk types like:
+   *   - `text-start`, `text-delta`, `text-end`: For streaming text content
+   *   - `tool-input-start`, `tool-input-delta`, `tool-input-available`: For tool calls
+   *   - `data-part-start`, `data-part-delta`, `data-part-available`: For data parts
+   *   - `error`: For error handling
+   *
+   * @throws Error when the API request fails or response is invalid
+   */
+  sendMessages: (
+    options: {
+      /** The type of message submission - either new message or regeneration */
+      trigger: 'submit-message' | 'regenerate-message';
+      /** Unique identifier for the chat session */
+      chatId: string;
+      /** ID of the message to regenerate, or undefined for new messages */
+      messageId: string | undefined;
+      /** Array of UI messages representing the conversation history */
+      messages: UI_MESSAGE[];
+      /** Signal to abort the request if needed */
+      abortSignal: AbortSignal | undefined;
+    } & ChatRequestOptions,
+  ) => Promise<ReadableStream<UIMessageChunk>>;
+
+  /**
+   * Reconnects to an existing streaming response for the specified chat session.
+   *
+   * This method is used to resume streaming when a connection is interrupted
+   * or when resuming a chat session. It's particularly useful for maintaining
+   * continuity in long-running conversations or recovering from network issues.
+   *
+   * @param options - Configuration object containing:
+   * @param options.chatId - Unique identifier for the chat session to reconnect to
+   * @param options.headers - Additional HTTP headers to include in the reconnection request
+   * @param options.body - Additional JSON properties to include in the request body
+   * @param options.metadata - Custom metadata to attach to the request
+   *
+   * @returns Promise resolving to:
+   *   - `ReadableStream<UIMessageChunk>`: If an active stream is found and can be resumed
+   *   - `null`: If no active stream exists for the specified chat session (e.g., response already completed)
+   *
+   * @throws Error when the reconnection request fails or response is invalid
+   */
+  reconnectToStream: (
+    options: {
+      /** Unique identifier for the chat session to reconnect to */
+      chatId: string;
+    } & ChatRequestOptions,
+  ) => Promise<ReadableStream<UIMessageChunk> | null>;
+}