@hopemyl619/deepseek 0.1.0

package/src/utils/response-transformer.ts

@@ -0,0 +1,90 @@
+// 响应转换器 - V1 API 兼容版本
+
+import type {
+  LanguageModelV1,
+  LanguageModelV1FinishReason,
+  LanguageModelV1CallWarning,
+  LanguageModelV1FunctionToolCall,
+} from '@ai-sdk/provider';
+import type { DeepSeekResponse } from '../types';
+
+// V1 API 返回结果类型
+export interface V1GenerateResult {
+  text?: string;
+  reasoning?: string;
+  usage: {
+    promptTokens: number;
+    completionTokens: number;
+  };
+  finishReason: LanguageModelV1FinishReason;
+  toolCalls?: LanguageModelV1FunctionToolCall[];
+  rawCall: {
+    rawPrompt: unknown;
+    rawSettings: Record<string, unknown>;
+  };
+  warnings?: LanguageModelV1CallWarning[];
+}
+
+export class ResponseTransformer {
+  transform(apiResponse: DeepSeekResponse): V1GenerateResult {
+    const choice = apiResponse.choices?.[0];
+    const message = choice?.message || {};
+
+    // 修复 finish_reason
+    const finishReason = this.fixFinishReason(
+      choice?.finish_reason,
+      message.tool_calls
+    );
+
+    return {
+      text: message.content || '',
+      finishReason: finishReason as LanguageModelV1FinishReason,
+      usage: {
+        promptTokens: apiResponse.usage?.prompt_tokens || 0,
+        completionTokens: apiResponse.usage?.completion_tokens || 0,
+      },
+      rawCall: {
+        rawPrompt: '',
+        rawSettings: {},
+      },
+      toolCalls: this.transformToolCalls(message.tool_calls),
+      warnings: [],
+    };
+  }
+
+  private fixFinishReason(
+    originalFinishReason: string | undefined,
+    toolCalls: any[] | undefined
+  ): string {
+    // 如果有 tool_calls 但 finish_reason 是 "stop"，修复为 "tool-calls"
+    if (toolCalls && toolCalls.length > 0 && originalFinishReason === 'stop') {
+      return 'tool-calls';
+    }
+
+    // 映射其他 finish_reason 值
+    const finishReasonMap: Record<string, string> = {
+      'stop': 'stop',
+      'length': 'length',
+      'content_filter': 'content-filter',
+      'tool_calls': 'tool-calls',
+      'function_call': 'tool-calls',
+    };
+
+    return finishReasonMap[originalFinishReason || ''] || 'stop';
+  }
+
+  private transformToolCalls(toolCalls: any[] | undefined): LanguageModelV1FunctionToolCall[] {
+    if (!toolCalls || toolCalls.length === 0) {
+      return [];
+    }
+
+    return toolCalls.map((tc: any) => ({
+      toolCallType: 'function' as const,
+      toolCallId: tc.id,
+      toolName: tc.function.name,
+      args: typeof tc.function.arguments === 'string'
+        ? tc.function.arguments
+        : JSON.stringify(tc.function.arguments),
+    }));
+  }
+}

package/src/utils/stream-parser.ts

@@ -0,0 +1,176 @@
+// 流解析器
+
+import type { LanguageModelV1StreamPart } from '@ai-sdk/provider';
+import type { DeepSeekStreamResponse, DeepSeekUsage } from '../types';
+
+interface DeepSeekStreamChunk {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    delta: {
+      role?: string;
+      content?: string;
+      tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+          name: string;
+          arguments: string;
+        };
+      }>;
+    };
+    finish_reason?: string;
+  }>;
+  usage?: DeepSeekUsage;
+}
+
+export class StreamParser {
+  async *parse(body: ReadableStream<Uint8Array>): AsyncIterable<LanguageModelV1StreamPart> {
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    let partialJson = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim() === '') continue;
+          if (line.startsWith(':')) continue; // SSE 注释
+
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6).trim();
+            if (data === '[DONE]') {
+              yield* this.processPartialJson(partialJson);
+              partialJson = '';
+              return;
+            }
+
+            try {
+              // 尝试解析 JSON
+              const parsed = JSON.parse(data);
+              yield* this.processPartialJson(partialJson);
+              partialJson = '';
+              yield* this.processChunk(parsed);
+            } catch (e) {
+              // JSON 解析失败，可能是部分数据
+              partialJson += data;
+            }
+          }
+        }
+      }
+
+      // 处理剩余的部分 JSON
+      yield* this.processPartialJson(partialJson);
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  private async *processPartialJson(partialJson: string): AsyncIterable<LanguageModelV1StreamPart> {
+    if (!partialJson.trim()) return;
+
+    try {
+      const parsed = JSON.parse(partialJson);
+      yield* this.processChunk(parsed);
+    } catch (e) {
+      // 仍然无法解析，跳过
+      console.warn('Failed to parse partial JSON:', partialJson);
+    }
+  }
+
+  private async *processChunk(chunk: DeepSeekStreamChunk): AsyncIterable<LanguageModelV1StreamPart> {
+    const delta = chunk.choices?.[0]?.delta;
+
+    // 工具调用增量 - JSON in content 格式
+    if (delta?.content) {
+      const toolCallData = this.tryParseToolCall(delta.content);
+      if (toolCallData) {
+        yield {
+          type: 'tool-call-delta',
+          toolCallType: 'function',
+          toolCallId: toolCallData.id || `tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+          toolName: toolCallData.name,
+          argsTextDelta: JSON.stringify(toolCallData.arguments || {}),
+        } as LanguageModelV1StreamPart;
+      } else {
+        // 普通文本增量
+        yield {
+          type: 'text-delta',
+          textDelta: delta.content,
+        } as LanguageModelV1StreamPart;
+      }
+    }
+
+    // 工具调用增量 - 标准 tool_calls 格式
+    if (delta?.tool_calls && delta.tool_calls.length > 0) {
+      for (const toolCall of delta.tool_calls) {
+        yield {
+          type: 'tool-call-delta',
+          toolCallType: 'function',
+          toolCallId: toolCall.id,
+          toolName: toolCall.function?.name || '',
+          argsTextDelta: toolCall.function?.arguments || '',
+        } as LanguageModelV1StreamPart;
+      }
+    }
+
+    // 完成信号
+    const finishReason = chunk.choices?.[0]?.finish_reason;
+    if (finishReason) {
+      // V1 API: usage 在 finish 类型的 part 中
+      const usage = chunk.usage
+        ? {
+            promptTokens: chunk.usage.prompt_tokens,
+            completionTokens: chunk.usage.completion_tokens,
+          }
+        : { promptTokens: 0, completionTokens: 0 };
+
+      yield {
+        type: 'finish',
+        finishReason: this.mapFinishReason(finishReason),
+        usage,
+      } as LanguageModelV1StreamPart;
+    }
+  }
+
+  private mapFinishReason(reason: string): 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' | 'unknown' {
+    const reasonMap: Record<string, 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' | 'unknown'> = {
+      'stop': 'stop',
+      'length': 'length',
+      'content_filter': 'content-filter',
+      'tool_calls': 'tool-calls',
+      'function_call': 'tool-calls',
+      'error': 'error',
+    };
+    return reasonMap[reason] || 'unknown';
+  }
+
+  private tryParseToolCall(content: string): { id?: string; name: string; arguments: Record<string, unknown> } | null {
+    try {
+      const parsed = JSON.parse(content);
+      // 检查是否是工具调用格式: { name: "...", arguments: {...} }
+      if (parsed && typeof parsed.name === 'string' && (parsed.arguments === undefined || typeof parsed.arguments === 'object')) {
+        return {
+          id: parsed.id,
+          name: parsed.name,
+          arguments: parsed.arguments || {},
+        };
+      }
+    } catch {
+      // JSON 解析失败，不是工具调用
+    }
+    return null;
+  }
+}
+
+