aegiscode 3.1.8 → 3.1.10

package/src/agent/routerStats.ts

@@ -0,0 +1,121 @@
+/**
+ * Auto-router learning loop — v1.
+ *
+ * The only outcome signal available without new UI is whether the user
+ * aborted (Escape/Ctrl+C) an auto-routed response. That's a noisy proxy for
+ * "this model didn't deliver" (people also abort for unrelated reasons —
+ * wrong question, impatience), but it's real, already-wired data instead of
+ * a guessed-at shape. Tracked as a Beta(success, failure) per tier+model and
+ * sampled via Thompson sampling, so the fallback list self-corrects toward
+ * whichever configured model actually finishes tasks for that tier, instead
+ * of always picking the same hardcoded first candidate.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { ComplexityTier } from './router.js';
+
+type ModelStats = { success: number; failure: number };
+type RouterStats = Partial<Record<ComplexityTier, Record<string, ModelStats>>>;
+
+const STATS_PATH = path.join(os.homedir(), '.aegiscode', 'router-stats.json');
+
+let cache: RouterStats | null = null;
+
+function load(): RouterStats {
+  if (cache) return cache;
+  try {
+    cache = JSON.parse(fs.readFileSync(STATS_PATH, 'utf8'));
+  } catch {
+    cache = {};
+  }
+  return cache!;
+}
+
+function save(stats: RouterStats): void {
+  cache = stats;
+  try {
+    fs.mkdirSync(path.dirname(STATS_PATH), { recursive: true });
+    fs.writeFileSync(STATS_PATH, JSON.stringify(stats, null, 2));
+  } catch { /* non-fatal — learning is best-effort */ }
+}
+
+/** Record whether an auto-routed turn completed normally or was aborted/errored. */
+export function recordRouterOutcome(tier: ComplexityTier, modelId: string, success: boolean): void {
+  const stats = load();
+  const tierStats = stats[tier] || (stats[tier] = {});
+  const modelStats = tierStats[modelId] || (tierStats[modelId] = { success: 0, failure: 0 });
+  if (success) modelStats.success += 1;
+  else modelStats.failure += 1;
+  save(stats);
+}
+
+export function getRouterStats(): RouterStats {
+  return load();
+}
+
+/** Marsaglia-Tsang gamma sampler — shape > 0, scale 1. */
+function sampleGamma(shape: number): number {
+  if (shape < 1) {
+    // Boost via Johnk's trick: Gamma(shape) = Gamma(shape+1) * U^(1/shape)
+    const u = Math.random();
+    return sampleGamma(shape + 1) * Math.pow(u, 1 / shape);
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  for (;;) {
+    let x: number;
+    let v: number;
+    do {
+      // Box-Muller for a standard normal sample
+      const u1 = Math.random() || Number.EPSILON;
+      const u2 = Math.random();
+      x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+      v = 1 + c * x;
+    } while (v <= 0);
+    v = v * v * v;
+    const u = Math.random();
+    if (u < 1 - 0.0331 * (x * x) * (x * x)) return d * v;
+    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v;
+  }
+}
+
+function sampleBeta(alpha: number, beta: number): number {
+  const ga = sampleGamma(alpha);
+  const gb = sampleGamma(beta);
+  return ga / (ga + gb);
+}
+
+/**
+ * Thompson sampling pick among candidate model ids for this tier, in
+ * cost-ascending order (cheapest first). A flat Beta(1,1) prior would make
+ * brand-new, zero-data routing an even coin flip across candidates —
+ * defeating the point of a cost-ordered fallback list before any evidence
+ * exists. Instead each candidate's prior is biased by its cost rank (a
+ * "virtual success" head start that shrinks toward the back of the list),
+ * so with no data it deterministically prefers the cheapest candidate, and
+ * only drifts toward a pricier one once real failures (aborted responses)
+ * accumulate enough to outweigh that head start.
+ */
+export function pickByOutcomes(tier: ComplexityTier, candidateIdsCostOrder: string[]): string | undefined {
+  const n = candidateIdsCostOrder.length;
+  if (n === 0) return undefined;
+  if (n === 1) return candidateIdsCostOrder[0];
+
+  const stats = load();
+  const tierStats = stats[tier] || {};
+
+  let best: string | undefined;
+  let bestScore = -Infinity;
+  candidateIdsCostOrder.forEach((id, i) => {
+    const priorBonus = (n - 1 - i) * 3; // cheapest gets the biggest head start
+    const s = tierStats[id];
+    const score = sampleBeta(1 + priorBonus + (s?.success ?? 0), 1 + (s?.failure ?? 0));
+    if (score > bestScore) {
+      bestScore = score;
+      best = id;
+    }
+  });
+  return best;
+}

package/src/agent/types.ts

@@ -0,0 +1,318 @@
+/**
+ * Agent 类型定义
+ * 
+ * 
+ */
+
+// ========== 消息类
+
+/**
+ * 
+ */
+export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+
+/**
+ * 
+ */
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;  // JSON 字符
+  };
+}
+
+/**
+ * 
+ * 
+ */
+export interface Message {
+  role: MessageRole;
+  content: string;
+  
+  /** DeepSeek R1 等推理模型产生的思维链内容 */
+  reasoning_content?: string;
+  
+  /** assistant 消息专用：发起的工具调用列表 */
+  tool_calls?: ToolCall[];
+  
+  /** tool 消息专用：关联的调用 ID */
+  tool_call_id?: string;
+  
+  /** tool 消息专用：工具名称 */
+  name?: string;
+}
+
+// ========== 上下文类
+
+/**
+ * 
+ */
+export type PermissionMode = 'default' | 'autoEdit' | 'yolo' | 'plan';
+
+/**
+ * 
+ */
+export interface ConfirmationDetails {
+  title: string;
+  message: string;
+  details?: string;
+  risks?: string[];
+  affectedFiles?: string[];
+}
+
+/**
+ * 
+ */
+export interface ConfirmationResponse {
+  approved: boolean;
+  reason?: string;
+  scope?: 'once' | 'session';
+}
+
+/**
+ * 
+ */
+export interface ConfirmationHandler {
+  requestConfirmation(details: ConfirmationDetails): Promise<ConfirmationResponse>;
+}
+
+/**
+ * 
+ * 
+ * Agent 是无状态的，所有状态通过 context 传入
+ */
+export interface ChatContext {
+  /** 会话 ID */
+  sessionId: string;
+  
+  /** 消息历史 */
+  messages: Message[];
+  
+  /** 权限模式 */
+  permissionMode?: PermissionMode;
+  
+  /** 中断信号 */
+  signal?: AbortSignal;
+  
+  /** 确认处理器 */
+  confirmationHandler?: ConfirmationHandler;
+}
+
+// ========== 循环选项与结
+
+/**
+ * 
+ */
+export interface LoopOptions {
+  /** 最大轮次 */
+  maxTurns?: number;
+  
+  /** 中断信号 */
+  signal?: AbortSignal;
+  
+  /** 轮次开始回调 */
+  onTurnStart?: (info: { turn: number; maxTurns: number }) => void;
+  
+  /** 内容回调（完整内容，用于非流式场景） */
+  onContent?: (content: string) => void;
+  
+  /** Unified Anthropic-format stream event (preferred over individual delta callbacks) */
+  onStreamEvent?: (event: import('../services/streaming/types.js').AnthropicStreamEvent) => void;
+
+  /** 内容增量回调（流式） */
+  onContentDelta?: (delta: string) => void;
+
+  /** 思考内容回调（完整内容） */
+  onThinking?: (content: string) => void;
+
+  /** 思考内容增量回调（流式） */
+  onThinkingDelta?: (delta: string) => void;
+
+  /** 工具调用开始回调 */
+  onToolCallStart?: (toolCall: Partial<ToolCall>) => void;
+
+  /** 工具调用参数增量回调（流式） */
+  onToolCallDelta?: (toolCallId: string, argumentsDelta: string) => void;
+
+  /** 工具结果回调 */
+  onToolResult?: (toolCall: ToolCall, result: ToolResult) => void;
+  
+  /** 轮次上限回调 */
+  onTurnLimitReached?: (info: { turnsCount: number }) => Promise<{ continue: boolean }>;
+}
+
+/**
+ * 
+ */
+export type LoopErrorType = 
+  | 'aborted'
+  | 'max_turns_exceeded'
+  | 'chat_disabled'
+  | 'initialization_failed'
+  | 'llm_error'
+  | 'tool_error';
+
+/**
+ * 
+ */
+export interface LoopError {
+  type: LoopErrorType;
+  message?: string;
+  cause?: Error;
+}
+
+/**
+ * 
+ */
+export interface LoopResult {
+  success: boolean;
+  finalMessage?: string;
+  error?: LoopError;
+  metadata?: {
+    turnsCount: number;
+    toolCallsCount: number;
+    totalTokens?: number;
+  };
+}
+
+// ========== 工具类
+
+/**
+ * 
+ */
+export interface ToolResult {
+  success: boolean;
+  
+  /** 显示给用户的内容 */
+  displayContent?: string;
+  
+  /** 发送给 LLM 的内容 */
+  llmContent?: string;
+  
+  /** 错误信息 */
+  error?: string;
+  
+  /** 元数据 */
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * 
+ */
+export interface ToolDefinition {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: {
+      type: 'object';
+      properties: Record<string, {
+        type: string;
+        description: string;
+        enum?: string[];
+      }>;
+      required?: string[];
+    };
+  };
+}
+
+// ========== Agent 配
+
+/**
+ * Agent 配置
+ */
+export interface AgentConfig {
+  /** API Key */
+  apiKey: string;
+  
+  /** API Base URL */
+  baseURL?: string;
+  
+  /** 模型名称 */
+  model?: string;
+  
+  /** 最大轮次 (-1 表示无限) */
+  maxTurns?: number;
+  
+  /** 最大上下文 Token */
+  maxContextTokens?: number;
+  
+  /** 最大输出 Token */
+  maxOutputTokens?: number;
+  
+  /** 系统提示词 */
+  systemPrompt?: string;
+
+  /** Request timeout in ms (default 60000) */
+  timeout?: number;
+
+  /** Show confirmation prompts before sensitive tool calls (default true) */
+  requireConfirmation?: boolean;
+
+  /** aegiscode's own permission mode; only consulted for OAuth (claude CLI) transport. */
+  permissionMode?: string;
+}
+
+/**
+ * Agent 创建选项
+ */
+export interface AgentOptions {
+  /** 最大轮次 */
+  maxTurns?: number;
+  
+  /** 工具白名单 */
+  toolWhitelist?: string[];
+  
+  /** 工具黑名单 */
+  toolBlacklist?: string[];
+}
+
+// ========== ChatService 类
+
+/**
+ * ChatService 响应
+ */
+export interface ChatResponse {
+  content: string;
+  reasoningContent?: string;
+  toolCalls?: ToolCall[];
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    /** Tokens served from the prompt cache (~0.1x cost) — native Anthropic transport only. */
+    cacheReadTokens?: number;
+    /** Tokens written to the prompt cache this request (~1.25x cost) — native Anthropic transport only. */
+    cacheCreationTokens?: number;
+  };
+}
+
+/**
+ * 
+ */
+export interface StreamCallbacks {
+  /** Unified Anthropic-format stream event (preferred over the individual callbacks below) */
+  onStreamEvent?: (event: import('../services/streaming/types.js').AnthropicStreamEvent) => void;
+  /** 内容增量回调 */
+  onContentDelta?: (delta: string) => void;
+  /** 思考内容增量回调 */
+  onThinkingDelta?: (delta: string) => void;
+  /** 工具调用开始回调 */
+  onToolCallStart?: (toolCall: Partial<ToolCall>) => void;
+  /** 工具调用参数增量回调 */
+  onToolCallDelta?: (toolCallId: string, argumentsDelta: string) => void;
+}
+
+/**
+ * ChatService 接口
+ */
+export interface IChatService {
+  chat(
+    messages: Message[],
+    tools?: ToolDefinition[],
+    signal?: AbortSignal,
+    streamCallbacks?: StreamCallbacks
+  ): Promise<ChatResponse>;
+}