@ai-sdk/deepseek 3.0.0-beta.4 → 3.0.0-beta.55

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

@@ -1,53 +1,59 @@
-import {
+import type {
   APICallError,
-  InvalidResponseDataError,
-  LanguageModelV3,
-  LanguageModelV3CallOptions,
-  LanguageModelV3Content,
-  LanguageModelV3FinishReason,
-  LanguageModelV3GenerateResult,
-  LanguageModelV3StreamPart,
-  LanguageModelV3StreamResult,
+  LanguageModelV4,
+  LanguageModelV4CallOptions,
+  LanguageModelV4Content,
+  LanguageModelV4FinishReason,
+  LanguageModelV4GenerateResult,
+  LanguageModelV4StreamPart,
+  LanguageModelV4StreamResult,
+  SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
-  FetchFunction,
   generateId,
-  InferSchema,
-  isParsableJson,
+  isCustomReasoning,
+  mapReasoningToProviderEffort,
   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;
+  supportsThinking?: boolean;
 };
 
-export class DeepSeekChatLanguageModel implements LanguageModelV3 {
-  readonly specificationVersion = 'v3';
+export class DeepSeekChatLanguageModel implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
 
   readonly modelId: DeepSeekChatModelId;
   readonly supportedUrls = {};
@@ -55,6 +61,20 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
   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;
@@ -82,31 +102,34 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
     topK,
     frequencyPenalty,
     presencePenalty,
+    reasoning,
     providerOptions,
     stopSequences,
     responseFormat,
     seed,
     toolChoice,
     tools,
-  }: LanguageModelV3CallOptions) {
+  }: LanguageModelV4CallOptions) {
     const deepseekOptions =
       (await parseProviderOptions({
         provider: this.providerOptionsName,
         providerOptions,
-        schema: deepseekLanguageModelOptions,
+        schema: deepseekLanguageModelChatOptions,
       })) ?? {};
 
     const { messages, warnings } = convertToDeepSeekChatMessages({
       prompt,
       responseFormat,
+      modelId: this.modelId,
     });
+    const allWarnings: SharedV4Warning[] = [...warnings];
 
     if (topK != null) {
-      warnings.push({ type: 'unsupported', feature: 'topK' });
+      allWarnings.push({ type: 'unsupported', feature: 'topK' });
     }
 
     if (seed != null) {
-      warnings.push({ type: 'unsupported', feature: 'seed' });
+      allWarnings.push({ type: 'unsupported', feature: 'seed' });
     }
 
     const {
@@ -118,6 +141,31 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
       toolChoice,
     });
 
+    const thinking =
+      this.config.supportsThinking === false
+        ? undefined
+        : deepseekOptions.thinking?.type != null
+          ? { type: deepseekOptions.thinking.type }
+          : isCustomReasoning(reasoning)
+            ? { type: reasoning === 'none' ? 'disabled' : 'enabled' }
+            : undefined;
+
+    const reasoningEffort =
+      deepseekOptions.reasoningEffort ??
+      (isCustomReasoning(reasoning) && reasoning !== 'none'
+        ? mapReasoningToProviderEffort({
+            reasoning,
+            effortMap: {
+              minimal: 'low',
+              low: 'low',
+              medium: 'medium',
+              high: 'high',
+              xhigh: 'max',
+            },
+            warnings: allWarnings,
+          })
+        : undefined);
+
     return {
       args: {
         model: this.modelId,
@@ -132,18 +180,19 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
         messages,
         tools: deepseekTools,
         tool_choice: deepseekToolChoices,
-        thinking:
-          deepseekOptions.thinking?.type != null
-            ? { type: deepseekOptions.thinking.type }
-            : undefined,
+        thinking,
+        ...(thinking?.type !== 'disabled' &&
+          reasoningEffort != null && {
+            reasoning_effort: reasoningEffort,
+          }),
       },
-      warnings: [...warnings, ...toolWarnings],
+      warnings: [...allWarnings, ...toolWarnings],
     };
   }
 
   async doGenerate(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3GenerateResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4GenerateResult> {
     const { args, warnings } = await this.getArgs({ ...options });
 
     const {
@@ -155,7 +204,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
         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(
@@ -166,7 +215,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
     });
 
     const choice = responseBody.choices[0];
-    const content: Array<LanguageModelV3Content> = [];
+    const content: Array<LanguageModelV4Content> = [];
 
     // reasoning content (before text):
     const reasoning = choice.message.reasoning_content;
@@ -219,8 +268,8 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
   }
 
   async doStream(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3StreamResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4StreamResult> {
     const { args, warnings } = await this.getArgs({ ...options });
 
     const body = {
@@ -234,7 +283,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
         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(
@@ -244,17 +293,9 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
-    const toolCalls: Array<{
-      id: string;
-      type: 'function';
-      function: {
-        name: string;
-        arguments: string;
-      };
-      hasFinished: boolean;
-    }> = [];
-
-    let finishReason: LanguageModelV3FinishReason = {
+    let toolCallTracker: StreamingToolCallTracker;
+
+    let finishReason: LanguageModelV4FinishReason = {
       unified: 'other',
       raw: undefined,
     };
@@ -268,9 +309,12 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
       stream: response.pipeThrough(
         new TransformStream<
           ParseResult<InferSchema<typeof deepseekChatChunkSchema>>,
-          LanguageModelV3StreamPart
+          LanguageModelV4StreamPart
         >({
           start(controller) {
+            toolCallTracker = new StreamingToolCallTracker(controller, {
+              generateId,
+            });
             controller.enqueue({ type: 'stream-start', warnings });
           },
 
@@ -374,113 +418,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
               }
 
               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);
               }
             }
           },
@@ -494,22 +432,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
               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 { LanguageModelV3CallOptions, SharedV3Warning } from '@ai-sdk/provider';
-import {
+import type {
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
+} from '@ai-sdk/provider';
+import type {
   DeepSeekFunctionTool,
   DeepSeekToolChoice,
 } from './deepseek-chat-api-types';
@@ -8,17 +11,17 @@ export function prepareTools({
   tools,
   toolChoice,
 }: {
-  tools: LanguageModelV3CallOptions['tools'];
-  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+  tools: LanguageModelV4CallOptions['tools'];
+  toolChoice?: LanguageModelV4CallOptions['toolChoice'];
 }): {
   tools: undefined | Array<DeepSeekFunctionTool>;
   toolChoice: DeepSeekToolChoice;
-  toolWarnings: SharedV3Warning[];
+  toolWarnings: SharedV4Warning[];
 } {
   // when the tools array is empty, change it to undefined to prevent errors:
   tools = tools?.length ? tools : undefined;
 
-  const toolWarnings: SharedV3Warning[] = [];
+  const toolWarnings: SharedV4Warning[] = [];
 
   if (tools == null) {
     return { tools: undefined, toolChoice: undefined, toolWarnings };

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

@@ -1,8 +1,8 @@
-import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 export function mapDeepSeekFinishReason(
   finishReason: string | null | undefined,
-): LanguageModelV3FinishReason['unified'] {
+): LanguageModelV4FinishReason['unified'] {
   switch (finishReason) {
     case 'stop':
       return 'stop';

package/src/deepseek-provider.ts

@@ -1,15 +1,15 @@
 import {
-  LanguageModelV3,
   NoSuchModelError,
-  ProviderV3,
+  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';
 
@@ -36,21 +36,21 @@ export interface DeepSeekProviderSettings {
   fetch?: FetchFunction;
 }
 
-export interface DeepSeekProvider extends ProviderV3 {
+export interface DeepSeekProvider extends ProviderV4 {
   /**
    * Creates a DeepSeek model for text generation.
    */
-  (modelId: DeepSeekChatModelId): LanguageModelV3;
+  (modelId: DeepSeekChatModelId): LanguageModelV4;
 
   /**
    * Creates a DeepSeek model for text generation.
    */
-  languageModel(modelId: DeepSeekChatModelId): LanguageModelV3;
+  languageModel(modelId: DeepSeekChatModelId): LanguageModelV4;
 
   /**
    * Creates a DeepSeek chat model for text generation.
    */
-  chat(modelId: DeepSeekChatModelId): LanguageModelV3;
+  chat(modelId: DeepSeekChatModelId): LanguageModelV4;
 
   /**
    * @deprecated Use `embeddingModel` instead.
@@ -90,7 +90,7 @@ export function createDeepSeek(
   const provider = (modelId: DeepSeekChatModelId) =>
     createLanguageModel(modelId);
 
-  provider.specificationVersion = 'v3' as const;
+  provider.specificationVersion = 'v4' as const;
   provider.languageModel = createLanguageModel;
   provider.chat = createLanguageModel;
 
@@ -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/src/internal/index.ts

@@ -0,0 +1,2 @@
+export * from '../chat/deepseek-chat-language-model';
+export * from '../chat/deepseek-chat-language-model-options';

package/dist/index.d.mts

@@ -1,68 +0,0 @@
-import { ProviderV3, LanguageModelV3 } 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 ProviderV3 {
-    /**
-     * Creates a DeepSeek model for text generation.
-     */
-    (modelId: DeepSeekChatModelId): LanguageModelV3;
-    /**
-     * Creates a DeepSeek model for text generation.
-     */
-    languageModel(modelId: DeepSeekChatModelId): LanguageModelV3;
-    /**
-     * Creates a DeepSeek chat model for text generation.
-     */
-    chat(modelId: DeepSeekChatModelId): LanguageModelV3;
-    /**
-     * @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 };