thatgfsj-code 3.0.4 → 3.0.7

package/src/llm/index.ts

@@ -1,303 +0,0 @@
-/**
- * LLM Service - Factory for creating providers
- * Supports all providers + custom relay stations (中转站)
- *
- * v3.0.0+: streaming protocol migrated to structured StreamChunk
- *   - chatStream yields { type: 'text' | 'tool_calls' | 'thinking' | 'usage' }
- *   - Tool call execution is now part of the agent loop; consumers see
- *     { type: 'tool_calls', toolCalls } for dispatch and { type: 'text', content }
- *     for model output. The legacy @@TOOL@@ sentinel-string protocol is GONE.
- *   - Usage / cache stats are emitted as the final { type: 'usage' } chunk,
- *     which the TUI cache stats store consumes.
- */
-
-import chalk from 'chalk';
-import type { ChatMessage, ChatResponse, ChatOptions, ToolCall, StreamChunk } from '../types.js';
-import type { Tool } from '../tools/types.js';
-import type { LLMProvider } from './provider.js';
-import type { AIConfig, Config, ProviderName } from '../config/types.js';
-import { PROVIDERS } from '../config/providers.js';
-import { OpenAIProvider } from './openai.js';
-import { AnthropicProvider } from './anthropic.js';
-import { GeminiProvider } from './gemini.js';
-import { decideTTL } from '../cache/smartModel.js';
-
-export class LLMService {
-  private provider: LLMProvider;
-  private tools: Map<string, Tool> = new Map();
-  private apiKey: string;
-
-  constructor(provider: LLMProvider, apiKey: string) {
-    this.provider = provider;
-    this.apiKey = apiKey;
-  }
-
-  /**
-   * v3.0.3: TTL resolved from config + smart routing. Stays null until
-   * the first round, then never changes for the session. Anthropic
-   * provider's setResolvedTTL is called at the same time, so the wire
-   * prefix is consistent across rounds.
-   */
-  private resolvedTtl: '5m' | '1h' | null = null;
-
-  /** Public accessor used by App.streamResponse to surface TTL in the UI. */
-  getResolvedTTL(): '5m' | '1h' | null {
-    return this.resolvedTtl;
-  }
-
-  static fromConfig(config: AIConfig & { cache?: Config['cache'] }): LLMService {
-    const providerName = config.provider || 'siliconflow';
-    const providerConfig = PROVIDERS[providerName];
-
-    const providerCfg = {
-      apiKey: config.apiKey || '',
-      model: config.model || providerConfig.defaultModel,
-      baseUrl: config.baseUrl || providerConfig.baseUrl,
-      temperature: config.temperature ?? 0.7,
-      maxTokens: config.maxTokens ?? 4096,
-      // v3.0.0: forward cache policy. Anthropic reads this to decide
-      // whether to attach cache_control markers; other providers ignore it.
-      // v3.0.3: ttl accepts '5m' | '1h' | 'auto'. 'auto' is resolved
-      // per-session by decideTTL() inside chatStream.
-      cache: config.cache ?? { enabled: true, ttl: 'auto' as const, strategy: 'auto' as const },
-    };
-
-    const format = providerConfig.format;
-    let provider: LLMProvider;
-
-    switch (format) {
-      case 'anthropic':
-        provider = new AnthropicProvider(providerCfg);
-        break;
-      case 'gemini':
-        provider = new GeminiProvider(providerCfg);
-        break;
-      default:
-        provider = new OpenAIProvider(providerCfg);
-    }
-
-    return new LLMService(provider, providerCfg.apiKey);
-  }
-
-  registerTools(tools: Tool[]): void {
-    for (const tool of tools) {
-      this.tools.set(tool.name, tool);
-    }
-  }
-
-  getProviderName(): string { return this.provider.name; }
-  hasApiKey(): boolean { return !!this.apiKey; }
-
-  async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse> {
-    if (!this.hasApiKey()) throw new Error(this.getNoKeyMessage());
-    const toolsArray = [...this.tools.values()];
-    return this.provider.chat(messages, options, toolsArray.length > 0 ? toolsArray : undefined);
-  }
-
-  /**
-   * Streaming chat with agent loop (tool call support).
-   *
-   * Structured chunk protocol (replaces the @@TOOL@@ sentinel strings):
-   *   { type: 'text',       content: string }      model output, accumulate + render
-   *   { type: 'tool_calls', toolCalls: ToolCall[] } dispatch tools, results will
-   *                                                be folded into the next request
-   *   { type: 'thinking',   content: string }      reasoning text (consumers may
-   *                                                display in debug mode)
-   *   { type: 'usage',      usage: Usage }         cache hit/miss + token counts;
-   *                                                emitted on the final round
-   *
-   * Returns the final ChatResponse of the agent loop when done.
-   */
-  async *chatStream(
-    messages: ChatMessage[],
-    options?: ChatOptions & { maxIterations?: number }
-  ): AsyncGenerator<StreamChunk, ChatResponse> {
-    if (!this.hasApiKey()) throw new Error(this.getNoKeyMessage());
-
-    // v3.0.3: Resolve TTL once per session.
-    // v3.0.4: default is 1h (long-task). 'auto' (legacy config value)
-    // resolves via decideTTL which now always returns 1h — we cannot
-    // predict task length at round 0, so we default to the TTL that
-    // cannot expire mid-task. '5m'/'1h' are explicit user pins.
-    const configTtl = (this.provider as any).config?.cache?.ttl;
-    if (configTtl === 'auto' && this.resolvedTtl === null) {
-      const decision = decideTTL(messages, null);
-      this.resolvedTtl = decision.ttl;
-      if (typeof (this.provider as any).setResolvedTTL === 'function') {
-        (this.provider as any).setResolvedTTL(decision.ttl);
-      }
-    } else if (configTtl === '5m' || configTtl === '1h') {
-      // User pinned a specific TTL — apply it once and keep it.
-      if (this.resolvedTtl === null) {
-        this.resolvedTtl = configTtl;
-        if (typeof (this.provider as any).setResolvedTTL === 'function') {
-          (this.provider as any).setResolvedTTL(configTtl);
-        }
-      }
-    }
-
-    const maxIterations = options?.maxIterations ?? 10;
-    let currentMessages = [...messages];
-    let iterations = 0;
-    let lastUsage: ChatResponse['usage'] | undefined;
-
-    while (iterations < maxIterations) {
-      iterations++;
-      const toolsArray = [...this.tools.values()];
-      const hasTools = toolsArray.length > 0;
-
-      let fullContent = '';
-      let detectedToolCalls: ToolCall[] | undefined;
-
-      // Forward stream chunks from the provider. We collect text internally for
-      // tool-call persistence but always re-emit the original chunks unchanged.
-      const stream = this.provider.chatStream(currentMessages, options, hasTools ? toolsArray : undefined);
-
-      for await (const chunk of stream) {
-        if (chunk.type === 'text' && chunk.content) {
-          fullContent += chunk.content;
-          yield chunk;
-        } else if (chunk.type === 'tool_calls' && chunk.toolCalls) {
-          detectedToolCalls = chunk.toolCalls;
-          // Don't yield the raw tool_calls chunk here — we emit one combined
-          // chunk after persisting the assistant message so consumers don't
-          // double-render.
-        } else if (chunk.type === 'thinking') {
-          yield chunk;
-        } else if (chunk.type === 'usage') {
-          lastUsage = chunk.usage;
-          yield chunk;
-        }
-      }
-
-      // If we got tool calls, execute them and loop
-      if (detectedToolCalls && detectedToolCalls.length > 0) {
-        // Add assistant message with tool calls (append-only, preserves prefix cache)
-        currentMessages.push({
-          role: 'assistant',
-          content: fullContent || '',
-          tool_calls: detectedToolCalls,
-        });
-
-        // Execute each tool and emit a single structured tool_calls chunk
-        // describing the dispatch plan. Per-tool results are appended to
-        // currentMessages but NOT yielded as additional chunks — consumers
-        // that want to display result text can introspect tool_calls[*].result
-        // on a synthesized combined chunk, OR we re-emit one tool_calls chunk
-        // at the end with results attached. We choose the simpler approach:
-        // emit ONE tool_calls chunk per iteration with all the calls; results
-        // are surfaced through the next assistant turn's text content.
-        //
-        // v3.0.0 Tool-call Repair (Reasonix P2): on tool failure we APPEND
-        // a `[TOOL_REPAIR]` system message rather than mutating the existing
-        // tool_call message. This preserves the upstream cache prefix —
-        // re-writing an earlier message would shift the prefix by N bytes
-        // and bust the cache for every subsequent round.
-        for (const toolCall of detectedToolCalls) {
-          const tool = this.tools.get(toolCall.function.name);
-
-          if (!tool) {
-            const errMsg = `Tool "${toolCall.function.name}" not found`;
-            // Repair message — explain the failure and tell the model to
-            // try a different tool. Cache-safe because we are APPENDING,
-            // never modifying existing messages.
-            currentMessages.push({
-              role: 'system',
-              content: `[TOOL_REPAIR] Previous tool_call "${toolCall.function.name}" (id=${toolCall.id}) failed: ${errMsg}. Available tools: ${[...this.tools.keys()].join(', ')}.`,
-            });
-            currentMessages.push({
-              role: 'tool',
-              content: errMsg,
-              tool_call_id: toolCall.id,
-              name: toolCall.function.name,
-            });
-            continue;
-          }
-
-          try {
-            const params = JSON.parse(toolCall.function.arguments || '{}');
-            const result = await tool.execute(params);
-            const output = result.success ? (result.output || JSON.stringify(result.data)) : (result.error || 'Tool failed');
-
-            currentMessages.push({
-              role: 'tool',
-              content: output,
-              tool_call_id: toolCall.id,
-              name: toolCall.function.name,
-            });
-
-            if (!result.success) {
-              // Soft failure: tool returned success=false. Same repair pattern.
-              currentMessages.push({
-                role: 'system',
-                content: `[TOOL_REPAIR] Tool "${toolCall.function.name}" returned success=false: ${output}. Consider correcting the arguments and retrying.`,
-              });
-            }
-          } catch (error: any) {
-            const errMsg = `Error: ${error.message}`;
-            currentMessages.push({
-              role: 'tool',
-              content: errMsg,
-              tool_call_id: toolCall.id,
-              name: toolCall.function.name,
-            });
-            // Hard failure: tool.execute threw. Repair message so the model
-            // can see the failure next round and adjust (e.g. fix a path
-            // typo, retry without the optional arg).
-            currentMessages.push({
-              role: 'system',
-              content: `[TOOL_REPAIR] Tool "${toolCall.function.name}" threw an exception: ${errMsg}. Inspect the arguments and retry with a corrected call.`,
-            });
-          }
-        }
-
-        // Emit one tool_calls chunk for this iteration. TUI renders this as a
-        // "tool invoked" entry. Per-tool outputs are summarized on the next
-        // assistant turn.
-        yield { type: 'tool_calls', toolCalls: detectedToolCalls };
-        continue;
-      }
-
-      // No tool calls - done. Return final response (with usage if we have it).
-      return {
-        content: fullContent,
-        role: 'assistant',
-        usage: lastUsage,
-      };
-    }
-
-    return { content: '[Agent loop exceeded maximum iterations]', role: 'assistant' };
-  }
-
-  private truncateArgs(args: string): string {
-    try {
-      const obj = JSON.parse(args || '{}');
-      const entries = Object.entries(obj);
-      if (entries.length === 0) return '';
-      return entries.map(([k, v]) => {
-        const val = typeof v === 'string' && v.length > 50 ? v.slice(0, 50) + '...' : v;
-        return `${k}: ${JSON.stringify(val)}`;
-      }).join(', ');
-    } catch {
-      return args.length > 80 ? args.slice(0, 80) + '...' : args;
-    }
-  }
-
-  private getNoKeyMessage(): string {
-    return [
-      '❌ 未配置 API Key，无法调用 AI。',
-      '',
-      '请先运行: gfcode init',
-      '',
-      '或设置环境变量:',
-      '  export SILICONFLOW_API_KEY="sk-..."',
-      '  export OPENAI_API_KEY="sk-..."',
-      '  export DEEPSEEK_API_KEY="sk-..."',
-    ].join('\n');
-  }
-}
-
-export type { LLMProvider, ProviderConfig, StreamChunk } from './provider.js';
-export { OpenAIProvider } from './openai.js';
-export { AnthropicProvider } from './anthropic.js';
-export { GeminiProvider } from './gemini.js';

package/src/llm/openai.ts

@@ -1,243 +0,0 @@
-/**
- * OpenAI-compatible Provider
- * Works with: OpenAI, SiliconFlow, DeepSeek, Kimi, Zhipu, MiniMax, Baichuan, Stepfun, Doubao, Ollama, ERNIE
- * Also works with any OpenAI-compatible relay station (中转站)
- *
- * v3.0.0+: caching-friendly wire format
- *   - StreamChunk is now imported from ../types (single source of truth)
- *   - buildRequest uses stableStringify so that the bytes sent are byte-equal
- *     between requests with the same logical payload (required for DeepSeek
- *     automatic prefix-cache hit)
- *   - cache_control on individual ChatMessage is forwarded (Anthropic-style
- *     markers are no-ops on OpenAI-compatible APIs but harmless)
- *   - chatStream yields a final { type: 'usage' } chunk if the upstream
- *     returned usage info (stream_options.include_usage already requested)
- */
-
-import type { ChatMessage, ChatResponse, ChatOptions, ToolCall, StreamChunk } from '../types.js';
-import type { Tool } from '../tools/types.js';
-import type { LLMProvider, ProviderConfig } from './provider.js';
-import { stableStringify } from '../utils/stableStringify.js';
-
-export class OpenAIProvider implements LLMProvider {
-  readonly name = 'openai';
-  protected config: ProviderConfig;
-
-  constructor(config: ProviderConfig) {
-    this.config = config;
-  }
-
-  buildTools(tools: Tool[]): any[] {
-    return tools.map(tool => ({
-      type: 'function' as const,
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.inputSchema || {
-          type: 'object',
-          properties: Object.fromEntries(
-            tool.parameters.map(p => [p.name, { type: p.type, description: p.description }])
-          ),
-          required: tool.parameters.filter(p => p.required).map(p => p.name),
-        },
-      },
-    }));
-  }
-
-  async chat(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): Promise<ChatResponse> {
-    const body = this.buildRequest(messages, false, options, tools);
-    const response = await this.doRequest(body);
-    const data = await response.json();
-    const choice = data.choices?.[0];
-
-    return {
-      content: choice?.message?.content || '',
-      role: 'assistant',
-      usage: data.usage ? this.normalizeUsage(data.usage) : undefined,
-      tool_calls: choice?.message?.tool_calls,
-    };
-  }
-
-  async *chatStream(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): AsyncGenerator<StreamChunk, ChatResponse> {
-    const body = this.buildRequest(messages, true, options, tools);
-    const response = await this.doRequest(body);
-
-    if (!response.ok || !response.body) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`API error ${response.status}: ${text}`);
-    }
-
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let fullContent = '';
-    let buffer = '';
-    // Accumulate streaming tool call chunks
-    const toolCallBuffers: Map<number, { id: string; name: string; arguments: string }> = new Map();
-    // Some providers attach usage only on the last chunk (DeepSeek / OpenAI with
-    // stream_options.include_usage). We capture it here and yield at the end.
-    let capturedUsage: ChatResponse['usage'] | undefined;
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed) continue;
-          if (trimmed === 'data: [DONE]') continue;
-          if (!trimmed.startsWith('data: ')) continue;
-
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            const delta = data.choices?.[0]?.delta;
-
-            // Text content
-            if (delta?.content) {
-              fullContent += delta.content;
-              yield { type: 'text', content: delta.content };
-            }
-
-            // Streaming tool calls - accumulate chunks
-            if (delta?.tool_calls) {
-              for (const tc of delta.tool_calls) {
-                const idx = tc.index ?? 0;
-                if (!toolCallBuffers.has(idx)) {
-                  toolCallBuffers.set(idx, { id: '', name: '', arguments: '' });
-                }
-                const buf = toolCallBuffers.get(idx)!;
-                if (tc.id) buf.id = tc.id;
-                if (tc.function?.name) buf.name += tc.function.name;
-                if (tc.function?.arguments) buf.arguments += tc.function.arguments;
-              }
-            }
-
-            // DeepSeek/OpenAI stream-end usage (only present on the last chunk)
-            if (data.usage) {
-              capturedUsage = this.normalizeUsage(data.usage);
-            }
-          } catch {
-            // Skip invalid JSON lines
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-
-    // Convert accumulated tool call buffers to ToolCall[]
-    const toolCalls: ToolCall[] = [];
-    for (const [, buf] of toolCallBuffers) {
-      if (buf.id && buf.name) {
-        toolCalls.push({
-          id: buf.id,
-          type: 'function',
-          function: { name: buf.name, arguments: buf.arguments },
-        });
-      }
-    }
-
-    if (toolCalls.length > 0) {
-      yield { type: 'tool_calls', toolCalls };
-    }
-
-    // Yield captured usage so TUI / cache stats can observe cache hits
-    if (capturedUsage) {
-      yield { type: 'usage', usage: capturedUsage };
-    }
-
-    return {
-      content: fullContent,
-      role: 'assistant',
-      usage: capturedUsage,
-      tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-    };
-  }
-
-  /**
-   * Build the request body for OpenAI-compatible API.
-   *
-   * Why stableStringify matters: DeepSeek (and most OpenAI-compatible APIs)
-   * perform automatic prefix cache lookup by byte-level hash of the request
-   * payload. If the JSON we send today differs from yesterday's by even one
-   * reordered key, the cache misses. Insertion-order stability is good enough
-   * when the same code path runs every time, but we now use stableStringify
-   * as a belt-and-suspenders guarantee against accidental key reordering from
-   * future refactors (spread / Object.fromEntries / map merging).
-   */
-  protected buildRequest(messages: ChatMessage[], stream: boolean, options?: ChatOptions, tools?: Tool[]) {
-    const body: any = {
-      model: this.config.model,
-      messages: messages.map(m => ({
-        role: m.role,
-        // content is string | ContentBlock[]. OpenAI wire format accepts both:
-        // - string for plain text messages
-        // - array of {type,text} or {type,image_url} blocks for multimodal
-        content: m.content,
-        ...(m.name && { name: m.name }),
-        ...(m.tool_call_id && { tool_call_id: m.tool_call_id }),
-        ...(m.tool_calls && { tool_calls: m.tool_calls }),
-        ...(m.cache_control && { cache_control: m.cache_control }),
-      })),
-      temperature: options?.temperature ?? this.config.temperature,
-      max_tokens: options?.maxTokens ?? this.config.maxTokens,
-      stream,
-      ...(stream && { stream_options: { include_usage: true } }),
-    };
-
-    // Add tools if provided - this is critical for structured tool calling
-    if (tools && tools.length > 0) {
-      body.tools = this.buildTools(tools);
-    }
-
-    return body;
-  }
-
-  /**
-   * Execute the HTTP request. Serializes via stableStringify so the byte
-   * sequence is deterministic across requests.
-   */
-  protected async doRequest(body: any): Promise<Response> {
-    const url = `${this.config.baseUrl}/chat/completions`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 60000); // 60s timeout
-
-    try {
-      const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.config.apiKey}`,
-        },
-        body: stableStringify(body),
-        signal: controller.signal,
-      });
-      return response;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-
-  /**
-   * Map upstream usage JSON to the canonical Usage shape. Different providers
-   * attach different cache-related fields; we pass everything through so the
-   * cache stats layer can interpret per-provider.
-   */
-  protected normalizeUsage(raw: any): ChatResponse['usage'] {
-    return {
-      prompt_tokens: raw.prompt_tokens || 0,
-      completion_tokens: raw.completion_tokens || 0,
-      total_tokens: raw.total_tokens || 0,
-      // DeepSeek automatic prefix cache fields
-      prompt_cache_hit_tokens: raw.prompt_cache_hit_tokens,
-      prompt_cache_miss_tokens: raw.prompt_cache_miss_tokens,
-      // Anthropic prompt cache fields (passed through if relay forwards them)
-      cache_creation_input_tokens: raw.cache_creation_input_tokens,
-      cache_read_input_tokens: raw.cache_read_input_tokens,
-    };
-  }
-}

package/src/llm/provider.ts

@@ -1,71 +0,0 @@
-/**
- * Abstract LLM Provider interface
- * All providers implement this interface.
- *
- * v3.0.0+: StreamChunk is now imported from the shared types module so that
- * TUI / session / cache layers can consume it uniformly. Providers no longer
- * carry their own definition; see src/types.ts for the union (text/tool_calls/
- * thinking/usage). The previous local 'text' | 'tool_calls' shape was kept as
- * a structural type alias for backward compatibility with existing call sites
- * that destructure by .type only.
- */
-
-import type { ChatMessage, ChatResponse, ChatOptions, StreamChunk as SharedStreamChunk } from '../types.js';
-import type { Tool } from '../tools/types.js';
-
-/**
- * Re-export of the structured streaming chunk. Now structurally compatible
- * with the old { type, content?, toolCalls? } shape — callers that previously
- * destructured chunk.type and chunk.content / chunk.toolCalls still work, and
- * new variants ('thinking', 'usage') are opt-in.
- */
-export type StreamChunk = SharedStreamChunk;
-
-export interface LLMProvider {
-  readonly name: string;
-
-  /** Non-streaming chat with optional tools */
-  chat(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): Promise<ChatResponse>;
-
-  /**
-   * Streaming chat with optional tools.
-   * Yields structured StreamChunks:
-   *   { type: 'text',       content: string }
-   *   { type: 'tool_calls', toolCalls: ToolCall[] }
-   *   { type: 'thinking',   content: string }
-   *   { type: 'usage',      usage: Usage }
-   * Returns the final ChatResponse (with usage) when the stream completes.
-   */
-  chatStream(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): AsyncGenerator<StreamChunk, ChatResponse>;
-
-  /** Convert Tool[] to provider-specific format */
-  buildTools(tools: Tool[]): any[];
-}
-
-export interface ProviderConfig {
-  apiKey: string;
-  model: string;
-  baseUrl: string;
-  temperature: number;
-  maxTokens: number;
-  /**
-   * Optional cache control policy. When omitted, providers fall back to their
-   * default behavior (Anthropic: explicit cache_control markers; OpenAI / Gemini
-   * / DeepSeek: automatic prefix cache, no markers needed).
-   *
-   * v3.0.3: `ttl` accepts '5m' | '1h' | 'auto'. 'auto' lets the runtime
-   * decide per-session via decideTTL() in cache/smartModel.ts. The actual
-   * value used at request time is what gets stored on the provider's
-   * resolvedTtl field (set by LLMService.chatStream).
-   */
-  cache?: {
-    enabled: boolean;
-    ttl?: '5m' | '1h' | 'auto';
-    /**
-     * 'auto'   — provider default (Anthropic: explicit, OpenAI/DeepSeek: auto)
-     * 'manual' — always emit cache_control markers regardless of provider
-     * 'off'    — never emit markers (force disable, useful for benchmarking)
-     */
-    strategy?: 'auto' | 'manual' | 'off';
-  };
-}