@huyooo/ai-chat-core 0.2.45 → 0.3.2

package/src/llm-config.ts

@@ -0,0 +1,137 @@
+/**
+ * LLM 配置（Model 中心）
+ *
+ * LLMConfig.models 是模型的唯一真相源：
+ * - key = 模型 ID（自定义字符串）
+ * - value = ModelConfig（路由 + 元数据）
+ * - 前端只展示这里配置的模型
+ * - 每个模型必须显式指定 family，不做任何隐式推导
+ */
+
+import type { ProtocolFactory, Protocol, ProtocolConfig } from './protocols';
+import type { ModelFamilyConfig, ModelFamilyId } from './families';
+
+/** 模型定价（每百万 tokens） */
+export interface ModelPricing {
+  currency: 'CNY' | 'USD';
+  /** 输入价格（每百万 tokens） */
+  input: number;
+  /** 输出价格，单值或 [最低, 最高] 区间（如思考/非思考差价） */
+  output: number | [number, number];
+  /** 缓存命中价格（每百万 tokens，部分模型支持） */
+  cached?: number;
+}
+
+/** 单条模型访问路径 */
+export interface ModelRoute {
+  /** 基础 URL */
+  baseUrl: string;
+  /** 访问 key（代理 token 或厂商 key） */
+  accessKey: string;
+  /** 可选，透传给厂商的 key（BYOK，优先于 accessKey） */
+  vendorKey?: string;
+  /** 协议类型（内置或自定义 protocolId） */
+  protocol: string;
+  /** 该供应商 API 要求的 model 名 */
+  providerModelId: string;
+  /** 协议子路径，直连 ''，代理 '/openai' 等 */
+  path?: string;
+}
+
+/** 模型配置（路由 + 元数据） */
+export interface ModelConfig {
+  /** 路由链（数组顺序 = 降级优先级） */
+  routes: ModelRoute[];
+  /** 显示名称（不传则从预设库补全，再 fallback 到 modelId） */
+  displayName?: string;
+  /**
+   * 所属家族（决定 thinking/toolCall 行为）——必填，不做任何隐式推导
+   * - 字符串：引用内置 ModelFamilyId 或 LLMConfig.families 中的自定义 familyId
+   * - 对象：内联自定义家族配置
+   */
+  family: ModelFamilyId | ModelFamilyConfig;
+  /** 是否在前端模型选择器中显示（默认 true） */
+  visible?: boolean;
+  /** 是否支持深度思考（必填，不做隐式推导） */
+  supportsThinking: boolean;
+  /** 是否支持图片理解（必填，不做隐式推导） */
+  supportsVision: boolean;
+  /** 上下文窗口 token 数（必填，压缩器依赖此值计算预算，前端展示自动推导为 "256K" 格式） */
+  contextWindowTokens: number;
+  /** 定价信息（结构化，展示时自动格式化） */
+  pricing?: ModelPricing;
+  /** 最大输出 token（必填，每个模型限制不同，不做隐式推导） */
+  maxOutputTokens: number;
+}
+
+/**
+ * 压缩模型配置（可选，不配则用默认值）
+ *
+ * 历史压缩直接复用当前对话模型，零配置。
+ * 仅单条超长消息（如用户粘贴巨量文本）需要长上下文模型。
+ */
+export interface CompressionConfig {
+  /** 超长内容压缩模型（默认 qwen-long） */
+  longModel?: string;
+}
+
+/** 完整 LLM 配置 */
+export interface LLMConfig {
+  /**
+   * 模型配置（唯一真相源）
+   *
+   * key = 模型 ID，value = 路由 + 元数据。
+   * 前端模型选择器只展示这里 visible !== false 的模型。
+   */
+  models: Record<string, ModelConfig>;
+
+  /**
+   * 自定义协议工厂（可插拔）
+   *
+   * key = 自定义 protocolId，value = Protocol 工厂函数。
+   * ModelRoute.protocol 引用此处的 key 或内置 protocolId。
+   */
+  protocols?: Record<string, ProtocolFactory>;
+
+  /**
+   * 自定义家族配置（可插拔）
+   *
+   * key = 自定义 familyId，value = ModelFamilyConfig。
+   * ModelConfig.family 引用此处的 key 或内置 familyId。
+   */
+  families?: Record<string, ModelFamilyConfig>;
+
+  /** 压缩模型配置（可选） */
+  compression?: CompressionConfig;
+}
+
+/** 解析 route 的完整 API URL */
+export function resolveRouteUrl(route: ModelRoute): string {
+  const p = route.path ?? '';
+  return p ? `${route.baseUrl.replace(/\/$/, '')}${p}` : route.baseUrl;
+}
+
+/**
+ * 获取模型的 route 链（按优先级）
+ */
+export function getRouteChain(
+  config: LLMConfig,
+  modelId: string,
+): ModelRoute[] {
+  return config.models?.[modelId]?.routes ?? [];
+}
+
+/**
+ * 查找第一个支持指定 protocol 的 route
+ */
+export function findRouteByProtocol(
+  config: LLMConfig,
+  protocolId: string,
+): ModelRoute | undefined {
+  for (const modelConfig of Object.values(config.models)) {
+    if (!modelConfig?.routes) continue;
+    const found = modelConfig.routes.find(r => r.protocol === protocolId);
+    if (found) return found;
+  }
+  return undefined;
+}

package/src/logger/core.ts

@@ -0,0 +1,96 @@
+/**
+ * Pino 日志核心（与 SuperX 架构一致）
+ *
+ * 使用 pino.multistream + pino.destination，避免 pino.transport（打包后 worker 不可用）。
+ * - 开发：pino-pretty 输出到 stdout
+ * - 生产：JSON 输出 + 可选文件持久化
+ * - 模块：child({ module: 'Name' }) 创建带前缀的 logger
+ */
+import pino, { type Logger } from 'pino';
+import pinoPretty from 'pino-pretty';
+import path from 'node:path';
+import fs from 'node:fs';
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+export interface LoggerConfig {
+  /** 日志级别 */
+  level?: LogLevel;
+  /** 用户数据目录（用于 logs/ai-chat.log） */
+  baseDir?: string;
+  /** 是否开发模式（使用 pino-pretty） */
+  isDev?: boolean;
+}
+
+let rootLogger: Logger | null = null;
+
+function isDev(): boolean {
+  return process.env.NODE_ENV === 'development';
+}
+
+function getLogLevel(): LogLevel {
+  const v = process.env.LOG_LEVEL?.toLowerCase();
+  if (v && ['debug', 'info', 'warn', 'error'].includes(v)) return v as LogLevel;
+  return isDev() ? 'debug' : 'info';
+}
+
+/**
+ * 创建默认 logger（无文件，仅 stdout）
+ */
+function createDefaultLogger(): Logger {
+  const level = getLogLevel();
+  if (isDev()) {
+    const stream = pinoPretty({ colorize: true, translateTime: 'SYS:standard' });
+    return pino({ level }, stream);
+  }
+  return pino({ level }, pino.destination(1));
+}
+
+/**
+ * 创建完整配置的 logger
+ * 使用 multistream + destination，避免 pino.transport（Electron 打包后不可用）
+ */
+function createFullLogger(config: LoggerConfig): Logger {
+  const level = config.level ?? (config.isDev ? 'debug' : 'info');
+  const streams: Parameters<typeof pino.multistream>[0] = [];
+
+  if (config.isDev) {
+    streams.push({ stream: pinoPretty({ colorize: true, translateTime: 'SYS:standard' }), level });
+  } else {
+    streams.push({ stream: pino.destination(1), level });
+  }
+
+  if (config.baseDir) {
+    const logsDir = path.join(config.baseDir, 'logs');
+    try {
+      fs.mkdirSync(logsDir, { recursive: true });
+    } catch {
+      // 忽略
+    }
+    const logPath = path.join(logsDir, 'ai-chat.log');
+    streams.push({ stream: pino.destination(logPath), level });
+  }
+
+  return pino({ level }, pino.multistream(streams));
+}
+
+/**
+ * 初始化 logger（应在 app.whenReady 后调用）
+ */
+export function initLogger(config: LoggerConfig): void {
+  rootLogger = createFullLogger(config);
+}
+
+/**
+ * 获取 root logger，未初始化时返回默认 logger
+ */
+export function getLogger(): Logger {
+  return rootLogger ?? createDefaultLogger();
+}
+
+/**
+ * 创建模块专用 logger（替代原 DebugLogger.module）
+ */
+export function createModuleLogger(moduleName: string): Logger {
+  return getLogger().child({ module: moduleName });
+}

package/src/logger/index.ts

@@ -0,0 +1,8 @@
+/**
+ * 日志模块导出（barrel）
+ *
+ * - 基于 `core` 的 init / get / createModuleLogger
+ * - 与 SuperX 一致：开发 pretty、生产 JSON、可选落盘
+ */
+export { initLogger, getLogger, createModuleLogger } from './core';
+export type { LogLevel, LoggerConfig } from './core';

package/src/orchestrator/compression-handler.ts

@@ -0,0 +1,137 @@
+/**
+ * 压缩处理器
+ *
+ * 从 orchestrator 提取的两个独立压缩逻辑：
+ * 1. compactIfNeeded — 历史消息整体压缩
+ * 2. compressSingleMessageIfNeeded — 单条超长 user 消息压缩
+ */
+
+import type { ProtocolMessage } from '../protocols';
+import type {
+  CompactStartEvent,
+  CompactEndEvent,
+  ContentCompressStartEvent,
+  ContentCompressEndEvent,
+} from '../events';
+import {
+  createCompactStart,
+  createCompactEnd,
+  createContentCompressStart,
+  createContentCompressEnd,
+} from '../events';
+import {
+  needsCompaction,
+  estimateTotalTokens,
+  estimateMessageTokens,
+  getPromptBudget,
+  needsSingleMessageCompression,
+  type CompactConfig,
+} from './context-compressor';
+import { summarizeHistory, compressSingleMessage } from './context-summarizer';
+import { createModuleLogger } from '../logger';
+import type { CompressionConfig } from '../llm-config';
+import type { SummarizeFn } from './context-summarizer';
+
+const DEFAULT_LONG_MODEL = 'qwen-long';
+
+const logger = createModuleLogger('Compression');
+
+/**
+ * 历史消息整体压缩
+ *
+ * 当消息总 token 超出 context window 预算时，
+ * 直接用当前对话模型压缩历史（无需额外配置）。
+ *
+ * 历史压缩触发点 = context window budget，远小于超长阈值（800K），
+ * 所以不会出现需要切长上下文模型的场景。
+ */
+export async function* compactIfNeeded(
+  messages: ProtocolMessage[],
+  compactConfig: CompactConfig,
+  summarizeFn?: SummarizeFn,
+  currentModel?: string,
+): AsyncGenerator<CompactStartEvent | CompactEndEvent, ProtocolMessage[]> {
+  if (!needsCompaction(messages, compactConfig)) {
+    return messages;
+  }
+
+  if (!summarizeFn || !currentModel) {
+    logger.warn('上下文超限但未配置 summarize 回调或模型，跳过压缩');
+    return messages;
+  }
+
+  const model = currentModel;
+
+  const compactStartedAt = Date.now();
+  const tokensBeforeCompact = estimateTotalTokens(messages);
+  const budget = getPromptBudget(compactConfig);
+  const originalCount = messages.length;
+
+  yield createCompactStart(tokensBeforeCompact, budget);
+
+  const { messages: result, success, summaryContent } = await summarizeHistory(
+    summarizeFn, messages, compactConfig, model,
+  );
+
+  yield createCompactEnd(
+    success,
+    tokensBeforeCompact,
+    estimateTotalTokens(result),
+    originalCount,
+    result.length,
+    compactStartedAt,
+    summaryContent,
+    model,
+  );
+
+  return result;
+}
+
+/**
+ * 单条超长 user 消息压缩
+ *
+ * 检测最后一条 user 消息是否超长，如果超长则用 qwen-long 压缩。
+ */
+export async function* compressSingleMessageIfNeeded(
+  messages: ProtocolMessage[],
+  compactConfig: CompactConfig,
+  summarizeFn?: SummarizeFn,
+  compressionConfig?: CompressionConfig,
+): AsyncGenerator<ContentCompressStartEvent | ContentCompressEndEvent, ProtocolMessage[]> {
+  const lastMsg = messages[messages.length - 1];
+  if (!lastMsg || lastMsg.role !== 'user') return messages;
+  if (!needsSingleMessageCompression(lastMsg, compactConfig)) return messages;
+
+  if (!summarizeFn) {
+    logger.warn('单条消息超长但未配置 summarize 回调，跳过压缩');
+    return messages;
+  }
+
+  const originalTokens = estimateMessageTokens(lastMsg);
+  const budget = getPromptBudget(compactConfig);
+  const startedAt = Date.now();
+
+  // 单条超长消息始终用长上下文模型
+  const model = compressionConfig?.longModel ?? DEFAULT_LONG_MODEL;
+
+  yield createContentCompressStart(originalTokens, budget);
+
+  const result = await compressSingleMessage(summarizeFn, lastMsg, model);
+
+  if (result.success) {
+    const newMessages = [...messages];
+    newMessages[newMessages.length - 1] = {
+      ...lastMsg,
+      content: result.summary,
+    };
+
+    yield createContentCompressEnd(
+      true, result.originalTokens, result.compressedTokens, startedAt, result.summary, model,
+    );
+    return newMessages;
+  }
+
+  // 压缩失败，保持原文
+  yield createContentCompressEnd(false, result.originalTokens, 0, startedAt);
+  return messages;
+}

package/src/{providers → orchestrator}/context-compressor.ts

@@ -8,22 +8,22 @@
  * 不机械截断，而是让 AI 生成高质量摘要，保留关键决策和上下文。
  */
 
-import type { StandardMessage } from './types';
-import { DebugLogger } from '../utils';
+import type { ProtocolMessage } from '../protocols';
+import { createModuleLogger } from '../logger';
 
-const logger = DebugLogger.module('ContextCompressor');
+const logger = createModuleLogger('ContextCompressor');
 
 // ==================== Token 估算 ====================
 
 const CHARS_PER_TOKEN = 3.2;
 const MESSAGE_OVERHEAD_TOKENS = 4;
 
-function estimateStringTokens(s: string): number {
+export function estimateStringTokens(s: string): number {
   if (!s) return 0;
   return Math.ceil(s.length / CHARS_PER_TOKEN);
 }
 
-export function estimateMessageTokens(msg: StandardMessage): number {
+export function estimateMessageTokens(msg: ProtocolMessage): number {
   let tokens = MESSAGE_OVERHEAD_TOKENS;
   tokens += estimateStringTokens(msg.content);
 
@@ -42,7 +42,7 @@ export function estimateMessageTokens(msg: StandardMessage): number {
   return tokens;
 }
 
-export function estimateTotalTokens(messages: StandardMessage[]): number {
+export function estimateTotalTokens(messages: ProtocolMessage[]): number {
   let total = 3;
   for (const msg of messages) {
     total += estimateMessageTokens(msg);
@@ -50,6 +50,7 @@ export function estimateTotalTokens(messages: StandardMessage[]): number {
   return total;
 }
 
+
 // ==================== 配置 ====================
 
 export interface CompactConfig {
@@ -73,7 +74,7 @@ export function getPromptBudget(config: CompactConfig): number {
 }
 
 /** 检测是否需要压缩 */
-export function needsCompaction(messages: StandardMessage[], config: CompactConfig): boolean {
+export function needsCompaction(messages: ProtocolMessage[], config: CompactConfig): boolean {
   return estimateTotalTokens(messages) > getPromptBudget(config);
 }
 
@@ -84,15 +85,14 @@ export function needsCompaction(messages: StandardMessage[], config: CompactConf
  * 总结完成后调用 applySummary 组装新的消息列表。
  */
 export function buildSummarizeRequest(
-  messages: StandardMessage[],
+  messages: ProtocolMessage[],
   config: CompactConfig,
-): { summarizeMessages: StandardMessage[]; keepMessages: StandardMessage[] } {
+): { summarizeMessages: ProtocolMessage[]; keepMessages: ProtocolMessage[] } {
   const keepRecent = config.keepRecentMessages ?? DEFAULT_KEEP_RECENT;
 
-  // 找边界
-  let systemEnd = 0;
-  if (messages[0]?.role === 'system') systemEnd = 1;
+  const systemEnd = messages[0]?.role === 'system' ? 1 : 0;
 
+  // 第一条 user 消息由 applySummary 原样保留，不参与总结
   let firstUserEnd = systemEnd;
   for (let i = systemEnd; i < messages.length; i++) {
     if (messages[i].role === 'user') {
@@ -101,32 +101,24 @@ export function buildSummarizeRequest(
     }
   }
 
-  // 要保留的最近消息
   const recentStart = Math.max(firstUserEnd, messages.length - keepRecent);
   const keepMessages = messages.slice(recentStart);
 
-  // 要被总结的中间历史
+  // 中间历史：从 firstUser 之后到 recentStart
+  // 多轮压缩时包含旧摘要（role=system），因为 applySummary 把摘要放在 firstUser 之后
   const middleMessages = messages.slice(firstUserEnd, recentStart);
 
   if (middleMessages.length < 2) {
-    // 中间太短，没什么可总结的
     return { summarizeMessages: [], keepMessages: messages.slice(systemEnd) };
   }
 
   const estimatedTokens = estimateTotalTokens(messages);
   const budget = getPromptBudget(config);
-  logger.info(`准备 AI 总结: ~${estimatedTokens} tokens > budget ${budget}, 总结 ${middleMessages.length} 条中间消息, 保留最近 ${keepMessages.length} 条`);
-
-  // 构建总结请求：把中间历史交给模型
-  const summarizeMessages: StandardMessage[] = [
-    {
-      role: 'system',
-      content: SUMMARIZE_SYSTEM_PROMPT,
-    },
-    {
-      role: 'user',
-      content: formatMessagesForSummary(middleMessages),
-    },
+  logger.info({ estimatedTokens, budget, middleCount: middleMessages.length, keepCount: keepMessages.length }, `准备 AI 总结: ~${estimatedTokens} tokens > budget ${budget}, 总结 ${middleMessages.length} 条中间消息, 保留最近 ${keepMessages.length} 条`);
+
+  const summarizeMessages: ProtocolMessage[] = [
+    { role: 'system', content: SUMMARIZE_SYSTEM_PROMPT },
+    { role: 'user', content: formatMessagesForSummary(middleMessages) },
   ];
 
   return { summarizeMessages, keepMessages };
@@ -136,16 +128,15 @@ export function buildSummarizeRequest(
  * 用 AI 返回的摘要组装新的消息列表
  */
 export function applySummary(
-  originalMessages: StandardMessage[],
+  originalMessages: ProtocolMessage[],
   summary: string,
-  keepMessages: StandardMessage[],
-): StandardMessage[] {
-  // 取原始的 system prompt
+  keepMessages: ProtocolMessage[],
+): ProtocolMessage[] {
   const systemPrompt = originalMessages[0]?.role === 'system' ? originalMessages[0] : null;
 
-  // 取第一条 user 消息
+  // 保留第一条 user 消息原文（初始需求/意图，AI 总结可能丢失细节）
   const startIdx = systemPrompt ? 1 : 0;
-  let firstUser: StandardMessage | null = null;
+  let firstUser: ProtocolMessage | null = null;
   for (let i = startIdx; i < originalMessages.length; i++) {
     if (originalMessages[i].role === 'user') {
       firstUser = originalMessages[i];
@@ -153,25 +144,64 @@ export function applySummary(
     }
   }
 
-  const result: StandardMessage[] = [];
+  const result: ProtocolMessage[] = [];
   if (systemPrompt) result.push(systemPrompt);
   if (firstUser) result.push(firstUser);
 
-  // 插入 AI 生成的摘要
   result.push({
     role: 'system',
     content: `[对话历史摘要]\n${summary}`,
   });
 
-  // 拼上最近保留的消息
   result.push(...keepMessages);
 
   const tokens = estimateTotalTokens(result);
-  logger.info(`AI 总结应用完成: ${originalMessages.length} → ${result.length} 条消息, ~${tokens} tokens`);
+  logger.info({ originalCount: originalMessages.length, resultCount: result.length, tokens }, `AI 总结应用完成: ${originalMessages.length} → ${result.length} 条消息, ~${tokens} tokens`);
 
   return result;
 }
 
+// ==================== 单条消息内容压缩 ====================
+
+/**
+ * 检测单条用户消息是否需要压缩
+ * 阈值：单条消息 token > contextWindowTokens * 0.8 - maxOutputTokens
+ */
+export function needsSingleMessageCompression(
+  message: ProtocolMessage,
+  config: CompactConfig,
+): boolean {
+  if (message.role !== 'user') return false;
+  const msgTokens = estimateMessageTokens(message);
+  const budget = getPromptBudget(config);
+  return msgTokens > budget;
+}
+
+/**
+ * 构建单条消息的总结请求
+ */
+export function buildSingleMessageSummarizeRequest(
+  message: ProtocolMessage,
+): { summarizeMessages: ProtocolMessage[] } {
+  const summarizeMessages: ProtocolMessage[] = [
+    { role: 'system', content: CONTENT_COMPRESS_SYSTEM_PROMPT },
+    { role: 'user', content: message.content },
+  ];
+  return { summarizeMessages };
+}
+
+const CONTENT_COMPRESS_SYSTEM_PROMPT = `你是一个文档压缩助手。用户将发送一段很长的文本（可能包含提问/指令 + 超长文档内容）。
+
+你的任务：
+1. 准确识别并保留用户的提问或指令（原文保留，不要改写）
+2. 将超长文档内容压缩为结构化要点，保留所有关键信息
+3. 输出格式：先输出用户的原始提问/指令，然后输出「文档要点：」+ 编号列表
+4. 如果用户没有明确的提问（只是贴了文档），则直接输出文档要点
+5. 要点应覆盖：核心主题、关键论点/数据、方法论、结论、重要细节
+6. 不要遗漏可能影响后续分析的信息
+
+直接输出结果，不要说"以下是摘要"之类的开头。`;
+
 // ==================== 内部 ====================
 
 const SUMMARIZE_SYSTEM_PROMPT = `你是一个对话历史压缩助手。请总结以下对话历史，保留所有关键信息：
@@ -187,27 +217,29 @@ const SUMMARIZE_SYSTEM_PROMPT = `你是一个对话历史压缩助手。请总
 直接输出摘要，不要开头说"以下是摘要"之类的话。`;
 
 /** 把消息列表格式化为可读文本，供总结用 */
-function formatMessagesForSummary(messages: StandardMessage[]): string {
+function formatMessagesForSummary(messages: ProtocolMessage[]): string {
   const parts: string[] = [];
 
   for (const msg of messages) {
+    if (msg.role === 'system') {
+      // 上一轮的历史摘要，去掉标记前缀后直接当上下文
+      const content = msg.content.startsWith('[对话历史摘要]\n')
+        ? msg.content.slice('[对话历史摘要]\n'.length)
+        : msg.content;
+      if (content) parts.push(`[上一轮摘要]\n${content}`);
+      continue;
+    }
+
     const role = msg.role === 'assistant' ? 'AI' : msg.role === 'user' ? '用户' : '工具';
 
     if (msg.role === 'assistant' && msg.toolCalls && msg.toolCalls.length > 0) {
       const calls = msg.toolCalls.map(tc => {
-        const argsPreview = tc.arguments.length > 200
-          ? tc.arguments.slice(0, 200) + '...'
-          : tc.arguments;
-        return `  调用 ${tc.name}(${argsPreview})`;
+        return `  调用 ${tc.name}(${tc.arguments})`;
       }).join('\n');
       const text = msg.content ? `${msg.content}\n${calls}` : calls;
       parts.push(`[${role}]\n${text}`);
     } else if (msg.role === 'tool') {
-      // tool result 保留前 1000 字符（总结模型能看到足够信息）
-      const content = msg.content.length > 1000
-        ? msg.content.slice(0, 1000) + `... (共 ${msg.content.length} 字符)`
-        : msg.content;
-      parts.push(`[${role}: ${msg.toolName ?? 'unknown'}]\n${content}`);
+      parts.push(`[${role}: ${msg.toolName ?? 'unknown'}]\n${msg.content}`);
     } else if (msg.content) {
       parts.push(`[${role}]\n${msg.content}`);
     }