@ai-sdk/deepseek 2.0.8 → 2.0.9

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

@@ -0,0 +1,178 @@
+import { describe, it, expect } from 'vitest';
+import { prepareTools } from './deepseek-prepare-tools';
+
+describe('prepareTools', () => {
+  it('should pass through strict mode when strict is true', () => {
+    const result = prepareTools({
+      tools: [
+        {
+          type: 'function',
+          name: 'testFunction',
+          description: 'A test function',
+          inputSchema: { type: 'object', properties: {} },
+          strict: true,
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "toolWarnings": [],
+        "tools": [
+          {
+            "function": {
+              "description": "A test function",
+              "name": "testFunction",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+              "strict": true,
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should pass through strict mode when strict is false', () => {
+    const result = prepareTools({
+      tools: [
+        {
+          type: 'function',
+          name: 'testFunction',
+          description: 'A test function',
+          inputSchema: { type: 'object', properties: {} },
+          strict: false,
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "toolWarnings": [],
+        "tools": [
+          {
+            "function": {
+              "description": "A test function",
+              "name": "testFunction",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+              "strict": false,
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should not include strict mode when strict is undefined', () => {
+    const result = prepareTools({
+      tools: [
+        {
+          type: 'function',
+          name: 'testFunction',
+          description: 'A test function',
+          inputSchema: { type: 'object', properties: {} },
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "toolWarnings": [],
+        "tools": [
+          {
+            "function": {
+              "description": "A test function",
+              "name": "testFunction",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should pass through strict mode for multiple tools with different strict settings', () => {
+    const result = prepareTools({
+      tools: [
+        {
+          type: 'function',
+          name: 'strictTool',
+          description: 'A strict tool',
+          inputSchema: { type: 'object', properties: {} },
+          strict: true,
+        },
+        {
+          type: 'function',
+          name: 'nonStrictTool',
+          description: 'A non-strict tool',
+          inputSchema: { type: 'object', properties: {} },
+          strict: false,
+        },
+        {
+          type: 'function',
+          name: 'defaultTool',
+          description: 'A tool without strict setting',
+          inputSchema: { type: 'object', properties: {} },
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "toolWarnings": [],
+        "tools": [
+          {
+            "function": {
+              "description": "A strict tool",
+              "name": "strictTool",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+              "strict": true,
+            },
+            "type": "function",
+          },
+          {
+            "function": {
+              "description": "A non-strict tool",
+              "name": "nonStrictTool",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+              "strict": false,
+            },
+            "type": "function",
+          },
+          {
+            "function": {
+              "description": "A tool without strict setting",
+              "name": "defaultTool",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+});

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

@@ -0,0 +1,82 @@
+import { LanguageModelV3CallOptions, SharedV3Warning } from '@ai-sdk/provider';
+import {
+  DeepSeekFunctionTool,
+  DeepSeekToolChoice,
+} from './deepseek-chat-api-types';
+
+export function prepareTools({
+  tools,
+  toolChoice,
+}: {
+  tools: LanguageModelV3CallOptions['tools'];
+  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+}): {
+  tools: undefined | Array<DeepSeekFunctionTool>;
+  toolChoice: DeepSeekToolChoice;
+  toolWarnings: SharedV3Warning[];
+} {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV3Warning[] = [];
+
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+
+  const deepseekTools: Array<DeepSeekFunctionTool> = [];
+
+  for (const tool of tools) {
+    if (tool.type === 'provider') {
+      toolWarnings.push({
+        type: 'unsupported',
+        feature: `provider-defined tool ${tool.id}`,
+      });
+    } else {
+      deepseekTools.push({
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          ...(tool.strict != null ? { strict: tool.strict } : {}),
+        },
+      });
+    }
+  }
+
+  if (toolChoice == null) {
+    return { tools: deepseekTools, toolChoice: undefined, toolWarnings };
+  }
+
+  const type = toolChoice?.type;
+
+  switch (type) {
+    case 'auto':
+    case 'none':
+    case 'required':
+      return { tools: deepseekTools, toolChoice: type, toolWarnings };
+    case 'tool':
+      return {
+        tools: deepseekTools,
+        toolChoice: {
+          type: 'function',
+          function: { name: toolChoice.toolName },
+        },
+        toolWarnings,
+      };
+    default: {
+      return {
+        tools: deepseekTools,
+        toolChoice: undefined,
+        toolWarnings: [
+          ...toolWarnings,
+          {
+            type: 'unsupported',
+            feature: `tool choice type: ${type}`,
+          },
+        ],
+      };
+    }
+  }
+}

package/src/chat/get-response-metadata.ts

@@ -0,0 +1,15 @@
+export function getResponseMetadata({
+  id,
+  model,
+  created,
+}: {
+  id?: string | undefined | null;
+  created?: number | undefined | null;
+  model?: string | undefined | null;
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined,
+  };
+}

package/src/chat/map-deepseek-finish-reason.ts

@@ -0,0 +1,20 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+
+export function mapDeepSeekFinishReason(
+  finishReason: string | null | undefined,
+): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case 'stop':
+      return 'stop';
+    case 'length':
+      return 'length';
+    case 'content_filter':
+      return 'content-filter';
+    case 'tool_calls':
+      return 'tool-calls';
+    case 'insufficient_system_resource':
+      return 'error';
+    default:
+      return 'other';
+  }
+}

package/src/deepseek-provider.ts

@@ -0,0 +1,108 @@
+import {
+  LanguageModelV3,
+  NoSuchModelError,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { DeepSeekChatModelId } from './chat/deepseek-chat-options';
+import { DeepSeekChatLanguageModel } from './chat/deepseek-chat-language-model';
+import { VERSION } from './version';
+
+export interface DeepSeekProviderSettings {
+  /**
+   * DeepSeek API key.
+   */
+  apiKey?: string;
+
+  /**
+   * Base URL for the API calls.
+   */
+  baseURL?: string;
+
+  /**
+   * Custom headers to include in the requests.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Custom fetch implementation. You can use it as a middleware to intercept requests,
+   * or to provide a custom fetch implementation for e.g. testing.
+   */
+  fetch?: FetchFunction;
+}
+
+export interface DeepSeekProvider extends ProviderV3 {
+  /**
+Creates a DeepSeek model for text generation.
+*/
+  (modelId: DeepSeekChatModelId): LanguageModelV3;
+
+  /**
+Creates a DeepSeek model for text generation.
+*/
+  languageModel(modelId: DeepSeekChatModelId): LanguageModelV3;
+
+  /**
+Creates a DeepSeek chat model for text generation.
+*/
+  chat(modelId: DeepSeekChatModelId): LanguageModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+export function createDeepSeek(
+  options: DeepSeekProviderSettings = {},
+): DeepSeekProvider {
+  const baseURL = withoutTrailingSlash(
+    options.baseURL ?? 'https://api.deepseek.com',
+  );
+
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'DEEPSEEK_API_KEY',
+          description: 'DeepSeek API key',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/deepseek/${VERSION}`,
+    );
+
+  const createLanguageModel = (modelId: DeepSeekChatModelId) => {
+    return new DeepSeekChatLanguageModel(modelId, {
+      provider: `deepseek.chat`,
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+  };
+
+  const provider = (modelId: DeepSeekChatModelId) =>
+    createLanguageModel(modelId);
+
+  provider.specificationVersion = 'v3' as const;
+  provider.languageModel = createLanguageModel;
+  provider.chat = createLanguageModel;
+
+  provider.embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+
+  return provider;
+}
+
+export const deepseek = createDeepSeek();

package/src/index.ts

@@ -0,0 +1,8 @@
+export { createDeepSeek, deepseek } from './deepseek-provider';
+export type {
+  DeepSeekProvider,
+  DeepSeekProviderSettings,
+} from './deepseek-provider';
+export { VERSION } from './version';
+export type { DeepSeekChatOptions } from './chat/deepseek-chat-options';
+export type { DeepSeekErrorData } from './chat/deepseek-chat-api-types';

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';