aegiscode 3.1.10 → 3.4.2

package/src/services/ChatService.ts

@@ -1,347 +0,0 @@
-/**
- * ChatService - LLM 通信服务
- */
-
-import OpenAI from 'openai';
-import type {
-  Message,
-  ToolDefinition,
-  ChatResponse,
-  IChatService,
-  ToolCall,
-  StreamCallbacks,
-} from '../agent/types.js';
-import { OpenAIEventAdapter } from './streaming/OpenAIEventAdapter.js';
-import { ClaudeCliChatService } from './ClaudeCliChatService.js';
-import { AnthropicChatService } from './AnthropicChatService.js';
-
-// For local Ollama models, only include tools when the query looks like a coding task.
-// This avoids sending 350+ tokens of tool schemas on every conversational message,
-// which would add 25-30s of prefill time on CPU.
-function ollamaQueryNeedsTools(messages: Message[]): boolean {
-  const last = messages.filter(m => m.role === 'user').at(-1)?.content ?? '';
-  return /\b(read|edit|write|create|delete|run|execute|bash|file|folder|dir|list|search|grep|find|install|build|test|fix|debug|refactor|rename|move|copy|open|show|cat|ls|pwd|cd|git|npm|pip|python|node)\b/i.test(last);
-}
-
-export interface ChatServiceConfig {
-  apiKey: string;
-  baseURL?: string;
-  model?: string;
-  maxRetries?: number;
-  timeout?: number;
-  /** aegiscode's own permission mode; only consulted for OAuth (claude CLI) transport. */
-  permissionMode?: string;
-  /** Extended-thinking budget tier — only honored on the native Anthropic transport. */
-  thinkingBudget?: 'off' | 'low' | 'medium' | 'high' | 'max';
-  maxOutputTokens?: number;
-}
-
-export class OpenAIChatService implements IChatService {
-  private client: OpenAI;
-  private model: string;
-
-  constructor(config: ChatServiceConfig) {
-    const isAnthropic = config.baseURL?.includes('anthropic.com') ?? false;
-    this.client = new OpenAI({
-      apiKey: config.apiKey,
-      baseURL: config.baseURL,
-      maxRetries: config.maxRetries ?? 2,
-      timeout: config.timeout ?? 60000,
-      defaultHeaders: isAnthropic ? {
-        'anthropic-version': '2023-06-01',
-        'anthropic-beta': 'messages-2023-12-15',
-      } : undefined,
-    });
-    this.model = config.model || 'claude-sonnet-4-6';
-  }
-
-  async chat(
-    messages: Message[],
-    tools?: ToolDefinition[],
-    signal?: AbortSignal,
-    streamCallbacks?: StreamCallbacks,
-    attempt = 0
-  ): Promise<ChatResponse> {
-    const isGroq   = (this.client as any).baseURL?.includes('groq.com') || false;
-    const isOllama = (this.client as any).baseURL?.includes('11434') || false;
-    let content = '';
-    let reasoningContent = '';
-    let usage: ChatResponse['usage'] | undefined;
-
-    try {
-      // Strip zero-width characters and control characters that cause JSON parse errors
-      const cleanContent = (s: string) => s.replace(/[\u200b-\u200f\u2028-\u202f\ufeff]/g, '');
-      const openaiMessages = messages.map(msg => {
-        const converted = this.convertMessage(msg);
-        if (typeof converted.content === 'string') {
-          converted.content = cleanContent(converted.content);
-        }
-        return converted;
-      });
-
-      // For small local Ollama models, inject a guardrail into the system message
-      // so they don't hallucinate tool calls for casual/conversational input.
-      if (isOllama) {
-        const sysIdx = openaiMessages.findIndex(m => m.role === 'system');
-        const guardrail = '\n\nIMPORTANT: Only call tools when the user explicitly asks you to work with files, run commands, or perform a coding task. For greetings and conversational messages respond with plain text only — do NOT call any tool.';
-        if (sysIdx >= 0) {
-          const existing = openaiMessages[sysIdx];
-          openaiMessages[sysIdx] = {
-            ...existing,
-            content: (typeof existing.content === 'string' ? existing.content : '') + guardrail,
-          };
-        }
-      }
-
-      const requestParams: OpenAI.ChatCompletionCreateParams & { keep_alive?: number } = {
-        model: this.model,
-        messages: openaiMessages,
-        stream: true,
-      };
-
-      // Keep Ollama models loaded in memory between requests — eliminates cold-start latency
-      if (isOllama) {
-        (requestParams as any).keep_alive = -1;
-      }
-
-      const includeTools = tools && tools.length > 0 && !isGroq &&
-        (!isOllama || ollamaQueryNeedsTools(messages));
-
-      if (includeTools) {
-        requestParams.tools = tools!.map(tool => ({
-          type: 'function' as const,
-          function: tool.function,
-        }));
-      }
-
-      const stream = await this.client.chat.completions.create(
-        requestParams,
-        { signal }
-      );
-
-      const toolCalls: Map<number, { id: string; name: string; arguments: string }> = new Map();
-      const adapter = streamCallbacks?.onStreamEvent ? new OpenAIEventAdapter() : null;
-      let inOllamaThinkBlock = false;
-
-      for await (const chunk of stream) {
-        const delta = chunk.choices[0]?.delta;
-        if (!delta) continue;
-
-        // For ollama: extract <think>…</think> from delta.content before adapter/callbacks.
-        // Ollama embeds thinking in content as tags rather than a separate reasoning_content field.
-        let adaptDelta = delta as Parameters<typeof OpenAIEventAdapter.prototype.adapt>[0];
-        if (isOllama && delta.content) {
-          let remaining = delta.content;
-          let plainContent = '';
-          let thinkContent = '';
-
-          while (remaining.length > 0) {
-            if (inOllamaThinkBlock) {
-              const closeIdx = remaining.indexOf('</think>');
-              if (closeIdx === -1) {
-                thinkContent += remaining;
-                remaining = '';
-              } else {
-                thinkContent += remaining.slice(0, closeIdx);
-                remaining = remaining.slice(closeIdx + 8);
-                inOllamaThinkBlock = false;
-              }
-            } else {
-              const openIdx = remaining.indexOf('<think>');
-              if (openIdx === -1) {
-                plainContent += remaining;
-                remaining = '';
-              } else {
-                plainContent += remaining.slice(0, openIdx);
-                remaining = remaining.slice(openIdx + 7);
-                inOllamaThinkBlock = true;
-              }
-            }
-          }
-
-          adaptDelta = {
-            ...delta,
-            content: plainContent || null,
-            reasoning_content: thinkContent || null,
-          } as Parameters<typeof OpenAIEventAdapter.prototype.adapt>[0];
-        }
-
-        // Unified event path: convert chunk to AnthropicStreamEvents and emit
-        if (adapter && streamCallbacks?.onStreamEvent) {
-          const events = adapter.adapt(adaptDelta);
-          for (const event of events) {
-            streamCallbacks.onStreamEvent(event);
-          }
-        }
-
-        // Legacy individual callbacks (still called for backward compat)
-        if (adaptDelta.content) {
-          content += adaptDelta.content;
-          streamCallbacks?.onContentDelta?.(adaptDelta.content);
-        }
-
-        const reasoning = (adaptDelta as Record<string, unknown>).reasoning_content
-          || (adaptDelta as Record<string, unknown>).thinking
-          || (adaptDelta as Record<string, unknown>).reasoning;
-        if (reasoning && typeof reasoning === 'string') {
-          reasoningContent += reasoning;
-          streamCallbacks?.onThinkingDelta?.(reasoning);
-        }
-
-        if (delta.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            const index = tc.index;
-            if (!toolCalls.has(index)) {
-              toolCalls.set(index, {
-                id: tc.id || '',
-                name: tc.function?.name || '',
-                arguments: tc.function?.arguments || '',
-              });
-              if (tc.id && tc.function?.name) {
-                streamCallbacks?.onToolCallStart?.({
-                  id: tc.id,
-                  type: 'function',
-                  function: { name: tc.function.name, arguments: '' },
-                });
-              }
-            } else {
-              const existing = toolCalls.get(index)!;
-              if (tc.id) existing.id = tc.id;
-              if (tc.function?.name) existing.name = tc.function.name;
-              if (tc.function?.arguments) {
-                existing.arguments += tc.function.arguments;
-                streamCallbacks?.onToolCallDelta?.(existing.id, tc.function.arguments);
-              }
-            }
-          }
-        }
-
-        try {
-          if (chunk.usage) {
-            usage = {
-              promptTokens: chunk.usage.prompt_tokens || 0,
-              completionTokens: chunk.usage.completion_tokens || 0,
-              totalTokens: chunk.usage.total_tokens || 0,
-            };
-          }
-        } catch {}
-      }
-
-      // Emit finalize events (content_block_stop + message_stop)
-      if (adapter && streamCallbacks?.onStreamEvent) {
-        const stopReason = (stream as any).finalMessage?.stop_reason;
-        for (const event of adapter.finalize(stopReason)) {
-          streamCallbacks.onStreamEvent(event);
-        }
-      }
-
-      const result: ChatResponse = {
-        content,
-        reasoningContent: reasoningContent || undefined,
-        usage,
-      };
-
-      if (toolCalls.size > 0) {
-        result.toolCalls = Array.from(toolCalls.values()).map(tc => ({
-          id: tc.id,
-          type: 'function' as const,
-          function: { name: tc.name, arguments: tc.arguments },
-        }));
-      }
-
-      return result;
-    } catch (error) {
-      if (error instanceof Error && error.name === 'AbortError') throw error;
-
-      // Exponential backoff for transient errors (429, 500, 503)
-      const isTransient = (
-        error instanceof OpenAI.APIError && [429, 500, 502, 503, 504].includes(error.status)
-      ) || (
-        error instanceof Error && (
-          error.message.includes('Connection error') ||
-          error.message.includes('ECONNRESET') ||
-          error.message.includes('timeout')
-        )
-      );
-
-      if (isTransient) {
-        // Don't retry if content was already streaming: the UI buffer has partial
-        // content and a retry with the same streamCallbacks would double it.
-        if (content.length > 0) {
-          return { content, reasoningContent: reasoningContent || undefined, usage };
-        }
-
-        const MAX_RETRIES = 5;
-        if (attempt >= MAX_RETRIES) {
-          const status = error instanceof OpenAI.APIError ? error.status : undefined;
-          const reason = status === 429 ? 'Rate limited' : `Server error (${status ?? 'transient'})`;
-          throw new Error(
-            `${reason} — gave up after ${MAX_RETRIES} retries.\n` +
-            (status === 429
-              ? `The API is rate-limiting this key. Wait a few minutes or check usage.\n`
-              : (error as Error).message)
-          );
-        }
-
-        const delay = Math.min(1000 * 2 ** attempt, 16000);
-        process.stderr.write(`[RETRY] attempt ${attempt + 1}/${MAX_RETRIES} after ${delay}ms\n`);
-        await new Promise(r => setTimeout(r, delay));
-        return this.chat(messages, tools, signal, streamCallbacks, attempt + 1);
-      }
-
-      if (error instanceof OpenAI.APIError) {
-        if (isOllama && error.status === 400 && error.message.includes('does not support tools')) {
-          throw new Error(
-            `Model "${this.model}" does not support tools.\n\n` +
-            `Switch to a tool-capable model:\n` +
-            `  aegis --model llama3.2\n` +
-            `  aegis --model mistral-nemo\n` +
-            `  aegis --model qwen2.5-coder\n\n` +
-            `Or run: ollama pull llama3.2`
-          );
-        }
-        throw new Error(`LLM API Error: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-
-  private convertMessage(msg: Message): OpenAI.ChatCompletionMessageParam {
-    switch (msg.role) {
-      case 'system':
-        return { role: 'system', content: msg.content };
-      case 'user':
-        return { role: 'user', content: msg.content };
-      case 'assistant':
-        const assistantMsg: any = { role: 'assistant', content: msg.content };
-        if ((msg as any).reasoning_content) assistantMsg.reasoning_content = (msg as any).reasoning_content;
-        if (msg.tool_calls) {
-          assistantMsg.tool_calls = msg.tool_calls.map(tc => ({
-            id: tc.id,
-            type: 'function' as const,
-            function: { name: tc.function.name, arguments: tc.function.arguments },
-          }));
-        }
-        return assistantMsg;
-      case 'tool':
-        return { role: 'tool', tool_call_id: msg.tool_call_id || '', content: msg.content };
-      default:
-        throw new Error(`Unknown message role: ${msg.role}`);
-    }
-  }
-}
-
-export function createChatService(config: ChatServiceConfig): IChatService {
-  // Claude Code Pro/Max OAuth tokens (sk-ant-oat...) only work through the
-  // real `claude` binary — Anthropic rejects direct API calls using them
-  // from anything else. Same model selection, different transport.
-  if (config.apiKey?.startsWith('sk-ant-oat')) {
-    return new ClaudeCliChatService({ model: config.model, permissionMode: config.permissionMode });
-  }
-  // Native Anthropic transport — required for cache_control, thinking, and
-  // citations, none of which the OpenAI-compatible shim below can carry.
-  if (config.baseURL?.includes('anthropic.com')) {
-    return new AnthropicChatService(config);
-  }
-  return new OpenAIChatService(config);
-}

package/src/services/ClaudeCliChatService.ts

@@ -1,256 +0,0 @@
-/**
- * ClaudeCliChatService — backs chat completions with the real `claude` binary
- * as a subprocess, for Claude Code Pro/Max subscription auth.
- *
- * Anthropic gates OAuth subscription tokens (sk-ant-oat...) to the official
- * Claude Code client — direct API calls with that token get rejected, even
- * with the right beta headers, unless the request actually comes from the
- * claude binary. So instead of impersonating that client, this shells out to
- * the genuine `claude` CLI, which is the only sanctioned way to spend a
- * subscription on chat completions.
- *
- * `claude --print` doesn't emit OpenAI-style tool-call JSON aegiscode's own
- * Read/Write/Bash loop could intercept, so instead the spawned claude binary
- * runs its own tools directly against this directory. There's no stdin
- * channel for the subprocess to ask the user a permission question (it's
- * spawned headless), so it always runs with bypassPermissions regardless of
- * aegiscode's own permission mode — except 'plan', which is read-only by
- * design and passed through as-is.
- *
- * Each `claude --print` call exits after one response, so a fresh process
- * has no memory of tool calls the previous turn started. We capture the
- * `session_id` from the first reply and pass it back via `--resume` on
- * later turns so the CLI continues the same session instead of replaying
- * the whole transcript as flat text into a brand-new one (which left tool
- * calls half-finished and re-described as text on every "continue").
- */
-
-import { spawn } from 'node:child_process';
-import { existsSync, mkdtempSync, writeFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
-import type {
-  Message,
-  ToolDefinition,
-  ChatResponse,
-  IChatService,
-  StreamCallbacks,
-} from '../agent/types.js';
-import { getPermissionMode as getStorePermissionMode } from '../store/vanilla.js';
-
-export interface ClaudeCliChatServiceConfig {
-  model?: string;
-  /** aegiscode permission mode ('default' | 'autoEdit' | 'yolo' | 'plan'); mapped to claude CLI's --permission-mode. */
-  permissionMode?: string;
-  /** Kill the subprocess and reject if no reply within this many ms (default 600000). */
-  timeout?: number;
-}
-
-// spawn('claude', ...) relies on process.env.PATH, which is fine in an interactive
-// shell but NOT when aegiscode is launched from a GUI app (Electron's main process
-// inherits whatever minimal PATH the desktop session/launcher set, often missing
-// ~/.local/bin) — this is exactly where Claude Code's own installer puts the
-// binary. Resolve an absolute path so Pro/Max chat doesn't ENOENT in that case.
-let cachedClaudeBin: string | null | undefined;
-function resolveClaudeBin(): string {
-  if (cachedClaudeBin !== undefined) return cachedClaudeBin ?? 'claude';
-
-  const home = homedir();
-  const candidates = [
-    ...(process.env.PATH || '').split(':').map(dir => join(dir, 'claude')),
-    join(home, '.local', 'bin', 'claude'),
-    join(home, '.npm-global', 'bin', 'claude'),
-    '/usr/local/bin/claude',
-    '/opt/homebrew/bin/claude',
-  ];
-
-  cachedClaudeBin = candidates.find(p => p && existsSync(p)) ?? null;
-  return cachedClaudeBin ?? 'claude';
-}
-
-// Anything other than 'bypassPermissions' makes the CLI block on an interactive
-// tool-permission prompt — but this subprocess is spawned headless (stdin
-// 'ignore'), so there's no channel to ever answer that prompt. It just hangs
-// until ClaudeCliChatService's own timeout kills it. So regardless of
-// aegiscode's own permission mode, the subprocess always runs with
-// bypassPermissions; 'plan' is the only mode kept distinct since it's
-// read-only by design and doesn't need permission prompts at all.
-const PERMISSION_MODE_MAP: Record<string, string> = {
-  default: 'bypassPermissions',
-  autoEdit: 'bypassPermissions',
-  yolo: 'bypassPermissions',
-  plan: 'plan',
-};
-
-// Pushed onto every call's system prompt — aegiscode already resolved relevant
-// memory/project context into that prompt; re-discovering it via the subprocess's
-// own Read/Grep/Bash tools wastes turns and can miss what aegiscode already knew.
-const ASK_DONT_DIG_INSTRUCTION =
-  'The system prompt above includes aegiscode\'s own project and memory context for ' +
-  'this turn. Prefer that context over re-deriving it yourself. If something relevant ' +
-  'is missing or ambiguous, ask the user directly rather than spending turns exploring ' +
-  'files, git history, or memory on your own.';
-
-function transcriptFor(messages: Message[]): { systemPrompt: string; prompt: string } {
-  const systemParts = messages.filter(m => m.role === 'system').map(m => m.content);
-  const turns = messages.filter(m => m.role === 'user' || m.role === 'assistant');
-
-  // claude --print answers one prompt at a time; fold prior turns into the
-  // prompt text itself so multi-turn context survives across calls (mirrors
-  // how OpenAIChatService is called — aegiscode always resends full history).
-  const lines: string[] = [];
-  for (const m of turns) {
-    lines.push(`${m.role === 'user' ? 'Human' : 'Assistant'}: ${m.content}`);
-  }
-
-  return { systemPrompt: systemParts.join('\n\n'), prompt: lines.join('\n\n') };
-}
-
-export class ClaudeCliChatService implements IChatService {
-  /** Set once the first reply gives us a session_id; reused via --resume on later turns. */
-  private sessionId: string | undefined;
-
-  constructor(private config: ClaudeCliChatServiceConfig) {}
-
-  async chat(
-    messages: Message[],
-    tools?: ToolDefinition[],
-    signal?: AbortSignal,
-    streamCallbacks?: StreamCallbacks
-  ): Promise<ChatResponse> {
-    const args = ['--print', '--output-format', 'stream-json', '--include-partial-messages', '--verbose'];
-    const currentMode = this.config.permissionMode || getStorePermissionMode() || 'default';
-    const cliPermissionMode = PERMISSION_MODE_MAP[currentMode] ?? 'default';
-    args.push('--permission-mode', cliPermissionMode);
-    if (this.config.model) args.push('--model', this.config.model);
-
-    // Always carry the current system message (Agent.ts rebuilds it fresh every
-    // call with that turn's memory/project context) — even on --resume turns,
-    // where it would otherwise be silently dropped, leaving the resumed session
-    // to re-derive context itself via its own tools instead of using what
-    // aegiscode already resolved.
-    const { systemPrompt, prompt: fullPrompt } = transcriptFor(messages);
-    const appendedSystem = [systemPrompt, ASK_DONT_DIG_INSTRUCTION].filter(Boolean).join('\n\n');
-
-    // Large system/memory context plus a full resent transcript can blow past
-    // the OS argv size limit (ARG_MAX) when passed as CLI arguments, killing
-    // spawn() with E2BIG. Write the system prompt to a temp file and send the
-    // prompt over stdin instead — neither touches argv, so there's no size cap.
-    let systemPromptFile: string | undefined;
-    let systemPromptDir: string | undefined;
-    if (appendedSystem) {
-      systemPromptDir = mkdtempSync(join(tmpdir(), 'aegis-sysprompt-'));
-      systemPromptFile = join(systemPromptDir, 'system-prompt.txt');
-      writeFileSync(systemPromptFile, appendedSystem);
-      args.push('--append-system-prompt-file', systemPromptFile);
-    }
-
-    let prompt: string;
-    if (this.sessionId) {
-      // Resuming: the CLI already has the prior turns (and any tool calls it
-      // started) in its own session — just send the newest user message.
-      args.push('--resume', this.sessionId);
-      prompt = messages.filter(m => m.role === 'user').at(-1)?.content ?? '';
-    } else {
-      prompt = fullPrompt;
-    }
-
-    const cleanupSystemPromptFile = () => {
-      if (systemPromptDir) { try { rmSync(systemPromptDir, { recursive: true, force: true }); } catch { /* best effort */ } }
-    };
-
-    const result = await new Promise<{ content: string; usage?: ChatResponse['usage'] }>((resolve, reject) => {
-      // Strip ANTHROPIC_API_KEY so the child claude binary uses its own
-      // OAuth subscription login instead of our (possibly out-of-credit) key.
-      const { ANTHROPIC_API_KEY, ...env } = process.env;
-      const child = spawn(resolveClaudeBin(), args, { stdio: ['pipe', 'pipe', 'pipe'], env });
-      child.stdin.write(prompt);
-      child.stdin.end();
-
-      const timeoutMs = this.config.timeout ?? 600000;
-      const timeoutTimer = setTimeout(() => {
-        child.kill('SIGTERM');
-        reject(new Error(
-          `claude CLI timed out after ${Math.round(timeoutMs / 1000)}s with no response ` +
-          `(likely blocked waiting on a tool-permission prompt that nothing can answer in this context)`
-        ));
-      }, timeoutMs);
-
-      let stderr = '';
-      let stdoutBuffer = '';
-      let finalResult: { result?: string; usage?: { input_tokens?: number; output_tokens?: number }; is_error?: boolean } | null = null;
-
-      const handleLine = (line: string) => {
-        if (!line.trim()) return;
-        let parsed: any;
-        try {
-          parsed = JSON.parse(line);
-        } catch {
-          return;
-        }
-
-        if (parsed.session_id) this.sessionId = parsed.session_id;
-
-        if (parsed.type === 'stream_event' && parsed.event) {
-          // Wire format is identical to AnthropicChatService's SSE events —
-          // forward as-is so the UI streams incrementally instead of one block.
-          streamCallbacks?.onStreamEvent?.(parsed.event);
-        } else if (parsed.type === 'result') {
-          finalResult = parsed;
-        }
-      };
-
-      child.stdout.on('data', d => {
-        stdoutBuffer += d;
-        let idx: number;
-        while ((idx = stdoutBuffer.indexOf('\n')) !== -1) {
-          handleLine(stdoutBuffer.slice(0, idx));
-          stdoutBuffer = stdoutBuffer.slice(idx + 1);
-        }
-      });
-      child.stderr.on('data', d => { stderr += d; });
-
-      const onAbort = () => child.kill('SIGTERM');
-      signal?.addEventListener('abort', onAbort);
-
-      child.on('error', err => {
-        clearTimeout(timeoutTimer);
-        signal?.removeEventListener('abort', onAbort);
-        cleanupSystemPromptFile();
-        reject(new Error(
-          `Failed to launch the claude CLI (${err.message}). Install it with: ` +
-          `npm install -g @anthropic-ai/claude-code — then run "claude setup-token" ` +
-          `and "/login --claude-pro" in aegiscode to connect your subscription.`
-        ));
-      });
-
-      child.on('close', code => {
-        clearTimeout(timeoutTimer);
-        signal?.removeEventListener('abort', onAbort);
-        cleanupSystemPromptFile();
-        if (stdoutBuffer.trim()) handleLine(stdoutBuffer);
-        if (signal?.aborted) {
-          const err = new Error('Aborted');
-          err.name = 'AbortError';
-          reject(err);
-          return;
-        }
-        if (code !== 0 || !finalResult || finalResult.is_error) {
-          reject(new Error(finalResult?.result || stderr.trim() || `claude CLI exited with code ${code}`));
-          return;
-        }
-        const usage = finalResult.usage;
-        resolve({
-          content: finalResult.result ?? '',
-          usage: usage && {
-            promptTokens: usage.input_tokens ?? 0,
-            completionTokens: usage.output_tokens ?? 0,
-            totalTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
-          },
-        });
-      });
-    });
-
-    return { content: result.content, usage: result.usage };
-  }
-}