@ai-sdk/deepseek 2.0.7 → 2.0.9

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

@@ -0,0 +1,332 @@
+import { convertToDeepSeekChatMessages } from './convert-to-deepseek-chat-messages';
+import { describe, it, expect } from 'vitest';
+
+describe('convertToDeepSeekChatMessages', () => {
+  describe('user messages', () => {
+    it('should convert messages with only a text part to a string content', async () => {
+      const result = convertToDeepSeekChatMessages({
+        prompt: [
+          {
+            role: 'user',
+            content: [{ type: 'text', text: 'Hello' }],
+          },
+        ],
+        responseFormat: undefined,
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "messages": [
+            {
+              "content": "Hello",
+              "role": "user",
+            },
+          ],
+          "warnings": [],
+        }
+      `);
+    });
+
+    it('should warn about unsupported file parts', async () => {
+      const result = convertToDeepSeekChatMessages({
+        prompt: [
+          {
+            role: 'user',
+            content: [
+              { type: 'text', text: 'Hello' },
+              {
+                type: 'file',
+                data: Buffer.from([0, 1, 2, 3]).toString('base64'),
+                mediaType: 'image/png',
+              },
+            ],
+          },
+        ],
+        responseFormat: undefined,
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "messages": [
+            {
+              "content": "Hello",
+              "role": "user",
+            },
+          ],
+          "warnings": [
+            {
+              "feature": "user message part type: file",
+              "type": "unsupported",
+            },
+          ],
+        }
+      `);
+    });
+  });
+
+  describe('tool calls', () => {
+    it('should stringify arguments to tool calls', () => {
+      const result = convertToDeepSeekChatMessages({
+        prompt: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                input: { foo: 'bar123' },
+                toolCallId: 'quux',
+                toolName: 'thwomp',
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-result',
+                toolCallId: 'quux',
+                toolName: 'thwomp',
+                output: { type: 'json', value: { oof: '321rab' } },
+              },
+            ],
+          },
+        ],
+        responseFormat: undefined,
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "messages": [
+            {
+              "content": "",
+              "reasoning_content": undefined,
+              "role": "assistant",
+              "tool_calls": [
+                {
+                  "function": {
+                    "arguments": "{"foo":"bar123"}",
+                    "name": "thwomp",
+                  },
+                  "id": "quux",
+                  "type": "function",
+                },
+              ],
+            },
+            {
+              "content": "{"oof":"321rab"}",
+              "role": "tool",
+              "tool_call_id": "quux",
+            },
+          ],
+          "warnings": [],
+        }
+      `);
+    });
+
+    it('should handle text output type in tool results', () => {
+      const result = convertToDeepSeekChatMessages({
+        prompt: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                input: { query: 'weather' },
+                toolCallId: 'call-1',
+                toolName: 'getWeather',
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-result',
+                toolCallId: 'call-1',
+                toolName: 'getWeather',
+                output: { type: 'text', value: 'It is sunny today' },
+              },
+            ],
+          },
+        ],
+        responseFormat: undefined,
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "messages": [
+            {
+              "content": "",
+              "reasoning_content": undefined,
+              "role": "assistant",
+              "tool_calls": [
+                {
+                  "function": {
+                    "arguments": "{"query":"weather"}",
+                    "name": "getWeather",
+                  },
+                  "id": "call-1",
+                  "type": "function",
+                },
+              ],
+            },
+            {
+              "content": "It is sunny today",
+              "role": "tool",
+              "tool_call_id": "call-1",
+            },
+          ],
+          "warnings": [],
+        }
+      `);
+    });
+
+    it('should support reasoning content in tool calls', () => {
+      const result = convertToDeepSeekChatMessages({
+        prompt: [
+          {
+            role: 'user',
+            content: [{ type: 'text', text: 'Hello' }],
+          },
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'reasoning',
+                text: 'I think the tool will return the correct value.',
+              },
+              {
+                type: 'tool-call',
+                input: { foo: 'bar123' },
+                toolCallId: 'quux',
+                toolName: 'thwomp',
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-result',
+                toolCallId: 'quux',
+                toolName: 'thwomp',
+                output: { type: 'json', value: { oof: '321rab' } },
+              },
+            ],
+          },
+        ],
+        responseFormat: undefined,
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "messages": [
+            {
+              "content": "Hello",
+              "role": "user",
+            },
+            {
+              "content": "",
+              "reasoning_content": "I think the tool will return the correct value.",
+              "role": "assistant",
+              "tool_calls": [
+                {
+                  "function": {
+                    "arguments": "{"foo":"bar123"}",
+                    "name": "thwomp",
+                  },
+                  "id": "quux",
+                  "type": "function",
+                },
+              ],
+            },
+            {
+              "content": "{"oof":"321rab"}",
+              "role": "tool",
+              "tool_call_id": "quux",
+            },
+          ],
+          "warnings": [],
+        }
+      `);
+    });
+
+    it('should filter out reasoning content from turns before the last user message', () => {
+      const result = convertToDeepSeekChatMessages({
+        prompt: [
+          {
+            role: 'user',
+            content: [{ type: 'text', text: 'Hello' }],
+          },
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'reasoning',
+                text: 'I think the tool will return the correct value.',
+              },
+              {
+                type: 'tool-call',
+                input: { foo: 'bar123' },
+                toolCallId: 'quux',
+                toolName: 'thwomp',
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-result',
+                toolCallId: 'quux',
+                toolName: 'thwomp',
+                output: { type: 'json', value: { oof: '321rab' } },
+              },
+            ],
+          },
+          {
+            role: 'user',
+            content: [{ type: 'text', text: 'Goodbye' }],
+          },
+        ],
+        responseFormat: undefined,
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "messages": [
+            {
+              "content": "Hello",
+              "role": "user",
+            },
+            {
+              "content": "",
+              "reasoning_content": undefined,
+              "role": "assistant",
+              "tool_calls": [
+                {
+                  "function": {
+                    "arguments": "{"foo":"bar123"}",
+                    "name": "thwomp",
+                  },
+                  "id": "quux",
+                  "type": "function",
+                },
+              ],
+            },
+            {
+              "content": "{"oof":"321rab"}",
+              "role": "tool",
+              "tool_call_id": "quux",
+            },
+            {
+              "content": "Goodbye",
+              "role": "user",
+            },
+          ],
+          "warnings": [],
+        }
+      `);
+    });
+  });
+});

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

@@ -0,0 +1,177 @@
+import {
+  LanguageModelV3CallOptions,
+  LanguageModelV3Prompt,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import { DeepSeekChatPrompt } from './deepseek-chat-api-types';
+
+export function convertToDeepSeekChatMessages({
+  prompt,
+  responseFormat,
+}: {
+  prompt: LanguageModelV3Prompt;
+  responseFormat: LanguageModelV3CallOptions['responseFormat'];
+}): {
+  messages: DeepSeekChatPrompt;
+  warnings: Array<SharedV3Warning>;
+} {
+  const messages: DeepSeekChatPrompt = [];
+  const warnings: Array<SharedV3Warning> = [];
+
+  // Inject system message if response format is JSON
+  if (responseFormat?.type === 'json') {
+    if (responseFormat.schema == null) {
+      messages.push({
+        role: 'system',
+        content: 'Return JSON.',
+      });
+    } else {
+      messages.push({
+        role: 'system',
+        content:
+          'Return JSON that conforms to the following schema: ' +
+          JSON.stringify(responseFormat.schema),
+      });
+      warnings.push({
+        type: 'compatibility',
+        feature: 'responseFormat JSON schema',
+        details: 'JSON response schema is injected into the system message.',
+      });
+    }
+  }
+
+  // TODO use findLastIndex once we use ES2023
+  let lastUserMessageIndex = -1;
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    if (prompt[i].role === 'user') {
+      lastUserMessageIndex = i;
+      break;
+    }
+  }
+
+  let index = -1;
+  for (const { role, content } of prompt) {
+    index++;
+
+    switch (role) {
+      case 'system': {
+        messages.push({ role: 'system', content });
+        break;
+      }
+
+      case 'user': {
+        let userContent = '';
+        for (const part of content) {
+          if (part.type === 'text') {
+            userContent += part.text;
+          } else {
+            warnings.push({
+              type: 'unsupported',
+              feature: `user message part type: ${part.type}`,
+            });
+          }
+        }
+
+        messages.push({
+          role: 'user',
+          content: userContent,
+        });
+
+        break;
+      }
+      case 'assistant': {
+        let text = '';
+        let reasoning: string | undefined;
+
+        const toolCalls: Array<{
+          id: string;
+          type: 'function';
+          function: { name: string; arguments: string };
+        }> = [];
+
+        for (const part of content) {
+          switch (part.type) {
+            case 'text': {
+              text += part.text;
+              break;
+            }
+            case 'reasoning': {
+              if (index <= lastUserMessageIndex) {
+                break;
+              }
+
+              if (reasoning == null) {
+                reasoning = part.text;
+              } else {
+                reasoning += part.text;
+              }
+              break;
+            }
+            case 'tool-call': {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: 'function',
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input),
+                },
+              });
+              break;
+            }
+          }
+        }
+
+        messages.push({
+          role: 'assistant',
+          content: text,
+          reasoning_content: reasoning,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+        });
+
+        break;
+      }
+
+      case 'tool': {
+        for (const toolResponse of content) {
+          if (toolResponse.type === 'tool-approval-response') {
+            continue;
+          }
+          const output = toolResponse.output;
+
+          let contentValue: string;
+          switch (output.type) {
+            case 'text':
+            case 'error-text':
+              contentValue = output.value;
+              break;
+            case 'execution-denied':
+              contentValue = output.reason ?? 'Tool execution denied.';
+              break;
+            case 'content':
+            case 'json':
+            case 'error-json':
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+
+          messages.push({
+            role: 'tool',
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+          });
+        }
+        break;
+      }
+
+      default: {
+        warnings.push({
+          type: 'unsupported',
+          feature: `message role: ${role}`,
+        });
+        break;
+      }
+    }
+  }
+
+  return { messages, warnings };
+}

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

@@ -0,0 +1,56 @@
+import { LanguageModelV3Usage } from '@ai-sdk/provider';
+
+export function convertDeepSeekUsage(
+  usage:
+    | {
+        prompt_tokens?: number | null | undefined;
+        completion_tokens?: number | null | undefined;
+        prompt_cache_hit_tokens?: number | null | undefined;
+        completion_tokens_details?:
+          | {
+              reasoning_tokens?: number | null | undefined;
+            }
+          | null
+          | undefined;
+      }
+    | undefined
+    | null,
+): LanguageModelV3Usage {
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined,
+      },
+      raw: undefined,
+    };
+  }
+
+  const promptTokens = usage.prompt_tokens ?? 0;
+  const completionTokens = usage.completion_tokens ?? 0;
+  const cacheReadTokens = usage.prompt_cache_hit_tokens ?? 0;
+  const reasoningTokens =
+    usage.completion_tokens_details?.reasoning_tokens ?? 0;
+
+  return {
+    inputTokens: {
+      total: promptTokens,
+      noCache: promptTokens - cacheReadTokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: undefined,
+    },
+    outputTokens: {
+      total: completionTokens,
+      text: completionTokens - reasoningTokens,
+      reasoning: reasoningTokens,
+    },
+    raw: usage,
+  };
+}

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

@@ -0,0 +1,157 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type DeepSeekChatPrompt = Array<DeepSeekMessage>;
+
+export type DeepSeekMessage =
+  | DeepSeekSystemMessage
+  | DeepSeekUserMessage
+  | DeepSeekAssistantMessage
+  | DeepSeekToolMessage;
+
+export interface DeepSeekSystemMessage {
+  role: 'system';
+  content: string;
+}
+
+export interface DeepSeekUserMessage {
+  role: 'user';
+  content: string;
+}
+
+export interface DeepSeekAssistantMessage {
+  role: 'assistant';
+  content?: string | null;
+  reasoning_content?: string;
+  tool_calls?: Array<DeepSeekMessageToolCall>;
+}
+
+export interface DeepSeekMessageToolCall {
+  type: 'function';
+  id: string;
+  function: {
+    arguments: string;
+    name: string;
+  };
+}
+
+export interface DeepSeekToolMessage {
+  role: 'tool';
+  content: string;
+  tool_call_id: string;
+}
+
+export interface DeepSeekFunctionTool {
+  type: 'function';
+  function: {
+    name: string;
+    description: string | undefined;
+    parameters: unknown;
+    strict?: boolean;
+  };
+}
+
+export type DeepSeekToolChoice =
+  | { type: 'function'; function: { name: string } }
+  | 'auto'
+  | 'none'
+  | 'required'
+  | undefined;
+
+const tokenUsageSchema = z
+  .object({
+    prompt_tokens: z.number().nullish(),
+    completion_tokens: z.number().nullish(),
+    prompt_cache_hit_tokens: z.number().nullish(),
+    prompt_cache_miss_tokens: z.number().nullish(),
+    total_tokens: z.number().nullish(),
+    completion_tokens_details: z
+      .object({
+        reasoning_tokens: z.number().nullish(),
+      })
+      .nullish(),
+  })
+  .nullish();
+
+export type DeepSeekChatTokenUsage = z.infer<typeof tokenUsageSchema>;
+
+export const deepSeekErrorSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish(),
+  }),
+});
+
+export type DeepSeekErrorData = z.infer<typeof deepSeekErrorSchema>;
+
+// 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(),
+  choices: z.array(
+    z.object({
+      message: z.object({
+        role: z.literal('assistant').nullish(),
+        content: z.string().nullish(),
+        reasoning_content: z.string().nullish(),
+        tool_calls: z
+          .array(
+            z.object({
+              id: z.string().nullish(),
+              function: z.object({
+                name: z.string(),
+                arguments: z.string(),
+              }),
+            }),
+          )
+          .nullish(),
+      }),
+      finish_reason: z.string().nullish(),
+    }),
+  ),
+  usage: tokenUsageSchema,
+});
+
+// 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 deepseekChatChunkSchema = lazySchema(() =>
+  zodSchema(
+    z.union([
+      z.object({
+        id: z.string().nullish(),
+        created: z.number().nullish(),
+        model: z.string().nullish(),
+        choices: z.array(
+          z.object({
+            delta: z
+              .object({
+                role: z.enum(['assistant']).nullish(),
+                content: z.string().nullish(),
+                reasoning_content: z.string().nullish(),
+                tool_calls: z
+                  .array(
+                    z.object({
+                      index: z.number(),
+                      id: z.string().nullish(),
+                      function: z.object({
+                        name: z.string().nullish(),
+                        arguments: z.string().nullish(),
+                      }),
+                    }),
+                  )
+                  .nullish(),
+              })
+              .nullish(),
+            finish_reason: z.string().nullish(),
+          }),
+        ),
+        usage: tokenUsageSchema,
+      }),
+      deepSeekErrorSchema,
+    ]),
+  ),
+);