thatgfsj-code 0.3.0 → 0.4.1

package/src/llm/gemini.ts

@@ -2,36 +2,38 @@
  * Google Gemini Provider
  */
 
-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';
-  private config: ProviderConfig;
+  protected config: ProviderConfig;
 
   constructor(config: ProviderConfig) {
     this.config = config;
   }
 
   buildTools(tools: Tool[]): any[] {
-    return tools.map(tool => ({
-      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),
-      },
-    }));
+    return [{
+      functionDeclarations: tools.map(tool => ({
+        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): 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, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -45,7 +47,17 @@ export class GeminiProvider implements LLMProvider {
 
     const data = await response.json();
     const candidate = data.candidates?.[0];
-    const text = candidate?.content?.parts?.map((p: any) => p.text).join('') || '';
+    const parts = candidate?.content?.parts || [];
+    const text = parts.map((p: any) => p.text).filter(Boolean).join('');
+
+    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,
+      function: {
+        name: p.functionCall.name,
+        arguments: JSON.stringify(p.functionCall.args || {}),
+      },
+    }));
 
     return {
       content: text,
@@ -55,13 +67,14 @@ export class GeminiProvider implements LLMProvider {
         completion_tokens: data.usageMetadata.candidatesTokenCount || 0,
         total_tokens: data.usageMetadata.totalTokenCount || 0,
       } : undefined,
+      tool_calls: functionCalls.length > 0 ? functionCalls : undefined,
     };
   }
 
-  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 url = `${this.config.baseUrl}/models/${this.config.model}:streamGenerateContent?key=${this.config.apiKey}`;
     const response = await fetch(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -77,6 +90,7 @@ export class GeminiProvider implements LLMProvider {
     const decoder = new TextDecoder();
     let fullContent = '';
     let buffer = '';
+    const functionCalls: ToolCall[] = [];
 
     try {
       while (true) {
@@ -84,44 +98,72 @@ export class GeminiProvider implements LLMProvider {
         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 || !trimmed.startsWith('data: ')) continue;
 
-        // Gemini streams JSON array chunks
-        const jsonMatch = buffer.match(/\{"candidates":\[.*?\]\}/);
-        if (jsonMatch) {
           try {
-            const data = JSON.parse(jsonMatch[0]);
-            const text = data.candidates?.[0]?.content?.parts?.map((p: any) => p.text).join('') || '';
-            if (text) {
-              fullContent += text;
-              yield text;
+            const data = JSON.parse(trimmed.slice(6));
+            const parts = data.candidates?.[0]?.content?.parts || [];
+            for (const part of parts) {
+              if (part.text) {
+                fullContent += 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 {
             // Skip invalid JSON
           }
-          buffer = buffer.slice(jsonMatch.index! + jsonMatch[0].length);
         }
       }
     } finally {
       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 };
   }
 
-  private buildRequest(messages: ChatMessage[], options?: ChatOptions) {
-    const contents = messages
-      .filter(m => m.role !== 'system')
-      .map(m => ({
-        role: m.role === 'assistant' ? 'model' : 'user',
-        parts: [{ text: m.content }],
-      }));
+  private buildRequest(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]) {
+    const systemMsg = messages.find(m => m.role === 'system');
+    const nonSystemMsgs = messages.filter(m => m.role !== 'system');
 
-    return {
+    const contents = nonSystemMsgs.map(m => ({
+      role: m.role === 'assistant' ? 'model' : 'user',
+      parts: [{ text: m.content }],
+    }));
+
+    const body: any = {
       contents,
+      ...(systemMsg && {
+        systemInstruction: { parts: [{ text: systemMsg.content }] },
+      }),
       generationConfig: {
         temperature: options?.temperature ?? this.config.temperature,
         maxOutputTokens: options?.maxTokens ?? this.config.maxTokens,
       },
     };
+
+    if (tools && tools.length > 0) {
+      body.tools = this.buildTools(tools);
+    }
+
+    return body;
   }
 }

package/src/llm/index.ts

@@ -1,12 +1,12 @@
 /**
  * LLM Service - Factory for creating providers
- * Replaces the monolithic AIEngine with a clean provider abstraction
+ * Supports all providers + custom relay stations (中转站)
  */
 
 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';
@@ -16,14 +16,13 @@ import { GeminiProvider } from './gemini.js';
 export class LLMService {
   private provider: LLMProvider;
   private tools: Map<string, Tool> = new Map();
+  private apiKey: string;
 
-  constructor(provider: LLMProvider) {
+  constructor(provider: LLMProvider, apiKey: string) {
     this.provider = provider;
+    this.apiKey = apiKey;
   }
 
-  /**
-   * Create LLMService from AIConfig
-   */
   static fromConfig(config: AIConfig): LLMService {
     const providerName = config.provider || 'siliconflow';
     const providerConfig = PROVIDERS[providerName];
@@ -50,50 +49,35 @@ export class LLMService {
         provider = new OpenAIProvider(providerCfg);
     }
 
-    return new LLMService(provider);
+    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; }
 
-  /**
-   * Non-streaming chat
-   */
   async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse> {
-    if (!this.hasApiKey()) {
-      return this.getMockResponse(messages);
-    }
-    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()) {
-      const mock = this.getMockResponse(messages);
-      for (const char of mock.content) {
-        await new Promise(r => setTimeout(r, 10));
-        yield char;
-      }
-      return mock;
-    }
+    if (!this.hasApiKey()) throw new Error(this.getNoKeyMessage());
 
     const maxIterations = options?.maxIterations ?? 10;
     let currentMessages = [...messages];
@@ -101,109 +85,117 @@ export class LLMService {
 
     while (iterations < maxIterations) {
       iterations++;
-
-      // Get tools in provider format
       const toolsArray = [...this.tools.values()];
-      const providerTools = toolsArray.length > 0 ? this.provider.buildTools(toolsArray) : [];
+      const hasTools = toolsArray.length > 0;
 
-      // Stream the response
       let fullContent = '';
-      const streamOptions = { ...options };
+      let detectedToolCalls: ToolCall[] | undefined;
 
-      // Add tools to the request if available
-      if (providerTools.length > 0) {
-        // We need to pass tools differently depending on provider
-        // For now, inject into messages context
-      }
+      // Stream the response, passing tools so the API knows about them
+      const stream = this.provider.chatStream(currentMessages, options, hasTools ? toolsArray : undefined);
 
-      for await (const chunk of this.provider.chatStream(currentMessages, streamOptions)) {
-        fullContent += chunk;
-        yield chunk;
+      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 in the response
-      const response = await this.provider.chat(currentMessages, { ...streamOptions, stream: false });
-      const toolCalls = response.tool_calls;
-
-      if (toolCalls && toolCalls.length > 0) {
-        // Append assistant message with 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: toolCalls,
+          content: fullContent || '',
+          tool_calls: detectedToolCalls,
         });
 
         // Execute each tool
-        for (const toolCall of toolCalls) {
+        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 (!tool) {
+            const errMsg = `Tool "${toolCall.function.name}" not found`;
             currentMessages.push({
               role: 'tool',
-              content: `Tool "${toolCall.function.name}" not found`,
+              content: errMsg,
               tool_call_id: toolCall.id,
               name: toolCall.function.name,
             });
+            yield `@@TOOL@@${JSON.stringify({ action: 'result', error: errMsg })}\n`;
             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: result.success ? (result.output || JSON.stringify(result.data)) : (result.error || 'Tool failed'),
+              content: output,
               tool_call_id: toolCall.id,
               name: toolCall.function.name,
             });
-            yield `\n${chalk.gray(`[tool: ${toolCall.function.name}]`)}`;
+
+            yield `@@TOOL@@${JSON.stringify({ action: 'result', output })}\n`;
           } catch (error: any) {
+            const errMsg = `Error: ${error.message}`;
             currentMessages.push({
               role: 'tool',
-              content: `Tool execution error: ${error.message}`,
+              content: errMsg,
               tool_call_id: toolCall.id,
               name: toolCall.function.name,
             });
+            yield `@@TOOL@@${JSON.stringify({ action: 'result', error: errMsg })}\n`;
           }
         }
 
-        continue; // Loop back for next iteration
+        yield '\n';
+        continue;
       }
 
-      // No tool calls - we're done
-      return response;
+      // No tool calls - done
+      return { content: fullContent, role: 'assistant' };
     }
 
     return { content: '[Agent loop exceeded maximum iterations]', role: 'assistant' };
   }
 
-  /**
-   * Check if API key is available
-   */
-  private hasApiKey(): boolean {
-    return !!(this.provider as any).config?.apiKey;
-  }
-
-  /**
-   * Mock response when no API key is set
-   */
-  private getMockResponse(messages: ChatMessage[]): ChatResponse {
-    const last = messages[messages.length - 1]?.content || '';
-    let content: string;
-
-    if (/^(hi|hello|hey)/i.test(last)) {
-      content = 'Hi there! How can I help you today?';
-    } else if (last.toLowerCase().includes('who are you')) {
-      content = 'I am Thatgfsj Code, an AI coding assistant.';
-    } else {
-      content = `I understand you said: "${last.slice(0, 50)}..."\n\nThis is a demo response. Configure an API key for full AI capabilities.\nRun: gfcode init`;
+  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;
     }
+  }
 
-    return { content, role: 'assistant' };
+  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');
   }
 }
 
-// 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

@@ -1,15 +1,22 @@
 /**
  * OpenAI-compatible Provider
- * Works with: OpenAI, SiliconFlow, MiniMax (OpenAI mode), DeepSeek, Kimi, ERNIE, Ollama
+ * Works with: OpenAI, SiliconFlow, DeepSeek, Kimi, Zhipu, MiniMax, Baichuan, Stepfun, Doubao, Ollama, ERNIE
+ * Also works with any OpenAI-compatible relay station (中转站)
  */
 
-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';
-  private config: ProviderConfig;
+  protected config: ProviderConfig;
 
   constructor(config: ProviderConfig) {
     this.config = config;
@@ -32,55 +39,39 @@ export class OpenAIProvider implements LLMProvider {
     }));
   }
 
-  async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse> {
-    const body = this.buildRequest(messages, false, options);
-
-    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.config.apiKey}`,
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`OpenAI API error ${response.status}: ${text}`);
-    }
-
+  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,
+      usage: data.usage ? {
+        prompt_tokens: data.usage.prompt_tokens || 0,
+        completion_tokens: data.usage.completion_tokens || 0,
+        total_tokens: data.usage.total_tokens || 0,
+      } : undefined,
       tool_calls: choice?.message?.tool_calls,
     };
   }
 
-  async *chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse> {
-    const body = this.buildRequest(messages, true, options);
-
-    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.config.apiKey}`,
-      },
-      body: JSON.stringify(body),
-    });
+  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(`OpenAI API error ${response.status}: ${text}`);
+      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();
 
     try {
       while (true) {
@@ -93,14 +84,32 @@ export class OpenAIProvider implements LLMProvider {
 
         for (const line of lines) {
           const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith('data: ') || trimmed === 'data: [DONE]') continue;
+          if (!trimmed) continue;
+          if (trimmed === 'data: [DONE]') continue;
+          if (!trimmed.startsWith('data: ')) continue;
 
           try {
             const data = JSON.parse(trimmed.slice(6));
-            const content = data.choices?.[0]?.delta?.content;
-            if (content) {
-              fullContent += content;
-              yield content;
+            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;
+              }
             }
           } catch {
             // Skip invalid JSON lines
@@ -111,11 +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 };
+    }
 
-  private buildRequest(messages: ChatMessage[], stream: boolean, options?: ChatOptions) {
     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, tools?: Tool[]) {
+    const body: any = {
       model: this.config.model,
       messages: messages.map(m => ({
         role: m.role,
@@ -127,6 +159,29 @@ export class OpenAIProvider implements LLMProvider {
       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
+   */
+  protected async doRequest(body: any): Promise<Response> {
+    const url = `${this.config.baseUrl}/chat/completions`;
+    return fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
   }
 }