@arrislink/axon 1.1.1 → 1.1.3

package/README.md

@@ -161,8 +161,8 @@ ax plan  # Uses configured provider
 
 **Provider Priority:**
 1. **CLI Mode** - Uses OpenCode CLI (inherits full OMO capabilities)
-2. **Direct Mode** - Reads OMO config, calls APIs directly
-3. **Fallback Mode** - Uses `ANTHROPIC_API_KEY` environment variable
+2. **Direct Mode** - Reads OMO config and resolves **Antigravity** tokens automatically
+3. **Fallback Mode** - Uses `ANTHROPIC_API_KEY` etc. environment variables
 
 ### Environment Variables
 
@@ -216,8 +216,8 @@ graph TD
     
     subgraph "LLM Layer"
         Orch --> LLMInt[Unified LLM Interface]
-        LLMInt --> OMO[OhMyOpenCode Registry]
-        OMO --> Providers[Providers: Anthropic, OpenAI, Antigrav, etc.]
+        LLMInt --> OMO[OMO Config & Antigravity Auth]
+        OMO --> Providers[Providers: Anthropic, Google Gemini, OpenAI, etc.]
     end
 ```
 

package/README.zh-CN.md

@@ -156,12 +156,12 @@ omo config set-provider antigravity
 
 # Axon 自动检测并使用 OMO 配置
 ax plan  # 使用配置的提供商
-```
 
-**提供商优先级:**
-1. **CLI 模式** - 使用 OpenCode CLI（继承 OMO 全部能力）
-2. **直接模式** - 读取 OMO 配置，直接调用 API
-3. **回退模式** - 使用 `ANTHROPIC_API_KEY` 环境变量
+**Provider 优先级：**
+1. **CLI 模式** - 使用 OpenCode CLI (继承完整的 OMO 能力)
+2. **Direct 模式** - 读取 OMO 配置并自动解析 **Antigravity** 刷新令牌
+3. **Fallback 模式** - 使用 `ANTHROPIC_API_KEY` 等环境变量
+```
 
 ### 环境变量
 
@@ -215,8 +215,8 @@ graph TD
     
     subgraph "LLM 层"
         Orch --> LLMInt[统一 LLM 接口]
-        LLMInt --> OMO[OhMyOpenCode 注册表]
-        OMO --> Providers[平台: Anthropic, OpenAI, Antigrav 等]
+        LLMInt --> OMO[OMO 配置 & Antigravity 认证]
+        OMO --> Providers[提供商: Anthropic, Google Gemini, OpenAI, etc.]
     end
 ```
 

package/dist/index.js

@@ -2427,9 +2427,15 @@ var init_defaults = __esm(() => {
   MODEL_PRICING = {
     "claude-sonnet-4-20250514": { input: 3, output: 15 },
     "claude-opus-4-5-20251101": { input: 15, output: 75 },
+    "claude-opus-4-6": { input: 15, output: 75 },
     "gemini-2.0-flash-exp": { input: 0.5, output: 0.5 },
+    "gemini-3-pro": { input: 1.25, output: 3.75 },
+    "gemini-3-flash": { input: 0.1, output: 0.4 },
     "gpt-4-turbo": { input: 10, output: 30 },
-    "gpt-4o": { input: 5, output: 15 }
+    "gpt-4o": { input: 5, output: 15 },
+    "gpt-5.3-codex": { input: 10, output: 30 },
+    "gpt-5-nano": { input: 0.5, output: 1.5 },
+    "glm-4.7-free": { input: 0, output: 0 }
   };
 });
 
@@ -16362,11 +16368,21 @@ class AnthropicClient {
         body: JSON.stringify(body)
       });
       if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        throw new APIError(`LLM API \u8C03\u7528\u5931\u8D25 (${response.status}): ${errorData.error?.message || response.statusText}`, response.status);
+        const errorText = await response.text().catch(() => "");
+        let errorData = {};
+        try {
+          errorData = JSON.parse(errorText);
+        } catch {}
+        throw new APIError(`LLM API \u8C03\u7528\u5931\u8D25 (${response.status}): ${errorData.error?.message || errorText || response.statusText}`, response.status);
+      }
+      const responseText = await response.text();
+      let data;
+      try {
+        data = JSON.parse(responseText);
+      } catch (err) {
+        throw new APIError(`LLM API \u54CD\u5E94\u89E3\u6790\u5931\u8D25 (\u65E0\u6548\u7684 JSON): ${responseText.substring(0, 100)}...`, 500);
       }
-      const data = await response.json();
-      const textContent = data.content.find((c) => c.type === "text");
+      const textContent = data.content?.find((c) => c.type === "text");
       const content = textContent?.text || "";
       return {
         content,
@@ -16398,120 +16414,6 @@ var init_anthropic = __esm(() => {
   init_errors();
 });
 
-// src/core/llm/opencode-client.ts
-class OpenCodeLLMClient {
-  agent;
-  command;
-  constructor(agent = "sisyphus", command = ["opencode"]) {
-    this.agent = agent;
-    this.command = command;
-  }
-  async chat(messages, options) {
-    const iterator = this.streamChat(messages, options);
-    let result = await iterator.next();
-    while (!result.done) {
-      result = await iterator.next();
-    }
-    return result.value;
-  }
-  async* streamChat(messages, options) {
-    const prompt = this.formatMessages(messages);
-    const args = [...this.command, "run", "--agent", this.agent, "--format", "json"];
-    if (options?.model) {
-      args.push("--model", options.model);
-    }
-    const proc = Bun.spawn(args, {
-      stdin: new Blob([prompt]),
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    let fullResponse = "";
-    let metadata = {
-      model: "unknown",
-      tokens: { input: 0, output: 0 },
-      cost: 0
-    };
-    const decoder = new TextDecoder;
-    const reader = proc.stdout.getReader();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split(`
-`);
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (!line.trim())
-            continue;
-          try {
-            const event = JSON.parse(line);
-            if (event.type === "config" && event.part?.model) {
-              metadata.model = event.part.model;
-            } else if (event.model && metadata.model === "unknown") {
-              metadata.model = event.model;
-            }
-            if (event.type === "text" && event.part?.text) {
-              const text = event.part.text;
-              fullResponse += text;
-              yield text;
-            } else if (event.type === "content" && event.part?.content) {
-              const text = event.part.content;
-              fullResponse += text;
-              yield text;
-            } else if (event.type === "step_finish") {
-              if (event.part?.snapshot) {}
-              if (event.part?.tokens) {
-                metadata.tokens.input = event.part.tokens.input || 0;
-                metadata.tokens.output = event.part.tokens.output || 0;
-              }
-              if (event.part?.cost) {
-                metadata.cost = event.part.cost;
-              }
-            }
-          } catch (e) {}
-        }
-      }
-    } finally {
-      reader.releaseLock();
-      proc.kill();
-    }
-    const exitCode = await proc.exited;
-    const stderr = await new Response(proc.stderr).text();
-    if (exitCode !== 0) {
-      throw new Error(`OpenCode CLI Error: ${stderr || "Unknown error"}`);
-    }
-    if (fullResponse.trim() === "" && stderr.trim().length > 0) {
-      if (stderr.includes("Error") || stderr.includes("NotFound") || stderr.includes("|")) {
-        throw new Error(`OpenCode CLI Silent Crash: ${stderr.split(`
-`)[0]}`);
-      }
-    }
-    if (fullResponse.trim() === "") {
-      throw new Error("OpenCode CLI returned an empty response");
-    }
-    return {
-      content: fullResponse,
-      model: metadata.model,
-      tokens: metadata.tokens,
-      cost: metadata.cost
-    };
-  }
-  async complete(prompt, options) {
-    const result = await this.chat([{ role: "user", content: prompt }], options);
-    return result.content;
-  }
-  formatMessages(messages) {
-    return messages.map((m) => `<${m.role}>
-${m.content}
-</${m.role}>`).join(`
-
-`);
-  }
-}
-
 // src/core/llm/omo-config-reader.ts
 var exports_omo_config_reader = {};
 __export(exports_omo_config_reader, {
@@ -16521,6 +16423,18 @@ __export(exports_omo_config_reader, {
 });
 import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
+function resolveProviderType(modelString) {
+  const [prefix] = (modelString || "").split("/");
+  const typeMap = {
+    opencode: "antigravity",
+    anthropic: "anthropic",
+    google: "google",
+    openai: "openai",
+    mistral: "mistral",
+    deepseek: "deepseek"
+  };
+  return typeMap[prefix] || prefix;
+}
 function getOMOConfigPaths() {
   const home = homedir2();
   return [
@@ -16538,8 +16452,10 @@ class OMOConfigReader {
   configSource = "";
   defaultProvider;
   fallbackChain = [];
+  antigravityToken;
   constructor() {
     this.loadConfig();
+    this.loadAntigravityToken();
   }
   loadConfig() {
     const paths = getOMOConfigPaths();
@@ -16550,7 +16466,7 @@ class OMOConfigReader {
           if (path.endsWith(".yaml") || path.endsWith(".yml")) {
             this.loadYamlConfig(content);
           } else if (path.endsWith(".json")) {
-            this.loadJsonConfig(content);
+            this.loadJsonConfig(content, path);
           }
           if (this.providers.length > 0) {
             this.configSource = path;
@@ -16561,6 +16477,45 @@ class OMOConfigReader {
         }
       }
     }
+    if (this.providers.length > 0 && !this.configSource.endsWith("opencode.json")) {
+      this.mergeOpenCodeProviders();
+    }
+  }
+  loadAntigravityToken() {
+    try {
+      const accountsPath = `${homedir2()}/.config/opencode/antigravity-accounts.json`;
+      if (existsSync4(accountsPath)) {
+        const accounts = JSON.parse(readFileSync2(accountsPath, "utf-8"));
+        if (accounts.accounts?.length > 0) {
+          const activeIdx = accounts.activeIndex ?? 0;
+          const account = accounts.accounts.find((a) => a.enabled !== false) || accounts.accounts[activeIdx];
+          if (account) {
+            this.antigravityToken = account.token || account.refreshToken;
+          }
+        }
+      }
+    } catch {}
+  }
+  mergeOpenCodeProviders() {
+    const opencodePath = `${homedir2()}/.config/opencode/opencode.json`;
+    if (!existsSync4(opencodePath))
+      return;
+    try {
+      const content = readFileSync2(opencodePath, "utf-8");
+      const config = JSON.parse(content);
+      if (config.provider) {
+        for (const [name, details] of Object.entries(config.provider)) {
+          if (!this.providers.some((p) => p.name === name)) {
+            this.providers.push({
+              name,
+              type: name,
+              models: Object.keys(details.models || {}),
+              endpoint: details.endpoint
+            });
+          }
+        }
+      }
+    } catch {}
   }
   loadYamlConfig(content) {
     const config = $parse(content);
@@ -16570,15 +16525,15 @@ class OMOConfigReader {
       this.fallbackChain = config.fallback_chain || [];
     }
   }
-  loadJsonConfig(content) {
+  loadJsonConfig(content, _filePath) {
     const config = JSON.parse(content);
     if (config.agents) {
       this.providers = Object.entries(config.agents).map(([name, agent]) => {
-        const [providerType] = (agent.model || "").split("/");
+        const resolvedType = resolveProviderType(agent.model || "");
         return {
           name,
           models: [agent.model || "unknown"],
-          type: providerType || "unknown",
+          type: resolvedType,
           endpoint: undefined,
           api_key: undefined
         };
@@ -16612,11 +16567,14 @@ class OMOConfigReader {
       if (p)
         return p;
     }
-    const priority2 = ["antigravity", "anthropic", "openai", "google", "sisyphus"];
-    for (const name of priority2) {
-      const p = this.getProvider(name);
-      if (p)
-        return p;
+    const priority2 = ["antigravity", "anthropic", "openai", "google"];
+    for (const target of priority2) {
+      const byName = this.getProvider(target);
+      if (byName)
+        return byName;
+      const byType = this.providers.find((p) => p.type === target);
+      if (byType)
+        return byType;
     }
     return this.providers[0] || null;
   }
@@ -16633,20 +16591,155 @@ class OMOConfigReader {
   getConfigSource() {
     return this.configSource;
   }
+  hasAntigravityAuth() {
+    return !!this.antigravityToken;
+  }
+  getAntigravityToken() {
+    return this.antigravityToken;
+  }
   getProviderApiKey(provider) {
     if (provider.api_key) {
       const match = provider.api_key.match(/^\$\{(\w+)\}$/);
       return match ? process.env[match[1]] : provider.api_key;
     }
     const type = provider.type || provider.name;
-    const envVar = `${type.toUpperCase()}_API_KEY`;
-    return process.env[envVar];
+    const envMappings = {
+      anthropic: ["ANTHROPIC_API_KEY"],
+      openai: ["OPENAI_API_KEY"],
+      google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+      antigravity: ["ANTIGRAVITY_API_KEY"],
+      deepseek: ["DEEPSEEK_API_KEY"]
+    };
+    const envVars = envMappings[type] || [`${type.toUpperCase()}_API_KEY`];
+    for (const envVar of envVars) {
+      const envKey = process.env[envVar];
+      if (envKey)
+        return envKey;
+    }
+    if (this.antigravityToken) {
+      return this.antigravityToken;
+    }
+    return;
   }
 }
 var init_omo_config_reader = __esm(() => {
   init_dist();
 });
 
+// src/core/llm/opencode-client.ts
+class OpenCodeLLMClient {
+  agent;
+  command;
+  constructor(agent = "sisyphus", command = ["opencode"]) {
+    this.agent = agent;
+    this.command = command;
+  }
+  async chat(messages, options) {
+    const iterator = this.streamChat(messages, options);
+    let result = await iterator.next();
+    while (!result.done) {
+      result = await iterator.next();
+    }
+    return result.value;
+  }
+  async* streamChat(messages, options) {
+    const prompt = this.formatMessages(messages);
+    const args = [...this.command, "run", "--agent", this.agent, "--format", "json"];
+    if (options?.model) {
+      args.push("--model", options.model);
+    }
+    const proc = Bun.spawn(args, {
+      stdin: new Blob([prompt]),
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    let fullResponse = "";
+    let metadata = {
+      model: "unknown",
+      tokens: { input: 0, output: 0 },
+      cost: 0
+    };
+    const decoder = new TextDecoder;
+    const reader = proc.stdout.getReader();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim())
+            continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "config" && event.part?.model) {
+              metadata.model = event.part.model;
+            } else if (event.model && metadata.model === "unknown") {
+              metadata.model = event.model;
+            }
+            if (event.type === "text" && event.part?.text) {
+              const text = event.part.text;
+              fullResponse += text;
+              yield text;
+            } else if (event.type === "content" && event.part?.content) {
+              const text = event.part.content;
+              fullResponse += text;
+              yield text;
+            } else if (event.type === "step_finish") {
+              if (event.part?.snapshot) {}
+              if (event.part?.tokens) {
+                metadata.tokens.input = event.part.tokens.input || 0;
+                metadata.tokens.output = event.part.tokens.output || 0;
+              }
+              if (event.part?.cost) {
+                metadata.cost = event.part.cost;
+              }
+            }
+          } catch (e) {}
+        }
+      }
+    } finally {
+      reader.releaseLock();
+      proc.kill();
+    }
+    const exitCode = await proc.exited;
+    const stderr = await new Response(proc.stderr).text();
+    if (exitCode !== 0) {
+      throw new Error(`OpenCode CLI Error: ${stderr || "Unknown error"}`);
+    }
+    if (fullResponse.trim() === "" && stderr.trim().length > 0) {
+      if (stderr.includes("Error") || stderr.includes("NotFound") || stderr.includes("|")) {
+        throw new Error(`OpenCode CLI Silent Crash: ${stderr.split(`
+`)[0]}`);
+      }
+    }
+    if (fullResponse.trim() === "") {
+      throw new Error("OpenCode CLI returned an empty response");
+    }
+    return {
+      content: fullResponse,
+      model: metadata.model,
+      tokens: metadata.tokens,
+      cost: metadata.cost
+    };
+  }
+  async complete(prompt, options) {
+    const result = await this.chat([{ role: "user", content: prompt }], options);
+    return result.content;
+  }
+  formatMessages(messages) {
+    return messages.map((m) => `<${m.role}>
+${m.content}
+</${m.role}>`).join(`
+
+`);
+  }
+}
+
 // src/core/llm/unified-client.ts
 class UnifiedLLMClient {
   omoConfig;
@@ -16658,11 +16751,20 @@ class UnifiedLLMClient {
     if (!provider) {
       throw new Error("\u672A\u627E\u5230\u53EF\u7528\u7684 LLM Provider");
     }
-    switch (provider.name) {
+    const providerType = provider.type || provider.name;
+    switch (providerType) {
       case "anthropic":
-      case "antigravity":
         return this.chatAnthropic(provider, messages, options);
+      case "antigravity":
+        return this.chatAntigravity(provider, messages, options);
+      case "google":
+        return this.chatGoogle(provider, messages, options);
+      case "openai":
+        return this.chatOpenAI(provider, messages, options);
+      case "deepseek":
+        return this.chatOpenAI(provider, messages, options, "https://api.deepseek.com/v1");
       default:
+        console.warn(`\uD83E\uDDE0 Axon: \u672A\u77E5 provider type '${providerType}'\uFF0C\u4F7F\u7528 Anthropic \u517C\u5BB9\u6A21\u5F0F`);
         return this.chatAnthropic(provider, messages, options);
     }
   }
@@ -16670,17 +16772,39 @@ class UnifiedLLMClient {
     const result = await this.chat([{ role: "user", content: prompt }], options);
     return result.content;
   }
+  cleanModelName(model) {
+    return model.replace(/^[^/]+\//, "");
+  }
   async chatAnthropic(provider, messages, options) {
     const apiKey = this.omoConfig.getProviderApiKey(provider) || process.env["ANTHROPIC_API_KEY"];
     if (!apiKey) {
       throw new Error(`\u672A\u627E\u5230 ${provider.name} \u7684 API \u5BC6\u94A5`);
     }
+    const model = this.cleanModelName(options?.model || provider.models?.[0] || "claude-sonnet-4-20250514");
     const client = new AnthropicClient(apiKey, {
-      model: options?.model || provider.models?.[0] || "claude-sonnet-4-20250514",
+      model,
       provider: "anthropic",
       temperature: options?.temperature ?? 0.7,
       max_tokens: options?.maxTokens || 8000
-    }, provider.endpoint);
+    }, provider.endpoint || "https://api.anthropic.com/v1");
+    return this.executeAnthropicChat(client, model, messages, options);
+  }
+  async chatAntigravity(provider, messages, options) {
+    const apiKey = this.omoConfig.getProviderApiKey(provider);
+    if (!apiKey) {
+      throw new Error(`\u672A\u627E\u5230 ${provider.name} \u7684 API \u5BC6\u94A5 (Antigravity token \u6216\u73AF\u5883\u53D8\u91CF\u5747\u672A\u8BBE\u7F6E)`);
+    }
+    const rawModel = options?.model || provider.models?.[0] || "claude-sonnet-4-20250514";
+    const displayModel = this.cleanModelName(rawModel);
+    const client = new AnthropicClient(apiKey, {
+      model: rawModel,
+      provider: "anthropic",
+      temperature: options?.temperature ?? 0.7,
+      max_tokens: options?.maxTokens || 8000
+    }, provider.endpoint || "https://api.antigravity.ai/v1");
+    return this.executeAnthropicChat(client, displayModel, messages, options);
+  }
+  async executeAnthropicChat(client, model, messages, options) {
     const systemMessage = messages.find((m) => m.role === "system");
     const chatMessages = messages.filter((m) => m.role !== "system").map((m) => ({
       role: m.role,
@@ -16691,12 +16815,120 @@ class UnifiedLLMClient {
     });
     return {
       content: response.content,
-      model: options?.model || provider.models?.[0] || "unknown",
+      model,
       tokens: {
         input: response.usage.input_tokens,
         output: response.usage.output_tokens
       },
-      cost: this.calculateCost(options?.model || provider.models?.[0] || "unknown", response.usage)
+      cost: this.calculateCost(model, response.usage)
+    };
+  }
+  async chatGoogle(provider, messages, options) {
+    const apiKey = this.omoConfig.getProviderApiKey(provider);
+    if (!apiKey) {
+      throw new Error(`\u672A\u627E\u5230 ${provider.name} \u7684 API \u5BC6\u94A5`);
+    }
+    const model = this.cleanModelName(options?.model || provider.models?.[0] || "gemini-2.0-flash");
+    const isAntigravityAuth = this.omoConfig.hasAntigravityAuth() && apiKey === this.omoConfig.getAntigravityToken();
+    if (isAntigravityAuth) {
+      return this.chatAntigravity({
+        ...provider,
+        type: "antigravity",
+        endpoint: provider.endpoint || "https://api.opencode.ai/v1"
+      }, messages, options);
+    }
+    const systemMessage = messages.find((m) => m.role === "system");
+    const chatMessages = messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const endpoint = provider.endpoint || "https://generativelanguage.googleapis.com/v1beta";
+    const url = `${endpoint}/models/${model}:generateContent?key=${apiKey}`;
+    const body = {
+      contents: chatMessages,
+      generationConfig: {
+        temperature: options?.temperature ?? 0.7,
+        maxOutputTokens: options?.maxTokens || 8000
+      }
+    };
+    if (systemMessage) {
+      body.systemInstruction = { parts: [{ text: systemMessage.content }] };
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Google API \u8C03\u7528\u5931\u8D25 (${response.status}): ${errorData.error?.message || response.statusText}`);
+    }
+    const data = await response.json();
+    const content = data.candidates?.[0]?.content?.parts?.[0]?.text || "";
+    const usageMetadata = data.usageMetadata || {};
+    return {
+      content,
+      model,
+      tokens: {
+        input: usageMetadata.promptTokenCount || 0,
+        output: usageMetadata.candidatesTokenCount || 0
+      },
+      cost: this.calculateCost(model, {
+        input_tokens: usageMetadata.promptTokenCount || 0,
+        output_tokens: usageMetadata.candidatesTokenCount || 0
+      })
+    };
+  }
+  async chatOpenAI(provider, messages, options, defaultEndpoint = "https://api.openai.com/v1") {
+    const apiKey = this.omoConfig.getProviderApiKey(provider);
+    if (!apiKey) {
+      throw new Error(`\u672A\u627E\u5230 ${provider.name} \u7684 API \u5BC6\u94A5`);
+    }
+    const isAntigravityAuth = this.omoConfig.hasAntigravityAuth() && apiKey === this.omoConfig.getAntigravityToken();
+    if (isAntigravityAuth) {
+      return this.chatAntigravity({
+        ...provider,
+        type: "antigravity"
+      }, messages, options);
+    }
+    const model = this.cleanModelName(options?.model || provider.models?.[0] || "gpt-4o");
+    const endpoint = provider.endpoint || defaultEndpoint;
+    const url = `${endpoint}/chat/completions`;
+    const openaiMessages = messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: openaiMessages,
+        temperature: options?.temperature ?? 0.7,
+        max_tokens: options?.maxTokens || 8000
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`OpenAI API \u8C03\u7528\u5931\u8D25 (${response.status}): ${errorData.error?.message || response.statusText}`);
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content || "";
+    const usage = data.usage || {};
+    return {
+      content,
+      model,
+      tokens: {
+        input: usage.prompt_tokens || 0,
+        output: usage.completion_tokens || 0
+      },
+      cost: this.calculateCost(model, {
+        input_tokens: usage.prompt_tokens || 0,
+        output_tokens: usage.completion_tokens || 0
+      })
     };
   }
   calculateCost(model, usage) {
@@ -16746,7 +16978,10 @@ class AxonLLMClient {
       }
     } catch {}
     if (hasOMOConfig() && this.omoConfig.hasProviders()) {
-      return "direct";
+      const primary = this.omoConfig.getPrimaryProvider();
+      if (primary && this.omoConfig.getProviderApiKey(primary)) {
+        return "direct";
+      }
     }
     return "fallback";
   }
@@ -16759,18 +16994,32 @@ class AxonLLMClient {
         this.unifiedClient = new UnifiedLLMClient(this.omoConfig);
         break;
       case "fallback":
-        const apiKey = process.env["ANTHROPIC_API_KEY"];
-        if (apiKey) {
-          this.anthropicClient = new AnthropicClient(apiKey, {
-            model: "claude-3-5-sonnet-20240620",
-            provider: "anthropic",
-            temperature: 0.7,
-            max_tokens: 4000
-          });
-        }
+        this.initFallbackClient();
         break;
     }
   }
+  initFallbackClient() {
+    const envKeys = [
+      { key: "ANTHROPIC_API_KEY", model: "claude-sonnet-4-20250514", provider: "anthropic" },
+      { key: "OPENAI_API_KEY", model: "gpt-4o", provider: "openai" },
+      { key: "GOOGLE_API_KEY", model: "gemini-2.0-flash", provider: "google" }
+    ];
+    for (const { key, model, provider } of envKeys) {
+      const apiKey = process.env[key];
+      if (apiKey) {
+        this.anthropicClient = new AnthropicClient(apiKey, {
+          model,
+          provider,
+          temperature: 0.7,
+          max_tokens: 4000
+        });
+        return;
+      }
+    }
+    if (this.mode === "fallback" && this.omoConfig.hasProviders() && this.omoConfig.hasAntigravityAuth()) {
+      this.unifiedClient = new UnifiedLLMClient(this.omoConfig);
+    }
+  }
   async chat(messages, options) {
     try {
       if (this.mode === "cli" && this.openCodeClient) {
@@ -16783,20 +17032,55 @@ class AxonLLMClient {
         if (this.anthropicClient) {
           return await this.chatAnthropicFallback(messages, options);
         }
-        throw new APIError("\u672A\u627E\u5230\u6709\u6548\u7684 LLM \u914D\u7F6E\u6216 API \u5BC6\u94A5", 401);
+        if (this.unifiedClient) {
+          return await this.unifiedClient.chat(messages, options);
+        }
+        const diagInfo = this.getDiagnosticInfo();
+        throw new APIError(`\u672A\u627E\u5230\u6709\u6548\u7684 LLM \u914D\u7F6E\u6216 API \u5BC6\u94A5 (${diagInfo})`, 401);
       }
       throw new Error(`\u672A\u652F\u6301\u7684 LLM \u6A21\u5F0F: ${this.mode}`);
     } catch (error) {
-      if (this.mode !== "fallback") {
-        console.warn(`\uD83E\uDDE0 Axon: ${this.mode} \u6A21\u5F0F\u8C03\u7528\u5931\u8D25\u6216\u54CD\u5E94\u4E3A\u7A7A\uFF0C\u5C1D\u8BD5\u56DE\u9000...`);
-        if (process.env["DEBUG"])
-          console.error(error);
-        this.mode = "fallback";
-        this.initClient();
-        return await this.chat(messages, options);
-      }
-      throw error;
+      return this.handleChatError(error, messages, options);
+    }
+  }
+  async handleChatError(error, messages, options) {
+    if (this.mode === "cli") {
+      console.warn("\uD83E\uDDE0 Axon: CLI \u6A21\u5F0F\u8C03\u7528\u5931\u8D25\uFF0C\u5C1D\u8BD5 Direct \u6A21\u5F0F...");
+      if (process.env["DEBUG"])
+        console.error(error);
+      if (this.omoConfig.hasProviders()) {
+        const primary = this.omoConfig.getPrimaryProvider();
+        if (primary && this.omoConfig.getProviderApiKey(primary)) {
+          this.mode = "direct";
+          this.initClient();
+          return await this.chat(messages, options);
+        }
+      }
+      console.warn("\uD83E\uDDE0 Axon: Direct \u6A21\u5F0F\u65E0\u53EF\u7528 Provider\uFF0C\u5C1D\u8BD5 Fallback \u6A21\u5F0F...");
+      this.mode = "fallback";
+      this.initClient();
+      return await this.chat(messages, options);
+    }
+    if (this.mode === "direct" || this.mode === "fallback" && this.unifiedClient) {
+      console.warn("\uD83E\uDDE0 Axon: Direct/Proxy \u6A21\u5F0F\u8C03\u7528\u5931\u8D25\uFF0C\u5C1D\u8BD5\u73AF\u5883\u53D8\u91CF Fallback...");
+      if (process.env["DEBUG"])
+        console.error(error);
+      this.unifiedClient = undefined;
+      this.mode = "fallback";
+      this.initClient();
+      return await this.chat(messages, options);
     }
+    throw error;
+  }
+  getDiagnosticInfo() {
+    return [
+      `\u914D\u7F6E\u6587\u4EF6: ${this.omoConfig.getConfigSource() || "\u672A\u627E\u5230"}`,
+      `Providers: ${this.omoConfig.getAllProviders().length}`,
+      `Antigravity Token: ${this.omoConfig.hasAntigravityAuth() ? "\u5DF2\u627E\u5230" : "\u672A\u627E\u5230"}`,
+      `ANTHROPIC_API_KEY: ${process.env["ANTHROPIC_API_KEY"] ? "\u5DF2\u8BBE\u7F6E" : "\u672A\u8BBE\u7F6E"}`,
+      `OPENAI_API_KEY: ${process.env["OPENAI_API_KEY"] ? "\u5DF2\u8BBE\u7F6E" : "\u672A\u8BBE\u7F6E"}`,
+      `GOOGLE_API_KEY: ${process.env["GOOGLE_API_KEY"] ? "\u5DF2\u8BBE\u7F6E" : "\u672A\u8BBE\u7F6E"}`
+    ].join(", ");
   }
   async chatAnthropicFallback(messages, options) {
     if (!this.anthropicClient)
@@ -16813,7 +17097,7 @@ class AxonLLMClient {
     });
     return {
       content: response.content,
-      model: options?.model || "claude-3-5-sonnet-20240620",
+      model: options?.model || "claude-sonnet-4-20250514",
       tokens: {
         input: response.usage.input_tokens,
         output: response.usage.output_tokens
@@ -16845,10 +17129,10 @@ class AxonLLMClient {
   }
 }
 var init_llm = __esm(() => {
+  init_errors();
   init_anthropic();
-  init_unified_client();
   init_omo_config_reader();
-  init_errors();
+  init_unified_client();
 });
 
 // node_modules/underscore/underscore-node-f.cjs
@@ -54081,12 +54365,19 @@ var doctorCommand = new Command("doctor").description(t("Diagnose environment is
     let apiKey = process.env[envVar];
     let source = "environment";
     if (!apiKey) {
-      const provider = omoReader.getProvider(name);
+      let provider = omoReader.getProvider(name);
+      if (!provider) {
+        provider = omoReader.getAllProviders().find((p) => p.type === name) || null;
+      }
       if (provider) {
         apiKey = omoReader.getProviderApiKey(provider);
-        source = "OMO config (~/.omo/providers.yaml)";
+        source = `OMO config (${omoReader.getConfigSource()})`;
       }
     }
+    if (!apiKey && omoReader.hasAntigravityAuth()) {
+      apiKey = omoReader.getAntigravityToken();
+      source = "Antigravity token (~/.config/opencode/antigravity-accounts.json)";
+    }
     if (apiKey) {
       if (options.checkKeys) {
         spinner.start(`\u9A8C\u8BC1 ${name} API \u5BC6\u94A5 (${source})...`);
@@ -54287,7 +54578,7 @@ configCommand.command("show").description(t("Show current Axon running mode", "\
     console.log(source_default.cyan("  bunx oh-my-opencode install"));
   }
 });
-configCommand.command("test").description(t("Test Provider connection", "\u6D4B\u8BD5 Provider \u8FDE\u63A5")).option("-p, --provider <name>", t("Specify Provider to test", "\u6307\u5B9A Provider \u6D4B\u8BD5")).option("-m, --model <model>", t("Specify model for testing", "\u6307\u5B9A\u6D4B\u8BD5\u4F7F\u7528\u7684\u6A21\u578B")).action(async (options) => {
+configCommand.command("test").description(t("Test Provider connection", "\u6D4B\u8BD5 Provider \u8FDE\u63A5")).option("-p, --provider <name>", t("Specify Provider to test", "\u6307\u5B9A Provider \u6D4B\u8BD5")).option("-m, --model <model>", t("Specify model for testing", "\u6307\u5B9A\u6D4B\u8BD5\u4F7F\u7528\u7684\u6A21\u578B")).option("--mode <mode>", t("Force specific LLM mode (cli, direct, fallback)", "\u5F3A\u5236\u4F7F\u7528\u7279\u5B9A LLM \u6A21\u5F0F (cli, direct, fallback)")).action(async (options) => {
   const spinner2 = ora("\u6B63\u5728\u521D\u59CB\u5316 LLM \u5BA2\u6237\u7AEF...").start();
   try {
     const omo = new OMOConfigReader;
@@ -54307,8 +54598,9 @@ configCommand.command("test").description(t("Test Provider connection", "\u6D4B\
       }
     }
     const model = options.model || primary?.models?.[0];
-    spinner2.text = `\u6D4B\u8BD5\u8FDE\u63A5: ${source_default.cyan(providerName)}${model ? ` (\u6A21\u578B: ${source_default.cyan(model)})` : ""}...`;
-    const client = new AxonLLMClient;
+    const mode = options.mode;
+    spinner2.text = `\u6D4B\u8BD5\u8FDE\u63A5: ${source_default.cyan(providerName)}${model ? ` (\u6A21\u578B: ${source_default.cyan(model)})` : ""}${mode ? ` [\u6A21\u5F0F: ${source_default.cyan(mode)}]` : ""}...`;
+    const client = new AxonLLMClient(mode);
     const start = Date.now();
     const response = await client.chat([{ role: "user", content: 'Say "OK" if you can hear me.' }], {
       model,
@@ -54508,7 +54800,8 @@ var VERSION = pkg.version;
 var program2 = new Command;
 program2.name("ax").description(`${source_default.green("\uD83E\uDDE0")} ${source_default.bold("Axon")} - AI-Powered Development Operating System (v${VERSION})
 
-  ${source_default.dim("\u4ECE\u9700\u6C42\u5230\u4EE3\u7801\uFF0C\u8BA9 AI \u6210\u4E3A\u4F60\u7684\u5F00\u53D1\u4F19\u4F34\uFF0C\u800C\u975E\u5DE5\u5177\u3002")}`).version(VERSION, "-v, --version", "\u663E\u793A\u7248\u672C\u53F7").helpOption("-h, --help", "\u663E\u793A\u5E2E\u52A9\u4FE1\u606F");
+  From requirements to code, let AI be your development partner, not a tool.
+  \u4ECE\u9700\u6C42\u5230\u4EE3\u7801\uFF0C\u8BA9 AI \u6210\u4E3A\u4F60\u7684\u5F00\u53D1\u4F19\u4F34\uFF0C\u800C\u975E\u5DE5\u5177\u3002`).version(VERSION, "-v, --version", "Show version").helpOption("-h, --help", "Show help information");
 program2.addCommand(initCommand);
 program2.addCommand(specCommand);
 program2.addCommand(planCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrislink/axon",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "AI-Powered Development Operating System with unified LLM provider support",
   "type": "module",
   "main": "dist/index.js",