@ai-sdk/deepseek 3.0.30 → 3.0.32

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

@@ -34,6 +34,7 @@ import {
   deepseekChatChunkSchema,
   deepseekChatResponseSchema,
   deepSeekErrorSchema,
+  type DeepSeekChatLogprob,
   type DeepSeekChatTokenUsage,
 } from './deepseek-chat-api-types';
 import {
@@ -49,10 +50,38 @@ 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 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 +152,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 +174,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 +199,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 +300,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 +377,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 +438,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(
@@ -372,8 +497,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 +520,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 +589,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 +618,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(),
     }),
   ),
 );

package/src/files/deepseek-files.ts

@@ -1,13 +1,15 @@
-import type {
-  FilesV4,
-  FilesV4UploadFileCallOptions,
-  FilesV4UploadFileResult,
+import {
+  InvalidArgumentError,
+  type FilesV4,
+  type FilesV4UploadFileCallOptions,
+  type FilesV4UploadFileResult,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertInlineFileDataToUint8Array,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
+  detectMediaType,
   parseProviderOptions,
   postFormDataToApi,
   type FetchFunction,
@@ -33,6 +35,34 @@ const deepSeekFailedResponseHandler = createJsonErrorResponseHandler({
     error.error.message,
 });
 
+const MAX_FILE_SIZE_BYTES = 64 * 1024 * 1024;
+const MAX_FILENAME_LENGTH = 512;
+
+const supportedMediaTypes = new Set([
+  'image/gif',
+  'image/jpeg',
+  'image/jpg',
+  'image/png',
+  'image/webp',
+]);
+
+const genericMediaTypes = new Set([
+  '',
+  'application/binary',
+  'application/octet-stream',
+  'binary/octet-stream',
+  'image',
+  'image/*',
+]);
+
+const supportedFilenameExtensions = new Set([
+  'gif',
+  'jpeg',
+  'jpg',
+  'png',
+  'webp',
+]);
+
 export class DeepSeekFiles implements FilesV4 {
   readonly specificationVersion = 'v4';
 
@@ -55,6 +85,8 @@ export class DeepSeekFiles implements FilesV4 {
     })) as DeepSeekFilesOptions | undefined;
 
     const fileBytes = convertInlineFileDataToUint8Array(data);
+    validateFileUpload({ fileBytes, mediaType, filename });
+
     const blob = new Blob([fileBytes], { type: mediaType });
 
     const formData = new FormData();
@@ -93,6 +125,7 @@ export class DeepSeekFiles implements FilesV4 {
       ...(mediaType != null ? { mediaType } : {}),
       providerMetadata: {
         deepseek: {
+          ...(response.object != null ? { object: response.object } : {}),
           ...(response.filename != null ? { filename: response.filename } : {}),
           ...(response.purpose != null ? { purpose: response.purpose } : {}),
           ...(response.bytes != null ? { bytes: response.bytes } : {}),
@@ -107,3 +140,95 @@ export class DeepSeekFiles implements FilesV4 {
     };
   }
 }
+
+function validateFileUpload({
+  fileBytes,
+  mediaType,
+  filename,
+}: {
+  fileBytes: Uint8Array;
+  mediaType: string;
+  filename: string | undefined;
+}) {
+  if (fileBytes.length > MAX_FILE_SIZE_BYTES) {
+    throw new InvalidArgumentError({
+      argument: 'data',
+      message:
+        `DeepSeek file uploads must not exceed 64 MiB ` +
+        `(${MAX_FILE_SIZE_BYTES.toLocaleString('en-US')} bytes). ` +
+        `Received ${fileBytes.length.toLocaleString('en-US')} bytes.`,
+    });
+  }
+
+  if (filename != null) {
+    const filenameLength = Array.from(filename).length;
+
+    if (filenameLength > MAX_FILENAME_LENGTH) {
+      throw new InvalidArgumentError({
+        argument: 'filename',
+        message:
+          `DeepSeek filenames must not exceed ${MAX_FILENAME_LENGTH} characters. ` +
+          `Received ${filenameLength} characters.`,
+      });
+    }
+  }
+
+  const normalizedMediaType = normalizeMediaType(mediaType);
+  const detectedMediaType = detectMediaType({ data: fileBytes });
+
+  if (
+    detectedMediaType != null &&
+    !supportedMediaTypes.has(detectedMediaType)
+  ) {
+    throw new InvalidArgumentError({
+      argument: 'data',
+      message:
+        `DeepSeek file uploads support JPEG, PNG, GIF, and WebP images. ` +
+        `Detected unsupported file content type "${detectedMediaType}".`,
+    });
+  }
+
+  if (supportedMediaTypes.has(normalizedMediaType)) {
+    return;
+  }
+
+  if (!genericMediaTypes.has(normalizedMediaType)) {
+    throw new InvalidArgumentError({
+      argument: 'mediaType',
+      message:
+        `DeepSeek file uploads support JPEG, PNG, GIF, and WebP images. ` +
+        `Received unsupported media type "${mediaType}".`,
+    });
+  }
+
+  if (detectedMediaType != null || hasSupportedFilenameExtension(filename)) {
+    return;
+  }
+
+  throw new InvalidArgumentError({
+    argument: 'mediaType',
+    message:
+      `DeepSeek file uploads support JPEG, PNG, GIF, and WebP images. ` +
+      `Provide a supported media type or a filename ending in ` +
+      `.jpg, .jpeg, .png, .gif, or .webp. Received "${mediaType}".`,
+  });
+}
+
+function normalizeMediaType(mediaType: string): string {
+  return mediaType.split(';', 1)[0].trim().toLowerCase();
+}
+
+function hasSupportedFilenameExtension(filename: string | undefined): boolean {
+  if (filename == null) {
+    return false;
+  }
+
+  const extensionSeparatorIndex = filename.lastIndexOf('.');
+
+  return (
+    extensionSeparatorIndex !== -1 &&
+    supportedFilenameExtensions.has(
+      filename.slice(extensionSeparatorIndex + 1).toLowerCase(),
+    )
+  );
+}

package/src/index.ts

@@ -10,11 +10,14 @@ export type {
 } from './deepseek-provider';
 export { VERSION } from './version';
 export type {
+  DeepSeekAssistantMessageProviderOptions,
   DeepSeekLanguageModelChatOptions,
+  DeepSeekMessageProviderOptions,
   /** @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';
+export type { DeepSeekFilePartProviderOptions } from './chat/deepseek-file-part-options';
 export type { DeepSeekFilesOptions } from './files/deepseek-files-options';