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

package/docs/30-deepseek.mdx

@@ -30,10 +30,10 @@ The DeepSeek provider is available via the `@ai-sdk/deepseek` module. You can in
 
 ## Provider Instance
 
-You can import the default provider instance `deepseek` from `@ai-sdk/deepseek`:
+You can import the default provider instance `deepSeek` from `@ai-sdk/deepseek`:
 
 ```ts
-import { deepseek } from '@ai-sdk/deepseek';
+import { deepSeek } from '@ai-sdk/deepseek';
 ```
 
 For custom configuration, you can import `createDeepSeek` and create a provider instance with your settings:
@@ -41,7 +41,7 @@ For custom configuration, you can import `createDeepSeek` and create a provider
 ```ts
 import { createDeepSeek } from '@ai-sdk/deepseek';
 
-const deepseek = createDeepSeek({
+const deepSeek = createDeepSeek({
   apiKey: process.env.DEEPSEEK_API_KEY ?? '',
 });
 ```
@@ -71,11 +71,11 @@ You can use the following optional settings to customize the DeepSeek provider i
 You can create language models using a provider instance:
 
 ```ts
-import { deepseek } from '@ai-sdk/deepseek';
+import { deepSeek } from '@ai-sdk/deepseek';
 import { generateText } from 'ai';
 
 const { text } = await generateText({
-  model: deepseek('deepseek-chat'),
+  model: deepSeek('deepseek-chat'),
   prompt: 'Write a vegetarian lasagna recipe for 4 people.',
 });
 ```
@@ -83,9 +83,9 @@ const { text } = await generateText({
 You can also use the `.chat()` or `.languageModel()` factory methods:
 
 ```ts
-const model = deepseek.chat('deepseek-chat');
+const model = deepSeek.chat('deepseek-chat');
 // or
-const model = deepseek.languageModel('deepseek-chat');
+const model = deepSeek.languageModel('deepseek-chat');
 ```
 
 DeepSeek language models can be used in the `streamText` function
@@ -96,20 +96,32 @@ The following optional provider options are available for DeepSeek models:
 - `thinking` _object_
 
   Optional. Controls thinking mode (chain-of-thought reasoning). You can enable thinking mode either by using the `deepseek-reasoner` model or by setting this option.
-
-  - `type`: `'enabled' | 'disabled'` - Enable or disable thinking mode.
-
-```ts highlight="7-11"
-import { deepseek, type DeepSeekLanguageModelOptions } from '@ai-sdk/deepseek';
+  - `type`: `'adaptive' | 'enabled' | 'disabled'` - Enable, disable, or let the model decide (`adaptive`) when to think. See [DeepSeek's thinking mode docs](https://api-docs.deepseek.com/guides/thinking_mode).
+
+- `reasoningEffort` _'low' | 'medium' | 'high' | 'xhigh' | 'max'_
+
+  Optional. Controls thinking strength for DeepSeek V4 reasoning models. Per
+  DeepSeek's docs, `low` and `medium` are mapped to `high`, and `xhigh` is
+  mapped to `max` server-side for compatibility with other providers. When
+  using the top-level `reasoning` setting, `minimal` is sent as `low`, and
+  `low`, `medium`, `high`, and `xhigh` pass through to DeepSeek's native
+  effort values.
+
+```ts highlight="7-12"
+import {
+  deepSeek,
+  type DeepSeekLanguageModelChatOptions,
+} from '@ai-sdk/deepseek';
 import { generateText } from 'ai';
 
 const { text, reasoning } = await generateText({
-  model: deepseek('deepseek-chat'),
+  model: deepSeek('deepseek-chat'),
   prompt: 'How many "r"s are in the word "strawberry"?',
   providerOptions: {
     deepseek: {
       thinking: { type: 'enabled' },
-    } satisfies DeepSeekLanguageModelOptions,
+      reasoningEffort: 'high',
+    } satisfies DeepSeekLanguageModelChatOptions,
   },
 });
 ```
@@ -119,15 +131,15 @@ const { text, reasoning } = await generateText({
 DeepSeek has reasoning support for the `deepseek-reasoner` model. The reasoning is exposed through streaming:
 
 ```ts
-import { deepseek } from '@ai-sdk/deepseek';
+import { deepSeek } from '@ai-sdk/deepseek';
 import { streamText } from 'ai';
 
 const result = streamText({
-  model: deepseek('deepseek-reasoner'),
+  model: deepSeek('deepseek-reasoner'),
   prompt: 'How many "r"s are in the word "strawberry"?',
 });
 
-for await (const part of result.fullStream) {
+for await (const part of result.stream) {
   if (part.type === 'reasoning') {
     // This is the reasoning text
     console.log('Reasoning:', part.text);
@@ -146,11 +158,11 @@ on how to integrate reasoning into your chatbot.
 DeepSeek provides context caching on disk technology that can significantly reduce token costs for repeated content. You can access the cache hit/miss metrics through the `providerMetadata` property in the response:
 
 ```ts
-import { deepseek } from '@ai-sdk/deepseek';
+import { deepSeek } from '@ai-sdk/deepseek';
 import { generateText } from 'ai';
 
 const result = await generateText({
-  model: deepseek('deepseek-chat'),
+  model: deepSeek('deepseek-chat'),
   prompt: 'Your prompt here',
 });
 

package/internal.d.ts

@@ -0,0 +1 @@
+export * from './dist/internal';

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ai-sdk/deepseek",
-  "version": "3.0.0-beta.5",
+  "version": "3.0.0-beta.55",
+  "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
@@ -15,7 +15,8 @@
     "!src/**/__snapshots__",
     "!src/**/__fixtures__",
     "CHANGELOG.md",
-    "README.md"
+    "README.md",
+    "internal.d.ts"
   ],
   "directories": {
     "doc": "./docs"
@@ -24,35 +25,42 @@
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal/index.d.ts",
+      "import": "./dist/internal/index.js",
+      "default": "./dist/internal/index.js"
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.0-beta.2",
-    "@ai-sdk/provider-utils": "5.0.0-beta.4"
+    "@ai-sdk/provider": "4.0.0-beta.19",
+    "@ai-sdk/provider-utils": "5.0.0-beta.49"
   },
   "devDependencies": {
-    "@types/node": "20.17.24",
-    "tsup": "^8",
+    "@types/node": "22.19.19",
+    "tsup": "^8.5.1",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "2.0.0-beta.0",
+    "@ai-sdk/test-server": "2.0.0-beta.7",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "homepage": "https://ai-sdk.dev/docs",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vercel/ai.git"
+    "url": "https://github.com/vercel/ai",
+    "directory": "packages/deepseek"
   },
   "bugs": {
     "url": "https://github.com/vercel/ai/issues"
@@ -64,9 +72,7 @@
     "build": "pnpm clean && tsup --tsconfig tsconfig.build.json",
     "build:watch": "pnpm clean && tsup --watch",
     "clean": "del-cli dist docs *.tsbuildinfo",
-    "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --build",
-    "prettier-check": "prettier --check \"./**/*.ts*\"",
     "test": "pnpm test:node && pnpm test:edge",
     "test:update": "pnpm test:node -u",
     "test:watch": "vitest --config vitest.node.config.js",

package/src/chat/convert-to-deepseek-chat-messages.ts

@@ -1,20 +1,23 @@
-import {
+import type {
   LanguageModelV4CallOptions,
   LanguageModelV4Prompt,
   SharedV4Warning,
 } from '@ai-sdk/provider';
-import { DeepSeekChatPrompt } from './deepseek-chat-api-types';
+import type { DeepSeekChatPrompt } from './deepseek-chat-api-types';
 
 export function convertToDeepSeekChatMessages({
   prompt,
   responseFormat,
+  modelId,
 }: {
   prompt: LanguageModelV4Prompt;
   responseFormat: LanguageModelV4CallOptions['responseFormat'];
+  modelId: string;
 }): {
   messages: DeepSeekChatPrompt;
   warnings: Array<SharedV4Warning>;
 } {
+  const isDeepSeekV4 = modelId.includes('deepseek-v4');
   const messages: DeepSeekChatPrompt = [];
   const warnings: Array<SharedV4Warning> = [];
 
@@ -96,7 +99,8 @@ export function convertToDeepSeekChatMessages({
               break;
             }
             case 'reasoning': {
-              if (index <= lastUserMessageIndex) {
+              // R1 must not receive prior reasoning; V4 requires it.
+              if (index <= lastUserMessageIndex && !isDeepSeekV4) {
                 break;
               }
 
@@ -121,10 +125,12 @@ export function convertToDeepSeekChatMessages({
           }
         }
 
+        // V4 demands the field on every assistant turn — back-fill an empty
+        // string when the source message had no reasoning part at all.
         messages.push({
           role: 'assistant',
           content: text,
-          reasoning_content: reasoning,
+          reasoning_content: reasoning ?? (isDeepSeekV4 ? '' : undefined),
           tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
         });
 
@@ -145,7 +151,7 @@ export function convertToDeepSeekChatMessages({
               contentValue = output.value;
               break;
             case 'execution-denied':
-              contentValue = output.reason ?? 'Tool execution denied.';
+              contentValue = output.reason ?? 'Tool call execution denied.';
               break;
             case 'content':
             case 'json':

package/src/chat/convert-to-deepseek-usage.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV4Usage } from '@ai-sdk/provider';
+import type { LanguageModelV4Usage } from '@ai-sdk/provider';
 
 export function convertDeepSeekUsage(
   usage:

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

@@ -0,0 +1,34 @@
+import { z } from 'zod/v4';
+
+// https://api-docs.deepseek.com/quick_start/pricing
+export type DeepSeekChatModelId =
+  | 'deepseek-chat'
+  | 'deepseek-reasoner'
+  | (string & {});
+
+export const deepseekLanguageModelChatOptions = z.object({
+  /**
+   * Type of thinking to use. Defaults to `enabled`.
+   *
+   * See https://api-docs.deepseek.com/guides/thinking_mode for the
+   * `adaptive` option, which lets the model decide when to think.
+   */
+  thinking: z
+    .object({
+      type: z.enum(['adaptive', 'enabled', 'disabled']).optional(),
+    })
+    .optional(),
+
+  /**
+   * Controls the thinking strength for DeepSeek V4 reasoning models.
+   *
+   * DeepSeek's API accepts `low`, `medium`, `high`, `xhigh`, and `max`.
+   * Per their docs, `low` and `medium` are mapped to `high`, and `xhigh`
+   * is mapped to `max` server-side for compatibility with other providers.
+   */
+  reasoningEffort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
+});
+
+export type DeepSeekLanguageModelChatOptions = z.infer<
+  typeof deepseekLanguageModelChatOptions
+>;

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

@@ -1,6 +1,5 @@
-import {
+import type {
   APICallError,
-  InvalidResponseDataError,
   LanguageModelV4,
   LanguageModelV4CallOptions,
   LanguageModelV4Content,
@@ -8,42 +7,49 @@ import {
   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 LanguageModelV4 {
@@ -55,6 +61,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;
@@ -82,6 +102,7 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
     topK,
     frequencyPenalty,
     presencePenalty,
+    reasoning,
     providerOptions,
     stopSequences,
     responseFormat,
@@ -93,20 +114,22 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
       (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 LanguageModelV4 {
       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,12 +180,13 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
         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],
     };
   }
 
@@ -155,7 +204,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(
@@ -234,7 +283,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(
@@ -244,15 +293,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',
@@ -271,6 +312,9 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
           LanguageModelV4StreamPart
         >({
           start(controller) {
+            toolCallTracker = new StreamingToolCallTracker(controller, {
+              generateId,
+            });
             controller.enqueue({ type: 'stream-start', warnings });
           },
 
@@ -374,113 +418,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);
               }
             }
           },
@@ -494,22 +432,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,