@ai-sdk/deepseek 2.0.58 → 2.0.59

package/src/chat/deepseek-chat-api-types.ts

@@ -12,16 +12,19 @@ export type DeepSeekMessage =
 export interface DeepSeekSystemMessage {
   role: 'system';
   content: string;
+  name?: string;
 }
 
 export interface DeepSeekUserMessage {
   role: 'user';
   content: string | Array<DeepSeekContentPart>;
+  name?: string;
 }
 
 export type DeepSeekContentPart =
   | DeepSeekContentPartText
-  | DeepSeekContentPartImage;
+  | DeepSeekContentPartImage
+  | DeepSeekContentPartFile;
 
 export interface DeepSeekContentPartText {
   type: 'text';
@@ -30,12 +33,22 @@ export interface DeepSeekContentPartText {
 
 export interface DeepSeekContentPartImage {
   type: 'image_url';
-  image_url: { url: string };
+  image_url: {
+    url: string;
+    detail?: 'low' | 'high' | 'original' | 'auto';
+  };
 }
 
+export interface DeepSeekContentPartFile {
+  type: 'file';
+  file_data: string;
+  filename?: string;
+}
 export interface DeepSeekAssistantMessage {
   role: 'assistant';
   content?: string | null;
+  name?: string;
+  prefix?: true;
   reasoning_content?: string;
   tool_calls?: Array<DeepSeekMessageToolCall>;
 }
@@ -100,14 +113,39 @@ export const deepSeekErrorSchema = z.object({
 
 export type DeepSeekErrorData = z.infer<typeof deepSeekErrorSchema>;
 
+const deepseekChatLogprobSchema = z.object({
+  token: z.string(),
+  logprob: z.number(),
+  bytes: z.array(z.number()).nullable(),
+  top_logprobs: z.array(
+    z.object({
+      token: z.string(),
+      logprob: z.number(),
+      bytes: z.array(z.number()).nullable(),
+    }),
+  ),
+});
+
+const deepseekChatLogprobsSchema = z
+  .object({
+    content: z.array(deepseekChatLogprobSchema).nullish(),
+    reasoning_content: z.array(deepseekChatLogprobSchema).nullish(),
+  })
+  .nullish();
+
+export type DeepSeekChatLogprob = z.infer<typeof deepseekChatLogprobSchema>;
+
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
 export const deepseekChatResponseSchema = z.object({
   id: z.string().nullish(),
   created: z.number().nullish(),
   model: z.string().nullish(),
+  object: z.literal('chat.completion').nullish(),
+  system_fingerprint: z.string().nullish(),
   choices: z.array(
     z.object({
+      index: z.number().nullish(),
       message: z.object({
         role: z.literal('assistant').nullish(),
         content: z.string().nullish(),
@@ -116,6 +154,7 @@ export const deepseekChatResponseSchema = z.object({
           .array(
             z.object({
               id: z.string().nullish(),
+              type: z.literal('function').nullish(),
               function: z.object({
                 name: z.string(),
                 arguments: z.string(),
@@ -124,6 +163,7 @@ export const deepseekChatResponseSchema = z.object({
           )
           .nullish(),
       }),
+      logprobs: deepseekChatLogprobsSchema,
       finish_reason: z.string().nullish(),
     }),
   ),
@@ -139,8 +179,11 @@ export const deepseekChatChunkSchema = lazySchema(() =>
         id: z.string().nullish(),
         created: z.number().nullish(),
         model: z.string().nullish(),
+        object: z.literal('chat.completion.chunk').nullish(),
+        system_fingerprint: z.string().nullish(),
         choices: z.array(
           z.object({
+            index: z.number().nullish(),
             delta: z
               .object({
                 role: z.enum(['assistant']).nullish(),
@@ -151,6 +194,7 @@ export const deepseekChatChunkSchema = lazySchema(() =>
                     z.object({
                       index: z.number(),
                       id: z.string().nullish(),
+                      type: z.literal('function').nullish(),
                       function: z.object({
                         name: z.string().nullish(),
                         arguments: z.string().nullish(),
@@ -160,6 +204,7 @@ export const deepseekChatChunkSchema = lazySchema(() =>
                   .nullish(),
               })
               .nullish(),
+            logprobs: deepseekChatLogprobsSchema,
             finish_reason: z.string().nullish(),
           }),
         ),

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

@@ -8,6 +8,7 @@ import {
   type LanguageModelV3GenerateResult,
   type LanguageModelV3StreamPart,
   type LanguageModelV3StreamResult,
+  type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -28,6 +29,7 @@ import {
   deepseekChatChunkSchema,
   deepseekChatResponseSchema,
   deepSeekErrorSchema,
+  type DeepSeekChatLogprob,
   type DeepSeekChatTokenUsage,
 } from './deepseek-chat-api-types';
 import {
@@ -43,10 +45,38 @@ export type DeepSeekChatConfig = {
   headers: () => Record<string, string | undefined>;
   url: (options: { modelId: string; path: string }) => string;
   fetch?: FetchFunction;
+  supportsAssistantPrefixCompletion?: boolean;
+  supportsPenaltySampling?: boolean;
+  supportsStrictToolCalls?: boolean;
   supportsThinking?: boolean;
   supportsStructuredOutputs?: boolean;
 };
 
+function mapDeepSeekProviderReasoningEffort({
+  reasoningEffort,
+  warnings,
+}: {
+  reasoningEffort: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+  warnings: SharedV3Warning[];
+}): '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 LanguageModelV3 {
   readonly specificationVersion = 'v3';
 
@@ -102,20 +132,42 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
 
     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 = [...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' });
+    }
+
+    if (!supportsPenaltySampling && frequencyPenalty != null) {
+      allWarnings.push({
+        type: 'other',
+        message:
+          'frequencyPenalty is deprecated by DeepSeek and has been omitted. Remove frequencyPenalty from the request.',
+      });
+    }
+
+    if (!supportsPenaltySampling && presencePenalty != null) {
+      allWarnings.push({
+        type: 'other',
+        message:
+          'presencePenalty is deprecated by DeepSeek and has been omitted. Remove presencePenalty from the request.',
+      });
     }
 
     const {
@@ -125,23 +177,75 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
     } = prepareTools({
       tools,
       toolChoice,
+      supportsStrictToolCalls: this.config.supportsStrictToolCalls,
     });
+    allWarnings.push(...toolWarnings);
+
+    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 }
           : 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 != null
+        ? mapDeepSeekProviderReasoningEffort({
+            reasoningEffort: deepseekOptions.reasoningEffort,
+            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
@@ -161,12 +265,15 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
         tools: deepseekTools,
         tool_choice: deepseekToolChoices,
         thinking,
+        ...(deepseekOptions.userId != null && {
+          user_id: deepseekOptions.userId,
+        }),
         ...(thinking?.type !== 'disabled' &&
-          deepseekOptions.reasoningEffort != null && {
-            reasoning_effort: deepseekOptions.reasoningEffort,
+          reasoningEffort != null && {
+            reasoning_effort: reasoningEffort,
           }),
       },
-      warnings: [...warnings, ...toolWarnings],
+      warnings: allWarnings,
     };
   }
 
@@ -235,6 +342,22 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
         [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 },
@@ -288,10 +411,17 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
       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(
@@ -337,8 +467,22 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
               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),
@@ -346,12 +490,24 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
               };
             }
 
+            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) {
@@ -403,6 +559,10 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
               }
 
               for (const toolCallDelta of delta.tool_calls) {
+                if (toolCallDelta.type != null) {
+                  toolCallTypes.set(toolCallDelta.index, toolCallDelta.type);
+                }
+
                 const index = toolCallDelta.index;
 
                 if (toolCalls[index] == null) {
@@ -513,6 +673,26 @@ export class DeepSeekChatLanguageModel implements LanguageModelV3 {
                     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-chat-options.ts

@@ -2,31 +2,57 @@ import { z } from 'zod/v4';
 
 // https://api-docs.deepseek.com/quick_start/pricing
 export type DeepSeekChatModelId =
-  | 'deepseek-chat'
-  | 'deepseek-reasoner'
+  | 'deepseek-v4-flash'
+  | 'deepseek-v4-pro'
   | 'deepseek-v4-flash-vision-exp'
+  // Retired aliases remain assignable through the string escape hatch, but are
+  // intentionally omitted from first-class editor suggestions.
   | (string & {});
 
 export const deepseekLanguageModelOptions = z.object({
   /**
-   * Type of thinking to use. Defaults to `enabled`.
+   * Whether to return log probabilities for generated tokens.
+   */
+  logprobs: z.boolean().optional(),
+
+  /**
+   * Number of most likely tokens to return at each token position.
+   *
+   * Setting this option automatically enables `logprobs`.
+   */
+  topLogprobs: z.number().int().min(0).max(20).optional(),
+
+  /**
+   * An opaque identifier for the end user. DeepSeek uses this identifier for
+   * content-safety tracing and request isolation.
    *
-   * See https://api-docs.deepseek.com/guides/thinking_mode for the
-   * `adaptive` option, which lets the model decide when to think.
+   * Must contain only ASCII letters, numbers, underscores, and hyphens, and
+   * must be at most 512 characters long.
+   */
+  userId: z
+    .string()
+    .regex(/^[a-zA-Z0-9_-]+$/, 'userId must match /^[a-zA-Z0-9_-]+$/')
+    .max(512, 'userId must be at most 512 characters long')
+    .optional(),
+
+  /**
+   * Type of thinking to use. Defaults to `enabled`.
    */
   thinking: z
     .object({
+      // `adaptive` is accepted at runtime for backwards compatibility and
+      // mapped to `enabled`, but is intentionally excluded from the exported
+      // provider options type.
       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.
    */
+  // `medium` and `xhigh` are accepted at runtime for backwards compatibility
+  // and mapped to canonical DeepSeek values, but are intentionally excluded
+  // from the exported provider options type.
   reasoningEffort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
 
   /**
@@ -37,6 +63,71 @@ export const deepseekLanguageModelOptions = z.object({
   strictJsonSchema: z.boolean().optional(),
 });
 
-export type DeepSeekLanguageModelOptions = z.infer<
-  typeof deepseekLanguageModelOptions
+export type DeepSeekLanguageModelOptions = {
+  /**
+   * Whether to return log probabilities for generated tokens.
+   */
+  logprobs?: boolean;
+
+  /**
+   * Number of most likely tokens to return at each token position.
+   *
+   * Setting this option automatically enables `logprobs`.
+   */
+  topLogprobs?: number;
+
+  /**
+   * An opaque identifier for the end user. DeepSeek uses this identifier for
+   * content-safety tracing and request isolation.
+   *
+   * Must contain only ASCII letters, numbers, underscores, and hyphens, and
+   * must be at most 512 characters long.
+   */
+  userId?: string;
+
+  /**
+   * Controls whether thinking mode is enabled. Defaults to `enabled`.
+   */
+  thinking?: {
+    type?: 'enabled' | 'disabled';
+  };
+
+  /**
+   * Controls the thinking strength for DeepSeek V4 reasoning models.
+   */
+  reasoningEffort?: 'low' | 'high' | 'max';
+
+  /**
+   * Whether to use strict JSON schema validation for structured outputs.
+   * Only applies when the serving endpoint supports JSON schema response
+   * formats (e.g. Azure). Defaults to `true`.
+   */
+  strictJsonSchema?: boolean;
+};
+
+export const deepseekMessageProviderOptions = z.object({
+  /**
+   * The name of the participant represented by the message.
+   *
+   * Supported on system, user, and assistant messages.
+   */
+  name: z.string().optional(),
+});
+
+export type DeepSeekMessageProviderOptions = z.infer<
+  typeof deepseekMessageProviderOptions
+>;
+
+export const deepseekAssistantMessageProviderOptions =
+  deepseekMessageProviderOptions.extend({
+    /**
+     * Whether the assistant message content is a prefix that DeepSeek should
+     * continue. This beta feature is only supported on the final assistant
+     * message when using a beta base URL.
+     */
+    prefix: z.literal(true).optional(),
+  });
+
+export type DeepSeekAssistantMessageProviderOptions = z.infer<
+  typeof deepseekAssistantMessageProviderOptions
 >;

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 {
-  LanguageModelV3CallOptions,
-  SharedV3Warning,
+import {
+  UnsupportedFunctionalityError,
+  type LanguageModelV3CallOptions,
+  type SharedV3Warning,
 } from '@ai-sdk/provider';
 import type {
   DeepSeekFunctionTool,
@@ -10,9 +11,11 @@ import type {
 export function prepareTools({
   tools,
   toolChoice,
+  supportsStrictToolCalls,
 }: {
   tools: LanguageModelV3CallOptions['tools'];
   toolChoice?: LanguageModelV3CallOptions['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

@@ -61,9 +61,8 @@ export interface DeepSeekProvider extends ProviderV3 {
 export function createDeepSeek(
   options: DeepSeekProviderSettings = {},
 ): DeepSeekProvider {
-  const baseURL = withoutTrailingSlash(
-    options.baseURL ?? 'https://api.deepseek.com',
-  );
+  const baseURL =
+    withoutTrailingSlash(options.baseURL) ?? 'https://api.deepseek.com';
 
   const getHeaders = () =>
     withUserAgentSuffix(
@@ -84,6 +83,8 @@ export function createDeepSeek(
       url: ({ path }) => `${baseURL}${path}`,
       headers: getHeaders,
       fetch: options.fetch,
+      supportsAssistantPrefixCompletion: baseURL.endsWith('/beta'),
+      supportsStrictToolCalls: baseURL.endsWith('/beta'),
     });
   };