@huyooo/ai-chat-core 0.2.45 → 0.3.2

package/src/{providers/protocols → protocols}/types.ts

@@ -12,15 +12,31 @@
  * - 工具调用格式差异（由 Family 处理）
  */
 
-import type { ModelFamilyConfig } from '../model-registry';
+import type { ModelFamilyConfig } from '../families';
+
+// ==================== 协议标识 ====================
+
+/**
+ * 内置协议类型标识
+ *
+ * 默认带版本 _v1，当上游 API 有 breaking change 时新增 _v2、_v3 等。
+ */
+export type ProtocolId =
+  | 'ark_v1' | 'deepseek_v1' | 'qwen_v1' | 'glm_v1' | 'moonshot_v1' | 'minimax_v1'
+  | 'vercel_gateway_v1' | 'anthropic_v1' | 'gemini_v1' | 'openai_v1' | 'grok_v1'
+;
+
+/** 从 ProtocolId 提取 base 协议（如 anthropic_v1 → anthropic） */
+export function getBaseProtocol(protocol: string): string {
+  return protocol.replace(/_v\d+$/, '');
+}
 
 // ==================== 原始事件类型 ====================
 
 /**
  * Protocol 原始事件类型
  * 
- * 这是 Protocol 层产出的"原始"事件，
- * 后续由 FamilyBehavior 转换为标准 StreamChunk
+ * Protocol 层产出的事件，Orchestrator 直接消费
  */
 export type RawEventType =
   | 'text_delta'           // 文本增量
@@ -29,14 +45,10 @@ export type RawEventType =
   | 'tool_call_start'      // 工具调用开始
   | 'tool_call_delta'      // 工具调用参数增量
   | 'tool_call_done'       // 工具调用完成
-  | 'search_query'         // 搜索查询
-  | 'search_result'        // 搜索结果
   | 'done'                 // 流结束
   | 'error';               // 错误
 
-/**
- * 原始工具调用
- */
+/** 工具调用 */
 export interface RawToolCall {
   id: string;
   name: string;
@@ -45,26 +57,6 @@ export interface RawToolCall {
   thoughtSignature?: string;
 }
 
-/**
- * Protocol 消息中的工具调用
- */
-export interface ProtocolToolCall {
-  id: string;
-  name: string;
-  arguments: string;
-  /** Gemini 需要的 thoughtSignature */
-  thoughtSignature?: string;
-}
-
-/**
- * 原始搜索结果
- */
-export interface RawSearchResult {
-  title: string;
-  url: string;
-  snippet: string;
-}
-
 /**
  * Protocol 原始事件
  */
@@ -77,23 +69,29 @@ export interface RawTokenUsage {
   cachedTokens?: number;
 }
 
+/** 输出内容片段（用于图片生成、多模态结果等非纯文本产物） */
+export type RawOutputPart =
+  | { type: 'text'; text: string }
+  | { type: 'inline_data'; mimeType: string; data: string };
+
 export interface RawEvent {
   type: RawEventType;
   
   // text_delta / thinking_delta
   delta?: string;
   
+  // thinking_done（Anthropic 的 thinking signature）
+  thinkingSignature?: string;
+  
   // tool_call_*
   toolCall?: Partial<RawToolCall>;
   
-  // search_*
-  searchQuery?: string;
-  searchResults?: RawSearchResult[];
-  
   // done
   finishReason?: 'stop' | 'tool_calls' | 'length' | 'error';
   /** Token 使用统计（done 事件携带） */
   usage?: RawTokenUsage;
+  /** 完整输出片段（done 事件携带；用于图片生成等场景） */
+  outputParts?: RawOutputPart[];
   
   // error
   error?: string;
@@ -110,9 +108,18 @@ export interface ProtocolMessage {
   
   /** 图片列表（base64 或 URL） */
   images?: string[];
+
+  /** 多模态文件附件。Gemini 使用 fileData 引用 Files API URI。 */
+  attachments?: ProtocolAttachment[];
+  
+  /** 思考内容（assistant 消息，工具调用循环需回传给 API） */
+  thinkingContent?: string;
+  
+  /** 思考签名（Anthropic extended thinking 的 signature，工具调用循环需回传） */
+  thinkingSignature?: string;
   
   /** 工具调用（assistant 消息） */
-  toolCalls?: ProtocolToolCall[];
+  toolCalls?: RawToolCall[];
   
   /** 工具调用 ID（tool 消息） */
   toolCallId?: string;
@@ -121,10 +128,13 @@ export interface ProtocolMessage {
   toolName?: string;
 }
 
+export type ProtocolAttachment =
+  | { type: 'file_data'; mimeType: string; fileUri: string };
+
 /**
  * Protocol 工具定义（简化格式）
  */
-import type { JsonSchemaObject } from '../../types';
+import type { JsonSchemaObject } from '../types';
 
 export interface ProtocolToolDefinition {
   name: string;
@@ -140,10 +150,10 @@ export interface ProtocolRequestOptions {
   model: string;
   /** 模型家族配置 */
   familyConfig: ModelFamilyConfig;
+  /** 最大输出 token（从 ModelConfig.maxOutputTokens 直传） */
+  maxOutputTokens: number;
   /** 是否启用 thinking */
   enableThinking: boolean;
-  /** 是否启用搜索 */
-  enableSearch: boolean;
   /** 中断信号 */
   signal: AbortSignal;
 }
@@ -186,4 +196,3 @@ export interface Protocol {
  * Protocol 工厂函数类型
  */
 export type ProtocolFactory = (config: ProtocolConfig) => Protocol;
-

package/src/protocols/vercel-gateway.ts

@@ -0,0 +1,391 @@
+/**
+ * Vercel AI Gateway Protocol（LanguageModelV3）
+ *
+ * 调用 Vercel AI Gateway 内部协议端点 /v3/ai/language-model，
+ * 使用 LanguageModelV3 格式，完整保留各厂商原生能力：
+ * - Gemini: thinking + thoughtSignature（tool call 循环必需）
+ * - GPT: reasoning summary
+ * - Claude: reasoning
+ *
+ * 所有厂商返回统一的事件格式（reasoning-delta / text-delta / tool-call 等），
+ * 厂商特有字段通过 providerMetadata 透传。
+ */
+
+import type {
+  Protocol,
+  ProtocolConfig,
+  ProtocolMessage,
+  ProtocolToolDefinition,
+  ProtocolRequestOptions,
+  RawEvent,
+  RawTokenUsage,
+} from './types';
+import { createModuleLogger } from '../logger';
+import { friendlyHttpError } from './error-utils';
+import { readSSEJsonStream } from './sse-reader';
+import { parseProtocolToolArguments } from './tool-arguments';
+
+const logger = createModuleLogger('VercelGateway');
+
+const GATEWAY_BASE = 'https://ai-gateway.vercel.sh/v3/ai';
+
+// ==================== 消息转换（LanguageModelV3 Prompt） ====================
+
+/**
+ * LanguageModelV3 Prompt 格式：
+ * - system: { role: 'system', content: string }
+ * - user:   { role: 'user', content: [{ type: 'text', text } | { type: 'file', data, mediaType }] }
+ * - assistant: { role: 'assistant', content: [text | reasoning | tool-call] }
+ * - tool:   { role: 'tool', content: [{ type: 'tool-result', ... }] }
+ */
+function convertToPrompt(messages: ProtocolMessage[]): unknown[] {
+  const prompt: unknown[] = [];
+
+  for (const msg of messages) {
+    switch (msg.role) {
+      case 'system':
+        prompt.push({ role: 'system', content: msg.content });
+        break;
+
+      case 'user': {
+        const textContent = msg.content || (msg.images?.length ? '请分析这张图片' : '');
+        const parts: unknown[] = [{ type: 'text', text: textContent }];
+        if (msg.images?.length) {
+          for (const img of msg.images) {
+            const dataUrl = img.startsWith('data:') ? img : `data:image/jpeg;base64,${img}`;
+            parts.push({ type: 'file', data: dataUrl, mediaType: 'image/jpeg' });
+          }
+        }
+        prompt.push({ role: 'user', content: parts });
+        break;
+      }
+
+      case 'assistant': {
+        const parts: unknown[] = [];
+        if (msg.thinkingContent) {
+          // 回传思考内容，Gemini 的 thoughtSignature 在 providerOptions 中
+          const reasoningPart: Record<string, unknown> = { type: 'reasoning', text: msg.thinkingContent };
+          if (msg.toolCalls?.[0]?.thoughtSignature) {
+            reasoningPart.providerOptions = {
+              google: { thoughtSignature: msg.toolCalls[0].thoughtSignature },
+              vertex: { thoughtSignature: msg.toolCalls[0].thoughtSignature },
+            };
+          }
+          parts.push(reasoningPart);
+        }
+        if (msg.toolCalls?.length) {
+          if (msg.content) {
+            parts.push({ type: 'text', text: msg.content });
+          }
+          for (const tc of msg.toolCalls) {
+            // V3 协议要求 input 是对象（Gemini 需要 google.protobuf.Struct）
+            const toolPart: Record<string, unknown> = {
+              type: 'tool-call',
+              toolCallId: tc.id,
+              toolName: tc.name,
+              input: parseProtocolToolArguments(tc.arguments, {
+                protocol: 'vercel-gateway',
+                toolCallId: tc.id,
+                toolName: tc.name,
+              }),
+            };
+            if (tc.thoughtSignature) {
+              toolPart.providerOptions = {
+                google: { thoughtSignature: tc.thoughtSignature },
+                vertex: { thoughtSignature: tc.thoughtSignature },
+              };
+            }
+            parts.push(toolPart);
+          }
+        } else {
+          parts.push({ type: 'text', text: msg.content || '' });
+        }
+        prompt.push({ role: 'assistant', content: parts });
+        break;
+      }
+
+      case 'tool':
+        prompt.push({
+          role: 'tool',
+          content: [{
+            type: 'tool-result',
+            toolCallId: msg.toolCallId || '',
+            toolName: msg.toolName || 'unknown',
+            output: formatToolOutput(msg.content),
+          }],
+        });
+        break;
+    }
+  }
+
+  return prompt;
+}
+
+function formatToolOutput(content: string): { type: 'json'; value: unknown } | { type: 'text'; value: string } {
+  try {
+    return { type: 'json', value: JSON.parse(content) };
+  } catch {
+    return { type: 'text', value: content };
+  }
+}
+
+// ==================== 工具转换 ====================
+
+function convertTools(tools: ProtocolToolDefinition[]): unknown[] | undefined {
+  if (tools.length === 0) return undefined;
+  // V3 协议用 inputSchema（非 parameters），Claude/Bedrock 严格要求此字段
+  return tools.map(t => ({
+    type: 'function',
+    name: t.name,
+    description: t.description,
+    inputSchema: t.parameters,
+  }));
+}
+
+// ==================== Provider Options（thinking 配置） ====================
+
+/**
+ * 根据 model ID 前缀构建厂商特有的 thinking 配置：
+ * - google/*:    providerOptions.google.thinkingConfig
+ * - openai/*:    providerOptions.openai.reasoningEffort + reasoningSummary
+ * - anthropic/*: providerOptions.anthropic.thinking
+ */
+function buildProviderOptions(modelId: string, enableThinking: boolean): Record<string, unknown> | undefined {
+  if (modelId.startsWith('google/')) {
+    if (!enableThinking) return undefined;
+    return {
+      google: { thinkingConfig: { thinkingLevel: 'high', includeThoughts: true } },
+    };
+  }
+  if (modelId.startsWith('openai/')) {
+    return {
+      openai: {
+        reasoningEffort: enableThinking ? 'high' : 'low',
+        reasoningSummary: enableThinking ? 'detailed' : 'auto',
+      },
+    };
+  }
+  if (modelId.startsWith('anthropic/')) {
+    if (!enableThinking) return undefined;
+    return {
+      anthropic: { thinking: { type: 'enabled', budgetTokens: 10000 } },
+    };
+  }
+  return undefined;
+}
+
+// ==================== 请求体构建 ====================
+
+function buildRequestBody(
+  messages: ProtocolMessage[],
+  tools: ProtocolToolDefinition[],
+  options: ProtocolRequestOptions,
+): Record<string, unknown> {
+  const body: Record<string, unknown> = {
+    prompt: convertToPrompt(messages),
+  };
+
+  body.maxOutputTokens = options.maxOutputTokens;
+
+  const providerOptions = buildProviderOptions(options.model, options.enableThinking);
+  if (providerOptions) {
+    body.providerOptions = providerOptions;
+  }
+
+  const convertedTools = convertTools(tools);
+  if (convertedTools) {
+    body.tools = convertedTools;
+  }
+
+  return body;
+}
+
+// ==================== V3 SSE 流解析 ====================
+
+/**
+ * LanguageModelV3 流事件类型：
+ *
+ * 思考:     reasoning-start → reasoning-delta { delta } → reasoning-end
+ * 文本:     text-start → text-delta { delta } → text-end
+ * 工具调用: tool-input-start { toolName } → tool-input-delta { delta } → tool-input-end → tool-call { toolCallId, toolName, input }
+ * 完成:     finish { finishReason, usage }
+ * 错误:     error { error }
+ *
+ * 所有事件都可能携带 providerMetadata（如 Gemini 的 thoughtSignature）
+ */
+/**
+ * 解析 LanguageModelV3 SSE 流
+ *
+ * Layer 1 负责 bytes → JSON，此处做 V3 格式的语义映射。
+ */
+async function* parseV3Stream(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+): AsyncGenerator<RawEvent> {
+  let hasToolCalls = false;
+  const pendingCalls = new Map<string, { name: string; args: string; thoughtSignature?: string }>();
+
+  for await (const event of readSSEJsonStream(reader)) {
+    const type = event.type as string;
+
+    switch (type) {
+      case 'reasoning-delta': {
+        const delta = event.delta as string;
+        if (delta) {
+          yield { type: 'thinking_delta', delta };
+        }
+        break;
+      }
+      case 'reasoning-end': {
+        yield { type: 'thinking_done' };
+        break;
+      }
+
+      case 'text-delta': {
+        const delta = event.delta as string;
+        if (delta) {
+          yield { type: 'text_delta', delta };
+        }
+        break;
+      }
+
+      case 'tool-input-start': {
+        hasToolCalls = true;
+        const id = event.id as string;
+        const name = event.toolName as string;
+        const sig = extractThoughtSignature(event);
+        pendingCalls.set(id, { name, args: '', thoughtSignature: sig });
+        yield { type: 'tool_call_start', toolCall: { id, name } };
+        break;
+      }
+
+      case 'tool-input-delta': {
+        const id = event.id as string;
+        const delta = event.delta as string;
+        if (id && delta) {
+          const pending = pendingCalls.get(id);
+          if (pending) pending.args += delta;
+          yield { type: 'tool_call_delta', toolCall: { id, arguments: delta } };
+        }
+        break;
+      }
+
+      case 'tool-call': {
+        const id = event.toolCallId as string;
+        const name = event.toolName as string;
+        const input = (event.input ?? '{}') as string;
+        const pending = pendingCalls.get(id);
+        const sig = extractThoughtSignature(event) || pending?.thoughtSignature;
+        yield {
+          type: 'tool_call_done',
+          toolCall: {
+            id,
+            name: name || pending?.name || '',
+            arguments: input || pending?.args || '{}',
+            ...(sig ? { thoughtSignature: sig } : {}),
+          },
+        };
+        pendingCalls.delete(id);
+        break;
+      }
+
+      case 'finish': {
+        const rawUsage = event.usage as Record<string, unknown> | undefined;
+        let usage: RawTokenUsage | undefined;
+        if (rawUsage) {
+          const input = rawUsage.inputTokens as Record<string, number> | undefined;
+          const output = rawUsage.outputTokens as Record<string, number> | undefined;
+          usage = {
+            promptTokens: input?.total ?? 0,
+            completionTokens: output?.total ?? 0,
+            totalTokens: (input?.total ?? 0) + (output?.total ?? 0),
+            reasoningTokens: output?.reasoning ?? 0,
+            cachedTokens: input?.cacheRead ?? 0,
+          };
+        }
+        const reason = event.finishReason as Record<string, string> | undefined;
+        const unified = reason?.unified ?? 'stop';
+        const finishReason = hasToolCalls || unified === 'tool-calls' ? 'tool_calls' as const
+          : unified === 'length' ? 'length' as const
+            : unified === 'error' ? 'error' as const
+              : 'stop' as const;
+        yield { type: 'done', finishReason, usage };
+        return;
+      }
+
+      case 'error': {
+        const err = event.error;
+        const msg = typeof err === 'string' ? err : JSON.stringify(err);
+        yield { type: 'error', error: msg };
+        break;
+      }
+    }
+  }
+
+  yield { type: 'done', finishReason: hasToolCalls ? 'tool_calls' : 'stop' };
+}
+
+/** 从 providerMetadata 中提取 Gemini 的 thoughtSignature */
+function extractThoughtSignature(event: Record<string, unknown>): string | undefined {
+  const meta = event.providerMetadata as Record<string, Record<string, unknown>> | undefined;
+  const sig = meta?.vertex?.thoughtSignature ?? meta?.google?.thoughtSignature;
+  return typeof sig === 'string' ? sig : undefined;
+}
+
+// ==================== Protocol 实现 ====================
+
+class VercelGatewayProtocol implements Protocol {
+  readonly name = 'vercel_gateway';
+  private apiKey: string;
+
+  constructor(config: ProtocolConfig) {
+    this.apiKey = config.apiKey;
+  }
+
+  async *stream(
+    messages: ProtocolMessage[],
+    tools: ProtocolToolDefinition[],
+    options: ProtocolRequestOptions,
+  ): AsyncGenerator<RawEvent> {
+    const body = buildRequestBody(messages, tools, options);
+
+    logger.debug({
+      model: options.model,
+      enableThinking: options.enableThinking,
+      toolsCount: tools.length,
+    }, 'Vercel Gateway V3 请求');
+
+    const response = await fetch(`${GATEWAY_BASE}/language-model`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+        'ai-gateway-protocol-version': '0.0.1',
+        'ai-gateway-auth-method': 'api-key',
+        'ai-language-model-specification-version': '3',
+        'ai-language-model-id': options.model,
+        'ai-language-model-streaming': 'true',
+      },
+      body: JSON.stringify(body),
+      signal: options.signal,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error({ status: response.status, body: errorText.slice(0, 500) }, 'Vercel Gateway 错误');
+      yield { type: 'error', error: friendlyHttpError(response.status, errorText, 'Vercel Gateway') };
+      return;
+    }
+
+    const reader = response.body?.getReader();
+    if (!reader) {
+      yield { type: 'error', error: '无法获取响应流' };
+      return;
+    }
+
+    yield* parseV3Stream(reader);
+  }
+}
+
+export function createVercelGatewayProtocol(config: ProtocolConfig): Protocol {
+  return new VercelGatewayProtocol(config);
+}