thatgfsj-code 0.3.0 → 0.4.0

package/src/llm/gemini.ts

@@ -1,5 +1,15 @@
 /**
  * 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';
@@ -8,30 +18,32 @@ import type { LLMProvider, 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);
-
     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 +57,18 @@ 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('');
+
+    // 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,
+      function: {
+        name: p.functionCall.name,
+        arguments: JSON.stringify(p.functionCall.args || {}),
+      },
+    }));
 
     return {
       content: text,
@@ -55,13 +78,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);
+    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' },
@@ -84,21 +108,25 @@ 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 part.text;
+              }
             }
           } catch {
             // Skip invalid JSON
           }
-          buffer = buffer.slice(jsonMatch.index! + jsonMatch[0].length);
         }
       }
     } finally {
@@ -108,16 +136,23 @@ export class GeminiProvider implements LLMProvider {
     return { content: fullContent, role: 'assistant' };
   }
 
+  /**
+   * Build request body for Gemini API
+   */
   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 }],
-      }));
+    const systemMsg = messages.find(m => m.role === 'system');
+    const nonSystemMsgs = messages.filter(m => m.role !== 'system');
+
+    const contents = nonSystemMsgs.map(m => ({
+      role: m.role === 'assistant' ? 'model' : 'user',
+      parts: [{ text: m.content }],
+    }));
 
     return {
       contents,
+      ...(systemMsg && {
+        systemInstruction: { parts: [{ text: systemMsg.content }] },
+      }),
       generationConfig: {
         temperature: options?.temperature ?? this.config.temperature,
         maxOutputTokens: options?.maxTokens ?? this.config.maxTokens,

package/src/llm/index.ts

@@ -1,6 +1,6 @@
 /**
  * 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';
@@ -16,9 +16,11 @@ 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;
   }
 
   /**
@@ -50,7 +52,7 @@ export class LLMService {
         provider = new OpenAIProvider(providerCfg);
     }
 
-    return new LLMService(provider);
+    return new LLMService(provider, providerCfg.apiKey);
   }
 
   /**
@@ -69,12 +71,19 @@ export class LLMService {
     return this.provider.name;
   }
 
+  /**
+   * 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()) {
-      return this.getMockResponse(messages);
+      throw new Error(this.getNoKeyMessage());
     }
     return this.provider.chat(messages, options);
   }
@@ -87,12 +96,7 @@ export class LLMService {
     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;
+      throw new Error(this.getNoKeyMessage());
     }
 
     const maxIterations = options?.maxIterations ?? 10;
@@ -102,103 +106,89 @@ 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) : [];
-
       // Stream the response
       let fullContent = '';
-      const streamOptions = { ...options };
-
-      // 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
-      }
-
-      for await (const chunk of this.provider.chatStream(currentMessages, streamOptions)) {
+      for await (const chunk of this.provider.chatStream(currentMessages, options)) {
         fullContent += chunk;
         yield chunk;
       }
 
-      // 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
-        currentMessages.push({
-          role: 'assistant',
-          content: fullContent,
-          tool_calls: toolCalls,
-        });
-
-        // Execute each tool
-        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;
-          }
+      // 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;
 
-          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) {
+          if (toolCalls && toolCalls.length > 0) {
             currentMessages.push({
-              role: 'tool',
-              content: `Tool execution error: ${error.message}`,
-              tool_call_id: toolCall.id,
-              name: toolCall.function.name,
+              role: 'assistant',
+              content: response.content || fullContent,
+              tool_calls: toolCalls,
             });
+
+            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,
+                });
+              }
+            }
+            continue;
           }
+        } catch {
+          // If the non-streaming check fails, just return the streamed content
         }
-
-        continue; // Loop back for next iteration
       }
 
-      // No tool calls - we're done
-      return response;
+      return { content: fullContent, role: 'assistant' };
     }
 
     return { content: '[Agent loop exceeded maximum iterations]', role: 'assistant' };
   }
 
   /**
-   * Check if API key is available
+   * Error message when no API key is configured
    */
-  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`;
-    }
-
-    return { content, role: 'assistant' };
+  private getNoKeyMessage(): string {
+    return [
+      '❌ 未配置 API Key，无法调用 AI。',
+      '',
+      '请先运行以下命令配置:',
+      '  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',
+    ].join('\n');
   }
 }
 

package/src/llm/openai.ts

@@ -1,6 +1,11 @@
 /**
  * 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 (中转站)
+ *
+ * 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';
@@ -9,7 +14,7 @@ import type { LLMProvider, ProviderConfig } from './provider.js';
 
 export class OpenAIProvider implements LLMProvider {
   readonly name = 'openai';
-  private config: ProviderConfig;
+  protected config: ProviderConfig;
 
   constructor(config: ProviderConfig) {
     this.config = config;
@@ -34,47 +39,29 @@ 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}`);
-    }
-
+    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),
-    });
+    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();
@@ -93,14 +80,20 @@ 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;
+            if (delta?.content) {
+              fullContent += delta.content;
+              yield delta.content;
+            }
+            // Handle tool calls in streaming
+            if (delta?.tool_calls) {
+              // Store tool calls for final response
             }
           } catch {
             // Skip invalid JSON lines
@@ -114,7 +107,10 @@ export class OpenAIProvider implements LLMProvider {
     return { content: fullContent, role: 'assistant' };
   }
 
-  private buildRequest(messages: ChatMessage[], stream: boolean, options?: ChatOptions) {
+  /**
+   * Build the request body for OpenAI-compatible API
+   */
+  protected buildRequest(messages: ChatMessage[], stream: boolean, options?: ChatOptions) {
     return {
       model: this.config.model,
       messages: messages.map(m => ({
@@ -127,6 +123,22 @@ 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 } }),
     };
   }
+
+  /**
+   * 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),
+    });
+  }
 }

package/src/tui/output.ts

@@ -60,7 +60,7 @@ export class REPLOutput {
   printBanner(): void {
     console.log(chalk.cyan(`
 ╔═══════════════════════════════════════╗
-║     🤖 Thatgfsj Code v0.3.0        ║
+║     🤖 Thatgfsj Code v0.4.0        ║
 ║     AI Coding Assistant              ║
 ╚═══════════════════════════════════════╝
     `));