@ai-sdk/deepseek 3.0.31 → 3.0.34

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

@@ -14,6 +14,7 @@ import {
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
+  createProviderStreamError,
   generateId,
   isCustomReasoning,
   mapReasoningToProviderEffort,
@@ -34,6 +35,7 @@ import {
   deepseekChatChunkSchema,
   deepseekChatResponseSchema,
   deepSeekErrorSchema,
+  type DeepSeekChatLogprob,
   type DeepSeekChatTokenUsage,
 } from './deepseek-chat-api-types';
 import {
@@ -49,10 +51,133 @@ export type DeepSeekChatConfig = {
   headers?: () => Record<string, string | undefined>;
   url: (options: { modelId: string; path: string }) => string;
   fetch?: FetchFunction;
+  supportsAssistantPrefixCompletion?: boolean;
+  supportsStrictToolCalls?: boolean;
+  supportsPenaltySampling?: boolean;
   supportsThinking?: boolean;
   supportsStructuredOutputs?: boolean;
 };
 
+function createDeepSeekStreamError(
+  error: {
+    message: string;
+    type?: string | null;
+    code?: string | number | null;
+  },
+  data: unknown,
+) {
+  const metadata = getDeepSeekStreamErrorMetadata(error);
+
+  return createProviderStreamError({
+    message: error.message,
+    type: error.type ?? undefined,
+    code: error.code ?? undefined,
+    ...metadata,
+    data,
+  });
+}
+
+function getDeepSeekStreamErrorMetadata(error: {
+  type?: string | null;
+  code?: string | number | null;
+}): {
+  statusCode?: number;
+  isRetryable?: boolean;
+} {
+  if (
+    error.code === 'insufficient_quota' ||
+    error.type === 'insufficient_quota'
+  ) {
+    return { statusCode: 429, isRetryable: false };
+  }
+
+  const explicitStatusCode = getHttpStatusCode(error.code);
+  if (explicitStatusCode != null) {
+    return {
+      statusCode: explicitStatusCode,
+      isRetryable: isRetryableStatusCode(explicitStatusCode),
+    };
+  }
+
+  for (const discriminator of [error.code, error.type]) {
+    switch (discriminator) {
+      case 'rate_limit_exceeded':
+      case 'rate_limit_error':
+        return { statusCode: 429, isRetryable: true };
+      case 'server_error':
+      case 'api_error':
+      case 'internal_server_error':
+        return { statusCode: 500, isRetryable: true };
+      case 'overloaded_error':
+      case 'service_unavailable':
+        return { statusCode: 503, isRetryable: true };
+      case 'timeout':
+      case 'timeout_error':
+        return { statusCode: 504, isRetryable: true };
+      case 'authentication_error':
+      case 'invalid_api_key':
+        return { statusCode: 401, isRetryable: false };
+      case 'permission_error':
+        return { statusCode: 403, isRetryable: false };
+      case 'not_found_error':
+      case 'model_not_found':
+        return { statusCode: 404, isRetryable: false };
+      case 'bad_request':
+      case 'context_length_exceeded':
+      case 'invalid_request_error':
+        return { statusCode: 400, isRetryable: false };
+    }
+  }
+
+  return {};
+}
+
+function getHttpStatusCode(value: unknown): number | undefined {
+  const statusCode =
+    typeof value === 'string' && /^\d{3}$/.test(value) ? Number(value) : value;
+
+  return typeof statusCode === 'number' &&
+    Number.isInteger(statusCode) &&
+    statusCode >= 400 &&
+    statusCode <= 599
+    ? statusCode
+    : undefined;
+}
+
+function isRetryableStatusCode(statusCode: number): boolean {
+  return (
+    statusCode === 408 ||
+    statusCode === 409 ||
+    statusCode === 429 ||
+    statusCode >= 500
+  );
+}
+
+function mapDeepSeekProviderReasoningEffort({
+  reasoningEffort,
+  warnings,
+}: {
+  reasoningEffort: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+  warnings: SharedV4Warning[];
+}): 'low' | 'high' | 'max' {
+  const mapped =
+    reasoningEffort === 'medium'
+      ? 'high'
+      : reasoningEffort === 'xhigh'
+        ? 'max'
+        : reasoningEffort;
+
+  if (mapped !== reasoningEffort) {
+    warnings.push({
+      type: 'compatibility',
+      feature: 'reasoningEffort',
+      details: `reasoningEffort "${reasoningEffort}" is not a canonical DeepSeek value. mapped to "${mapped}".`,
+    });
+  }
+
+  return mapped;
+}
+
 export class DeepSeekChatLanguageModel implements LanguageModelV4 {
   readonly specificationVersion = 'v4';
 
@@ -123,11 +248,16 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
 
     const supportsStructuredOutputs =
       this.config.supportsStructuredOutputs === true;
+    const supportsPenaltySampling =
+      this.config.supportsPenaltySampling === true;
 
-    const { messages, warnings } = convertToDeepSeekChatMessages({
+    const { messages, warnings } = await convertToDeepSeekChatMessages({
       prompt,
       responseFormat,
       modelId: this.modelId,
+      providerOptionsName: this.providerOptionsName,
+      supportsAssistantPrefixCompletion:
+        this.config.supportsAssistantPrefixCompletion,
       supportsStructuredOutputs,
     });
     const allWarnings: SharedV4Warning[] = [...warnings];
@@ -140,6 +270,24 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
       allWarnings.push({ type: 'unsupported', feature: 'seed' });
     }
 
+    if (!supportsPenaltySampling && frequencyPenalty != null) {
+      allWarnings.push({
+        type: 'deprecated',
+        setting: 'frequencyPenalty',
+        message:
+          'frequencyPenalty is deprecated by DeepSeek and has been omitted. Remove frequencyPenalty from the request.',
+      });
+    }
+
+    if (!supportsPenaltySampling && presencePenalty != null) {
+      allWarnings.push({
+        type: 'deprecated',
+        setting: 'presencePenalty',
+        message:
+          'presencePenalty is deprecated by DeepSeek and has been omitted. Remove presencePenalty from the request.',
+      });
+    }
+
     const {
       tools: deepseekTools,
       toolChoice: deepseekToolChoices,
@@ -147,41 +295,88 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
     } = prepareTools({
       tools,
       toolChoice,
+      supportsStrictToolCalls: this.config.supportsStrictToolCalls,
     });
 
+    const thinkingType = deepseekOptions.thinking?.type;
+    if (thinkingType === 'adaptive') {
+      allWarnings.push({
+        type: 'compatibility',
+        feature: 'thinking.type',
+        details:
+          'thinking.type "adaptive" is not a canonical DeepSeek value. mapped to "enabled".',
+      });
+    }
+
     const thinking =
       this.config.supportsThinking === false
         ? undefined
-        : deepseekOptions.thinking?.type != null
-          ? { type: deepseekOptions.thinking.type }
+        : thinkingType != null
+          ? { type: thinkingType === 'adaptive' ? 'enabled' : thinkingType }
           : isCustomReasoning(reasoning)
             ? { type: reasoning === 'none' ? 'disabled' : 'enabled' }
             : undefined;
 
+    const isThinkingEnabled =
+      this.config.supportsThinking !== false &&
+      thinking?.type !== 'disabled' &&
+      (thinking != null ||
+        this.modelId === 'deepseek-reasoner' ||
+        this.modelId.includes('deepseek-v4'));
+
+    if (isThinkingEnabled && temperature != null) {
+      allWarnings.push({
+        type: 'unsupported',
+        feature: 'temperature',
+        details:
+          "temperature has no effect when DeepSeek thinking is enabled. Set providerOptions.deepseek.thinking.type to 'disabled' to use temperature.",
+      });
+    }
+
+    if (isThinkingEnabled && topP != null) {
+      allWarnings.push({
+        type: 'unsupported',
+        feature: 'topP',
+        details:
+          "topP has no effect when DeepSeek thinking is enabled. Set providerOptions.deepseek.thinking.type to 'disabled' to use topP.",
+      });
+    }
+
     const reasoningEffort =
-      deepseekOptions.reasoningEffort ??
-      (isCustomReasoning(reasoning) && reasoning !== 'none'
-        ? mapReasoningToProviderEffort({
-            reasoning,
-            effortMap: {
-              minimal: 'low',
-              low: 'low',
-              medium: 'medium',
-              high: 'high',
-              xhigh: 'max',
-            },
+      deepseekOptions.reasoningEffort != null
+        ? mapDeepSeekProviderReasoningEffort({
+            reasoningEffort: deepseekOptions.reasoningEffort,
             warnings: allWarnings,
           })
-        : undefined);
+        : isCustomReasoning(reasoning) && reasoning !== 'none'
+          ? mapReasoningToProviderEffort({
+              reasoning,
+              effortMap: {
+                minimal: 'low',
+                low: 'low',
+                medium: 'high',
+                high: 'high',
+                xhigh: 'max',
+              },
+              warnings: allWarnings,
+            })
+          : undefined;
 
     return {
       args: {
         model: this.modelId,
+        ...((deepseekOptions.logprobs === true ||
+          deepseekOptions.topLogprobs != null) && { logprobs: true }),
+        ...(deepseekOptions.topLogprobs != null && {
+          top_logprobs: deepseekOptions.topLogprobs,
+        }),
         max_tokens: maxOutputTokens,
-        temperature,
-        top_p: topP,
-        frequency_penalty: frequencyPenalty,
-        presence_penalty: presencePenalty,
+        temperature: isThinkingEnabled ? undefined : temperature,
+        top_p: isThinkingEnabled ? undefined : topP,
+        frequency_penalty: supportsPenaltySampling
+          ? frequencyPenalty
+          : undefined,
+        presence_penalty: supportsPenaltySampling ? presencePenalty : undefined,
         response_format:
           responseFormat?.type === 'json'
             ? supportsStructuredOutputs && responseFormat.schema != null
@@ -201,6 +396,9 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
         tools: deepseekTools,
         tool_choice: deepseekToolChoices,
         thinking,
+        ...(deepseekOptions.userId != null && {
+          user_id: deepseekOptions.userId,
+        }),
         ...(thinking?.type !== 'disabled' &&
           reasoningEffort != null && {
             reasoning_effort: reasoningEffort,
@@ -275,6 +473,22 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
         [this.providerOptionsName]: {
           promptCacheHitTokens: responseBody.usage?.prompt_cache_hit_tokens,
           promptCacheMissTokens: responseBody.usage?.prompt_cache_miss_tokens,
+          ...(responseBody.object != null && {
+            responseObject: responseBody.object,
+          }),
+          ...(choice.index != null && { choiceIndex: choice.index }),
+          ...(choice.message.role != null && {
+            messageRole: choice.message.role,
+          }),
+          ...(choice.message.tool_calls != null && {
+            toolCallTypes: choice.message.tool_calls
+              .map(toolCall => toolCall.type)
+              .filter(type => type != null),
+          }),
+          ...(choice.logprobs != null && { logprobs: choice.logprobs }),
+          ...(responseBody.system_fingerprint != null && {
+            systemFingerprint: responseBody.system_fingerprint,
+          }),
         },
       },
       request: { body: args },
@@ -320,10 +534,17 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
       raw: undefined,
     };
     let usage: DeepSeekChatTokenUsage | undefined = undefined;
+    let systemFingerprint: string | undefined = undefined;
     let isFirstChunk = true;
     const providerOptionsName = this.providerOptionsName;
     let isActiveReasoning = false;
     let isActiveText = false;
+    let responseObject: 'chat.completion.chunk' | undefined;
+    let choiceIndex: number | undefined;
+    let messageRole: 'assistant' | undefined;
+    const toolCallTypes = new Map<number, 'function'>();
+    const contentLogprobs: DeepSeekChatLogprob[] = [];
+    const reasoningLogprobs: DeepSeekChatLogprob[] = [];
 
     return {
       stream: response.pipeThrough(
@@ -355,7 +576,10 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
             // handle error chunks:
             if ('error' in value) {
               finishReason = { unified: 'error', raw: undefined };
-              controller.enqueue({ type: 'error', error: value.error.message });
+              controller.enqueue({
+                type: 'error',
+                error: createDeepSeekStreamError(value.error, value),
+              });
               return;
             }
 
@@ -372,8 +596,22 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
               usage = value.usage;
             }
 
+            if (value.object != null) {
+              responseObject = value.object;
+            }
+
+            // The fingerprint is repeated on stream chunks; keep the latest
+            // non-null value in case it changes during the response.
+            if (value.system_fingerprint != null) {
+              systemFingerprint = value.system_fingerprint;
+            }
+
             const choice = value.choices[0];
 
+            if (choice?.index != null) {
+              choiceIndex = choice.index;
+            }
+
             if (choice?.finish_reason != null) {
               finishReason = {
                 unified: mapDeepSeekFinishReason(choice.finish_reason),
@@ -381,12 +619,24 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
               };
             }
 
+            if (choice?.logprobs?.content != null) {
+              contentLogprobs.push(...choice.logprobs.content);
+            }
+
+            if (choice?.logprobs?.reasoning_content != null) {
+              reasoningLogprobs.push(...choice.logprobs.reasoning_content);
+            }
+
             if (choice?.delta == null) {
               return;
             }
 
             const delta = choice.delta;
 
+            if (delta.role != null) {
+              messageRole = delta.role;
+            }
+
             // enqueue reasoning before text deltas:
             const reasoningContent = delta.reasoning_content;
             if (reasoningContent) {
@@ -438,6 +688,9 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
               }
 
               for (const toolCallDelta of delta.tool_calls) {
+                if (toolCallDelta.type != null) {
+                  toolCallTypes.set(toolCallDelta.index, toolCallDelta.type);
+                }
                 toolCallTracker.processDelta(toolCallDelta);
               }
             }
@@ -464,6 +717,26 @@ export class DeepSeekChatLanguageModel implements LanguageModelV4 {
                     usage?.prompt_cache_hit_tokens ?? undefined,
                   promptCacheMissTokens:
                     usage?.prompt_cache_miss_tokens ?? undefined,
+                  ...(responseObject != null && { responseObject }),
+                  ...(choiceIndex != null && { choiceIndex }),
+                  ...(messageRole != null && { messageRole }),
+                  ...(toolCallTypes.size > 0 && {
+                    toolCallTypes: [...toolCallTypes.entries()]
+                      .sort(([left], [right]) => left - right)
+                      .map(([, type]) => type),
+                  }),
+                  ...((contentLogprobs.length > 0 ||
+                    reasoningLogprobs.length > 0) && {
+                    logprobs: {
+                      ...(contentLogprobs.length > 0 && {
+                        content: contentLogprobs,
+                      }),
+                      ...(reasoningLogprobs.length > 0 && {
+                        reasoning_content: reasoningLogprobs,
+                      }),
+                    },
+                  }),
+                  ...(systemFingerprint != null && { systemFingerprint }),
                 },
               },
             });

package/src/chat/deepseek-file-part-options.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod/v4';
+
+export const deepseekFilePartProviderOptions = z.object({
+  /**
+   * Controls how DeepSeek processes an image sent as an `image_url` part.
+   *
+   * @see https://api-docs.deepseek.com/api/create-chat-completion/
+   */
+  imageDetail: z.enum(['low', 'high', 'original', 'auto']).optional(),
+
+  /**
+   * Sends inline image data as a DeepSeek `file` part using `file_data`
+   * instead of an `image_url` data URL. When set, the file part's filename
+   * is preserved.
+   *
+   * This option only applies to inline image data. It cannot be combined
+   * with `imageDetail`.
+   */
+  fileData: z.literal(true).optional(),
+});
+
+export type DeepSeekFilePartProviderOptions = z.infer<
+  typeof deepseekFilePartProviderOptions
+>;

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

@@ -1,6 +1,7 @@
-import type {
-  LanguageModelV4CallOptions,
-  SharedV4Warning,
+import {
+  UnsupportedFunctionalityError,
+  type LanguageModelV4CallOptions,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import type {
   DeepSeekFunctionTool,
@@ -10,9 +11,11 @@ import type {
 export function prepareTools({
   tools,
   toolChoice,
+  supportsStrictToolCalls,
 }: {
   tools: LanguageModelV4CallOptions['tools'];
   toolChoice?: LanguageModelV4CallOptions['toolChoice'];
+  supportsStrictToolCalls?: boolean;
 }): {
   tools: undefined | Array<DeepSeekFunctionTool>;
   toolChoice: DeepSeekToolChoice;
@@ -27,6 +30,29 @@ export function prepareTools({
     return { tools: undefined, toolChoice: undefined, toolWarnings };
   }
 
+  const functionTools = tools.filter(tool => tool.type === 'function');
+  const hasStrictTool = functionTools.some(tool => tool.strict === true);
+
+  if (hasStrictTool && supportsStrictToolCalls === false) {
+    throw new UnsupportedFunctionalityError({
+      functionality: 'DeepSeek strict tool calls',
+      message:
+        'DeepSeek strict tool calls require a beta base URL ending in `/beta`.',
+    });
+  }
+
+  if (
+    hasStrictTool &&
+    supportsStrictToolCalls === true &&
+    functionTools.some(tool => tool.strict !== true)
+  ) {
+    throw new UnsupportedFunctionalityError({
+      functionality: 'mixed DeepSeek strict and non-strict tool calls',
+      message:
+        'DeepSeek strict mode requires every function tool in the request to set `strict: true`.',
+    });
+  }
+
   const deepseekTools: Array<DeepSeekFunctionTool> = [];
 
   for (const tool of tools) {

package/src/deepseek-provider.ts

@@ -91,6 +91,8 @@ export function createDeepSeek(
       url: ({ path }) => `${baseURL}${path}`,
       headers: getHeaders,
       fetch: options.fetch,
+      supportsAssistantPrefixCompletion: baseURL.endsWith('/beta'),
+      supportsStrictToolCalls: baseURL.endsWith('/beta'),
     });
   };
 

package/src/files/deepseek-files-api.ts

@@ -5,12 +5,16 @@ export const deepSeekFilesResponseSchema = lazySchema(() =>
   zodSchema(
     z.object({
       id: z.string(),
-      object: z.string().nullish(),
-      bytes: z.number().nullish(),
-      created_at: z.number().nullish(),
+      // These fields are required by DeepSeek's OpenAPI schema, but they are
+      // not needed to construct the provider reference. Keep them nullish so
+      // uploads remain resilient to incomplete responses while validating any
+      // returned values precisely enough to avoid misleading metadata.
+      object: z.literal('file').nullish(),
+      bytes: z.number().int().nonnegative().nullish(),
+      created_at: z.number().int().nonnegative().nullish(),
       filename: z.string().nullish(),
-      purpose: z.string().nullish(),
-      expires_at: z.number().nullish(),
+      purpose: z.literal('user_data').nullish(),
+      expires_at: z.number().int().nonnegative().nullish(),
     }),
   ),
 );