@elisym/cli 0.11.0 → 0.11.1

package/dist/index.js

@@ -338,6 +338,290 @@ var init_anthropic = __esm({
   }
 });
 
+// src/llm/providers/openai-compatible.ts
+function createOpenAICompatibleProvider(config) {
+  const billingMarkers = [...DEFAULT_BILLING_MARKERS, ...config.extraBillingMarkers ?? []];
+  function bodyLooksLikeBilling3(body) {
+    const lower = body.toLowerCase();
+    return billingMarkers.some((marker) => lower.includes(marker));
+  }
+  async function fetchModels4(apiKey, signal) {
+    try {
+      const response = await fetchWithTimeout(
+        `${config.baseUrl}/models`,
+        { method: "GET", headers: { Authorization: `Bearer ${apiKey}` } },
+        signal
+      );
+      if (!response.ok) {
+        return config.fallbackModels;
+      }
+      const data = await response.json();
+      const transformed = [];
+      for (const entry of data.data ?? []) {
+        const mapped = config.mapModelId ? config.mapModelId(entry.id) : entry.id;
+        if (mapped) {
+          transformed.push(mapped);
+        }
+      }
+      transformed.sort();
+      return transformed.length > 0 ? transformed : config.fallbackModels;
+    } catch {
+      return config.fallbackModels;
+    }
+  }
+  async function verifyKey3(apiKey, signal) {
+    try {
+      const response = await fetchWithTimeout(
+        `${config.baseUrl}/models`,
+        { method: "GET", headers: { Authorization: `Bearer ${apiKey}` } },
+        signal
+      );
+      if (response.ok) {
+        await response.body?.cancel().catch(() => void 0);
+        return { ok: true };
+      }
+      const body = (await response.text().catch(() => "")).slice(0, 500);
+      if (response.status === 401 || response.status === 403) {
+        return { ok: false, reason: "invalid", status: response.status, body };
+      }
+      return {
+        ok: false,
+        reason: "unavailable",
+        error: `HTTP ${response.status}: ${body.slice(0, 200)}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { ok: false, reason: "unavailable", error: message };
+    }
+  }
+  async function verifyKeyDeep3(apiKey, model, signal) {
+    try {
+      const response = await fetchWithTimeout(
+        `${config.baseUrl}/chat/completions`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model,
+            max_tokens: 1,
+            messages: [{ role: "user", content: "." }]
+          })
+        },
+        signal
+      );
+      if (response.ok) {
+        await response.body?.cancel().catch(() => void 0);
+        return { ok: true };
+      }
+      const body = (await response.text().catch(() => "")).slice(0, 500);
+      if (response.status === 401 || response.status === 403) {
+        return { ok: false, reason: "invalid", status: response.status, body };
+      }
+      if (response.status === 402) {
+        return { ok: false, reason: "billing", status: response.status, body };
+      }
+      if ((response.status === 400 || response.status === 429) && bodyLooksLikeBilling3(body)) {
+        return { ok: false, reason: "billing", status: response.status, body };
+      }
+      return {
+        ok: false,
+        reason: "unavailable",
+        error: `HTTP ${response.status}: ${body.slice(0, 200)}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { ok: false, reason: "unavailable", error: message };
+    }
+  }
+  function createClient(clientConfig) {
+    return new OpenAICompatibleClient({
+      apiKey: clientConfig.apiKey,
+      baseUrl: config.baseUrl,
+      model: clientConfig.model ?? config.defaultModel,
+      maxTokens: clientConfig.maxTokens ?? DEFAULT_MAX_TOKENS2,
+      providerLabel: config.displayName,
+      logUsage: clientConfig.logUsage
+    });
+  }
+  return {
+    id: config.id,
+    displayName: config.displayName,
+    envVar: config.envVar,
+    defaultModel: config.defaultModel,
+    fallbackModels: config.fallbackModels,
+    fetchModels: fetchModels4,
+    verifyKey: verifyKey3,
+    verifyKeyDeep: verifyKeyDeep3,
+    createClient
+  };
+}
+var DEFAULT_MAX_TOKENS2, DEFAULT_BILLING_MARKERS, OpenAICompatibleClient;
+var init_openai_compatible = __esm({
+  "src/llm/providers/openai-compatible.ts"() {
+    init_http();
+    DEFAULT_MAX_TOKENS2 = 4096;
+    DEFAULT_BILLING_MARKERS = ["credit balance", "billing", "insufficient_quota", "insufficient"];
+    OpenAICompatibleClient = class {
+      constructor(config) {
+        this.config = config;
+      }
+      totalIn = 0;
+      totalOut = 0;
+      logTokens(usage) {
+        if (!this.config.logUsage || !usage) {
+          return;
+        }
+        const inputTokens = usage.prompt_tokens ?? 0;
+        const outputTokens = usage.completion_tokens ?? 0;
+        this.totalIn += inputTokens;
+        this.totalOut += outputTokens;
+        console.log(
+          `  [LLM] ${this.config.model} tokens: in=${inputTokens} out=${outputTokens} (total: in=${this.totalIn} out=${this.totalOut})`
+        );
+      }
+      async complete(systemPrompt, userInput, signal) {
+        const response = await fetchWithRetry(
+          `${this.config.baseUrl}/chat/completions`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.config.apiKey}`
+            },
+            body: JSON.stringify({
+              model: this.config.model,
+              max_tokens: this.config.maxTokens,
+              messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: userInput }
+              ]
+            })
+          },
+          signal
+        );
+        if (!response.ok) {
+          throw new Error(
+            `${this.config.providerLabel} API error: ${response.status} ${await response.text()}`
+          );
+        }
+        const data = await response.json();
+        this.logTokens(data.usage);
+        return data.choices?.[0]?.message?.content ?? "";
+      }
+      async completeWithTools(systemPrompt, messages, tools, signal) {
+        const openaiTools = tools.map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+              type: "object",
+              properties: Object.fromEntries(
+                tool.parameters.map((param) => [
+                  param.name,
+                  { type: "string", description: param.description }
+                ])
+              ),
+              required: tool.parameters.filter((param) => param.required).map((param) => param.name)
+            }
+          }
+        }));
+        const response = await fetchWithRetry(
+          `${this.config.baseUrl}/chat/completions`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.config.apiKey}`
+            },
+            body: JSON.stringify({
+              model: this.config.model,
+              max_tokens: this.config.maxTokens,
+              messages: [{ role: "system", content: systemPrompt }, ...messages],
+              tools: openaiTools
+            })
+          },
+          signal
+        );
+        if (!response.ok) {
+          throw new Error(
+            `${this.config.providerLabel} API error: ${response.status} ${await response.text()}`
+          );
+        }
+        const data = await response.json();
+        this.logTokens(data.usage);
+        const message = data.choices?.[0]?.message;
+        const toolCalls = message?.tool_calls ?? [];
+        if (toolCalls.length > 0) {
+          const calls = toolCalls.map((call) => {
+            let args;
+            try {
+              args = JSON.parse(call.function?.arguments ?? "{}");
+            } catch {
+              args = {};
+            }
+            return { id: call.id ?? "", name: call.function?.name ?? "", arguments: args };
+          });
+          return { type: "tool_use", calls, assistantMessage: message };
+        }
+        return { type: "text", text: message?.content ?? "" };
+      }
+      formatToolResultMessages(results) {
+        return results.map((result) => ({
+          role: "tool",
+          tool_call_id: result.callId,
+          content: result.content
+        }));
+      }
+    };
+  }
+});
+
+// src/llm/providers/deepseek.ts
+var DEFAULT_MODEL2, FALLBACK_MODELS2, DEEPSEEK_PROVIDER;
+var init_deepseek = __esm({
+  "src/llm/providers/deepseek.ts"() {
+    init_openai_compatible();
+    DEFAULT_MODEL2 = "deepseek-chat";
+    FALLBACK_MODELS2 = ["deepseek-chat", "deepseek-reasoner"];
+    DEEPSEEK_PROVIDER = createOpenAICompatibleProvider({
+      id: "deepseek",
+      displayName: "DeepSeek",
+      envVar: "DEEPSEEK_API_KEY",
+      baseUrl: "https://api.deepseek.com/v1",
+      defaultModel: DEFAULT_MODEL2,
+      fallbackModels: FALLBACK_MODELS2
+    });
+  }
+});
+
+// src/llm/providers/google.ts
+function mapGeminiModelId(id) {
+  const stripped = id.startsWith(MODELS_PREFIX) ? id.slice(MODELS_PREFIX.length) : id;
+  return stripped.startsWith("gemini") ? stripped : null;
+}
+var DEFAULT_MODEL3, FALLBACK_MODELS3, MODELS_PREFIX, GOOGLE_PROVIDER;
+var init_google = __esm({
+  "src/llm/providers/google.ts"() {
+    init_openai_compatible();
+    DEFAULT_MODEL3 = "gemini-2.5-flash";
+    FALLBACK_MODELS3 = ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash"];
+    MODELS_PREFIX = "models/";
+    GOOGLE_PROVIDER = createOpenAICompatibleProvider({
+      id: "google",
+      displayName: "Google (Gemini)",
+      envVar: "GEMINI_API_KEY",
+      baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+      defaultModel: DEFAULT_MODEL3,
+      fallbackModels: FALLBACK_MODELS3,
+      mapModelId: mapGeminiModelId
+    });
+  }
+});
+
 // src/llm/providers/openai.ts
 function isOpenAIReasoningModel(model) {
   return /^o\d/.test(model) || /^gpt-5(\b|[-.])/.test(model);
@@ -353,15 +637,15 @@ async function fetchModels2(apiKey, signal) {
       signal
     );
     if (!response.ok) {
-      return FALLBACK_MODELS2;
+      return FALLBACK_MODELS4;
     }
     const data = await response.json();
     const models = (data.data ?? []).map((entry) => entry.id).filter(
       (id) => (id.startsWith("gpt-") || id.startsWith("o1") || id.startsWith("o3") || id.startsWith("o4") || id.startsWith("chatgpt-")) && !id.includes("instruct") && !id.includes("realtime") && !id.includes("audio") && !id.includes("tts") && !id.includes("whisper")
     ).sort();
-    return models.length > 0 ? models : FALLBACK_MODELS2;
+    return models.length > 0 ? models : FALLBACK_MODELS4;
   } catch {
-    return FALLBACK_MODELS2;
+    return FALLBACK_MODELS4;
   }
 }
 async function verifyKey2(apiKey, signal) {
@@ -442,13 +726,13 @@ async function verifyKeyDeep2(apiKey, model, signal) {
     return { ok: false, reason: "unavailable", error: message };
   }
 }
-var DEFAULT_MODEL2, DEFAULT_MAX_TOKENS2, FALLBACK_MODELS2, OpenAIClient, BILLING_BODY_MARKERS2, OPENAI_PROVIDER;
+var DEFAULT_MODEL4, DEFAULT_MAX_TOKENS3, FALLBACK_MODELS4, OpenAIClient, BILLING_BODY_MARKERS2, OPENAI_PROVIDER;
 var init_openai = __esm({
   "src/llm/providers/openai.ts"() {
     init_http();
-    DEFAULT_MODEL2 = "gpt-4o-mini";
-    DEFAULT_MAX_TOKENS2 = 4096;
-    FALLBACK_MODELS2 = ["gpt-4o", "gpt-4o-mini", "o3-mini"];
+    DEFAULT_MODEL4 = "gpt-4o-mini";
+    DEFAULT_MAX_TOKENS3 = 4096;
+    FALLBACK_MODELS4 = ["gpt-4o", "gpt-4o-mini", "o3-mini"];
     OpenAIClient = class {
       constructor(config) {
         this.config = config;
@@ -571,15 +855,15 @@ var init_openai = __esm({
       id: "openai",
       displayName: "OpenAI (GPT)",
       envVar: "OPENAI_API_KEY",
-      defaultModel: DEFAULT_MODEL2,
-      fallbackModels: FALLBACK_MODELS2,
+      defaultModel: DEFAULT_MODEL4,
+      fallbackModels: FALLBACK_MODELS4,
       fetchModels: fetchModels2,
       verifyKey: verifyKey2,
       verifyKeyDeep: verifyKeyDeep2,
       createClient: (config) => new OpenAIClient({
         apiKey: config.apiKey,
-        model: config.model ?? DEFAULT_MODEL2,
-        maxTokens: config.maxTokens ?? DEFAULT_MAX_TOKENS2,
+        model: config.model ?? DEFAULT_MODEL4,
+        maxTokens: config.maxTokens ?? DEFAULT_MAX_TOKENS3,
         logUsage: config.logUsage
       }),
       isReasoningModel: isOpenAIReasoningModel
@@ -587,6 +871,24 @@ var init_openai = __esm({
   }
 });
 
+// src/llm/providers/xai.ts
+var DEFAULT_MODEL5, FALLBACK_MODELS5, XAI_PROVIDER;
+var init_xai = __esm({
+  "src/llm/providers/xai.ts"() {
+    init_openai_compatible();
+    DEFAULT_MODEL5 = "grok-3-mini";
+    FALLBACK_MODELS5 = ["grok-4", "grok-3", "grok-3-mini"];
+    XAI_PROVIDER = createOpenAICompatibleProvider({
+      id: "xai",
+      displayName: "xAI (Grok)",
+      envVar: "XAI_API_KEY",
+      baseUrl: "https://api.x.ai/v1",
+      defaultModel: DEFAULT_MODEL5,
+      fallbackModels: FALLBACK_MODELS5
+    });
+  }
+});
+
 // src/llm/registry.ts
 function registerLlmProvider(descriptor) {
   REGISTRY.set(descriptor.id, descriptor);
@@ -604,10 +906,16 @@ var REGISTRY;
 var init_registry = __esm({
   "src/llm/registry.ts"() {
     init_anthropic();
+    init_deepseek();
+    init_google();
     init_openai();
+    init_xai();
     REGISTRY = /* @__PURE__ */ new Map();
     registerLlmProvider(ANTHROPIC_PROVIDER);
     registerLlmProvider(OPENAI_PROVIDER);
+    registerLlmProvider(XAI_PROVIDER);
+    registerLlmProvider(GOOGLE_PROVIDER);
+    registerLlmProvider(DEEPSEEK_PROVIDER);
   }
 });
 
@@ -1510,7 +1818,7 @@ var JobLedger = class {
 init_llm();
 
 // src/llm/resolve.ts
-var DEFAULT_MAX_TOKENS3 = 4096;
+var DEFAULT_MAX_TOKENS4 = 4096;
 function resolveSkillLlm(input, agentDefault) {
   const override = input.llmOverride;
   const overridePairSet = override?.provider !== void 0 && override.model !== void 0;
@@ -1528,7 +1836,7 @@ function resolveSkillLlm(input, agentDefault) {
       error: `Skill "${input.skillName}" at ${input.skillMdPath}: LLM model is required - declare "provider" + "model" in the SKILL.md frontmatter or set agent-level llm via 'npx @elisym/cli profile <agent>'.`
     };
   }
-  const maxTokens = override?.maxTokens ?? agentDefault?.max_tokens ?? DEFAULT_MAX_TOKENS3;
+  const maxTokens = override?.maxTokens ?? agentDefault?.max_tokens ?? DEFAULT_MAX_TOKENS4;
   return { provider, model, maxTokens };
 }
 
@@ -1554,7 +1862,7 @@ function resolveTripleForOverride(override, agentDefault) {
   if (!provider || !model) {
     return void 0;
   }
-  const maxTokens = override?.maxTokens ?? agentDefault?.max_tokens ?? DEFAULT_MAX_TOKENS3;
+  const maxTokens = override?.maxTokens ?? agentDefault?.max_tokens ?? DEFAULT_MAX_TOKENS4;
   return { provider, model, maxTokens };
 }