@ai-sdk/deepseek 3.0.30 → 3.0.32

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

@@ -1,11 +1,14 @@
-import type {
-  LanguageModelV4CallOptions,
-  LanguageModelV4Prompt,
-  SharedV4Warning,
+import {
+  InvalidPromptError,
+  UnsupportedFunctionalityError,
+  type LanguageModelV4CallOptions,
+  type LanguageModelV4Prompt,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   convertToBase64,
   getTopLevelMediaType,
+  parseProviderOptions,
   resolveFullMediaType,
   resolveProviderReference,
 } from '@ai-sdk/provider-utils';
@@ -13,21 +16,35 @@ import type {
   DeepSeekChatPrompt,
   DeepSeekContentPart,
 } from './deepseek-chat-api-types';
+import { deepseekFilePartProviderOptions } from './deepseek-file-part-options';
+import { deepseekAssistantMessageProviderOptions } from './deepseek-chat-language-model-options';
+
+const supportedImageMediaTypes = new Set([
+  'image/gif',
+  'image/jpeg',
+  'image/jpg',
+  'image/png',
+  'image/webp',
+]);
 
-export function convertToDeepSeekChatMessages({
+export async function convertToDeepSeekChatMessages({
   prompt,
   responseFormat,
   modelId,
+  providerOptionsName = 'deepseek',
+  supportsAssistantPrefixCompletion = false,
   supportsStructuredOutputs = false,
 }: {
   prompt: LanguageModelV4Prompt;
   responseFormat: LanguageModelV4CallOptions['responseFormat'];
   modelId: string;
+  providerOptionsName?: string;
+  supportsAssistantPrefixCompletion?: boolean;
   supportsStructuredOutputs?: boolean;
-}): {
+}): Promise<{
   messages: DeepSeekChatPrompt;
   warnings: Array<SharedV4Warning>;
-} {
+}> {
   const isDeepSeekV4 = modelId.includes('deepseek-v4');
   const messages: DeepSeekChatPrompt = [];
   const warnings: Array<SharedV4Warning> = [];
@@ -64,12 +81,34 @@ export function convertToDeepSeekChatMessages({
   }
 
   let index = -1;
-  for (const { role, content } of prompt) {
+  for (const { role, content, providerOptions } of prompt) {
     index++;
 
+    // The assistant schema extends the common message schema, so one parse
+    // validates names for every role and the assistant-only prefix option.
+    const deepseekMessageOptions = await parseProviderOptions({
+      provider: providerOptionsName,
+      providerOptions,
+      schema: deepseekAssistantMessageProviderOptions,
+    });
+
+    if (deepseekMessageOptions?.prefix === true && role !== 'assistant') {
+      throw new InvalidPromptError({
+        prompt,
+        message:
+          'DeepSeek assistant prefix completion requires `prefix: true` on an assistant message.',
+      });
+    }
+
     switch (role) {
       case 'system': {
-        messages.push({ role: 'system', content });
+        messages.push({
+          role: 'system',
+          content,
+          ...(deepseekMessageOptions?.name != null && {
+            name: deepseekMessageOptions.name,
+          }),
+        });
         break;
       }
 
@@ -96,7 +135,13 @@ export function convertToDeepSeekChatMessages({
             }
           }
 
-          messages.push({ role: 'user', content: userContent });
+          messages.push({
+            role: 'user',
+            content: userContent,
+            ...(deepseekMessageOptions?.name != null && {
+              name: deepseekMessageOptions.name,
+            }),
+          });
           break;
         }
 
@@ -108,6 +153,12 @@ export function convertToDeepSeekChatMessages({
             part.type === 'file' &&
             getTopLevelMediaType(part.mediaType) === 'image'
           ) {
+            const filePartOptions = await parseProviderOptions({
+              provider: providerOptionsName,
+              providerOptions: part.providerOptions,
+              schema: deepseekFilePartProviderOptions,
+            });
+
             if (part.data.type === 'reference') {
               userContent.push({
                 type: 'file',
@@ -117,15 +168,77 @@ export function convertToDeepSeekChatMessages({
                 }),
               });
             } else if (part.data.type === 'url' || part.data.type === 'data') {
-              userContent.push({
-                type: 'image_url',
-                image_url: {
-                  url:
-                    part.data.type === 'url'
-                      ? part.data.url.toString()
-                      : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`,
-                },
-              });
+              const resolvedMediaType = resolveFullMediaType({ part });
+
+              if (!supportedImageMediaTypes.has(resolvedMediaType)) {
+                throw new UnsupportedFunctionalityError({
+                  functionality: `DeepSeek image media type ${resolvedMediaType}`,
+                  message:
+                    'DeepSeek supports JPEG, PNG, GIF, and WebP image inputs.',
+                });
+              }
+
+              if (part.data.type === 'url') {
+                const url = part.data.url.toString();
+
+                if (url.length > 8192) {
+                  throw new InvalidPromptError({
+                    prompt,
+                    message:
+                      'DeepSeek image URLs must not exceed 8192 characters.',
+                  });
+                }
+
+                if (filePartOptions?.fileData === true) {
+                  throw new InvalidPromptError({
+                    prompt,
+                    message:
+                      'DeepSeek `fileData` image parts require inline data, not a URL.',
+                  });
+                }
+
+                userContent.push({
+                  type: 'image_url',
+                  image_url: {
+                    url,
+                    ...(filePartOptions?.imageDetail != null && {
+                      detail: filePartOptions.imageDetail,
+                    }),
+                  },
+                });
+              } else {
+                const dataUrl = `data:${
+                  resolvedMediaType === 'image/jpg'
+                    ? 'image/jpeg'
+                    : resolvedMediaType
+                };base64,${convertToBase64(part.data.data)}`;
+
+                if (filePartOptions?.fileData === true) {
+                  if (filePartOptions.imageDetail != null) {
+                    throw new InvalidPromptError({
+                      prompt,
+                      message:
+                        'DeepSeek `imageDetail` cannot be combined with `fileData`.',
+                    });
+                  }
+
+                  userContent.push({
+                    type: 'file',
+                    file_data: dataUrl,
+                    ...(part.filename != null && { filename: part.filename }),
+                  });
+                } else {
+                  userContent.push({
+                    type: 'image_url',
+                    image_url: {
+                      url: dataUrl,
+                      ...(filePartOptions?.imageDetail != null && {
+                        detail: filePartOptions.imageDetail,
+                      }),
+                    },
+                  });
+                }
+              }
             } else {
               warnings.push({
                 type: 'unsupported',
@@ -143,11 +256,32 @@ export function convertToDeepSeekChatMessages({
         messages.push({
           role: 'user',
           content: userContent,
+          ...(deepseekMessageOptions?.name != null && {
+            name: deepseekMessageOptions.name,
+          }),
         });
 
         break;
       }
       case 'assistant': {
+        if (deepseekMessageOptions?.prefix === true) {
+          if (index !== prompt.length - 1) {
+            throw new InvalidPromptError({
+              prompt,
+              message:
+                'DeepSeek assistant prefix completion requires the prefixed assistant message to be the final message.',
+            });
+          }
+
+          if (!supportsAssistantPrefixCompletion) {
+            throw new UnsupportedFunctionalityError({
+              functionality: 'DeepSeek assistant prefix completion',
+              message:
+                'DeepSeek assistant prefix completion requires a beta base URL ending in `/beta`.',
+            });
+          }
+        }
+
         let text = '';
         let reasoning: string | undefined;
 
@@ -195,6 +329,12 @@ export function convertToDeepSeekChatMessages({
         messages.push({
           role: 'assistant',
           content: text,
+          ...(deepseekMessageOptions?.name != null && {
+            name: deepseekMessageOptions.name,
+          }),
+          ...(deepseekMessageOptions?.prefix === true && {
+            prefix: true,
+          }),
           reasoning_content: reasoning ?? (isDeepSeekV4 ? '' : undefined),
           tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
         });
@@ -203,6 +343,13 @@ export function convertToDeepSeekChatMessages({
       }
 
       case 'tool': {
+        if (deepseekMessageOptions?.name != null) {
+          warnings.push({
+            type: 'unsupported',
+            feature: 'message name on tool messages',
+          });
+        }
+
         for (const toolResponse of content) {
           if (toolResponse.type === 'tool-approval-response') {
             continue;

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

@@ -36,7 +36,7 @@ export function convertDeepSeekUsage(
     },
     outputTokens: {
       total: completionTokens,
-      text: completionTokens - reasoningTokens,
+      text: Math.max(0, completionTokens - reasoningTokens),
       reasoning: reasoningTokens,
     },
     raw: usage,

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

@@ -12,11 +12,13 @@ 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 =
@@ -31,17 +33,28 @@ 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_id: string;
-}
+export type DeepSeekContentPartFile =
+  | {
+      type: 'file';
+      file_id: string;
+    }
+  | {
+      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>;
 }
@@ -106,14 +119,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(),
@@ -122,6 +160,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(),
@@ -130,6 +169,7 @@ export const deepseekChatResponseSchema = z.object({
           )
           .nullish(),
       }),
+      logprobs: deepseekChatLogprobsSchema,
       finish_reason: z.string().nullish(),
     }),
   ),
@@ -145,8 +185,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(),
@@ -157,6 +200,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(),
@@ -166,6 +210,7 @@ export const deepseekChatChunkSchema = lazySchema(() =>
                   .nullish(),
               })
               .nullish(),
+            logprobs: deepseekChatLogprobsSchema,
             finish_reason: z.string().nullish(),
           }),
         ),

package/src/chat/deepseek-chat-language-model-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 deepseekLanguageModelChatOptions = 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 deepseekLanguageModelChatOptions = z.object({
   strictJsonSchema: z.boolean().optional(),
 });
 
-export type DeepSeekLanguageModelChatOptions = z.infer<
-  typeof deepseekLanguageModelChatOptions
+export type DeepSeekLanguageModelChatOptions = {
+  /**
+   * 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
 >;