@huyooo/ai-chat-core 0.2.19 → 0.2.21

package/src/providers/protocols/anthropic.ts

@@ -0,0 +1,406 @@
+/**
+ * Anthropic Protocol（通过 Vercel AI Gateway）
+ * 
+ * 特点：
+ * - 使用 Vercel AI SDK 的 createGateway
+ * - 支持 extended thinking
+ * - 支持工具调用
+ * - 自动处理流式输出
+ * 
+ * 参考: https://vercel.com/docs/ai-gateway
+ */
+
+import { streamText, createGateway, tool } from 'ai';
+import { z } from 'zod';
+import type {
+  Protocol,
+  ProtocolConfig,
+  ProtocolMessage,
+  ProtocolToolDefinition,
+  ProtocolRequestOptions,
+  RawEvent,
+} from './types';
+import { DebugLogger } from '../../utils';
+
+const logger = DebugLogger.module('AnthropicProtocol');
+
+/** Gateway 类型 */
+type GatewayFunction = ReturnType<typeof createGateway>;
+
+/** AI SDK 消息类型 */
+type CoreMessage = Parameters<typeof streamText>[0]['messages'] extends infer M 
+  ? M extends readonly (infer T)[] ? T : never 
+  : never;
+
+/**
+ * Anthropic Protocol 实现（通过 Vercel AI Gateway）
+ */
+export class AnthropicProtocol implements Protocol {
+  readonly name = 'anthropic';
+  
+  private gateway: GatewayFunction;
+  
+  constructor(config: ProtocolConfig) {
+    // 创建 Vercel AI Gateway 客户端
+    this.gateway = createGateway({
+      apiKey: config.apiKey,
+    });
+  }
+  
+  async *stream(
+    messages: ProtocolMessage[],
+    tools: ProtocolToolDefinition[],
+    options: ProtocolRequestOptions
+  ): AsyncGenerator<RawEvent> {
+    logger.debug('使用 Vercel AI Gateway 调用 Claude', {
+      model: options.model,
+      enableThinking: options.enableThinking,
+      toolsCount: tools.length,
+    });
+    
+    try {
+      // 转换消息格式（简化版：只处理 user/assistant 文本消息）
+      const sdkMessages = this.convertMessages(messages);
+      
+      // 构建 streamText 参数
+      const streamParams: Parameters<typeof streamText>[0] = {
+        model: this.gateway(options.model),
+        messages: sdkMessages,
+        maxOutputTokens: options.familyConfig.defaultMaxTokens,
+        abortSignal: options.signal,
+      };
+      
+      // 添加工具（如果有）
+      if (tools.length > 0) {
+        streamParams.tools = this.convertTools(tools);
+      }
+      
+      // 添加 thinking 配置
+      if (options.enableThinking) {
+        streamParams.providerOptions = {
+          anthropic: {
+            thinking: {
+              type: 'enabled',
+              budgetTokens: 10000,
+            },
+          },
+        };
+      }
+      
+      logger.debug('发送请求到 Vercel AI Gateway', { 
+        model: options.model,
+        messagesCount: sdkMessages.length,
+        toolsCount: tools.length,
+        enableThinking: options.enableThinking,
+      });
+      
+      // 调用 streamText
+      const result = streamText(streamParams);
+      
+      // 处理流式响应
+      yield* this.parseStream(result);
+      
+    } catch (error: unknown) {
+      const friendly = extractGatewayErrorMessage(error);
+      logger.error('Vercel AI Gateway 错误', { error: friendly });
+      yield { type: 'error', error: friendly };
+    }
+  }
+  
+  /**
+   * 转换消息格式（ProtocolMessage → AI SDK CoreMessage）
+   * 简化版：主要处理文本消息，工具调用通过历史上下文传递
+   */
+  private convertMessages(messages: ProtocolMessage[]): CoreMessage[] {
+    const result: CoreMessage[] = [];
+    
+    for (const msg of messages) {
+      switch (msg.role) {
+        case 'system':
+          result.push({ role: 'system', content: msg.content });
+          break;
+          
+        case 'user': {
+          // 当只有图片没有文字时提供默认提示
+          const textContent = msg.content || (msg.images?.length ? '请分析这张图片' : '');
+          if (msg.images?.length) {
+            // 多模态消息
+            const content: Array<{ type: 'text'; text: string } | { type: 'image'; image: string }> = [
+              { type: 'text', text: textContent }
+            ];
+            for (const img of msg.images) {
+              content.push({
+                type: 'image',
+                image: img.startsWith('data:') ? img : `data:image/jpeg;base64,${img}`,
+              });
+            }
+            result.push({ role: 'user', content });
+          } else {
+            result.push({ role: 'user', content: textContent });
+          }
+          break;
+        }
+        
+        case 'assistant':
+          // 简化处理：只保留文本内容，工具调用信息暂时忽略
+          // AI SDK 6.x 的工具调用格式较复杂，需要完整的 tool-call/tool-result 对
+          if (msg.content) {
+            result.push({ role: 'assistant', content: msg.content });
+          }
+          break;
+          
+        case 'tool':
+          // 工具结果作为用户消息传递（简化处理）
+          result.push({ 
+            role: 'user', 
+            content: `[工具 ${msg.toolName || 'unknown'} 返回结果]: ${msg.content}` 
+          });
+          break;
+      }
+    }
+    
+    return result;
+  }
+  
+  /**
+   * 转换工具格式（ProtocolToolDefinition → AI SDK tools）
+   * 注意：Vercel Gateway 对工具格式有特殊要求，这里使用标准格式
+   */
+  private convertTools(tools: ProtocolToolDefinition[]): NonNullable<Parameters<typeof streamText>[0]['tools']> {
+    const result: NonNullable<Parameters<typeof streamText>[0]['tools']> = {};
+    
+    for (const t of tools) {
+      // 将 JSON Schema 转换为 zod schema
+      const zodSchema = this.jsonSchemaToZod(t.parameters);
+      // 使用类型断言绕过复杂的泛型类型问题
+      (result as Record<string, unknown>)[t.name] = tool({
+        description: t.description,
+        inputSchema: zodSchema,
+      });
+    }
+    
+    return result;
+  }
+  
+  /**
+   * 将 JSON Schema 转换为 Zod Schema
+   */
+  private jsonSchemaToZod(schema: ProtocolToolDefinition['parameters']): z.ZodType {
+    const shape: Record<string, z.ZodTypeAny> = {};
+    
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      let zodType: z.ZodTypeAny;
+      
+      switch (prop.type) {
+        case 'string':
+          zodType = prop.enum ? z.enum(prop.enum as [string, ...string[]]) : z.string();
+          break;
+        case 'number':
+        case 'integer':
+          zodType = z.number();
+          break;
+        case 'boolean':
+          zodType = z.boolean();
+          break;
+        case 'array':
+          zodType = z.array(z.string()); // 简化处理
+          break;
+        default:
+          zodType = z.unknown();
+      }
+      
+      // 添加描述
+      if (prop.description) {
+        zodType = zodType.describe(prop.description);
+      }
+      
+      // 处理可选性
+      if (!schema.required?.includes(key)) {
+        zodType = zodType.optional();
+      }
+      
+      shape[key] = zodType;
+    }
+    
+    return z.object(shape);
+  }
+  
+  /**
+   * 解析 AI SDK 流式响应
+   */
+  private async *parseStream(
+    result: ReturnType<typeof streamText>
+  ): AsyncGenerator<RawEvent> {
+    const toolCalls = new Map<string, { id: string; name: string; arguments: string }>();
+    let hasThinking = false;
+    let thinkingDone = false;
+    
+    for await (const part of result.fullStream) {
+      switch (part.type) {
+          case 'reasoning-delta':
+            // 处理思考内容（AI SDK 6.x 使用 text 属性）
+            if ('text' in part && part.text) {
+              hasThinking = true;
+              yield { type: 'thinking_delta', delta: part.text };
+            }
+            break;
+            
+          case 'reasoning-end':
+            // 思考结束
+            if (hasThinking && !thinkingDone) {
+              thinkingDone = true;
+              yield { type: 'thinking_done' };
+            }
+            break;
+            
+          case 'text-delta':
+            // 处理文本内容
+            // 如果有 thinking 但还没发送 thinking_done，先发送
+            if (hasThinking && !thinkingDone) {
+              thinkingDone = true;
+              yield { type: 'thinking_done' };
+            }
+            if ('text' in part && part.text) {
+              yield { type: 'text_delta', delta: part.text };
+            }
+            break;
+            
+          case 'tool-call':
+            // 处理工具调用
+            if ('toolCallId' in part && 'toolName' in part) {
+              const toolCallId = part.toolCallId;
+              const toolName = part.toolName;
+              const input = 'input' in part ? part.input : null;
+              const args = input ? (typeof input === 'string' ? input : JSON.stringify(input)) : '{}';
+              
+              // 发送开始事件
+              yield {
+                type: 'tool_call_start',
+                toolCall: { id: toolCallId, name: toolName },
+              };
+              
+              // 保存工具调用信息
+              toolCalls.set(toolCallId, {
+                id: toolCallId,
+                name: toolName,
+                arguments: args,
+              });
+              
+              // 发送完成事件
+              yield {
+                type: 'tool_call_done',
+                toolCall: {
+                  id: toolCallId,
+                  name: toolName,
+                  arguments: args,
+                },
+              };
+            }
+            break;
+            
+          case 'error': {
+            // AI SDK fullStream 产出的 error 事件（如 402 余额不足、500 等）
+            // error 字段结构：{ statusCode?, cause?: { responseBody?, data? } }
+            const sdkError = 'error' in part ? (part as any).error : undefined;
+            const friendly = sdkError
+              ? extractGatewayErrorMessage(sdkError)
+              : '模型请求失败';
+            logger.error('AI SDK stream error 事件', { error: friendly });
+            yield { type: 'error', error: friendly };
+            return;
+          }
+            
+          case 'finish': {
+            // 处理完成
+            const finishReason = toolCalls.size > 0 ? 'tool_calls' :
+                                ('finishReason' in part && part.finishReason === 'stop') ? 'stop' :
+                                ('finishReason' in part && part.finishReason === 'length') ? 'length' : 'stop';
+            
+            // 提取 Token 使用统计
+            // AI SDK 6.x: totalUsage 字段，LanguageModelUsage = { inputTokens, outputTokens }
+            const rawUsage = 'totalUsage' in part ? (part as any).totalUsage 
+              : 'usage' in part ? (part as any).usage 
+              : undefined;
+            const inputTokens = rawUsage?.promptTokens ?? rawUsage?.inputTokens ?? 0;
+            const outputTokens = rawUsage?.completionTokens ?? rawUsage?.outputTokens ?? 0;
+            const usage = rawUsage ? {
+              promptTokens: inputTokens,
+              completionTokens: outputTokens,
+              totalTokens: rawUsage.totalTokens ?? (inputTokens + outputTokens),
+            } : undefined;
+            
+            yield { type: 'done', finishReason, usage };
+            return;
+          }
+        }
+      }
+      
+    // 流结束但没有 finish 事件
+    yield { type: 'done', finishReason: 'stop' };
+  }
+}
+
+/**
+ * 从 Vercel AI Gateway / AI SDK 错误中提取用户友好的错误消息
+ * 
+ * GatewayInternalServerError 结构:
+ *   - error.message: "Insufficient funds..."
+ *   - error.statusCode: 402
+ *   - error.cause?.responseBody: '{"error":{"message":"...","type":"insufficient_funds"}}'
+ *   - error.cause?.statusCode: 402
+ */
+function extractGatewayErrorMessage(error: unknown): string {
+  if (!error || typeof error !== 'object') return '未知错误';
+
+  // 兼容 Error 实例和 AI SDK fullStream error 事件的普通对象
+  const err = error as {
+    message?: string;
+    statusCode?: number;
+    cause?: { statusCode?: number; responseBody?: string; data?: { error?: { message?: string; type?: string } } };
+  };
+
+  // 1. 尝试从 cause.data.error 提取结构化信息
+  const apiError = err.cause?.data?.error;
+  if (apiError?.message) {
+    const statusCode = err.cause?.statusCode || err.statusCode;
+    if (apiError.type === 'insufficient_funds' || statusCode === 402) {
+      return '账户余额不足，请充值后重试';
+    }
+    if (statusCode === 401) {
+      return 'API 认证失败，请检查 API Key 配置';
+    }
+    if (statusCode === 429) {
+      return '请求过于频繁，请稍后重试';
+    }
+    return `API 错误: ${apiError.message}`;
+  }
+
+  // 2. 尝试从 cause.responseBody 解析
+  if (err.cause?.responseBody) {
+    try {
+      const body = JSON.parse(err.cause.responseBody);
+      if (body?.error?.message) {
+        const statusCode = err.cause?.statusCode || err.statusCode;
+        if (body.error.type === 'insufficient_funds' || statusCode === 402) {
+          return '账户余额不足，请充值后重试';
+        }
+        return `API 错误: ${body.error.message}`;
+      }
+    } catch { /* ignore parse error */ }
+  }
+
+  // 3. 按 statusCode 兜底
+  const statusCode = err.statusCode || err.cause?.statusCode;
+  if (statusCode === 402) return '账户余额不足，请充值后重试';
+  if (statusCode === 401) return 'API 认证失败，请检查 API Key 配置';
+  if (statusCode === 429) return '请求过于频繁，请稍后重试';
+  if (statusCode === 503) return '服务暂时不可用，请稍后重试';
+
+  // 4. 直接用 error.message，但截断过长的内容
+  const msg = err.message || '未知错误';
+  return msg.length > 200 ? msg.slice(0, 200) + '...' : msg;
+}
+
+export function createAnthropicProtocol(config: ProtocolConfig): AnthropicProtocol {
+  return new AnthropicProtocol(config);
+}