@huyooo/ai-chat-core 0.2.44 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huyooo/ai-chat-core",
-  "version": "0.2.44",
+  "version": "0.3.2",
   "description": "AI Chat Core - HybridAgent with Doubao + Gemini",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,10 +17,20 @@
       "import": "./dist/events.js",
       "default": "./dist/events.js"
     },
-    "./mcp": {
-      "types": "./dist/mcp/index.d.ts",
-      "import": "./dist/mcp/index.js",
-      "default": "./dist/mcp/index.js"
+    "./tool-manager": {
+      "types": "./dist/tool-manager/index.d.ts",
+      "import": "./dist/tool-manager/index.js",
+      "default": "./dist/tool-manager/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js",
+      "default": "./dist/runtime.js"
+    },
+    "./platform": {
+      "types": "./dist/platform.d.ts",
+      "import": "./dist/platform.js",
+      "default": "./dist/platform.js"
     }
   },
   "files": [
@@ -28,25 +38,26 @@
     "src"
   ],
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "npm run clean && npm run build:js && npm run build:types",
+    "build:js": "tsdown",
+    "build:types": "tsc -b tsconfig.json --emitDeclarationOnly",
+    "dev": "tsdown --watch",
     "test": "vitest run",
+    "test:live": "vitest run --config vitest.live.config.ts",
+    "test:all": "npm run test && npm run test:live",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.1",
-    "@ai-sdk/openai": "^1.0.0",
-    "@google/genai": "^1.0.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "ai": "^6.0.3",
-    "openai": "^4.0.0",
-    "zod": "^3.24.0"
+    "@sinclair/typebox": "^0.34.48",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "tsup": "^8.0.0",
+    "tsdown": "^0.21.0",
     "typescript": "^5.0.0",
     "vitest": "^4.0.18"
   },

package/src/adapter/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Adapter 模块导出（barrel）
+ *
+ * - ModelAdapter：按 LLMConfig 路由协议、流式消费 RawEvent
+ * - model-options：从前端 LLMConfig 构建模型列表与上下文展示配置
+ */
+
+export { ModelAdapter } from './model-adapter';
+export {
+  buildModelOptions,
+  getModelContextConfigFromLLM,
+  formatContextWindow,
+  formatPricing,
+} from './model-options';
+
+export type {
+  ModelOption,
+  ModelContextConfig,
+} from './model-options';
+
+export type {
+  ProviderAdapter,
+  AdapterConfig,
+  StreamOnceOptions,
+} from './types';

package/src/adapter/model-adapter.ts

@@ -0,0 +1,196 @@
+/**
+ * ModelAdapter - 模型适配器（Model 中心）
+ *
+ * 直接使用 LLMConfig.models 的 ModelRoute 链，按顺序尝试，支持降级。
+ */
+
+import type {
+  Protocol,
+  ProtocolConfig,
+  ProtocolMessage,
+  ProtocolToolDefinition,
+  RawEvent,
+} from '../protocols/types';
+import { createArkProtocol } from '../protocols/ark';
+import { createDeepSeekProtocol } from '../protocols/deepseek';
+import { createQwenProtocol } from '../protocols/qwen';
+import { createGlmProtocol } from '../protocols/glm';
+import { createMoonshotProtocol } from '../protocols/moonshot';
+import { createMiniMaxProtocol } from '../protocols/minimax';
+import { createVercelGatewayProtocol } from '../protocols/vercel-gateway';
+import { createAnthropicProtocol } from '../protocols/anthropic';
+import { createGeminiProtocol } from '../protocols/gemini';
+import { createOpenAIProtocol } from '../protocols/openai';
+import { createGrokProtocol } from '../protocols/grok';
+import {
+  resolveModelFamilyConfig,
+  type ModelFamilyConfig,
+} from '../families';
+import type { ProviderAdapter, StreamOnceOptions } from './types';
+import type { LLMConfig, ModelRoute } from '../llm-config';
+import { getRouteChain, resolveRouteUrl } from '../llm-config';
+import { createModuleLogger } from '../logger';
+
+const logger = createModuleLogger('ModelAdapter');
+
+/** 内置协议工厂 */
+const BUILTIN_PROTOCOL_FACTORIES: Record<string, (config: ProtocolConfig) => Protocol> = {
+  ark_v1: createArkProtocol,
+  deepseek_v1: createDeepSeekProtocol,
+  qwen_v1: createQwenProtocol,
+  glm_v1: createGlmProtocol,
+  moonshot_v1: createMoonshotProtocol,
+  minimax_v1: createMiniMaxProtocol,
+  vercel_gateway_v1: createVercelGatewayProtocol,
+  anthropic_v1: createAnthropicProtocol,
+  gemini_v1: createGeminiProtocol,
+  openai_v1: createOpenAIProtocol,
+  grok_v1: createGrokProtocol,
+};
+
+export class ModelAdapter implements ProviderAdapter {
+  readonly name = 'model';
+  private llmConfig: LLMConfig;
+  /** 合并内置 + 自定义协议工厂 */
+  private protocolFactories: Record<string, (config: ProtocolConfig) => Protocol>;
+
+  constructor(config: LLMConfig) {
+    this.llmConfig = config;
+    this.protocolFactories = config.protocols
+      ? { ...BUILTIN_PROTOCOL_FACTORIES, ...config.protocols }
+      : BUILTIN_PROTOCOL_FACTORIES;
+    this.validateModels();
+  }
+
+  /** 启动时校验：所有模型的 family 必须可解析，失败立即 throw */
+  private validateModels(): void {
+    const errors: string[] = [];
+    for (const [modelId, modelConfig] of Object.entries(this.llmConfig.models)) {
+      if (!modelConfig) continue;
+      const familyConfig = resolveModelFamilyConfig(modelId, modelConfig, this.llmConfig);
+      if (!familyConfig) {
+        errors.push(`模型 ${modelId}: family "${String(modelConfig.family)}" 无法解析，请检查是否在 MODEL_FAMILIES 或 LLMConfig.families 中定义`);
+      }
+      if (!modelConfig.maxOutputTokens || modelConfig.maxOutputTokens <= 0) {
+        errors.push(`模型 ${modelId}: maxOutputTokens 未指定或无效，请为每个模型显式配置`);
+      }
+      if (!modelConfig.contextWindowTokens || modelConfig.contextWindowTokens <= 0) {
+        errors.push(`模型 ${modelId}: contextWindowTokens 未指定或无效，压缩器依赖此值`);
+      }
+      if (!modelConfig.routes?.length) {
+        errors.push(`模型 ${modelId}: routes 为空，至少需要一条路由`);
+      }
+      for (const route of modelConfig.routes ?? []) {
+        if (!this.protocolFactories[route.protocol]) {
+          errors.push(`模型 ${modelId}: 协议 "${route.protocol}" 未注册，请检查是否在内置协议或 LLMConfig.protocols 中定义`);
+        }
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`LLMConfig 校验失败:\n${errors.join('\n')}`);
+    }
+  }
+
+  private createProtocolForRoute(route: ModelRoute): Protocol {
+    const apiUrl = resolveRouteUrl(route);
+    const apiKey = route.vendorKey ?? route.accessKey;
+    const factory = this.protocolFactories[route.protocol];
+    if (!factory) throw new Error(`未知协议: ${route.protocol}，请在 LLMConfig.protocols 中注册`);
+    return factory({ apiKey, apiUrl });
+  }
+
+  get supportedModels(): string[] {
+    return Object.keys(this.llmConfig.models);
+  }
+
+  supportsModel(model: string): boolean {
+    return getRouteChain(this.llmConfig, model).length > 0;
+  }
+
+  getModelFamilyConfig(model: string): ModelFamilyConfig | undefined {
+    const modelConfig = this.llmConfig.models[model];
+    if (!modelConfig) return undefined;
+    return resolveModelFamilyConfig(model, modelConfig, this.llmConfig);
+  }
+
+  async *streamOnce(
+    messages: ProtocolMessage[],
+    tools: ProtocolToolDefinition[],
+    options: StreamOnceOptions,
+  ): AsyncGenerator<RawEvent> {
+    const filtered = messages.filter(
+      m => !(m.role === 'assistant' && !m.content && !m.toolCalls?.length),
+    );
+    yield* this.streamWithFallback(filtered, tools, options);
+  }
+
+  private async *streamWithFallback(
+    messages: ProtocolMessage[],
+    tools: ProtocolToolDefinition[],
+    options: StreamOnceOptions,
+  ): AsyncGenerator<RawEvent> {
+    const { model } = options;
+
+    const modelConfig = this.llmConfig.models[model];
+    if (!modelConfig) {
+      yield { type: 'error', error: `模型 ${model} 未在 LLMConfig.models 中配置` };
+      return;
+    }
+
+    const familyConfig = resolveModelFamilyConfig(model, modelConfig, this.llmConfig);
+    if (!familyConfig) {
+      yield { type: 'error', error: `模型 ${model} 无法解析家族配置，请在 ModelConfig.family 或 LLMConfig.families 中指定` };
+      return;
+    }
+
+    const chain = getRouteChain(this.llmConfig, model);
+    if (chain.length === 0) {
+      yield { type: 'error', error: `模型 ${model} 无可用路径，请检查 LLMConfig.models` };
+      return;
+    }
+
+    let lastError = '';
+
+    for (let i = 0; i < chain.length; i++) {
+      const route = chain[i];
+      const isLast = i === chain.length - 1;
+
+      try {
+        const protocol = this.createProtocolForRoute(route);
+        let committed = false;
+
+        logger.info({ model, protocol: route.protocol, providerModelId: route.providerModelId, attempt: i + 1, total: chain.length }, '请求 LLM');
+
+        for await (const event of protocol.stream(messages, tools, {
+          model: route.providerModelId,
+          familyConfig,
+          maxOutputTokens: modelConfig.maxOutputTokens,
+          enableThinking: options.enableThinking ?? false,
+          signal: options.signal,
+        })) {
+          if (!committed && event.type === 'error' && !isLast) {
+            lastError = event.error ?? 'unknown';
+            logger.warn({ protocol: route.protocol, error: lastError }, '路径返回错误，降级');
+            break;
+          }
+
+          if (!committed && event.type !== 'error') committed = true;
+          yield event;
+          // 不在 done 时提前 return：否则内层 protocol.stream 的 async generator
+          // 在最后一 yield 之后的收尾（如 GlmProtocol 空流诊断）不会执行。
+        }
+
+        if (committed) return;
+      } catch (err) {
+        lastError = err instanceof Error ? err.message : String(err);
+        if (isLast) {
+          yield { type: 'error', error: lastError };
+          return;
+        }
+        logger.warn({ protocol: route.protocol, error: lastError }, '路径异常，尝试降级');
+      }
+    }
+
+    yield { type: 'error', error: `所有路径均失败: ${lastError}` };
+  }
+}

package/src/adapter/model-options.ts

@@ -0,0 +1,143 @@
+/**
+ * 模型选项与上下文展示配置
+ *
+ * - 从 LLMConfig 推导前端下拉模型列表（capabilities、定价文案、上下文窗口）
+ * - formatPricing / formatContextWindow：人类可读展示
+ */
+
+import type { LLMConfig, ModelConfig, ModelPricing } from '../llm-config';
+import { resolveModelFamilyConfig, type ModelFamilyConfig } from '../families';
+
+// ==================== 工具函数 ====================
+
+/** 将 ModelPricing 格式化为展示用字符串数组：["¥2/M 输入", "¥3/M 输出"] */
+export function formatPricing(pricing: ModelPricing): string[] {
+  const sym = pricing.currency === 'CNY' ? '¥' : '$';
+  const fmtNum = (n: number) => Number.isInteger(n) ? String(n) : n.toFixed(2).replace(/0+$/, '').replace(/\.$/, '');
+  const result: string[] = [];
+
+  result.push(`${sym}${fmtNum(pricing.input)}/M 输入`);
+
+  if (Array.isArray(pricing.output)) {
+    result.push(`${sym}${fmtNum(pricing.output[0])}~${fmtNum(pricing.output[1])}/M 输出`);
+  } else {
+    result.push(`${sym}${fmtNum(pricing.output)}/M 输出`);
+  }
+
+  if (pricing.cached != null) {
+    result.push(`${sym}${fmtNum(pricing.cached)}/M 缓存`);
+  }
+
+  return result;
+}
+
+/** 将 token 数自动推导为人类可读格式："256K" / "1M" / "10M" */
+export function formatContextWindow(tokens: number): string {
+  if (tokens >= 1_000_000 && tokens % 1_000_000 === 0) {
+    return `${tokens / 1_000_000}M`;
+  }
+  if (tokens >= 1_000_000) {
+    const m = tokens / 1_000_000;
+    return Number.isInteger(m) ? `${m}M` : `${parseFloat(m.toFixed(1))}M`;
+  }
+  const k = tokens / 1_000;
+  return Number.isInteger(k) ? `${k}K` : `${parseFloat(k.toFixed(1))}K`;
+}
+
+// ==================== ModelOption（前端显示用） ====================
+
+export interface ModelOption {
+  modelId: string;
+  displayName: string;
+  supportsThinking: boolean;
+  thinkingAlwaysOn?: boolean;
+  supportsVision: boolean;
+  /**
+   * 模型上下文窗口（token）。
+   * 前端据此为 @ 资源区块、历史消息等分配 token 预算，避免拍脑袋硬编码。
+   * 与 {@link ModelContextConfig.contextWindowTokens} 来自同一 ModelConfig 字段。
+   */
+  contextWindowTokens: number;
+  /**
+   * 单次生成允许的最大输出 token。
+   * 前端在估算可用 prompt 预算时需要从 context window 中扣除这部分。
+   */
+  maxOutputTokens: number;
+  tooltip?: {
+    features?: string[];
+    cost?: string[];
+    description?: string;
+  };
+}
+
+/**
+ * 从 LLMConfig 动态构建前端模型列表
+ *
+ * 只返回 visible !== false 的模型。
+ * 所有元数据只从 ModelConfig + familyConfig 取，不查预设库。
+ */
+export function buildModelOptions(config: LLMConfig): ModelOption[] {
+  const result: ModelOption[] = [];
+
+  for (const [modelId, modelConfig] of Object.entries(config.models)) {
+    if (!modelConfig || modelConfig.visible === false) continue;
+
+    const familyConfig = resolveModelFamilyConfig(modelId, modelConfig, config);
+
+    const displayName = modelConfig.displayName ?? modelId;
+    const supportsThinking = modelConfig.supportsThinking;
+    const supportsVision = modelConfig.supportsVision;
+    const thinkingAlwaysOn = familyConfig?.thinkingAlwaysOn ?? false;
+
+    const features: string[] = [];
+    if (supportsVision) features.push('多模态');
+    if (supportsThinking) {
+      features.push(thinkingAlwaysOn ? '深度思考（始终开启）' : '深度思考');
+    }
+    if (modelConfig.contextWindowTokens) {
+      features.push(`长上下文（${formatContextWindow(modelConfig.contextWindowTokens)}）`);
+    }
+
+    result.push({
+      modelId,
+      displayName,
+      supportsThinking,
+      thinkingAlwaysOn,
+      supportsVision,
+      contextWindowTokens: modelConfig.contextWindowTokens,
+      maxOutputTokens: modelConfig.maxOutputTokens,
+      tooltip: {
+        features: features.length > 0 ? features : undefined,
+        cost: modelConfig.pricing ? formatPricing(modelConfig.pricing) : undefined,
+      },
+    });
+  }
+
+  return result;
+}
+
+// ==================== ModelContextConfig（运行时 LLMConfig 感知） ====================
+
+export interface ModelContextConfig {
+  contextWindowTokens: number;
+  maxOutputTokens: number;
+}
+
+/**
+ * 获取模型的 context 配置（从 LLMConfig 感知）
+ *
+ * 只从 ModelConfig 取，不做注册表 fallback。
+ * contextWindowTokens 和 maxOutputTokens 均为必填字段。
+ */
+export function getModelContextConfigFromLLM(
+  modelId: string,
+  config: LLMConfig,
+): ModelContextConfig | undefined {
+  const modelConfig = config.models[modelId];
+  if (!modelConfig) return undefined;
+
+  return {
+    contextWindowTokens: modelConfig.contextWindowTokens,
+    maxOutputTokens: modelConfig.maxOutputTokens,
+  };
+}

package/src/adapter/types.ts

@@ -0,0 +1,41 @@
+/**
+ * Adapter 层类型定义
+ *
+ * 仅包含适配器接口和配置，不含编排器类型。
+ * 编排器类型定义在 orchestrator/types.ts
+ */
+
+import type {
+  RawEvent,
+  ProtocolMessage,
+  ProtocolToolDefinition,
+} from '../protocols/types';
+
+export interface AdapterConfig {
+  apiKey: string;
+  apiUrl?: string;
+}
+
+export interface StreamOnceOptions {
+  model: string;
+  enableThinking?: boolean;
+  signal: AbortSignal;
+}
+
+/**
+ * Provider Adapter 接口
+ *
+ * 职责：协议路由 + 消息格式转换 + 返回 RawEvent 流
+ */
+export interface ProviderAdapter {
+  readonly name: string;
+  readonly supportedModels: string[];
+
+  streamOnce(
+    messages: ProtocolMessage[],
+    tools: ProtocolToolDefinition[],
+    options: StreamOnceOptions
+  ): AsyncGenerator<RawEvent>;
+
+  supportsModel(model: string): boolean;
+}