@hopemyl619/deepseek 0.1.0

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@hopemyl619/deepseek",
+  "version": "0.1.0",
+  "description": "DeepSeek provider for the Vercel AI SDK with Chinese parameter preprocessing and automatic finish_reason fix",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "^1.0.2",
+    "@ai-sdk/provider-utils": "^2.0.4"
+  },
+  "devDependencies": {
+    "@ai-sdk/deepseek": "^2.0.11",
+    "@types/node": "^20.0.0",
+    "eslint": "^8.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "peerDependencies": {
+    "ai": "^3.0.0"
+  },
+  "keywords": [
+    "ai",
+    "ai-sdk",
+    "deepseek",
+    "llm",
+    "language-model",
+    "streaming",
+    "tool-calling"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/ai-sdk-deepseek"
+  },
+  "bugs": {
+    "url": "https://github.com/your-username/ai-sdk-deepseek/issues"
+  },
+  "homepage": "https://github.com/your-username/ai-sdk-deepseek#readme"
+}

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

@@ -0,0 +1,98 @@
+// DeepSeek Chat 模型实现
+
+import type {
+  LanguageModelV1,
+  LanguageModelV1CallOptions,
+} from '@ai-sdk/provider';
+import type { DeepSeekChatSettings, DeepSeekResponse } from './types';
+import { validateChatSettings } from './deepseek-chat-settings';
+import { RequestTransformer } from './utils/request-transformer';
+import { ResponseTransformer } from './utils/response-transformer';
+import { StreamParser } from './utils/stream-parser';
+
+export class DeepSeekChatLanguageModel implements LanguageModelV1 {
+  readonly specificationVersion = 'v1' as const;
+  readonly provider = 'deepseek' as const;
+  readonly modelId: string;
+  readonly settings: Required<DeepSeekChatSettings>;
+  readonly defaultObjectGenerationMode: 'json' | 'tool' | undefined = undefined;
+
+  private baseURL: string;
+  private headers: () => Record<string, string>;
+  private requestTransformer: RequestTransformer;
+  private responseTransformer: ResponseTransformer;
+  private streamParser: StreamParser;
+
+  constructor(
+    modelId: string,
+    settings: DeepSeekChatSettings = {},
+    config: {
+      baseURL: string;
+      headers: () => Record<string, string>;
+    }
+  ) {
+    this.modelId = modelId;
+    this.settings = validateChatSettings(settings);
+    this.baseURL = config.baseURL;
+    this.headers = config.headers;
+    this.requestTransformer = new RequestTransformer();
+    this.responseTransformer = new ResponseTransformer();
+    this.streamParser = new StreamParser();
+  }
+
+  async doGenerate(options: LanguageModelV1CallOptions) {
+    const requestBody = this.requestTransformer.transform(this.modelId, options);
+
+    const response = await fetch(`${this.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.headers(),
+      },
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`DeepSeek API error: ${response.status} - ${error}`);
+    }
+
+    const apiResponse = (await response.json()) as DeepSeekResponse;
+    return this.responseTransformer.transform(apiResponse);
+  }
+
+  async doStream(options: LanguageModelV1CallOptions) {
+    const requestBody = {
+      ...this.requestTransformer.transform(this.modelId, options),
+      stream: true,
+    };
+
+    const response = await fetch(`${this.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+        ...this.headers(),
+      },
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`DeepSeek API error: ${response.status} - ${error}`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+
+    return {
+      stream: this.streamParser.parse(response.body) as any,
+      rawCall: {
+        rawPrompt: requestBody as unknown,
+        rawSettings: {},
+      },
+      warnings: [],
+    };
+  }
+}

package/src/deepseek-chat-settings.ts

@@ -0,0 +1,13 @@
+// DeepSeek Chat 模型配置
+
+import type { DeepSeekChatSettings } from './types';
+
+export function validateChatSettings(settings: DeepSeekChatSettings = {}): Required<DeepSeekChatSettings> {
+  return {
+    temperature: settings.temperature ?? 0.7,
+    topP: settings.topP ?? 1.0,
+    maxTokens: settings.maxTokens ?? 4096,
+    presencePenalty: settings.presencePenalty ?? 0,
+    frequencyPenalty: settings.frequencyPenalty ?? 0,
+  };
+}

package/src/deepseek-provider.ts

@@ -0,0 +1,50 @@
+// DeepSeek Provider 工厂
+
+import { loadApiKey, withoutTrailingSlash } from '@ai-sdk/provider-utils';
+import { DeepSeekChatLanguageModel } from './deepseek-chat-language-model';
+import type { DeepSeekProviderSettings, DeepSeekChatSettings } from './types';
+
+export function createDeepSeek(options: DeepSeekProviderSettings = {}) {
+  const baseURL = withoutTrailingSlash(
+    options.baseURL || 'https://api.deepseek.com/v1'
+  ) ?? 'https://api.deepseek.com/v1';
+
+  const getHeaders = (): Record<string, string> => {
+    const apiKeyResult = loadApiKey({
+      apiKey: options.apiKey,
+      environmentVariableName: 'DEEPSEEK_API_KEY',
+      description: 'DeepSeek API key',
+    });
+    // loadApiKey 可能返回 undefined，使用空字符串作为默认值并确保类型为 string
+    const apiKey = (apiKeyResult ?? '') as string;
+    const authHeader: string = 'Bearer ' + apiKey;
+    const result: Record<string, string> = {
+      Authorization: authHeader,
+    };
+    if (options.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        if (typeof value === 'string') {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  };
+
+  const createChatModel = (
+    modelId: string,
+    settings: DeepSeekChatSettings = {}
+  ) => {
+    return new DeepSeekChatLanguageModel(modelId, settings, {
+      baseURL,
+      headers: getHeaders,
+    });
+  };
+
+  return {
+    chat: createChatModel,
+  };
+}
+
+// 默认导出
+export const deepseek = createDeepSeek();

package/src/index.ts

@@ -0,0 +1,31 @@
+// 公开导出
+
+export { createDeepSeek, deepseek } from './deepseek-provider';
+export { DeepSeekChatLanguageModel } from './deepseek-chat-language-model';
+export { validateChatSettings } from './deepseek-chat-settings';
+export {
+  ChineseParamsPreprocessor,
+} from './utils/chinese-params-preprocessor';
+export {
+  RequestTransformer,
+} from './utils/request-transformer';
+export {
+  ResponseTransformer,
+} from './utils/response-transformer';
+export {
+  StreamParser,
+} from './utils/stream-parser';
+
+export type {
+  DeepSeekProviderSettings,
+  DeepSeekChatSettings,
+  DeepSeekMessage,
+  DeepSeekToolCall,
+  DeepSeekTool,
+  DeepSeekRequest,
+  DeepSeekChoice,
+  DeepSeekUsage,
+  DeepSeekResponse,
+  DeepSeekStreamChoice,
+  DeepSeekStreamResponse,
+} from './types';

package/src/types.ts

@@ -0,0 +1,100 @@
+// DeepSeek Provider 类型定义
+
+export interface DeepSeekProviderSettings {
+  apiKey?: string;
+  baseURL?: string;
+  headers?: Record<string, string | undefined>;
+}
+
+export interface DeepSeekChatSettings {
+  temperature?: number;
+  topP?: number;
+  maxTokens?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+}
+
+export interface DeepSeekMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | Array<{
+    type: 'text' | 'image_url';
+    text?: string;
+    image_url?: { url: string };
+  }>;
+  tool_calls?: DeepSeekToolCall[];
+  tool_call_id?: string;
+}
+
+export interface DeepSeekToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface DeepSeekTool {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, any>;
+  };
+}
+
+export interface DeepSeekRequest {
+  model: string;
+  messages: DeepSeekMessage[];
+  temperature?: number;
+  top_p?: number;
+  max_tokens?: number;
+  presence_penalty?: number;
+  frequency_penalty?: number;
+  stream?: boolean;
+  tools?: DeepSeekTool[];
+  tool_choice?: 'auto' | 'none' | 'required' | string;
+}
+
+export interface DeepSeekChoice {
+  index: number;
+  message: {
+    role: string;
+    content: string | null;
+    tool_calls?: DeepSeekToolCall[];
+  };
+  finish_reason: string;
+}
+
+export interface DeepSeekUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+}
+
+export interface DeepSeekResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: DeepSeekChoice[];
+  usage: DeepSeekUsage;
+}
+
+export interface DeepSeekStreamChoice {
+  index: number;
+  delta: {
+    role?: string;
+    content?: string;
+    tool_calls?: DeepSeekToolCall[];
+  };
+  finish_reason?: string;
+}
+
+export interface DeepSeekStreamResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: DeepSeekStreamChoice[];
+}

package/src/utils/chinese-params-preprocessor.ts

@@ -0,0 +1,161 @@
+// 中文参数预处理器
+
+import type { DeepSeekRequest } from '../types';
+
+export class ChineseParamsPreprocessor {
+  private cityMap: Record<string, string> = {
+    // 中国城市
+    '北京': 'Beijing',
+    '上海': 'Shanghai',
+    '广州': 'Guangzhou',
+    '深圳': 'Shenzhen',
+    '杭州': 'Hangzhou',
+    '南京': 'Nanjing',
+    '成都': 'Chengdu',
+    '武汉': 'Wuhan',
+    '西安': 'Xi\'an',
+    '重庆': 'Chongqing',
+    '天津': 'Tianjin',
+    '苏州': 'Suzhou',
+    '长沙': 'Changsha',
+    '青岛': 'Qingdao',
+    '大连': 'Dalian',
+    '厦门': 'Xiamen',
+    '宁波': 'Ningbo',
+    '无锡': 'Wuxi',
+    '佛山': 'Foshan',
+    '东莞': 'Dongguan',
+    '合肥': 'Hefei',
+    '郑州': 'Zhengzhou',
+    '福州': 'Fuzhou',
+    '济南': 'Jinan',
+    '昆明': 'Kunming',
+    '沈阳': 'Shenyang',
+    '长春': 'Changchun',
+    '哈尔滨': 'Harbin',
+    '石家庄': 'Shijiazhuang',
+    '太原': 'Taiyuan',
+    '南昌': 'Nanchang',
+    '南宁': 'Nanning',
+    '贵阳': 'Guiyang',
+    '兰州': 'Lanzhou',
+    '海口': 'Haikou',
+    '呼和浩特': 'Hohhot',
+    '银川': 'Yinchuan',
+    '西宁': 'Xining',
+    '乌鲁木齐': 'Urumqi',
+    '拉萨': 'Lhasa',
+    // 国际城市
+    '伦敦': 'London',
+    '纽约': 'New York',
+    '东京': 'Tokyo',
+    '巴黎': 'Paris',
+    '柏林': 'Berlin',
+    '悉尼': 'Sydney',
+    '洛杉矶': 'Los Angeles',
+    '多伦多': 'Toronto',
+    '新加坡': 'Singapore',
+    '香港': 'Hong Kong',
+    '台北': 'Taipei',
+    '首尔': 'Seoul',
+    '曼谷': 'Bangkok',
+    '迪拜': 'Dubai',
+    '莫斯科': 'Moscow',
+    '旧金山': 'San Francisco',
+    '波士顿': 'Boston',
+    '芝加哥': 'Chicago',
+    '华盛顿': 'Washington',
+    '休斯顿': 'Houston',
+    '费城': 'Philadelphia',
+    '凤凰城': 'Phoenix',
+    '圣迭戈': 'San Diego',
+    '达拉斯': 'Dallas',
+    '圣何塞': 'San Jose',
+    '奥斯汀': 'Austin',
+    '温哥华': 'Vancouver',
+    '蒙特利尔': 'Montreal',
+    '卡尔加里': 'Calgary',
+    '渥太华': 'Ottawa',
+    '魁北克': 'Quebec',
+    '埃德蒙顿': 'Edmonton',
+    '温尼伯': 'Winnipeg',
+    '哈利法克斯': 'Halifax',
+    '维多利亚': 'Victoria',
+  };
+
+  process(request: DeepSeekRequest): DeepSeekRequest {
+    const processed = JSON.parse(JSON.stringify(request));
+
+    // 处理消息内容
+    if (processed.messages) {
+      processed.messages = this.processMessages(processed.messages);
+    }
+
+    // 处理工具参数
+    if (processed.tools) {
+      processed.tools = this.processTools(processed.tools);
+    }
+
+    return processed;
+  }
+
+  private processMessages(messages: any[]): any[] {
+    return messages.map(msg => {
+      if (msg.content && typeof msg.content === 'string') {
+        msg.content = this.replaceCityNames(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        msg.content = msg.content.map((part: any) => {
+          if (part.type === 'text' && part.text) {
+            part.text = this.replaceCityNames(part.text);
+          }
+          return part;
+        });
+      }
+      return msg;
+    });
+  }
+
+  private processTools(tools: any[]): any[] {
+    return tools.map(tool => {
+      if (tool.function?.parameters?.properties) {
+        this.processProperties(tool.function.parameters.properties);
+      }
+      if (tool.function?.description) {
+        tool.function.description = this.replaceCityNames(tool.function.description);
+      }
+      return tool;
+    });
+  }
+
+  private processProperties(properties: any): void {
+    for (const key in properties) {
+      if (properties[key].description) {
+        properties[key].description = this.replaceCityNames(properties[key].description);
+      }
+      if (properties[key].example) {
+        const exampleStr = JSON.stringify(properties[key].example);
+        properties[key].example = JSON.parse(this.replaceCityNames(exampleStr));
+      }
+    }
+  }
+
+  private replaceCityNames(text: string): string {
+    let result = text;
+    for (const [chinese, english] of Object.entries(this.cityMap)) {
+      // 使用正则表达式替换，避免替换部分匹配的词
+      const regex = new RegExp(`\\b${chinese}\\b`, 'g');
+      result = result.replace(regex, english);
+    }
+    return result;
+  }
+
+  // 添加自定义城市映射
+  addCityMapping(chinese: string, english: string): void {
+    this.cityMap[chinese] = english;
+  }
+
+  // 批量添加城市映射
+  addCityMappings(mappings: Record<string, string>): void {
+    Object.assign(this.cityMap, mappings);
+  }
+}

package/src/utils/request-transformer.ts

@@ -0,0 +1,183 @@
+// 请求转换器
+
+import type {
+  LanguageModelV1CallOptions,
+  LanguageModelV1Prompt,
+} from '@ai-sdk/provider';
+import type { DeepSeekRequest } from '../types';
+import { ChineseParamsPreprocessor } from './chinese-params-preprocessor';
+
+export class RequestTransformer {
+  private preprocessor: ChineseParamsPreprocessor;
+
+  constructor() {
+    this.preprocessor = new ChineseParamsPreprocessor();
+  }
+
+  transform(modelId: string, options: LanguageModelV1CallOptions): DeepSeekRequest {
+    const transformed: DeepSeekRequest = {
+      model: modelId,
+      messages: this.transformMessages(options.prompt),
+      stream: false,
+    };
+
+    // 添加温度参数
+    if (options.temperature !== undefined) {
+      transformed.temperature = options.temperature;
+    }
+
+    // 添加 top_p 参数
+    if (options.topP !== undefined) {
+      transformed.top_p = options.topP;
+    }
+
+    // 添加 max_tokens 参数
+    if (options.maxTokens !== undefined) {
+      transformed.max_tokens = options.maxTokens;
+    }
+
+    // 添加 presence_penalty 参数
+    if (options.presencePenalty !== undefined) {
+      transformed.presence_penalty = options.presencePenalty;
+    }
+
+    // 添加 frequency_penalty 参数
+    if (options.frequencyPenalty !== undefined) {
+      transformed.frequency_penalty = options.frequencyPenalty;
+    }
+
+    // 添加工具配置
+    const mode = options.mode;
+    let toolsArray: Array<any> = [];
+    let toolChoice: any;
+
+    // 只有 'regular' 模式支持工具
+    if (mode && mode.type === 'regular') {
+      toolsArray = mode.tools ?? [];
+      toolChoice = mode.toolChoice;
+    }
+
+    if (toolsArray.length > 0) {
+      transformed.tools = this.transformTools(toolsArray);
+      transformed.tool_choice = this.transformToolChoice(toolChoice);
+    }
+
+    // 预处理中文参数
+    return this.preprocessor.process(transformed);
+  }
+
+  private transformMessages(messages: LanguageModelV1Prompt): Array<any> {
+    return messages.map((msg) => {
+      const transformed: any = {
+        role: msg.role,
+      };
+
+      // 处理内容
+      if (msg.content && Array.isArray(msg.content)) {
+        const contentParts: Array<any> = [];
+        let hasToolCalls = false;
+        let toolCallsArray: Array<any> = [];
+
+        for (const part of msg.content) {
+          // 处理文本内容
+          if (part.type === 'text') {
+            contentParts.push({ type: 'text', text: part.text });
+          }
+          // 处理图像内容
+          else if (part.type === 'image') {
+            // V1 image part has 'image' property, convert to data for DeepSeek API
+            const imageData = part.image;
+            if (typeof imageData === 'string') {
+              contentParts.push({ type: 'image_url', image_url: { url: imageData } });
+            } else if (imageData instanceof URL) {
+              contentParts.push({ type: 'image_url', image_url: { url: imageData.toString() } });
+            }
+          }
+          // 处理工具调用 (V1 格式)
+          else if (part.type === 'tool-call') {
+            hasToolCalls = true;
+            toolCallsArray.push({
+              id: part.toolCallId,
+              type: 'function',
+              function: {
+                name: part.toolName,
+                arguments: typeof part.args === 'string' ? part.args : JSON.stringify(part.args),
+              },
+            });
+          }
+          // 处理工具结果 (V1 格式)
+          else if (part.type === 'tool-result') {
+            // Tool results in V1 don't get added to content directly
+            // They are already part of the prompt structure
+          }
+          // 处理推理内容
+          else if (part.type === 'reasoning' || part.type === 'redacted-reasoning') {
+            // DeepSeek API doesn't support reasoning content directly
+            // We'll add it as text if there's a text field
+            if ('text' in part && part.text) {
+              contentParts.push({ type: 'text', text: part.text });
+            }
+          }
+          // 处理文件内容
+          else if (part.type === 'file') {
+            contentParts.push({
+              type: 'text',
+              text: `[File: ${part.filename || 'unnamed'}]`,
+            });
+          }
+          // 其他未知类型
+          else {
+            contentParts.push(part);
+          }
+        }
+
+        // 设置内容
+        if (contentParts.length > 0) {
+          transformed.content = contentParts;
+        }
+
+        // 添加工具调用
+        if (hasToolCalls && toolCallsArray.length > 0) {
+          transformed.tool_calls = toolCallsArray;
+        }
+      } else if (typeof msg.content === 'string') {
+        // 系统消息等内容为字符串的情况
+        transformed.content = msg.content;
+      }
+
+      return transformed;
+    });
+  }
+
+  private transformTools(tools: Array<any>): Array<any> {
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+      },
+    }));
+  }
+
+  private transformToolChoice(toolChoice: any): 'auto' | 'none' | 'required' | string {
+    if (toolChoice === undefined || toolChoice === 'auto') {
+      return 'auto';
+    }
+    if (toolChoice === 'none') {
+      return 'none';
+    }
+    if (toolChoice === 'required') {
+      return 'required';
+    }
+    if (typeof toolChoice === 'object' && toolChoice.type === 'tool') {
+      return JSON.stringify({
+        type: 'function',
+        function: {
+          name: toolChoice.toolName,
+        },
+      });
+    }
+    return 'auto';
+  }
+}