@huyooo/ai-chat-core 0.2.44 → 0.3.2

package/src/providers/protocols/qwen.ts

@@ -1,315 +0,0 @@
-/**
- * Qwen Protocol（通义千问 OpenAI 兼容模式 API）
- * 
- * 使用 OpenAI 兼容端点以支持工具调用：
- * https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions
- */
-
-import type {
-  Protocol,
-  ProtocolConfig,
-  ProtocolMessage,
-  ProtocolToolDefinition,
-  ProtocolRequestOptions,
-  RawEvent,
-  RawToolCall,
-} from './types';
-import { DebugLogger } from '../../utils';
-import { friendlyHttpError } from './error-utils';
-
-const logger = DebugLogger.module('QwenProtocol');
-
-// OpenAI 兼容模式端点
-const DEFAULT_QWEN_COMPATIBLE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
-
-/**
- * Qwen Protocol 实现（OpenAI 兼容模式）
- */
-export class QwenProtocol implements Protocol {
-  readonly name = 'qwen';
-  
-  private apiKey: string;
-  private apiUrl: string;
-  
-  constructor(config: ProtocolConfig) {
-    this.apiKey = config.apiKey;
-    // 使用兼容模式端点
-    this.apiUrl = config.apiUrl ?? DEFAULT_QWEN_COMPATIBLE_URL;
-  }
-  
-  /**
-   * 发送请求并返回原始事件流
-   */
-  async *stream(
-    messages: ProtocolMessage[],
-    tools: ProtocolToolDefinition[],
-    options: ProtocolRequestOptions
-  ): AsyncGenerator<RawEvent> {
-    const requestBody = this.buildRequestBody(messages, tools, options);
-    const url = `${this.apiUrl}/chat/completions`;
-    
-    logger.debug('发送 Qwen 请求（兼容模式）', {
-      url,
-      model: options.model,
-      enableThinking: options.enableThinking,
-      toolsCount: tools.length,
-    });
-    
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(requestBody),
-      signal: options.signal,
-    });
-    
-    if (!response.ok) {
-      const errorText = await response.text();
-      logger.error('Qwen API 错误', { status: response.status, body: errorText.slice(0, 500) });
-      yield { type: 'error', error: friendlyHttpError(response.status, errorText, 'Qwen') };
-      return;
-    }
-    
-    const reader = response.body?.getReader();
-    if (!reader) {
-      yield { type: 'error', error: '无法获取响应流' };
-      return;
-    }
-    
-    yield* this.parseSSE(reader, options.enableThinking);
-  }
-  
-  /**
-   * 构建请求体（OpenAI 格式）
-   */
-  private buildRequestBody(
-    messages: ProtocolMessage[],
-    tools: ProtocolToolDefinition[],
-    options: ProtocolRequestOptions
-  ): Record<string, unknown> {
-    const convertedMessages = this.convertMessages(messages);
-    
-    const body: Record<string, unknown> = {
-      model: options.model,
-      messages: convertedMessages,
-      stream: true,
-      // 请求返回 Token 使用统计（Chat Completions 格式）
-      stream_options: { include_usage: true },
-    };
-    
-    // 启用 thinking（Qwen 直接在请求体中设置）
-    if (options.enableThinking) {
-      body.enable_thinking = true;
-      body.thinking_budget = 38400;
-    }
-    
-    // 注意：Qwen 搜索通过 Tavily web_search 工具实现（searchStrategy: tavily）
-    // 不使用原生 enable_search 参数，保持与其他 Provider 一致
-    
-    // 添加工具
-    if (tools.length > 0) {
-      body.tools = tools.map(t => ({
-        type: 'function',
-        function: {
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters,
-        },
-      }));
-    }
-    
-    return body;
-  }
-  
-  /**
-   * 转换消息格式（OpenAI 标准格式）
-   */
-  private convertMessages(messages: ProtocolMessage[]): unknown[] {
-    const result: unknown[] = [];
-    
-    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: unknown[] = [{ type: 'text', text: textContent }];
-            for (const img of msg.images) {
-              content.push({
-                type: 'image_url',
-                image_url: { url: img.startsWith('data:') ? img : `data:image/jpeg;base64,${img}` },
-              });
-            }
-            result.push({ role: 'user', content });
-          } else {
-            result.push({ role: 'user', content: textContent });
-          }
-          break;
-        }
-        
-        case 'assistant':
-          if (msg.toolCalls?.length) {
-            result.push({
-              role: 'assistant',
-              content: msg.content || null,
-              tool_calls: msg.toolCalls.map(tc => ({
-                id: tc.id,
-                type: 'function',
-                function: { name: tc.name, arguments: tc.arguments },
-              })),
-            });
-          } else {
-            result.push({ role: 'assistant', content: msg.content });
-          }
-          break;
-          
-        case 'tool':
-          result.push({
-            role: 'tool',
-            tool_call_id: msg.toolCallId,
-            content: msg.content,
-          });
-          break;
-      }
-    }
-    
-    return result;
-  }
-  
-  /**
-   * 解析 SSE 流（OpenAI 格式）
-   */
-  private async *parseSSE(
-    reader: ReadableStreamDefaultReader<Uint8Array>,
-    enableThinking: boolean
-  ): AsyncGenerator<RawEvent> {
-    const decoder = new TextDecoder();
-    let buffer = '';
-    const toolCallsMap = new Map<number, RawToolCall>();
-    let textStarted = false;
-    let thinkingDone = false;
-    let lastUsage: { promptTokens: number; completionTokens: number; totalTokens: number } | undefined;
-    // 不在 finish_reason 处立即 return，因为 usage chunk 在 finish_reason 之后、[DONE] 之前到达
-    let lastFinishReason: string | undefined;
-    
-    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.startsWith('data:')) continue;
-        
-        const data = line.slice(5).trim();
-        if (!data || data === '[DONE]') {
-          if (data === '[DONE]') {
-            const toolCalls = Array.from(toolCallsMap.values());
-            if (toolCalls.length > 0) {
-              for (const tc of toolCalls) {
-                yield { type: 'tool_call_done', toolCall: tc };
-              }
-              yield { type: 'done', finishReason: 'tool_calls', usage: lastUsage };
-            } else {
-              const reason: RawEvent['finishReason'] = (lastFinishReason === 'tool_calls' || lastFinishReason === 'length' || lastFinishReason === 'error')
-                ? lastFinishReason
-                : 'stop';
-              yield { type: 'done', finishReason: reason, usage: lastUsage };
-            }
-            return;
-          }
-          continue;
-        }
-        
-        try {
-          const json = JSON.parse(data);
-          
-          if (json.usage) {
-            lastUsage = {
-              promptTokens: json.usage.prompt_tokens || 0,
-              completionTokens: json.usage.completion_tokens || 0,
-              totalTokens: json.usage.total_tokens || (json.usage.prompt_tokens || 0) + (json.usage.completion_tokens || 0),
-            };
-          }
-          
-          const choice = json.choices?.[0];
-          if (!choice) continue;
-          
-          const delta = choice.delta;
-          if (!delta) continue;
-          
-          if (enableThinking && delta.reasoning_content && !thinkingDone) {
-            yield { type: 'thinking_delta', delta: delta.reasoning_content };
-          }
-          
-          if (delta.content) {
-            if (enableThinking && !textStarted && !thinkingDone) {
-              thinkingDone = true;
-              yield { type: 'thinking_done' };
-            }
-            textStarted = true;
-            yield { type: 'text_delta', delta: delta.content };
-          }
-          
-          if (delta.tool_calls?.length) {
-            for (const tc of delta.tool_calls) {
-              const index = tc.index ?? 0;
-              const existing = toolCallsMap.get(index);
-              
-              if (existing) {
-                if (tc.function?.arguments) {
-                  existing.arguments += tc.function.arguments;
-                }
-              } else {
-                toolCallsMap.set(index, {
-                  id: tc.id || `call_${index}`,
-                  name: tc.function?.name || '',
-                  arguments: tc.function?.arguments || '',
-                });
-                yield { 
-                  type: 'tool_call_start', 
-                  toolCall: { id: tc.id || `call_${index}`, name: tc.function?.name || '' } 
-                };
-              }
-            }
-          }
-          
-          if (choice.finish_reason) {
-            lastFinishReason = choice.finish_reason;
-          }
-        } catch {
-          // 忽略解析错误
-        }
-      }
-    }
-    
-    // 流异常中断兜底
-    const toolCalls = Array.from(toolCallsMap.values());
-    if (toolCalls.length > 0) {
-      for (const tc of toolCalls) {
-        yield { type: 'tool_call_done', toolCall: tc };
-      }
-      yield { type: 'done', finishReason: 'tool_calls', usage: lastUsage };
-    } else {
-      const reason: RawEvent['finishReason'] = (lastFinishReason === 'tool_calls' || lastFinishReason === 'length' || lastFinishReason === 'error')
-        ? lastFinishReason
-        : 'stop';
-      yield { type: 'done', finishReason: reason, usage: lastUsage };
-    }
-  }
-}
-
-/**
- * 创建 Qwen Protocol
- */
-export function createQwenProtocol(config: ProtocolConfig): QwenProtocol {
-  return new QwenProtocol(config);
-}

package/src/providers/types.ts

@@ -1,264 +0,0 @@
-/**
- * Provider 统一类型定义
- * 
- * 核心设计原则：
- * 1. Adapter 只负责 API 格式转换，不处理业务逻辑
- * 2. Orchestrator 统一处理工具调用循环、消息历史、事件发射
- * 3. 所有 Adapter 返回标准化的 StreamChunk
- */
-
-import type { ChatMessage, Tool } from '../types';
-
-
-/** 简化的工具定义（供 Adapter 使用） */
-import type { JsonSchemaObject } from '../types';
-
-export interface SimpleToolDefinition {
-  name: string;
-  description: string;
-  parameters: JsonSchemaObject;
-}
-
-// ==================== 标准化流式响应 ====================
-
-/** 流式响应块类型 */
-export type StreamChunkType = 
-  | 'text'           // 文本内容
-  | 'thinking'       // 思考内容
-  | 'thinking_done'  // 思考完成
-  | 'tool_call'      // 工具调用请求
-  | 'search_result'  // 搜索结果
-  | 'done'           // 响应完成
-  | 'error';         // 错误
-
-/** 工具调用请求 */
-export interface ToolCallRequest {
-  id: string;
-  name: string;
-  arguments: string;
-  /** Gemini 模型需要的 thought_signature（用于工具调用循环） */
-  thought_signature?: string;
-}
-
-/** 搜索结果项 */
-export interface SearchResultItem {
-  title: string;
-  url: string;
-  snippet: string;
-}
-
-/** 流式响应块 - 所有 Adapter 必须返回此格式 */
-/** Token 使用统计 */
-export interface StreamTokenUsage {
-  promptTokens?: number;
-  completionTokens?: number;
-  totalTokens?: number;
-  reasoningTokens?: number;
-  cachedTokens?: number;
-}
-
-export interface StreamChunk {
-  type: StreamChunkType;
-  
-  // 文本内容 (type: 'text')
-  text?: string;
-  
-  // 思考内容 (type: 'thinking')
-  thinking?: string;
-  
-  // 工具调用 (type: 'tool_call')
-  toolCall?: ToolCallRequest;
-  
-  // 搜索结果 (type: 'search_result')
-  searchResults?: SearchResultItem[];
-  
-  // 完成信号 (type: 'done')
-  finishReason?: 'stop' | 'tool_calls' | 'length' | 'error';
-  /** Token 使用统计（done 事件携带） */
-  usage?: StreamTokenUsage;
-  
-  // 错误信息 (type: 'error')
-  error?: string;
-}
-
-// ==================== 标准化消息格式 ====================
-
-/** 标准化消息 - Orchestrator 内部使用 */
-export interface StandardMessage {
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  content: string;
-  
-  // 图片（用户消息）
-  images?: string[];
-  
-  // 工具调用（assistant 消息）
-  toolCalls?: ToolCallRequest[];
-  
-  // 工具调用 ID（tool 消息）
-  toolCallId?: string;
-  
-  // 工具名称（tool 消息，Gemini 需要）
-  toolName?: string;
-}
-
-// ==================== Adapter 接口 ====================
-
-/** Adapter 配置 */
-export interface AdapterConfig {
-  apiKey: string;
-  apiUrl?: string;
-  /** Tavily API Key（用于统一 Web Search） */
-  tavilyApiKey?: string;
-}
-
-/** 单次调用选项 */
-export interface StreamOnceOptions {
-  /** 模型 ID */
-  model: string;
-  /** 是否启用思考 */
-  enableThinking?: boolean;
-  /** 是否启用搜索 */
-  enableSearch?: boolean;
-  /** 中断信号 */
-  signal: AbortSignal;
-}
-
-/**
- * Provider Adapter 接口
- * 
- * 职责：
- * - 将标准消息转换为 API 特定格式
- * - 调用 API 并返回标准化的 StreamChunk
- * - 不处理工具执行、消息历史维护
- */
-export interface ProviderAdapter {
-  /** 适配器名称 */
-  readonly name: string;
-  
-  /** 支持的模型列表 */
-  readonly supportedModels: string[];
-  
-  /**
-   * 单次流式调用
-   * 
-   * @param messages 标准化消息列表
-   * @param tools 工具定义列表
-   * @param options 调用选项
-   * @returns 标准化的流式响应
-   */
-  streamOnce(
-    messages: StandardMessage[],
-    tools: SimpleToolDefinition[],
-    options: StreamOnceOptions
-  ): AsyncGenerator<StreamChunk>;
-  
-  /**
-   * 检查是否支持指定模型
-   */
-  supportsModel(model: string): boolean;
-}
-
-// ==================== Orchestrator 类型 ====================
-
-export interface ToolExecutionHooks {
-  /** 工具调用 ID（用于把输出归属到具体 tool_call 卡片） */
-  toolCallId: string;
-  /** 工具名称 */
-  toolName: string;
-  /** stdout 增量 */
-  onStdout?: (chunk: string) => void;
-  /** stderr 增量 */
-  onStderr?: (chunk: string) => void;
-}
-
-export type ToolExecutor = (
-  name: string,
-  args: Record<string, unknown>,
-  signal?: AbortSignal,
-  hooks?: ToolExecutionHooks
-) => Promise<object>;
-
-/** 自动运行配置 */
-export interface AutoRunConfig {
-  /** 
-   * 自动运行模式
-   * - 'run-everything': 运行所有内容（自动执行）
-   * - 'manual': 手动批准（每次执行前询问）
-   */
-  mode?: 'run-everything' | 'manual';
-}
-
-/** 工具批准回调函数 */
-export type ToolApprovalCallback = (toolCall: {
-  id: string;
-  name: string;
-  args: Record<string, unknown>;
-}) => Promise<boolean>;
-
-/** 获取自动运行配置回调 */
-export type GetAutoRunConfigCallback = () => Promise<AutoRunConfig | undefined>;
-
-/** Orchestrator 配置 */
-export interface OrchestratorConfig {
-  /** 最大迭代次数 */
-  maxIterations?: number;
-  /** 工具执行器 */
-  executeTool: ToolExecutor;
-  /** 完整的工具列表（用于获取 ui/requiresApproval/timeout），key: 工具名称 */
-  tools?: Map<string, Tool>;
-  /** 自动运行配置（静态配置，优先使用 getAutoRunConfig） */
-  autoRunConfig?: AutoRunConfig;
-  /** 
-   * 动态获取自动运行配置回调
-   * 每次检查工具批准时调用，获取最新配置
-   */
-  getAutoRunConfig?: GetAutoRunConfigCallback;
-  /** 
-   * 工具批准回调（manual 模式使用）
-   * 返回 true 表示批准执行，false 表示跳过
-   */
-  onToolApprovalRequest?: ToolApprovalCallback;
-  /**
-   * 客户端工具名称集合（透传模式）
-   * 
-   * 这些工具不在服务端执行，而是：
-   * 1. 发送 tool_call_request 事件给客户端
-   * 2. 结束本轮对话
-   * 3. 客户端执行后，发新请求继续对话
-   */
-  clientToolNames?: Set<string>;
-  /** 上下文总结回调（走 ai-server 等外部服务） */
-  summarize?: (systemPrompt: string, userPrompt: string) => Promise<string>;
-}
-
-/** Orchestrator 上下文 */
-export interface OrchestratorContext {
-  /** 系统提示 */
-  systemPrompt: string;
-  /** 对话历史（会被修改） */
-  history: ChatMessage[];
-  /** 工具定义 */
-  tools: SimpleToolDefinition[];
-  /** 中断信号 */
-  signal: AbortSignal;
-  /** 图片列表 */
-  images?: string[];
-  /**
-   * 客户端工具名称集合（透传模式）
-   * 
-   * 这些工具不在服务端执行，而是发送 tool_call_request 事件给客户端
-   */
-  clientToolNames?: Set<string>;
-}
-
-/** Orchestrator 选项 */
-export interface OrchestratorOptions {
-  /** 模型 ID */
-  model: string;
-  /** 是否启用思考 */
-  enableThinking?: boolean;
-  /** 是否启用搜索 */
-  enableSearch?: boolean;
-  /** 自动运行配置 */
-  autoRunConfig?: AutoRunConfig;
-}