@ai-sdk/deepseek 3.0.0-beta.8 → 3.0.0-canary.34

package/src/chat/deepseek-chat-language-model.ts

@@ -1,6 +1,5 @@
-import {
+import type {
   APICallError,
-  InvalidResponseDataError,
   LanguageModelV4,
   LanguageModelV4CallOptions,
   LanguageModelV4Content,
@@ -14,35 +13,38 @@ import {
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
-  FetchFunction,
   generateId,
-  InferSchema,
   isCustomReasoning,
-  isParsableJson,
   parseProviderOptions,
-  ParseResult,
   postJsonToApi,
-  ResponseHandler,
+  serializeModelOptions,
+  StreamingToolCallTracker,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type FetchFunction,
+  type InferSchema,
+  type ParseResult,
+  type ResponseHandler,
 } from '@ai-sdk/provider-utils';
 import { convertToDeepSeekChatMessages } from './convert-to-deepseek-chat-messages';
 import { convertDeepSeekUsage } from './convert-to-deepseek-usage';
 import {
   deepseekChatChunkSchema,
   deepseekChatResponseSchema,
-  DeepSeekChatTokenUsage,
   deepSeekErrorSchema,
+  type DeepSeekChatTokenUsage,
 } from './deepseek-chat-api-types';
 import {
-  DeepSeekChatModelId,
-  deepseekLanguageModelOptions,
-} from './deepseek-chat-options';
+  deepseekLanguageModelChatOptions,
+  type DeepSeekChatModelId,
+} from './deepseek-chat-language-model-options';
 import { prepareTools } from './deepseek-prepare-tools';
 import { getResponseMetadata } from './get-response-metadata';
 import { mapDeepSeekFinishReason } from './map-deepseek-finish-reason';
 
 export type DeepSeekChatConfig = {
   provider: string;
-  headers: () => Record<string, string | undefined>;
+  headers?: () => Record<string, string | undefined>;
   url: (options: { modelId: string; path: string }) => string;
   fetch?: FetchFunction;
 };
@@ -56,6 +58,20 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
   private readonly config: DeepSeekChatConfig;
   private readonly failedResponseHandler: ResponseHandler<APICallError>;
 
+  static [WORKFLOW_SERIALIZE](model: DeepSeekChatLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: DeepSeekChatModelId;
+    config: DeepSeekChatConfig;
+  }) {
+    return new DeepSeekChatLanguageModel(options.modelId, options.config);
+  }
+
   constructor(modelId: DeepSeekChatModelId, config: DeepSeekChatConfig) {
     this.modelId = modelId;
     this.config = config;
@@ -95,12 +111,13 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
       (await parseProviderOptions({
         provider: this.providerOptionsName,
         providerOptions,
-        schema: deepseekLanguageModelOptions,
+        schema: deepseekLanguageModelChatOptions,
       })) ?? {};
 
     const { messages, warnings } = convertToDeepSeekChatMessages({
       prompt,
       responseFormat,
+      modelId: this.modelId,
     });
 
     if (topK != null) {
@@ -159,7 +176,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
         path: '/chat/completions',
         modelId: this.modelId,
       }),
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body: args,
       failedResponseHandler: this.failedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
@@ -238,7 +255,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
         path: '/chat/completions',
         modelId: this.modelId,
       }),
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body,
       failedResponseHandler: this.failedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
@@ -248,15 +265,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
       fetch: this.config.fetch,
     });
 
-    const toolCalls: Array<{
-      id: string;
-      type: 'function';
-      function: {
-        name: string;
-        arguments: string;
-      };
-      hasFinished: boolean;
-    }> = [];
+    let toolCallTracker: StreamingToolCallTracker;
 
     let finishReason: LanguageModelV4FinishReason = {
       unified: 'other',
@@ -275,6 +284,9 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
           LanguageModelV4StreamPart
         >({
           start(controller) {
+            toolCallTracker = new StreamingToolCallTracker(controller, {
+              generateId,
+            });
             controller.enqueue({ type: 'stream-start', warnings });
           },
 
@@ -378,113 +390,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
               }
 
               for (const toolCallDelta of delta.tool_calls) {
-                const index = toolCallDelta.index;
-
-                if (toolCalls[index] == null) {
-                  if (toolCallDelta.id == null) {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'id' to be a string.`,
-                    });
-                  }
-
-                  if (toolCallDelta.function?.name == null) {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'function.name' to be a string.`,
-                    });
-                  }
-
-                  controller.enqueue({
-                    type: 'tool-input-start',
-                    id: toolCallDelta.id,
-                    toolName: toolCallDelta.function.name,
-                  });
-
-                  toolCalls[index] = {
-                    id: toolCallDelta.id,
-                    type: 'function',
-                    function: {
-                      name: toolCallDelta.function.name,
-                      arguments: toolCallDelta.function.arguments ?? '',
-                    },
-                    hasFinished: false,
-                  };
-
-                  const toolCall = toolCalls[index];
-
-                  if (
-                    toolCall.function?.name != null &&
-                    toolCall.function?.arguments != null
-                  ) {
-                    // send delta if the argument text has already started:
-                    if (toolCall.function.arguments.length > 0) {
-                      controller.enqueue({
-                        type: 'tool-input-delta',
-                        id: toolCall.id,
-                        delta: toolCall.function.arguments,
-                      });
-                    }
-
-                    // check if tool call is complete
-                    // (some providers send the full tool call in one chunk):
-                    if (isParsableJson(toolCall.function.arguments)) {
-                      controller.enqueue({
-                        type: 'tool-input-end',
-                        id: toolCall.id,
-                      });
-
-                      controller.enqueue({
-                        type: 'tool-call',
-                        toolCallId: toolCall.id ?? generateId(),
-                        toolName: toolCall.function.name,
-                        input: toolCall.function.arguments,
-                      });
-                      toolCall.hasFinished = true;
-                    }
-                  }
-
-                  continue;
-                }
-
-                // existing tool call, merge if not finished
-                const toolCall = toolCalls[index];
-
-                if (toolCall.hasFinished) {
-                  continue;
-                }
-
-                if (toolCallDelta.function?.arguments != null) {
-                  toolCall.function!.arguments +=
-                    toolCallDelta.function?.arguments ?? '';
-                }
-
-                // send delta
-                controller.enqueue({
-                  type: 'tool-input-delta',
-                  id: toolCall.id,
-                  delta: toolCallDelta.function.arguments ?? '',
-                });
-
-                // check if tool call is complete
-                if (
-                  toolCall.function?.name != null &&
-                  toolCall.function?.arguments != null &&
-                  isParsableJson(toolCall.function.arguments)
-                ) {
-                  controller.enqueue({
-                    type: 'tool-input-end',
-                    id: toolCall.id,
-                  });
-
-                  controller.enqueue({
-                    type: 'tool-call',
-                    toolCallId: toolCall.id ?? generateId(),
-                    toolName: toolCall.function.name,
-                    input: toolCall.function.arguments,
-                  });
-                  toolCall.hasFinished = true;
-                }
+                toolCallTracker.processDelta(toolCallDelta);
               }
             }
           },
@@ -498,22 +404,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
               controller.enqueue({ type: 'text-end', id: 'txt-0' });
             }
 
-            // go through all tool calls and send the ones that are not finished
-            for (const toolCall of toolCalls.filter(
-              toolCall => !toolCall.hasFinished,
-            )) {
-              controller.enqueue({
-                type: 'tool-input-end',
-                id: toolCall.id,
-              });
-
-              controller.enqueue({
-                type: 'tool-call',
-                toolCallId: toolCall.id ?? generateId(),
-                toolName: toolCall.function.name,
-                input: toolCall.function.arguments,
-              });
-            }
+            toolCallTracker.flush();
 
             controller.enqueue({
               type: 'finish',

package/src/chat/deepseek-prepare-tools.ts

@@ -1,5 +1,8 @@
-import { LanguageModelV4CallOptions, SharedV4Warning } from '@ai-sdk/provider';
-import {
+import type {
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
+} from '@ai-sdk/provider';
+import type {
   DeepSeekFunctionTool,
   DeepSeekToolChoice,
 } from './deepseek-chat-api-types';

package/src/chat/map-deepseek-finish-reason.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV4FinishReason } from '@ai-sdk/provider';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 export function mapDeepSeekFinishReason(
   finishReason: string | null | undefined,

package/src/deepseek-provider.ts

@@ -1,15 +1,15 @@
 import {
-  LanguageModelV4,
   NoSuchModelError,
-  ProviderV4,
+  type LanguageModelV4,
+  type ProviderV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
   loadApiKey,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
-import { DeepSeekChatModelId } from './chat/deepseek-chat-options';
+import type { DeepSeekChatModelId } from './chat/deepseek-chat-language-model-options';
 import { DeepSeekChatLanguageModel } from './chat/deepseek-chat-language-model';
 import { VERSION } from './version';
 
@@ -105,4 +105,4 @@ export function createDeepSeek(
   return provider;
 }
 
-export const deepseek = createDeepSeek();
+export const deepSeek = createDeepSeek();

package/src/index.ts

@@ -1,12 +1,19 @@
-export { createDeepSeek, deepseek } from './deepseek-provider';
+export {
+  createDeepSeek,
+  deepSeek,
+  /** @deprecated Use `deepSeek` instead. */
+  deepSeek as deepseek,
+} from './deepseek-provider';
 export type {
   DeepSeekProvider,
   DeepSeekProviderSettings,
 } from './deepseek-provider';
 export { VERSION } from './version';
 export type {
-  DeepSeekLanguageModelOptions,
-  /** @deprecated Use `DeepSeekLanguageModelOptions` instead. */
-  DeepSeekLanguageModelOptions as DeepSeekChatOptions,
-} from './chat/deepseek-chat-options';
+  DeepSeekLanguageModelChatOptions,
+  /** @deprecated Use `DeepSeekLanguageModelChatOptions` instead. */
+  DeepSeekLanguageModelChatOptions as DeepSeekLanguageModelOptions,
+  /** @deprecated Use `DeepSeekLanguageModelChatOptions` instead. */
+  DeepSeekLanguageModelChatOptions as DeepSeekChatOptions,
+} from './chat/deepseek-chat-language-model-options';
 export type { DeepSeekErrorData } from './chat/deepseek-chat-api-types';

package/dist/index.d.mts

@@ -1,68 +0,0 @@
-import { ProviderV4, LanguageModelV4 } from '@ai-sdk/provider';
-import { FetchFunction } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
-
-type DeepSeekChatModelId = 'deepseek-chat' | 'deepseek-reasoner' | (string & {});
-declare const deepseekLanguageModelOptions: z.ZodObject<{
-    thinking: z.ZodOptional<z.ZodObject<{
-        type: z.ZodOptional<z.ZodEnum<{
-            enabled: "enabled";
-            disabled: "disabled";
-        }>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type DeepSeekLanguageModelOptions = z.infer<typeof deepseekLanguageModelOptions>;
-
-interface DeepSeekProviderSettings {
-    /**
-     * DeepSeek API key.
-     */
-    apiKey?: string;
-    /**
-     * Base URL for the API calls.
-     */
-    baseURL?: string;
-    /**
-     * Custom headers to include in the requests.
-     */
-    headers?: Record<string, string>;
-    /**
-     * Custom fetch implementation. You can use it as a middleware to intercept requests,
-     * or to provide a custom fetch implementation for e.g. testing.
-     */
-    fetch?: FetchFunction;
-}
-interface DeepSeekProvider extends ProviderV4 {
-    /**
-     * Creates a DeepSeek model for text generation.
-     */
-    (modelId: DeepSeekChatModelId): LanguageModelV4;
-    /**
-     * Creates a DeepSeek model for text generation.
-     */
-    languageModel(modelId: DeepSeekChatModelId): LanguageModelV4;
-    /**
-     * Creates a DeepSeek chat model for text generation.
-     */
-    chat(modelId: DeepSeekChatModelId): LanguageModelV4;
-    /**
-     * @deprecated Use `embeddingModel` instead.
-     */
-    textEmbeddingModel(modelId: string): never;
-}
-declare function createDeepSeek(options?: DeepSeekProviderSettings): DeepSeekProvider;
-declare const deepseek: DeepSeekProvider;
-
-declare const VERSION: string;
-
-declare const deepSeekErrorSchema: z.ZodObject<{
-    error: z.ZodObject<{
-        message: z.ZodString;
-        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        param: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
-        code: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-type DeepSeekErrorData = z.infer<typeof deepSeekErrorSchema>;
-
-export { type DeepSeekLanguageModelOptions as DeepSeekChatOptions, type DeepSeekErrorData, type DeepSeekLanguageModelOptions, type DeepSeekProvider, type DeepSeekProviderSettings, VERSION, createDeepSeek, deepseek };