thatgfsj-code 0.4.0 → 0.5.0

package/src/llm/gemini.ts

@@ -1,20 +1,10 @@
 /**
  * Google Gemini Provider
- *
- * API: POST {baseUrl}/models/{model}:streamGenerateContent?key={apiKey}
- * Auth: API key in URL query parameter
- * Streaming: JSON array chunks (not SSE)
- *
- * Key differences:
- * - No "system" role in contents, use "systemInstruction" field
- * - Roles are "user" and "model" (not "assistant")
- * - Content is array of "parts" with "text" field
- * - Auth via URL query param, not header
  */
 
-import type { ChatMessage, ChatResponse, ChatOptions } from '../types.js';
+import type { ChatMessage, ChatResponse, ChatOptions, ToolCall } from '../types.js';
 import type { Tool } from '../tools/types.js';
-import type { LLMProvider, ProviderConfig } from './provider.js';
+import type { LLMProvider, StreamChunk, ProviderConfig } from './provider.js';
 
 export class GeminiProvider implements LLMProvider {
   readonly name = 'gemini';
@@ -40,8 +30,8 @@ export class GeminiProvider implements LLMProvider {
     }];
   }
 
-  async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse> {
-    const body = this.buildRequest(messages, options);
+  async chat(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): Promise<ChatResponse> {
+    const body = this.buildRequest(messages, options, tools);
     const url = `${this.config.baseUrl}/models/${this.config.model}:generateContent?key=${this.config.apiKey}`;
 
     const response = await fetch(url, {
@@ -60,7 +50,6 @@ export class GeminiProvider implements LLMProvider {
     const parts = candidate?.content?.parts || [];
     const text = parts.map((p: any) => p.text).filter(Boolean).join('');
 
-    // Extract function calls
     const functionCalls = parts.filter((p: any) => p.functionCall).map((p: any) => ({
       id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
       type: 'function' as const,
@@ -82,8 +71,8 @@ export class GeminiProvider implements LLMProvider {
     };
   }
 
-  async *chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse> {
-    const body = this.buildRequest(messages, options);
+  async *chatStream(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): AsyncGenerator<StreamChunk, ChatResponse> {
+    const body = this.buildRequest(messages, options, tools);
     const url = `${this.config.baseUrl}/models/${this.config.model}:streamGenerateContent?alt=sse&key=${this.config.apiKey}`;
 
     const response = await fetch(url, {
@@ -101,6 +90,7 @@ export class GeminiProvider implements LLMProvider {
     const decoder = new TextDecoder();
     let fullContent = '';
     let buffer = '';
+    const functionCalls: ToolCall[] = [];
 
     try {
       while (true) {
@@ -121,7 +111,17 @@ export class GeminiProvider implements LLMProvider {
             for (const part of parts) {
               if (part.text) {
                 fullContent += part.text;
-                yield part.text;
+                yield { type: 'text', content: part.text };
+              }
+              if (part.functionCall) {
+                functionCalls.push({
+                  id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                  type: 'function',
+                  function: {
+                    name: part.functionCall.name,
+                    arguments: JSON.stringify(part.functionCall.args || {}),
+                  },
+                });
               }
             }
           } catch {
@@ -133,13 +133,14 @@ export class GeminiProvider implements LLMProvider {
       reader.releaseLock();
     }
 
-    return { content: fullContent, role: 'assistant' };
+    if (functionCalls.length > 0) {
+      yield { type: 'tool_calls', toolCalls: functionCalls };
+    }
+
+    return { content: fullContent, role: 'assistant', tool_calls: functionCalls.length > 0 ? functionCalls : undefined };
   }
 
-  /**
-   * Build request body for Gemini API
-   */
-  private buildRequest(messages: ChatMessage[], options?: ChatOptions) {
+  private buildRequest(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]) {
     const systemMsg = messages.find(m => m.role === 'system');
     const nonSystemMsgs = messages.filter(m => m.role !== 'system');
 
@@ -148,7 +149,7 @@ export class GeminiProvider implements LLMProvider {
       parts: [{ text: m.content }],
     }));
 
-    return {
+    const body: any = {
       contents,
       ...(systemMsg && {
         systemInstruction: { parts: [{ text: systemMsg.content }] },
@@ -158,5 +159,11 @@ export class GeminiProvider implements LLMProvider {
         maxOutputTokens: options?.maxTokens ?? this.config.maxTokens,
       },
     };
+
+    if (tools && tools.length > 0) {
+      body.tools = this.buildTools(tools);
+    }
+
+    return body;
   }
 }

package/src/llm/index.ts

@@ -6,7 +6,7 @@
 import chalk from 'chalk';
 import type { ChatMessage, ChatResponse, ChatOptions, ToolCall } from '../types.js';
 import type { Tool } from '../tools/types.js';
-import type { LLMProvider } from './provider.js';
+import type { LLMProvider, StreamChunk } from './provider.js';
 import type { AIConfig, ProviderName } from '../config/types.js';
 import { PROVIDERS } from '../config/providers.js';
 import { OpenAIProvider } from './openai.js';
@@ -23,9 +23,6 @@ export class LLMService {
     this.apiKey = apiKey;
   }
 
-  /**
-   * Create LLMService from AIConfig
-   */
   static fromConfig(config: AIConfig): LLMService {
     const providerName = config.provider || 'siliconflow';
     const providerConfig = PROVIDERS[providerName];
@@ -55,49 +52,32 @@ export class LLMService {
     return new LLMService(provider, providerCfg.apiKey);
   }
 
-  /**
-   * Register tools for function calling
-   */
   registerTools(tools: Tool[]): void {
     for (const tool of tools) {
       this.tools.set(tool.name, tool);
     }
   }
 
-  /**
-   * Get provider name
-   */
-  getProviderName(): string {
-    return this.provider.name;
-  }
+  getProviderName(): string { return this.provider.name; }
+  hasApiKey(): boolean { return !!this.apiKey; }
 
-  /**
-   * Check if API key is available
-   */
-  hasApiKey(): boolean {
-    return !!this.apiKey;
-  }
-
-  /**
-   * Non-streaming chat
-   */
   async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse> {
-    if (!this.hasApiKey()) {
-      throw new Error(this.getNoKeyMessage());
-    }
-    return this.provider.chat(messages, options);
+    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)
+   * - Streams text to the user
+   * - Detects structured tool calls from the API
+   * - Executes tools and loops back for more
    */
   async *chatStream(
     messages: ChatMessage[],
     options?: ChatOptions & { maxIterations?: number }
   ): AsyncGenerator<string, ChatResponse> {
-    if (!this.hasApiKey()) {
-      throw new Error(this.getNoKeyMessage());
-    }
+    if (!this.hasApiKey()) throw new Error(this.getNoKeyMessage());
 
     const maxIterations = options?.maxIterations ?? 10;
     let currentMessages = [...messages];
@@ -105,95 +85,116 @@ export class LLMService {
 
     while (iterations < maxIterations) {
       iterations++;
+      const toolsArray = [...this.tools.values()];
+      const hasTools = toolsArray.length > 0;
 
-      // Stream the response
       let fullContent = '';
-      for await (const chunk of this.provider.chatStream(currentMessages, options)) {
-        fullContent += chunk;
-        yield chunk;
+      let detectedToolCalls: ToolCall[] | undefined;
+
+      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.content;
+        } else if (chunk.type === 'tool_calls' && chunk.toolCalls) {
+          detectedToolCalls = chunk.toolCalls;
+        }
       }
 
-      // Check for tool calls by making a non-streaming request
-      // (streaming tool calls are complex, so we check after stream completes)
-      const toolsArray = [...this.tools.values()];
-      if (toolsArray.length > 0 && iterations < maxIterations) {
-        try {
-          const response = await this.provider.chat(currentMessages, options);
-          const toolCalls = response.tool_calls;
+      // If we got tool calls, execute them and loop
+      if (detectedToolCalls && detectedToolCalls.length > 0) {
+        // Add assistant message with tool calls
+        currentMessages.push({
+          role: 'assistant',
+          content: fullContent || '',
+          tool_calls: detectedToolCalls,
+        });
+
+        // Execute each tool
+        for (const toolCall of detectedToolCalls) {
+          const tool = this.tools.get(toolCall.function.name);
+
+          // Yield structured tool call as JSON line
+          yield `\n@@TOOL@@${JSON.stringify({ action: 'call', name: toolCall.function.name, args: toolCall.function.arguments })}\n`;
 
-          if (toolCalls && toolCalls.length > 0) {
+          if (!tool) {
+            const errMsg = `Tool "${toolCall.function.name}" not found`;
             currentMessages.push({
-              role: 'assistant',
-              content: response.content || fullContent,
-              tool_calls: toolCalls,
+              role: 'tool',
+              content: errMsg,
+              tool_call_id: toolCall.id,
+              name: toolCall.function.name,
             });
-
-            for (const toolCall of toolCalls) {
-              const tool = this.tools.get(toolCall.function.name);
-              if (!tool) {
-                currentMessages.push({
-                  role: 'tool',
-                  content: `Tool "${toolCall.function.name}" not found`,
-                  tool_call_id: toolCall.id,
-                  name: toolCall.function.name,
-                });
-                continue;
-              }
-
-              try {
-                const params = JSON.parse(toolCall.function.arguments || '{}');
-                const result = await tool.execute(params);
-                currentMessages.push({
-                  role: 'tool',
-                  content: result.success ? (result.output || JSON.stringify(result.data)) : (result.error || 'Tool failed'),
-                  tool_call_id: toolCall.id,
-                  name: toolCall.function.name,
-                });
-                yield `\n${chalk.gray(`[tool: ${toolCall.function.name}]`)}`;
-              } catch (error: any) {
-                currentMessages.push({
-                  role: 'tool',
-                  content: `Tool execution error: ${error.message}`,
-                  tool_call_id: toolCall.id,
-                  name: toolCall.function.name,
-                });
-              }
-            }
+            yield `@@TOOL@@${JSON.stringify({ action: 'result', error: errMsg })}\n`;
             continue;
           }
-        } catch {
-          // If the non-streaming check fails, just return the streamed content
+
+          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,
+            });
+
+            yield `@@TOOL@@${JSON.stringify({ action: 'result', output })}\n`;
+          } catch (error: any) {
+            const errMsg = `Error: ${error.message}`;
+            currentMessages.push({
+              role: 'tool',
+              content: errMsg,
+              tool_call_id: toolCall.id,
+              name: toolCall.function.name,
+            });
+            yield `@@TOOL@@${JSON.stringify({ action: 'result', error: errMsg })}\n`;
+          }
         }
+
+        yield '\n';
+        continue;
       }
 
+      // No tool calls - done
       return { content: fullContent, role: 'assistant' };
     }
 
     return { content: '[Agent loop exceeded maximum iterations]', role: 'assistant' };
   }
 
-  /**
-   * Error message when no API key is configured
-   */
+  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',
+      '请先运行: gfcode init',
       '',
-      '或手动设置环境变量:',
-      '  export SILICONFLOW_API_KEY="sk-..."     # 硅基流动',
-      '  export OPENAI_API_KEY="sk-..."          # OpenAI',
-      '  export DEEPSEEK_API_KEY="sk-..."        # DeepSeek',
-      '  export KIMI_API_KEY="sk-..."            # Kimi',
-      '  export ANTHROPIC_API_KEY="sk-ant-..."   # Claude',
+      '或设置环境变量:',
+      '  export SILICONFLOW_API_KEY="sk-..."',
+      '  export OPENAI_API_KEY="sk-..."',
+      '  export DEEPSEEK_API_KEY="sk-..."',
     ].join('\n');
   }
 }
 
-// Re-export provider types
-export type { LLMProvider, ProviderConfig } from './provider.js';
+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

@@ -2,16 +2,18 @@
  * OpenAI-compatible Provider
  * Works with: OpenAI, SiliconFlow, DeepSeek, Kimi, Zhipu, MiniMax, Baichuan, Stepfun, Doubao, Ollama, ERNIE
  * Also works with any OpenAI-compatible relay station (中转站)
- *
- * API: POST {baseUrl}/chat/completions
- * Auth: Authorization: Bearer {apiKey}
- * Streaming: SSE with "data: {...}" lines, ends with "data: [DONE]"
  */
 
-import type { ChatMessage, ChatResponse, ChatOptions } from '../types.js';
+import type { ChatMessage, ChatResponse, ChatOptions, ToolCall } from '../types.js';
 import type { Tool } from '../tools/types.js';
 import type { LLMProvider, ProviderConfig } from './provider.js';
 
+export interface StreamChunk {
+  type: 'text' | 'tool_calls';
+  content?: string;
+  toolCalls?: ToolCall[];
+}
+
 export class OpenAIProvider implements LLMProvider {
   readonly name = 'openai';
   protected config: ProviderConfig;
@@ -37,8 +39,8 @@ export class OpenAIProvider implements LLMProvider {
     }));
   }
 
-  async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse> {
-    const body = this.buildRequest(messages, false, options);
+  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];
@@ -55,8 +57,8 @@ export class OpenAIProvider implements LLMProvider {
     };
   }
 
-  async *chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse> {
-    const body = this.buildRequest(messages, true, options);
+  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) {
@@ -68,6 +70,8 @@ export class OpenAIProvider implements LLMProvider {
     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();
 
     try {
       while (true) {
@@ -87,13 +91,25 @@ export class OpenAIProvider implements LLMProvider {
           try {
             const data = JSON.parse(trimmed.slice(6));
             const delta = data.choices?.[0]?.delta;
+
+            // Text content
             if (delta?.content) {
               fullContent += delta.content;
-              yield delta.content;
+              yield { type: 'text', content: delta.content };
             }
-            // Handle tool calls in streaming
+
+            // Streaming tool calls - accumulate chunks
             if (delta?.tool_calls) {
-              // Store tool calls for final response
+              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;
+              }
             }
           } catch {
             // Skip invalid JSON lines
@@ -104,14 +120,34 @@ export class OpenAIProvider implements LLMProvider {
       reader.releaseLock();
     }
 
-    return { content: fullContent, role: 'assistant' };
+    // 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 };
+    }
+
+    return {
+      content: fullContent,
+      role: 'assistant',
+      tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+    };
   }
 
   /**
    * Build the request body for OpenAI-compatible API
    */
-  protected buildRequest(messages: ChatMessage[], stream: boolean, options?: ChatOptions) {
-    return {
+  protected buildRequest(messages: ChatMessage[], stream: boolean, options?: ChatOptions, tools?: Tool[]) {
+    const body: any = {
       model: this.config.model,
       messages: messages.map(m => ({
         role: m.role,
@@ -125,6 +161,13 @@ export class OpenAIProvider implements LLMProvider {
       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;
   }
 
   /**

package/src/llm/provider.ts

@@ -3,32 +3,28 @@
  * All providers implement this interface
  */
 
-import type { ChatMessage, ChatResponse, ChatOptions } from '../types.js';
+import type { ChatMessage, ChatResponse, ChatOptions, ToolCall } from '../types.js';
 import type { Tool } from '../tools/types.js';
 
+export interface StreamChunk {
+  type: 'text' | 'tool_calls';
+  content?: string;
+  toolCalls?: ToolCall[];
+}
+
 export interface LLMProvider {
-  /** Provider name for logging */
   readonly name: string;
 
-  /**
-   * Non-streaming chat completion
-   */
-  chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>;
+  /** Non-streaming chat with optional tools */
+  chat(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): Promise<ChatResponse>;
 
-  /**
-   * Streaming chat completion - yields text chunks
-   */
-  chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse>;
+  /** Streaming chat with optional tools - yields StreamChunks */
+  chatStream(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): AsyncGenerator<StreamChunk, ChatResponse>;
 
-  /**
-   * Convert Tool[] to provider-specific format
-   */
+  /** Convert Tool[] to provider-specific format */
   buildTools(tools: Tool[]): any[];
 }
 
-/**
- * Provider configuration passed to each provider
- */
 export interface ProviderConfig {
   apiKey: string;
   model: string;

package/src/tui/input.ts

@@ -1,6 +1,5 @@
 /**
  * REPL Input Handler
- * Migrated from old src/repl/input.ts
  */
 
 import readline from 'readline';
@@ -20,13 +19,11 @@ export class REPLInput {
       tabSize: 4,
     });
 
-    // Handle Ctrl+C
     this.rl.on('SIGINT', () => {
-      process.stdout.write(chalk.gray('\n\n👋 Exiting...\n'));
+      process.stdout.write(chalk.gray('\n  Goodbye! 👋\n'));
       process.exit(0);
     });
 
-    // Track history
     this.rl.on('line', (line) => {
       if (line.trim()) {
         this.history.push(line);
@@ -36,7 +33,7 @@ export class REPLInput {
     });
   }
 
-  async prompt(prefix: string = chalk.green('\n> ')): Promise<string> {
+  async prompt(prefix: string = chalk.cyan('❯ ')): Promise<string> {
     return new Promise((resolve) => {
       this.rl.question(prefix, (answer) => {
         resolve(answer);