@hopemyl619/deepseek 0.1.2 → 0.3.0

package/src/deepseek-provider.ts

@@ -1,66 +1,79 @@
-// DeepSeek Provider 工厂
+// DeepSeek Provider - 完全兼容官方 @ai-sdk/deepseek 接口
 
-import { loadApiKey, withoutTrailingSlash } from '@ai-sdk/provider-utils';
-import { DeepSeekChatLanguageModel } from './deepseek-chat-language-model';
+import { loadApiKey } from '@ai-sdk/provider-utils';
 import type { DeepSeekProviderSettings, DeepSeekChatSettings } from './types';
+import { DeepSeekChatLanguageModel } from './deepseek-chat-language-model';
 
-export async function createProvider(options: DeepSeekProviderSettings = {}) {
-  const baseURL = withoutTrailingSlash(
-    options.baseURL || 'https://api.deepseek.com/v1'
-  ) ?? 'https://api.deepseek.com/v1';
+// Provider 接口定义（兼容官方）
+export interface DeepSeekProvider {
+  /**
+   * 创建 DeepSeek 模型用于文本生成
+   */
+  (modelId: string, settings?: DeepSeekChatSettings): DeepSeekChatLanguageModel;
 
-  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;
-  };
+  /**
+   * 创建 DeepSeek 模型用于文本生成
+   */
+  languageModel(modelId: string, settings?: DeepSeekChatSettings): DeepSeekChatLanguageModel;
 
-  const createChatModel = (
-    modelId: string,
-    settings: DeepSeekChatSettings = {}
-  ) => {
-    return new DeepSeekChatLanguageModel(modelId, settings, {
-      baseURL,
-      headers: getHeaders,
-    });
-  };
+  /**
+   * 创建 DeepSeek 聊天模型用于文本生成
+   */
+  chat(modelId: string, settings?: DeepSeekChatSettings): DeepSeekChatLanguageModel;
 
-  const provider = {
-    id: 'deepseek',
-    name: 'DeepSeek AI',
-    async initialize() {
-      // 初始化逻辑：验证配置
-      try {
-        await loadApiKey({
-          apiKey: options.apiKey,
-          environmentVariableName: 'DEEPSEEK_API_KEY',
-          description: 'DeepSeek API key',
-        });
-      } catch (error) {
-        throw new Error(`DeepSeek provider initialization failed: ${error}`);
+  /**
+   * 文本嵌入模型（暂不支持）
+   * @deprecated
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+/**
+ * 创建 DeepSeek Provider
+ * 完全兼容官方 @ai-sdk/deepseek 的 createDeepSeek 函数
+ */
+export async function createDeepSeek(
+  options: DeepSeekProviderSettings = {}
+): Promise<DeepSeekProvider> {
+  // 加载 API Key
+  const apiKey = await loadApiKey({
+    apiKey: options.apiKey,
+    environmentVariableName: 'DEEPSEEK_API_KEY',
+    description: 'DeepSeek API key',
+  });
+
+  const baseURL = options.baseURL || 'https://api.deepseek.com';
+
+  // 创建 provider 函数
+  const providerFunction = function(
+    modelId: string,
+    settings?: DeepSeekChatSettings
+  ): DeepSeekChatLanguageModel {
+    return new DeepSeekChatLanguageModel(
+      modelId,
+      settings,
+      {
+        baseURL,
+        headers: () => ({
+          Authorization: `Bearer ${apiKey}`,
+          ...(options.headers || {}),
+        }),
       }
-    },
-    chat: createChatModel,
+    );
+  } as DeepSeekProvider;
+
+  // 添加方法到 provider 函数对象
+  providerFunction.languageModel = providerFunction;
+  providerFunction.chat = providerFunction;
+  providerFunction.textEmbeddingModel = () => {
+    throw new Error('Text embedding models are not supported for DeepSeek');
   };
 
-  return provider;
+  return providerFunction;
 }
 
-// 默认导出
-export const deepseek = createProvider();
+// 默认导出的 provider 实例
+export const deepseek = createDeepSeek();
+
+// 为了向后兼容，保留 createProvider 作为别名
+export const createProvider = createDeepSeek;

package/src/index.ts

@@ -1,21 +1,18 @@
-// 公开导出
+// 公开导出 - 完全兼容官方 @ai-sdk/deepseek
 
-export { createProvider, deepseek } from './deepseek-provider';
+// 主要导出（与官方一致）
+export { createDeepSeek, deepseek, createProvider } 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 { RequestTransformer } from './utils/request-transformer';
+export { ResponseTransformer } from './utils/response-transformer';
+export { StreamParser } from './utils/stream-parser';
+
+// 类型导出（与官方一致）
 export type {
   DeepSeekProviderSettings,
   DeepSeekChatSettings,
@@ -28,4 +25,10 @@ export type {
   DeepSeekResponse,
   DeepSeekStreamChoice,
   DeepSeekStreamResponse,
-} from './types';
+} from './types';
+
+// VERSION 常量（与官方一致）
+export const VERSION = '0.2.0';
+
+// DeepSeekProvider 类型导出
+export type { DeepSeekProvider } from './deepseek-provider';

package/src/utils/request-transformer.ts

@@ -5,15 +5,8 @@ import type {
   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,
@@ -57,13 +50,18 @@ export class RequestTransformer {
       toolChoice = mode.toolChoice;
     }
 
+    // 如果没有通过 mode 传递工具，检查直接传递的 tools 参数（向后兼容）
+    if (toolsArray.length === 0 && options.tools && options.tools.length > 0) {
+      toolsArray = options.tools;
+      toolChoice = options.toolChoice;
+    }
+
     if (toolsArray.length > 0) {
       transformed.tools = this.transformTools(toolsArray);
       transformed.tool_choice = this.transformToolChoice(toolChoice);
     }
 
-    // 预处理中文参数
-    return this.preprocessor.process(transformed);
+    return transformed;
   }
 
   private transformMessages(messages: LanguageModelV1Prompt): Array<any> {
@@ -150,34 +148,59 @@ export class RequestTransformer {
   }
 
   private transformTools(tools: Array<any>): Array<any> {
-    return tools.map(tool => ({
-      type: 'function',
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.parameters,
-      },
-    }));
+    return tools.map(tool => {
+      // AI SDK V1 格式: { type: 'function', function: { name, description, parameters } }
+      if (tool.type === 'function' && tool.function) {
+        return {
+          type: 'function',
+          function: {
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters,
+          },
+        };
+      }
+
+      // 备用格式（向后兼容）
+      return {
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+        },
+      };
+    });
   }
 
-  private transformToolChoice(toolChoice: any): 'auto' | 'none' | 'required' | string {
+  private transformToolChoice(toolChoice: any): any {
+    // undefined 或 auto -> 'auto'
     if (toolChoice === undefined || toolChoice === 'auto') {
       return 'auto';
     }
+
+    // none -> 'none'
     if (toolChoice === 'none') {
       return 'none';
     }
-    if (toolChoice === 'required') {
+
+    // required -> 'required' (强制调用至少一个工具)
+    if (toolChoice === 'required' || (typeof toolChoice === 'object' && toolChoice.type === 'required')) {
       return 'required';
     }
+
+    // 特定工具: { type: 'tool', toolName: 'function_name' }
     if (typeof toolChoice === 'object' && toolChoice.type === 'tool') {
-      return JSON.stringify({
+      // DeepSeek API 可能支持的格式
+      return {
         type: 'function',
         function: {
           name: toolChoice.toolName,
         },
-      });
+      };
     }
+
+    // 默认: auto
     return 'auto';
   }
 }

package/src/utils/response-transformer.ts

@@ -1,28 +1,30 @@
-// 响应转换器 - V1 API 兼容版本
+// 响应转换器 - 新 AI SDK 格式
 
 import type {
-  LanguageModelV1,
   LanguageModelV1FinishReason,
   LanguageModelV1CallWarning,
   LanguageModelV1FunctionToolCall,
+  LanguageModelV1ContentPart,
 } from '@ai-sdk/provider';
 import type { DeepSeekResponse } from '../types';
 
-// V1 API 返回结果类型
+// 新 AI SDK 返回结果类型
 export interface V1GenerateResult {
-  text?: string;
-  reasoning?: string;
+  content: LanguageModelV1ContentPart[];
+  finishReason: LanguageModelV1FinishReason;
   usage: {
     promptTokens: number;
     completionTokens: number;
   };
-  finishReason: LanguageModelV1FinishReason;
-  toolCalls?: LanguageModelV1FunctionToolCall[];
   rawCall: {
     rawPrompt: unknown;
     rawSettings: Record<string, unknown>;
   };
   warnings?: LanguageModelV1CallWarning[];
+  // 兼容旧格式的字段
+  text?: string;
+  toolCalls?: LanguageModelV1FunctionToolCall[];
+  reasoning?: string;
 }
 
 export class ResponseTransformer {
@@ -36,8 +38,28 @@ export class ResponseTransformer {
       message.tool_calls
     );
 
+    // 转换工具调用
+    const toolCalls = this.transformToolCalls(message.tool_calls);
+
+    // 构建内容数组
+    const content: LanguageModelV1ContentPart[] = [];
+
+    // 添加文本内容
+    if (message.content) {
+      content.push({
+        type: 'text',
+        text: message.content,
+      });
+    }
+
+    // 添加工具调用
+    if (toolCalls.length > 0) {
+      content.push(...toolCalls);
+    }
+
     return {
-      text: message.content || '',
+      content,
+      text: message.content || '', // 兼容旧格式
       finishReason: finishReason as LanguageModelV1FinishReason,
       usage: {
         promptTokens: apiResponse.usage?.prompt_tokens || 0,
@@ -47,7 +69,7 @@ export class ResponseTransformer {
         rawPrompt: '',
         rawSettings: {},
       },
-      toolCalls: this.transformToolCalls(message.tool_calls),
+      toolCalls, // 兼容旧格式
       warnings: [],
     };
   }
@@ -79,6 +101,7 @@ export class ResponseTransformer {
     }
 
     return toolCalls.map((tc: any) => ({
+      type: 'tool-call' as const,
       toolCallType: 'function' as const,
       toolCallId: tc.id,
       toolName: tc.function.name,
@@ -87,4 +110,4 @@ export class ResponseTransformer {
         : JSON.stringify(tc.function.arguments),
     }));
   }
-}
+}

package/src/utils/stream-parser.ts

@@ -28,11 +28,14 @@ interface DeepSeekStreamChunk {
 }
 
 export class StreamParser {
+  private hasToolCalls: boolean = false;
+
   async *parse(body: ReadableStream<Uint8Array>): AsyncIterable<LanguageModelV1StreamPart> {
     const reader = body.getReader();
     const decoder = new TextDecoder('utf-8');
     let buffer = '';
     let partialJson = '';
+    this.hasToolCalls = false; // 重置状态
 
     try {
       while (true) {
@@ -95,6 +98,7 @@ export class StreamParser {
     if (delta?.content) {
       const toolCallData = this.tryParseToolCall(delta.content);
       if (toolCallData) {
+        this.hasToolCalls = true; // 标记有工具调用
         yield {
           type: 'tool-call-delta',
           toolCallType: 'function',
@@ -113,6 +117,7 @@ export class StreamParser {
 
     // 工具调用增量 - 标准 tool_calls 格式
     if (delta?.tool_calls && delta.tool_calls.length > 0) {
+      this.hasToolCalls = true; // 标记有工具调用
       for (const toolCall of delta.tool_calls) {
         yield {
           type: 'tool-call-delta',
@@ -144,6 +149,11 @@ export class StreamParser {
   }
 
   private mapFinishReason(reason: string): 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' | 'unknown' {
+    // 修复：如果有工具调用但 finish_reason 是 "stop"，改为 "tool-calls"
+    if (reason === 'stop' && this.hasToolCalls) {
+      return 'tool-calls';
+    }
+
     const reasonMap: Record<string, 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' | 'unknown'> = {
       'stop': 'stop',
       'length': 'length',

package/dist/index.d.ts

@@ -1,184 +0,0 @@
-import { LanguageModelV1FinishReason, LanguageModelV1FunctionToolCall, LanguageModelV1CallWarning, LanguageModelV1, LanguageModelV1CallOptions, LanguageModelV1StreamPart } from '@ai-sdk/provider';
-
-interface DeepSeekProviderSettings {
-    apiKey?: string;
-    baseURL?: string;
-    headers?: Record<string, string | undefined>;
-}
-interface DeepSeekChatSettings {
-    temperature?: number;
-    topP?: number;
-    maxTokens?: number;
-    presencePenalty?: number;
-    frequencyPenalty?: number;
-}
-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;
-}
-interface DeepSeekToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-interface DeepSeekTool {
-    type: 'function';
-    function: {
-        name: string;
-        description?: string;
-        parameters?: Record<string, any>;
-    };
-}
-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;
-}
-interface DeepSeekChoice {
-    index: number;
-    message: {
-        role: string;
-        content: string | null;
-        tool_calls?: DeepSeekToolCall[];
-    };
-    finish_reason: string;
-}
-interface DeepSeekUsage {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-}
-interface DeepSeekResponse {
-    id: string;
-    object: string;
-    created: number;
-    model: string;
-    choices: DeepSeekChoice[];
-    usage: DeepSeekUsage;
-}
-interface DeepSeekStreamChoice {
-    index: number;
-    delta: {
-        role?: string;
-        content?: string;
-        tool_calls?: DeepSeekToolCall[];
-    };
-    finish_reason?: string;
-}
-interface DeepSeekStreamResponse {
-    id: string;
-    object: string;
-    created: number;
-    model: string;
-    choices: DeepSeekStreamChoice[];
-}
-
-interface V1GenerateResult {
-    text?: string;
-    reasoning?: string;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-    };
-    finishReason: LanguageModelV1FinishReason;
-    toolCalls?: LanguageModelV1FunctionToolCall[];
-    rawCall: {
-        rawPrompt: unknown;
-        rawSettings: Record<string, unknown>;
-    };
-    warnings?: LanguageModelV1CallWarning[];
-}
-declare class ResponseTransformer {
-    transform(apiResponse: DeepSeekResponse): V1GenerateResult;
-    private fixFinishReason;
-    private transformToolCalls;
-}
-
-declare class DeepSeekChatLanguageModel implements LanguageModelV1 {
-    readonly specificationVersion: "v1";
-    readonly provider: "deepseek";
-    readonly modelId: string;
-    readonly settings: Required<DeepSeekChatSettings>;
-    readonly defaultObjectGenerationMode: 'json' | 'tool' | undefined;
-    private baseURL;
-    private headers;
-    private requestTransformer;
-    private responseTransformer;
-    private streamParser;
-    constructor(modelId: string, settings: DeepSeekChatSettings | undefined, config: {
-        baseURL: string;
-        headers: () => Record<string, string>;
-    });
-    doGenerate(options: LanguageModelV1CallOptions): Promise<V1GenerateResult>;
-    doStream(options: LanguageModelV1CallOptions): Promise<{
-        stream: any;
-        rawCall: {
-            rawPrompt: unknown;
-            rawSettings: {};
-        };
-        warnings: never[];
-    }>;
-}
-
-declare function createProvider(options?: DeepSeekProviderSettings): Promise<{
-    id: string;
-    name: string;
-    initialize(): Promise<void>;
-    chat: (modelId: string, settings?: DeepSeekChatSettings) => DeepSeekChatLanguageModel;
-}>;
-declare const deepseek: Promise<{
-    id: string;
-    name: string;
-    initialize(): Promise<void>;
-    chat: (modelId: string, settings?: DeepSeekChatSettings) => DeepSeekChatLanguageModel;
-}>;
-
-declare function validateChatSettings(settings?: DeepSeekChatSettings): Required<DeepSeekChatSettings>;
-
-declare class ChineseParamsPreprocessor {
-    private cityMap;
-    process(request: DeepSeekRequest): DeepSeekRequest;
-    private processMessages;
-    private processTools;
-    private processProperties;
-    private replaceCityNames;
-    addCityMapping(chinese: string, english: string): void;
-    addCityMappings(mappings: Record<string, string>): void;
-}
-
-declare class RequestTransformer {
-    private preprocessor;
-    constructor();
-    transform(modelId: string, options: LanguageModelV1CallOptions): DeepSeekRequest;
-    private transformMessages;
-    private transformTools;
-    private transformToolChoice;
-}
-
-declare class StreamParser {
-    parse(body: ReadableStream<Uint8Array>): AsyncIterable<LanguageModelV1StreamPart>;
-    private processPartialJson;
-    private processChunk;
-    private mapFinishReason;
-    private tryParseToolCall;
-}
-
-export { ChineseParamsPreprocessor, DeepSeekChatLanguageModel, type DeepSeekChatSettings, type DeepSeekChoice, type DeepSeekMessage, type DeepSeekProviderSettings, type DeepSeekRequest, type DeepSeekResponse, type DeepSeekStreamChoice, type DeepSeekStreamResponse, type DeepSeekTool, type DeepSeekToolCall, type DeepSeekUsage, RequestTransformer, ResponseTransformer, StreamParser, createProvider, deepseek, validateChatSettings };