@huyooo/ai-chat-core 0.2.45 → 0.3.3

package/src/providers/unified-adapter.ts

@@ -1,367 +0,0 @@
-/**
- * UnifiedAdapter - 统一适配器
- * 
- * 组合 Protocol + FamilyConfig，产出标准 StreamChunk
- * 
- * 设计原则：
- * 1. Protocol 只负责 HTTP/SSE 通信，产出 RawEvent
- * 2. UnifiedAdapter 根据 FamilyConfig 将 RawEvent 转换为 StreamChunk
- * 3. 所有模型都使用同一个 UnifiedAdapter，行为差异由 FamilyConfig 决定
- * 4. 实现 ProviderAdapter 接口，可与现有 Orchestrator 无缝集成
- */
-
-import type {
-  Protocol,
-  ProtocolMessage,
-  ProtocolToolDefinition,
-  RawEvent,
-} from './protocols';
-import {
-  createArkProtocol,
-  createDeepSeekProtocol,
-  createQwenProtocol,
-  createGeminiProtocol,
-  createOpenAIProtocol,
-  createAnthropicProtocol,
-} from './protocols';
-import {
-  getModelFamily,
-  getModelProtocol,
-  getVisibleModels,
-  type ModelFamilyConfig,
-  type ProtocolId,
-} from './model-registry';
-import type { 
-  ProviderAdapter,
-  StreamChunk, 
-  ToolCallRequest, 
-  SearchResultItem,
-  StandardMessage,
-  SimpleToolDefinition,
-  StreamOnceOptions,
-} from './types';
-import { DebugLogger } from '../utils';
-
-const logger = DebugLogger.module('UnifiedAdapter');
-
-// ==================== 配置类型 ====================
-
-/**
- * UnifiedAdapter 配置
- */
-export interface UnifiedAdapterConfig {
-  /** ARK API Key（豆包/DeepSeek） */
-  arkApiKey?: string;
-  arkApiUrl?: string;
-  
-  /** Qwen API Key（通义千问） */
-  qwenApiKey?: string;
-  qwenApiUrl?: string;
-  
-  /** Gemini API Key */
-  geminiApiKey?: string;
-  geminiApiUrl?: string;
-  
-  /** OpenRouter API Key */
-  openrouterApiKey?: string;
-  openrouterApiUrl?: string;
-  
-  /** Vercel API Key（用于 Vercel AI Gateway 访问 Claude） */
-  vercelApiKey?: string;
-}
-
-/**
- * 流式调用选项
- */
-export interface StreamOptions {
-  /** 模型 ID */
-  model: string;
-  /** 是否启用 thinking */
-  enableThinking?: boolean;
-  /** 是否启用搜索 */
-  enableSearch?: boolean;
-  /** 中断信号 */
-  signal: AbortSignal;
-}
-
-// ==================== UnifiedAdapter ====================
-
-/**
- * 统一适配器
- * 
- * 实现 ProviderAdapter 接口，根据模型自动选择 Protocol，并根据 FamilyConfig 转换事件
- */
-export class UnifiedAdapter implements ProviderAdapter {
-  readonly name = 'unified';
-  
-  /** 支持的模型列表（从 Registry 获取） */
-  get supportedModels(): string[] {
-    return getVisibleModels().map(m => m.id);
-  }
-  
-  private protocols: Map<ProtocolId, Protocol> = new Map();
-  
-  constructor(config: UnifiedAdapterConfig) {
-    // 初始化各 Protocol
-    if (config.arkApiKey) {
-      // 豆包（ARK 原生）
-      this.protocols.set('ark', createArkProtocol({
-        apiKey: config.arkApiKey,
-        apiUrl: config.arkApiUrl,
-      }));
-      // DeepSeek（通过 ARK，但独立 Protocol）
-      this.protocols.set('deepseek', createDeepSeekProtocol({
-        apiKey: config.arkApiKey,
-        apiUrl: config.arkApiUrl,
-      }));
-    }
-    
-    if (config.qwenApiKey) {
-      this.protocols.set('qwen', createQwenProtocol({
-        apiKey: config.qwenApiKey,
-        apiUrl: config.qwenApiUrl,
-      }));
-    }
-    
-    if (config.geminiApiKey) {
-      this.protocols.set('gemini', createGeminiProtocol({
-        apiKey: config.geminiApiKey,
-        apiUrl: config.geminiApiUrl,
-      }));
-    }
-    
-    // OpenAI 通过 OpenRouter 访问
-    if (config.openrouterApiKey) {
-      this.protocols.set('openai', createOpenAIProtocol({
-        apiKey: config.openrouterApiKey,
-        apiUrl: config.openrouterApiUrl,
-      }));
-    }
-    
-    // Anthropic 使用 Vercel AI SDK
-    if (config.vercelApiKey) {
-      this.protocols.set('anthropic', createAnthropicProtocol({
-        apiKey: config.vercelApiKey,
-      }));
-    }
-  }
-  
-  /**
-   * 检查是否支持指定模型
-   */
-  supportsModel(model: string): boolean {
-    const protocol = getModelProtocol(model);
-    return protocol ? this.protocols.has(protocol) : false;
-  }
-  
-  /**
-   * 获取模型的家族配置
-   */
-  getModelFamilyConfig(model: string): ModelFamilyConfig | undefined {
-    return getModelFamily(model);
-  }
-  
-  /**
-   * 实现 ProviderAdapter.streamOnce 接口
-   * 
-   * @param messages 标准消息列表
-   * @param tools 工具定义
-   * @param options 调用选项
-   * @returns 标准 StreamChunk 流
-   */
-  async *streamOnce(
-    messages: StandardMessage[],
-    tools: SimpleToolDefinition[],
-    options: StreamOnceOptions
-  ): AsyncGenerator<StreamChunk> {
-    const { model, enableThinking = false, enableSearch = false, signal } = options;
-    
-    // 转换消息格式（StandardMessage → ProtocolMessage）
-    const protocolMessages: ProtocolMessage[] = messages.map(m => ({
-      role: m.role,
-      content: m.content,
-      images: m.images,
-      toolCalls: m.toolCalls?.map(tc => ({
-        id: tc.id,
-        name: tc.name,
-        arguments: tc.arguments,
-        thoughtSignature: tc.thought_signature,
-      })),
-      toolCallId: m.toolCallId,
-      toolName: m.toolName,
-    }));
-    
-    // 转换工具格式（SimpleToolDefinition → ProtocolToolDefinition）
-    const protocolTools: ProtocolToolDefinition[] = tools;
-    
-    yield* this.stream(protocolMessages, protocolTools, {
-      model,
-      enableThinking,
-      enableSearch,
-      signal,
-    });
-  }
-  
-  /**
-   * 流式调用（内部方法）
-   */
-  private async *stream(
-    messages: ProtocolMessage[],
-    tools: ProtocolToolDefinition[],
-    options: StreamOptions
-  ): AsyncGenerator<StreamChunk> {
-    const { model, enableThinking = false, enableSearch = false, signal } = options;
-    
-    // 获取模型配置
-    const protocolId = getModelProtocol(model);
-    const familyConfig = getModelFamily(model);
-    
-    if (!protocolId) {
-      yield { type: 'error', error: `未知模型: ${model}` };
-      return;
-    }
-    
-    if (!familyConfig) {
-      yield { type: 'error', error: `模型 ${model} 缺少家族配置` };
-      return;
-    }
-    
-    const protocol = this.protocols.get(protocolId);
-    if (!protocol) {
-      yield { type: 'error', error: `Protocol ${protocolId} 未配置` };
-      return;
-    }
-    
-    logger.debug('开始流式调用', {
-      model,
-      protocol: protocolId,
-      family: familyConfig.id,
-      enableThinking,
-      enableSearch,
-    });
-    
-    // 调用 Protocol 获取原始事件流
-    const rawStream = protocol.stream(messages, tools, {
-      model,
-      familyConfig,
-      enableThinking,
-      enableSearch,
-      signal,
-    });
-    
-    // 转换为标准 StreamChunk
-    yield* this.transformEvents(rawStream, familyConfig, enableThinking, enableSearch);
-  }
-  
-  /**
-   * 将 RawEvent 转换为 StreamChunk
-   * 
-   * 根据 FamilyConfig 处理行为差异
-   */
-  private async *transformEvents(
-    rawStream: AsyncGenerator<RawEvent>,
-    familyConfig: ModelFamilyConfig,
-    enableThinking: boolean,
-    enableSearch: boolean
-  ): AsyncGenerator<StreamChunk> {
-    // 状态跟踪
-    let thinkingBuffer = '';
-    let thinkingStarted = false;
-    
-    for await (const event of rawStream) {
-      switch (event.type) {
-        // ========== Thinking 处理 ==========
-        case 'thinking_delta':
-          // 只有启用 thinking 且家族支持时才输出
-          if (enableThinking && familyConfig.supportsThinking && event.delta) {
-            // 去除开头的换行
-            let delta = event.delta;
-            if (!thinkingStarted) {
-              delta = delta.replace(/^\n+/, '');
-              if (delta) thinkingStarted = true;
-            }
-            if (delta) {
-              thinkingBuffer += delta;
-              yield { type: 'thinking', thinking: delta };
-            }
-          }
-          break;
-          
-        case 'thinking_done':
-          if (enableThinking && familyConfig.supportsThinking) {
-            yield { type: 'thinking_done' };
-          }
-          break;
-          
-        // ========== 文本处理 ==========
-        case 'text_delta':
-          if (event.delta) {
-            yield { type: 'text', text: event.delta };
-          }
-          break;
-          
-        // ========== 工具调用处理 ==========
-        case 'tool_call_done':
-          if (event.toolCall) {
-            const toolCall: ToolCallRequest = {
-              id: event.toolCall.id || '',
-              name: event.toolCall.name || '',
-              arguments: event.toolCall.arguments || '{}',
-            };
-            // 保留 Gemini 的 thoughtSignature
-            if (event.toolCall.thoughtSignature) {
-              toolCall.thought_signature = event.toolCall.thoughtSignature;
-            }
-            yield { type: 'tool_call', toolCall };
-          }
-          break;
-          
-        // ========== 搜索结果处理 ==========
-        case 'search_result':
-          if (enableSearch && event.searchResults) {
-            const searchResults: SearchResultItem[] = event.searchResults.map(r => ({
-              title: r.title,
-              url: r.url,
-              snippet: r.snippet,
-            }));
-            yield { type: 'search_result', searchResults };
-          }
-          break;
-          
-        // ========== 完成处理 ==========
-        case 'done':
-          // usage 数据由 protocol 层透传
-          yield {
-            type: 'done',
-            finishReason: event.finishReason || 'stop',
-            // 透传 Token 使用统计
-            usage: event.usage ? {
-              promptTokens: event.usage.promptTokens,
-              completionTokens: event.usage.completionTokens,
-              totalTokens: event.usage.totalTokens,
-              reasoningTokens: event.usage.reasoningTokens,
-              cachedTokens: event.usage.cachedTokens,
-            } : undefined,
-          };
-          break;
-          
-        // ========== 错误处理 ==========
-        case 'error':
-          yield { type: 'error', error: event.error || '未知错误' };
-          break;
-          
-        // 忽略其他事件（如 tool_call_start, tool_call_delta）
-        default:
-          break;
-      }
-    }
-  }
-}
-
-/**
- * 创建 UnifiedAdapter
- */
-export function createUnifiedAdapter(config: UnifiedAdapterConfig): UnifiedAdapter {
-  return new UnifiedAdapter(config);
-}
-

package/src/router.ts

@@ -1,72 +0,0 @@
-/**
- * 模型路由模块
- * 
- * 根据模型 ID 查询对应的 Protocol 和 Family 配置
- */
-
-import { 
-  getModelEntry, 
-  getModelFamily,
-  type ProtocolId, 
-  type ModelFamilyConfig,
-  type ModelRegistryEntry,
-} from './providers/model-registry';
-
-/** Provider 类型 = Protocol 类型 */
-export type ProviderType = ProtocolId;
-
-/** 路由结果 */
-export interface RouteResult {
-  /** Protocol 类型 */
-  provider: ProviderType;
-  /** 是否未注册（使用默认 Provider） */
-  isDefault: boolean;
-  /** 模型注册信息 */
-  registryEntry?: ModelRegistryEntry;
-  /** 模型家族配置 */
-  familyConfig?: ModelFamilyConfig;
-}
-
-/** 默认 Provider（未注册模型的兜底） */
-const DEFAULT_PROVIDER: ProviderType = 'ark';
-
-/**
- * 获取模型的 Provider
- */
-export function routeModelToProvider(model: string): ProviderType {
-  return routeModelWithDetails(model).provider;
-}
-
-/**
- * 获取模型的完整路由信息
- */
-export function routeModelWithDetails(model: string): RouteResult {
-  const registryEntry = getModelEntry(model);
-  if (registryEntry) {
-    return {
-      provider: registryEntry.protocol,
-      registryEntry,
-      familyConfig: getModelFamily(model),
-      isDefault: false,
-    };
-  }
-  
-  return {
-    provider: DEFAULT_PROVIDER,
-    isDefault: true
-  };
-}
-
-/**
- * 获取默认 Provider
- */
-export function getDefaultProvider(): ProviderType {
-  return DEFAULT_PROVIDER;
-}
-
-/**
- * 检查模型是否属于指定 Provider
- */
-export function isModelForProvider(model: string, provider: ProviderType): boolean {
-  return routeModelToProvider(model) === provider;
-}

package/src/tools.ts

@@ -1,162 +0,0 @@
-/**
- * 工具执行器
- */
-
-import type { ToolExecutor } from './types';
-
-/** 危险命令黑名单 */
-const DANGEROUS_COMMANDS = [
-  'rm -rf /', 'rm -rf ~', 'format', 'mkfs', 'dd if=',
-  'shutdown', 'reboot', 'sudo rm', 'sudo format'
-];
-
-function isDangerousCommand(command: string): boolean {
-  const lowerCommand = command.toLowerCase().trim();
-  return DANGEROUS_COMMANDS.some(dangerous => 
-    lowerCommand.includes(dangerous.toLowerCase())
-  );
-}
-
-/**
- * 创建默认工具执行器（Node.js 环境）
- * 
- * 用于执行 shell 命令，包含基本安全检查
- * 支持通过 AbortSignal 取消命令执行
- */
-export function createDefaultToolExecutor(defaultCwd: string = process.cwd()): ToolExecutor {
-  return {
-    async executeCommand(command: string, cwd?: string, signal?: AbortSignal, hooks?: { onStdout?: (chunk: string) => void; onStderr?: (chunk: string) => void }) {
-      // 检查是否已取消
-      if (signal?.aborted) {
-        return { success: false, error: '操作已取消' };
-      }
-      
-      if (isDangerousCommand(command)) {
-        return { success: false, error: '该命令被安全策略阻止' };
-      }
-
-      try {
-        const { spawn } = await import('child_process');
-        
-        return new Promise((resolve) => {
-          let stdout = '';
-          let stderr = '';
-          let killed = false;
-          let killTimer: NodeJS.Timeout | null = null;
-          
-          const child = spawn('sh', ['-c', command], {
-            cwd: cwd || defaultCwd,
-            env: process.env,
-            // 关键：让 sh 及其子进程处于同一进程组，便于取消/超时时“一锅端”
-            // macOS/Linux: 可用负 PID kill 进程组；Windows 会忽略 detached 的语义
-            detached: process.platform !== 'win32',
-          });
-
-          const killProcessTree = (signalName: NodeJS.Signals) => {
-            if (killed) return;
-            killed = true;
-            try {
-              if (process.platform !== 'win32' && typeof child.pid === 'number') {
-                // 负 PID => 发送到该进程组（避免 sh 死了但子进程继续跑）
-                process.kill(-child.pid, signalName);
-              } else {
-                child.kill(signalName);
-              }
-            } catch {
-              try {
-                child.kill(signalName);
-              } catch {
-                // ignore
-              }
-            }
-
-            // 兜底：若 SIGTERM 不生效，短延迟后再 SIGKILL
-            if (killTimer) clearTimeout(killTimer);
-            killTimer = setTimeout(() => {
-              try {
-                if (process.platform !== 'win32' && typeof child.pid === 'number') {
-                  process.kill(-child.pid, 'SIGKILL');
-                } else {
-                  child.kill('SIGKILL');
-                }
-              } catch {
-                // ignore
-              }
-            }, 1500);
-          };
-          
-          // 设置超时
-          const timeout = setTimeout(() => {
-            if (killed) return;
-            killProcessTree('SIGTERM');
-            resolve({ success: false, error: '命令执行超时（30秒）' });
-          }, 30000);
-          
-          // 监听取消信号
-          const abortHandler = () => {
-            if (killed) return;
-            killProcessTree('SIGTERM');
-            clearTimeout(timeout);
-            resolve({ success: false, error: '操作已取消' });
-          };
-          signal?.addEventListener('abort', abortHandler);
-          
-          child.stdout?.on('data', (data) => {
-            const chunk = data.toString();
-            stdout += chunk;
-            hooks?.onStdout?.(chunk);
-          });
-          
-          child.stderr?.on('data', (data) => {
-            const chunk = data.toString();
-            stderr += chunk;
-            hooks?.onStderr?.(chunk);
-          });
-          
-          child.on('close', (code) => {
-            clearTimeout(timeout);
-            signal?.removeEventListener('abort', abortHandler);
-            if (killTimer) {
-              clearTimeout(killTimer);
-              killTimer = null;
-            }
-            
-            if (killed) return;
-            
-            const output = stdout.trim();
-            const errOutput = stderr.trim();
-            
-            if (code === 0) {
-              resolve({ success: true, output: output || errOutput || '执行成功' });
-            } else {
-              // 非零退出码但有输出时，也算成功（某些命令会这样）
-              if (output) {
-                const warning = errOutput ? `\n[警告: ${errOutput}]` : '';
-                resolve({ success: true, output: output + warning });
-              } else if (errOutput) {
-                resolve({ success: false, error: errOutput });
-              } else {
-                resolve({ success: false, error: `命令退出码: ${code}` });
-              }
-            }
-          });
-          
-          child.on('error', (err) => {
-            clearTimeout(timeout);
-            signal?.removeEventListener('abort', abortHandler);
-            if (killTimer) {
-              clearTimeout(killTimer);
-              killTimer = null;
-            }
-            
-            if (!killed) {
-              resolve({ success: false, error: err.message });
-            }
-          });
-        });
-      } catch (error) {
-        return { success: false, error: error instanceof Error ? error.message : String(error) };
-      }
-    }
-  };
-}

package/src/utils.ts

@@ -1,86 +0,0 @@
-/**
- * 调试日志工具
- * 
- * 通过 DebugLogger.enable(true) 全局开启，
- * 通过 DebugLogger.setLogFile(path) 同时写入 JSONL 文件，
- * 各模块通过 DebugLogger.module('Name') 创建带前缀的 logger。
- */
-
-import { appendFileSync } from 'node:fs';
-
-let enabled = false;
-let logFilePath: string | null = null;
-
-export class DebugLogger {
-  private prefix: string;
-
-  private constructor(prefix: string) {
-    this.prefix = prefix;
-  }
-
-  /** 全局启停调试日志 */
-  static enable(value: boolean): void {
-    enabled = value;
-  }
-
-  /** 查询是否已启用 */
-  static isEnabled(): boolean {
-    return enabled;
-  }
-
-  /** 设置日志文件路径（JSONL 格式，追加写入） */
-  static setLogFile(filePath: string): void {
-    logFilePath = filePath;
-  }
-
-  /** 创建模块专用 logger */
-  static module(name: string): DebugLogger {
-    return new DebugLogger(`[${name}]`);
-  }
-
-  debug(...args: unknown[]): void {
-    if (enabled) {
-      console.debug(this.prefix, ...args);
-      this.writeToFile('debug', args);
-    }
-  }
-
-  info(...args: unknown[]): void {
-    if (enabled) {
-      console.info(this.prefix, ...args);
-      this.writeToFile('info', args);
-    }
-  }
-
-  warn(...args: unknown[]): void {
-    if (enabled) {
-      console.warn(this.prefix, ...args);
-      this.writeToFile('warn', args);
-    }
-  }
-
-  error(...args: unknown[]): void {
-    if (enabled) {
-      console.error(this.prefix, ...args);
-      this.writeToFile('error', args);
-    }
-  }
-
-  private writeToFile(level: string, args: unknown[]): void {
-    if (!logFilePath) return;
-    try {
-      const entry = JSON.stringify({
-        t: Date.now(),
-        level,
-        module: this.prefix,
-        args: args.map(a => {
-          try { return typeof a === 'string' ? a : JSON.parse(JSON.stringify(a)); }
-          catch { return String(a); }
-        }),
-      });
-      appendFileSync(logFilePath, entry + '\n');
-    } catch {
-      // 写文件失败不影响主流程
-    }
-  }
-}