@elisym/cli 0.9.1 → 0.11.0

package/dist/index.js

@@ -8,6 +8,7 @@ import { generateSecretKey, getPublicKey, nip19, verifyEvent } from 'nostr-tools
 import YAML from 'yaml';
 import { Command } from 'commander';
 import { createHash } from 'node:crypto';
+import { LlmHealthMonitor, startLlmHeartbeat, createFreeLlmLimiterSet, FREE_LLM_GLOBAL_KEY, freeLlmCustomerKey } from '@elisym/sdk/llm-health';
 import { lookup } from 'node:dns/promises';
 import { Socket } from 'node:net';
 import pino from 'pino';
@@ -25,42 +26,643 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/commands/init.ts
-var init_exports = {};
-__export(init_exports, {
-  cmdInit: () => cmdInit,
-  fetchModels: () => fetchModels
+// src/llm/providers/http.ts
+function createAbortError() {
+  const err = new Error("The operation was aborted");
+  err.name = "AbortError";
+  return err;
+}
+function sleepWithSignal(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(createAbortError());
+  }
+  if (!signal) {
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  }
+  return new Promise((resolve3, reject) => {
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(createAbortError());
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve3();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function fetchWithTimeout(url, init, signal) {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), LLM_TIMEOUT_MS);
+  const onAbort = () => controller.abort();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+async function fetchWithRetry(url, init, signal) {
+  for (let attempt = 0; ; attempt++) {
+    let response;
+    try {
+      response = await fetchWithTimeout(url, init, signal);
+    } catch (error) {
+      const name = error instanceof Error ? error.name : "";
+      if (attempt >= MAX_RETRIES || name === "AbortError") {
+        throw error;
+      }
+      await sleepWithSignal(Math.min(1e3 * 2 ** attempt, 8e3), signal);
+      continue;
+    }
+    if (response.ok || attempt >= MAX_RETRIES || !RETRYABLE_STATUSES.has(response.status)) {
+      return response;
+    }
+    const retryAfter = response.headers.get("retry-after");
+    const delay = retryAfter ? Math.min(parseInt(retryAfter, 10) * 1e3 || 1e3 * 2 ** attempt, 3e4) : Math.min(1e3 * 2 ** attempt, 8e3);
+    await response.body?.cancel().catch(() => void 0);
+    await sleepWithSignal(delay, signal);
+  }
+}
+var LLM_TIMEOUT_MS, MAX_RETRIES, RETRYABLE_STATUSES;
+var init_http = __esm({
+  "src/llm/providers/http.ts"() {
+    LLM_TIMEOUT_MS = 12e4;
+    MAX_RETRIES = 2;
+    RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+  }
 });
-async function fetchModels(provider, apiKey) {
+
+// src/llm/providers/anthropic.ts
+async function fetchModels(apiKey, signal) {
   try {
-    if (provider === "anthropic") {
-      const res = await fetch("https://api.anthropic.com/v1/models?limit=1000", {
+    const response = await fetchWithTimeout(
+      "https://api.anthropic.com/v1/models?limit=1000",
+      {
+        method: "GET",
         headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
-      });
-      if (!res.ok) {
-        throw new Error(`${res.status}`);
-      }
-      const data = await res.json();
-      const models = (data.data ?? []).map((m) => m.id).sort();
-      return models.length > 0 ? models : FALLBACK_MODELS.anthropic;
+      },
+      signal
+    );
+    if (!response.ok) {
+      return FALLBACK_MODELS;
     }
-    if (provider === "openai") {
-      const res = await fetch("https://api.openai.com/v1/models", {
-        headers: { Authorization: `Bearer ${apiKey}` }
-      });
-      if (!res.ok) {
-        throw new Error(`${res.status}`);
+    const data = await response.json();
+    const models = (data.data ?? []).map((entry) => entry.id).sort();
+    return models.length > 0 ? models : FALLBACK_MODELS;
+  } catch {
+    return FALLBACK_MODELS;
+  }
+}
+async function verifyKey(apiKey, signal) {
+  try {
+    const response = await fetchWithTimeout(
+      "https://api.anthropic.com/v1/models?limit=1",
+      {
+        method: "GET",
+        headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
+      },
+      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 };
+  }
+}
+function bodyLooksLikeBilling(body) {
+  const lower = body.toLowerCase();
+  return BILLING_BODY_MARKERS.some((marker) => lower.includes(marker));
+}
+async function verifyKeyDeep(apiKey, model, signal) {
+  try {
+    const response = await fetchWithTimeout(
+      "https://api.anthropic.com/v1/messages",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        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 && bodyLooksLikeBilling(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 };
+  }
+}
+var DEFAULT_MODEL, DEFAULT_MAX_TOKENS, FALLBACK_MODELS, AnthropicClient, BILLING_BODY_MARKERS, ANTHROPIC_PROVIDER;
+var init_anthropic = __esm({
+  "src/llm/providers/anthropic.ts"() {
+    init_http();
+    DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+    DEFAULT_MAX_TOKENS = 4096;
+    FALLBACK_MODELS = ["claude-sonnet-4-6", "claude-haiku-4-5-20251001", "claude-opus-4-6"];
+    AnthropicClient = class {
+      constructor(config) {
+        this.config = config;
+      }
+      totalIn = 0;
+      totalOut = 0;
+      logTokens(usage) {
+        if (!this.config.logUsage || !usage) {
+          return;
+        }
+        const inputTokens = usage.input_tokens ?? 0;
+        const outputTokens = usage.output_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})`
+        );
       }
-      const data = await res.json();
-      const models = (data.data ?? []).map((m) => m.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_MODELS.openai;
+      async complete(systemPrompt, userInput, signal) {
+        const response = await fetchWithRetry(
+          "https://api.anthropic.com/v1/messages",
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": this.config.apiKey,
+              "anthropic-version": "2023-06-01"
+            },
+            body: JSON.stringify({
+              model: this.config.model,
+              max_tokens: this.config.maxTokens,
+              system: systemPrompt,
+              messages: [{ role: "user", content: userInput }]
+            })
+          },
+          signal
+        );
+        if (!response.ok) {
+          throw new Error(`Anthropic API error: ${response.status} ${await response.text()}`);
+        }
+        const data = await response.json();
+        this.logTokens(data.usage);
+        const textBlock = data.content?.find((block) => block.type === "text");
+        return textBlock?.text ?? "";
+      }
+      async completeWithTools(systemPrompt, messages, tools, signal) {
+        const anthropicTools = tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          input_schema: {
+            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(
+          "https://api.anthropic.com/v1/messages",
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": this.config.apiKey,
+              "anthropic-version": "2023-06-01"
+            },
+            body: JSON.stringify({
+              model: this.config.model,
+              max_tokens: this.config.maxTokens,
+              system: systemPrompt,
+              messages,
+              tools: anthropicTools
+            })
+          },
+          signal
+        );
+        if (!response.ok) {
+          throw new Error(`Anthropic API error: ${response.status} ${await response.text()}`);
+        }
+        const data = await response.json();
+        this.logTokens(data.usage);
+        const content = data.content ?? [];
+        const toolUses = content.filter((block) => block.type === "tool_use");
+        if (toolUses.length > 0) {
+          const calls = toolUses.map((block) => ({
+            id: block.id ?? "",
+            name: block.name ?? "",
+            arguments: block.input ?? {}
+          }));
+          return {
+            type: "tool_use",
+            calls,
+            assistantMessage: { role: "assistant", content }
+          };
+        }
+        const textBlock = content.find((block) => block.type === "text");
+        return { type: "text", text: textBlock?.text ?? "" };
+      }
+      formatToolResultMessages(results) {
+        return [
+          {
+            role: "user",
+            content: results.map((result) => ({
+              type: "tool_result",
+              tool_use_id: result.callId,
+              content: result.content
+            }))
+          }
+        ];
+      }
+    };
+    BILLING_BODY_MARKERS = ["credit balance", "billing", "insufficient"];
+    ANTHROPIC_PROVIDER = {
+      id: "anthropic",
+      displayName: "Anthropic (Claude)",
+      envVar: "ANTHROPIC_API_KEY",
+      defaultModel: DEFAULT_MODEL,
+      fallbackModels: FALLBACK_MODELS,
+      fetchModels,
+      verifyKey,
+      verifyKeyDeep,
+      createClient: (config) => new AnthropicClient({
+        apiKey: config.apiKey,
+        model: config.model ?? DEFAULT_MODEL,
+        maxTokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
+        logUsage: config.logUsage
+      })
+    };
+  }
+});
+
+// src/llm/providers/openai.ts
+function isOpenAIReasoningModel(model) {
+  return /^o\d/.test(model) || /^gpt-5(\b|[-.])/.test(model);
+}
+async function fetchModels2(apiKey, signal) {
+  try {
+    const response = await fetchWithTimeout(
+      "https://api.openai.com/v1/models",
+      {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}` }
+      },
+      signal
+    );
+    if (!response.ok) {
+      return FALLBACK_MODELS2;
+    }
+    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;
+  } catch {
+    return FALLBACK_MODELS2;
+  }
+}
+async function verifyKey2(apiKey, signal) {
+  try {
+    const response = await fetchWithTimeout(
+      "https://api.openai.com/v1/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 };
+  }
+}
+function bodyLooksLikeBilling2(body) {
+  const lower = body.toLowerCase();
+  return BILLING_BODY_MARKERS2.some((marker) => lower.includes(marker));
+}
+async function verifyKeyDeep2(apiKey, model, signal) {
+  try {
+    const reasoning = isOpenAIReasoningModel(model);
+    const response = await fetchWithTimeout(
+      "https://api.openai.com/v1/chat/completions",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          ...reasoning ? { max_completion_tokens: 1 } : { 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 === 429 && bodyLooksLikeBilling2(body)) {
+      return { ok: false, reason: "billing", status: response.status, body };
+    }
+    if (response.status === 400 && bodyLooksLikeBilling2(body)) {
+      return { ok: false, reason: "billing", status: response.status, body };
     }
-    return ["gpt-4o"];
+    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 };
+  }
+}
+var DEFAULT_MODEL2, DEFAULT_MAX_TOKENS2, FALLBACK_MODELS2, 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"];
+    OpenAIClient = class {
+      constructor(config) {
+        this.config = config;
+      }
+      totalIn = 0;
+      totalOut = 0;
+      isReasoningModel() {
+        return isOpenAIReasoningModel(this.config.model);
+      }
+      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 reasoning = this.isReasoningModel();
+        const response = await fetchWithRetry(
+          "https://api.openai.com/v1/chat/completions",
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.config.apiKey}`
+            },
+            body: JSON.stringify({
+              model: this.config.model,
+              ...reasoning ? { max_completion_tokens: this.config.maxTokens } : { max_tokens: this.config.maxTokens },
+              messages: [
+                { role: reasoning ? "developer" : "system", content: systemPrompt },
+                { role: "user", content: userInput }
+              ]
+            })
+          },
+          signal
+        );
+        if (!response.ok) {
+          throw new Error(`OpenAI 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 reasoning = this.isReasoningModel();
+        const response = await fetchWithRetry(
+          "https://api.openai.com/v1/chat/completions",
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.config.apiKey}`
+            },
+            body: JSON.stringify({
+              model: this.config.model,
+              ...reasoning ? { max_completion_tokens: this.config.maxTokens } : { max_tokens: this.config.maxTokens },
+              messages: [
+                { role: reasoning ? "developer" : "system", content: systemPrompt },
+                ...messages
+              ],
+              tools: openaiTools
+            })
+          },
+          signal
+        );
+        if (!response.ok) {
+          throw new Error(`OpenAI 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
+        }));
+      }
+    };
+    BILLING_BODY_MARKERS2 = ["credit balance", "billing", "insufficient_quota", "insufficient"];
+    OPENAI_PROVIDER = {
+      id: "openai",
+      displayName: "OpenAI (GPT)",
+      envVar: "OPENAI_API_KEY",
+      defaultModel: DEFAULT_MODEL2,
+      fallbackModels: FALLBACK_MODELS2,
+      fetchModels: fetchModels2,
+      verifyKey: verifyKey2,
+      verifyKeyDeep: verifyKeyDeep2,
+      createClient: (config) => new OpenAIClient({
+        apiKey: config.apiKey,
+        model: config.model ?? DEFAULT_MODEL2,
+        maxTokens: config.maxTokens ?? DEFAULT_MAX_TOKENS2,
+        logUsage: config.logUsage
+      }),
+      isReasoningModel: isOpenAIReasoningModel
+    };
+  }
+});
+
+// src/llm/registry.ts
+function registerLlmProvider(descriptor) {
+  REGISTRY.set(descriptor.id, descriptor);
+}
+function getLlmProvider(id) {
+  return REGISTRY.get(id);
+}
+function listLlmProviders() {
+  return Array.from(REGISTRY.values());
+}
+function getRegisteredProviderIds() {
+  return Array.from(REGISTRY.keys());
+}
+var REGISTRY;
+var init_registry = __esm({
+  "src/llm/registry.ts"() {
+    init_anthropic();
+    init_openai();
+    REGISTRY = /* @__PURE__ */ new Map();
+    registerLlmProvider(ANTHROPIC_PROVIDER);
+    registerLlmProvider(OPENAI_PROVIDER);
+  }
+});
+
+// src/llm/index.ts
+function createLlmClient(config) {
+  const descriptor = getLlmProvider(config.provider);
+  if (!descriptor) {
+    const known = getRegisteredProviderIds().join(", ") || "<none>";
+    throw new Error(`Unknown LLM provider "${config.provider}". Registered: ${known}.`);
+  }
+  if (!config.apiKey) {
+    throw new Error(`${descriptor.envVar} is required for skill runtime`);
+  }
+  return descriptor.createClient({
+    apiKey: config.apiKey,
+    model: config.model,
+    maxTokens: config.maxTokens,
+    logUsage: config.logUsage
+  });
+}
+async function verifyLlmApiKeyDeep(provider, apiKey, model, signal) {
+  const descriptor = getLlmProvider(provider);
+  if (!descriptor) {
+    return {
+      ok: false,
+      reason: "unavailable",
+      error: `Unknown LLM provider "${provider}"`
+    };
+  }
+  return descriptor.verifyKeyDeep(apiKey, model, signal);
+}
+var init_llm = __esm({
+  "src/llm/index.ts"() {
+    init_registry();
+    init_registry();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  cmdInit: () => cmdInit,
+  fetchModels: () => fetchModels3
+});
+async function fetchModels3(provider, apiKey) {
+  const descriptor = getLlmProvider(provider);
+  if (!descriptor) {
+    console.warn(`  ! Unknown provider "${provider}". No models available.`);
+    return [];
+  }
+  try {
+    return await descriptor.fetchModels(apiKey);
   } catch (e) {
     console.warn(`  ! Could not fetch models: ${e.message}. Using defaults.`);
-    return FALLBACK_MODELS[provider] ?? ["gpt-4o"];
+    return descriptor.fallbackModels;
   }
 }
 function pickTarget(options) {
@@ -140,55 +742,61 @@ async function cmdInit(nameArg, options = {}) {
     promptedApiKey = result.apiKey;
   }
   let defaultProviderKey;
-  if (yaml.llm) {
-    const envKey = yaml.llm.provider === "anthropic" ? process.env.ANTHROPIC_API_KEY : process.env.OPENAI_API_KEY;
-    if (envKey) {
+  const defaultProviderId = yaml.llm?.provider;
+  if (yaml.llm && defaultProviderId) {
+    const descriptor = getLlmProvider(defaultProviderId);
+    const envKey = descriptor ? process.env[descriptor.envVar] : void 0;
+    if (envKey && descriptor) {
       defaultProviderKey = envKey;
-      console.log(
-        `  Using ${yaml.llm.provider === "anthropic" ? "ANTHROPIC" : "OPENAI"}_API_KEY from environment.`
-      );
+      console.log(`  Using ${descriptor.envVar} from environment.`);
     } else if (promptedApiKey) {
       defaultProviderKey = promptedApiKey;
     } else {
+      const label = descriptor?.displayName ?? defaultProviderId;
       const { apiKey } = await inquirer.prompt([
         {
           type: "password",
           name: "apiKey",
-          message: `${yaml.llm.provider === "anthropic" ? "Anthropic" : "OpenAI"} API key:`,
+          message: `${label} API key:`,
           mask: "*"
         }
       ]);
       defaultProviderKey = apiKey || void 0;
     }
   }
-  let otherProviderKey;
-  if (yaml.llm && !template) {
-    const otherProvider = yaml.llm.provider === "anthropic" ? "openai" : "anthropic";
-    const otherProviderLabel = otherProvider === "anthropic" ? "Anthropic" : "OpenAI";
-    const otherEnvVar = otherProvider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
-    const otherEnvKey = process.env[otherEnvVar];
-    const { configureOther } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "configureOther",
-        message: `Configure ${otherProviderLabel} API key too (for skills that override the default provider)?`,
-        default: Boolean(otherEnvKey)
+  const otherProviderKeys = /* @__PURE__ */ new Map();
+  if (yaml.llm && !template && defaultProviderId) {
+    const otherDescriptors = listLlmProviders().filter(
+      (descriptor) => descriptor.id !== defaultProviderId
+    );
+    for (const descriptor of otherDescriptors) {
+      const otherEnvKey = process.env[descriptor.envVar];
+      const { configureOther } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "configureOther",
+          message: `Configure ${descriptor.displayName} API key too (for skills that override the default provider)?`,
+          default: Boolean(otherEnvKey)
+        }
+      ]);
+      if (!configureOther) {
+        continue;
       }
-    ]);
-    if (configureOther) {
       if (otherEnvKey) {
-        otherProviderKey = otherEnvKey;
-        console.log(`  Using ${otherEnvVar} from environment.`);
+        otherProviderKeys.set(descriptor.id, otherEnvKey);
+        console.log(`  Using ${descriptor.envVar} from environment.`);
       } else {
         const { promptedOther } = await inquirer.prompt([
           {
             type: "password",
             name: "promptedOther",
-            message: `${otherProviderLabel} API key:`,
+            message: `${descriptor.displayName} API key:`,
             mask: "*"
           }
         ]);
-        otherProviderKey = promptedOther || void 0;
+        if (promptedOther) {
+          otherProviderKeys.set(descriptor.id, promptedOther);
+        }
       }
     }
   }
@@ -224,15 +832,17 @@ async function cmdInit(nameArg, options = {}) {
   const nostrPubkey = getPublicKey(nostrSecretBytes);
   const nostrSecretHex = Buffer.from(nostrSecretBytes).toString("hex");
   const created = await createAgentDir({ target, name: agentName, cwd });
-  const anthropicKey = yaml.llm?.provider === "anthropic" ? defaultProviderKey : otherProviderKey;
-  const openaiKey = yaml.llm?.provider === "openai" ? defaultProviderKey : otherProviderKey;
+  const collectedKeys = new Map(otherProviderKeys);
+  if (yaml.llm && defaultProviderKey) {
+    collectedKeys.set(yaml.llm.provider, defaultProviderKey);
+  }
+  const llmApiKeys = Object.fromEntries(collectedKeys);
   await writeYaml(created.dir, yaml);
   await writeSecrets(
     created.dir,
     {
       nostr_secret_key: nostrSecretHex,
-      anthropic_api_key: anthropicKey,
-      openai_api_key: openaiKey
+      llm_api_keys: Object.keys(llmApiKeys).length > 0 ? llmApiKeys : void 0
     },
     passphrase || void 0
   );
@@ -334,8 +944,10 @@ async function promptYaml(inquirer) {
           name: "None (non-LLM agent - static-file / static-script / dynamic-script only)",
           value: "none"
         },
-        { name: "Anthropic (Claude)", value: "anthropic" },
-        { name: "OpenAI (GPT)", value: "openai" }
+        ...listLlmProviders().map((descriptor2) => ({
+          name: descriptor2.displayName,
+          value: descriptor2.id
+        }))
       ]
     }
   ]);
@@ -352,21 +964,25 @@ async function promptYaml(inquirer) {
     const yaml2 = ElisymYamlSchema.parse(baseYaml);
     return { yaml: yaml2 };
   }
-  const envKey = llmProvider === "anthropic" ? process.env.ANTHROPIC_API_KEY : process.env.OPENAI_API_KEY;
+  const descriptor = getLlmProvider(llmProvider);
+  if (!descriptor) {
+    throw new Error(`Internal: provider "${llmProvider}" not registered.`);
+  }
+  const envKey = process.env[descriptor.envVar];
   let apiKey = envKey;
   if (!apiKey) {
     const { promptedKey } = await inquirer.prompt([
       {
         type: "password",
         name: "promptedKey",
-        message: `${llmProvider === "anthropic" ? "Anthropic" : "OpenAI"} API key:`,
+        message: `${descriptor.displayName} API key:`,
         mask: "*"
       }
     ]);
     apiKey = promptedKey || void 0;
   }
   console.log("  Fetching available models...");
-  const models = await fetchModels(llmProvider, apiKey ?? "");
+  const models = await fetchModels3(llmProvider, apiKey ?? "");
   const { model } = await inquirer.prompt([
     {
       type: "list",
@@ -389,18 +1005,17 @@ async function promptYaml(inquirer) {
   });
   return { yaml, apiKey: envKey ? void 0 : apiKey };
 }
-var FALLBACK_MODELS;
 var init_init = __esm({
   "src/commands/init.ts"() {
-    FALLBACK_MODELS = {
-      anthropic: ["claude-sonnet-4-6", "claude-haiku-4-5-20251001", "claude-opus-4-6"],
-      openai: ["gpt-4o", "gpt-4o-mini", "o3-mini"]
-    };
+    init_llm();
   }
 });
 
 // src/index.ts
 init_init();
+
+// src/commands/profile.ts
+init_llm();
 async function cmdProfile(name) {
   const { default: inquirer } = await import('inquirer');
   const cwd = process.cwd();
@@ -519,32 +1134,45 @@ async function cmdProfile(name) {
       console.log("  Wallet updated.\n");
     }
     if (section === "llm") {
+      const providerChoices = listLlmProviders().map((descriptor) => ({
+        name: descriptor.displayName,
+        value: descriptor.id
+      }));
+      if (providerChoices.length === 0) {
+        console.error("  ! No LLM providers registered.");
+        continue;
+      }
+      const firstChoice = providerChoices[0];
+      if (!firstChoice) {
+        console.error("  ! No LLM providers registered.");
+        continue;
+      }
       const { llmProvider } = await inquirer.prompt([
         {
           type: "list",
           name: "llmProvider",
           message: "Default LLM provider (used by skills without a `provider:` override):",
-          choices: [
-            { name: "Anthropic (Claude)", value: "anthropic" },
-            { name: "OpenAI (GPT)", value: "openai" }
-          ],
-          default: loaded.yaml.llm?.provider ?? "anthropic"
+          choices: providerChoices,
+          default: loaded.yaml.llm?.provider ?? firstChoice.value
         }
       ]);
-      const otherProvider = llmProvider === "anthropic" ? "openai" : "anthropic";
+      const defaultDescriptor = getLlmProvider(llmProvider);
+      if (!defaultDescriptor) {
+        throw new Error(`Internal: provider "${llmProvider}" not registered.`);
+      }
       const defaultKeyStatus = describeKeyStatus(loaded.secrets, llmProvider);
       const { apiKey } = await inquirer.prompt([
         {
           type: "password",
           name: "apiKey",
-          message: `${labelFor(llmProvider)} API key [${defaultKeyStatus}] (leave empty to keep current):`,
+          message: `${defaultDescriptor.displayName} API key [${defaultKeyStatus}] (leave empty to keep current):`,
           mask: "*"
         }
       ]);
       const probeKey = apiKey || pickPlainKey(loaded.secrets, llmProvider);
       console.log("  Fetching available models...");
-      const { fetchModels: fetchModels2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-      const models = await fetchModels2(llmProvider, probeKey);
+      const { fetchModels: fetchModels4 } = await Promise.resolve().then(() => (init_init(), init_exports));
+      const models = await fetchModels4(llmProvider, probeKey);
       const { model } = await inquirer.prompt([
         {
           type: "list",
@@ -562,35 +1190,42 @@ async function cmdProfile(name) {
           default: loaded.yaml.llm?.max_tokens ?? 4096
         }
       ]);
-      const otherKeyStatus = describeKeyStatus(loaded.secrets, otherProvider);
-      const { otherApiKey } = await inquirer.prompt([
-        {
-          type: "password",
-          name: "otherApiKey",
-          message: `${labelFor(otherProvider)} API key for skill overrides [${otherKeyStatus}] (leave empty to keep current):`,
-          mask: "*"
+      const otherDescriptors = listLlmProviders().filter(
+        (descriptor) => descriptor.id !== llmProvider
+      );
+      const otherKeys = /* @__PURE__ */ new Map();
+      for (const descriptor of otherDescriptors) {
+        const status = describeKeyStatus(loaded.secrets, descriptor.id);
+        const { otherApiKey } = await inquirer.prompt([
+          {
+            type: "password",
+            name: "otherApiKey",
+            message: `${descriptor.displayName} API key for skill overrides [${status}] (leave empty to keep current):`,
+            mask: "*"
+          }
+        ]);
+        if (otherApiKey) {
+          otherKeys.set(descriptor.id, otherApiKey);
         }
-      ]);
+      }
       const nextLlm = { provider: llmProvider, model, max_tokens: maxTokens };
       const nextYaml = { ...loaded.yaml, llm: nextLlm };
       await writeYaml(loaded.dir, nextYaml);
       loaded.yaml = nextYaml;
-      if (apiKey || otherApiKey) {
-        const nextSecrets = { ...loaded.secrets };
+      if (apiKey || otherKeys.size > 0) {
+        const nextLlmApiKeys = {
+          ...loaded.secrets.llm_api_keys ?? {}
+        };
         if (apiKey) {
-          if (llmProvider === "anthropic") {
-            nextSecrets.anthropic_api_key = apiKey;
-          } else {
-            nextSecrets.openai_api_key = apiKey;
-          }
+          nextLlmApiKeys[llmProvider] = apiKey;
         }
-        if (otherApiKey) {
-          if (otherProvider === "anthropic") {
-            nextSecrets.anthropic_api_key = otherApiKey;
-          } else {
-            nextSecrets.openai_api_key = otherApiKey;
-          }
+        for (const [providerId, key] of otherKeys) {
+          nextLlmApiKeys[providerId] = key;
         }
+        const nextSecrets = {
+          ...loaded.secrets,
+          llm_api_keys: nextLlmApiKeys
+        };
         await writeSecrets(loaded.dir, nextSecrets, passphrase);
         loaded.secrets = nextSecrets;
       }
@@ -606,16 +1241,12 @@ function truncate(value, max = 40) {
   }
   return value.slice(0, max - 1) + "\u2026";
 }
-function labelFor(provider) {
-  return provider === "anthropic" ? "Anthropic" : "OpenAI";
-}
-function describeKeyStatus(secrets, provider) {
-  const perProviderField = provider === "anthropic" ? "anthropic_api_key" : "openai_api_key";
-  return secrets[perProviderField] ? "set" : "not set";
+function describeKeyStatus(secrets, providerId) {
+  return secrets.llm_api_keys?.[providerId] ? "set" : "not set";
 }
-function pickPlainKey(secrets, provider) {
-  const perProviderField = provider === "anthropic" ? "anthropic_api_key" : "openai_api_key";
-  return secrets[perProviderField] ?? "";
+function pickPlainKey(secrets, providerId) {
+  const value = secrets.llm_api_keys?.[providerId];
+  return typeof value === "string" ? value : "";
 }
 var TCP_PROBE_TIMEOUT_MS = 3e3;
 function parseRelayUrl(url) {
@@ -875,322 +1506,11 @@ var JobLedger = class {
   }
 };
 
-// src/llm/index.ts
-var LLM_TIMEOUT_MS = 12e4;
-var MAX_RETRIES = 2;
-var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
-function createAbortError() {
-  const err = new Error("The operation was aborted");
-  err.name = "AbortError";
-  return err;
-}
-function sleepWithSignal(ms, signal) {
-  if (signal?.aborted) {
-    throw createAbortError();
-  }
-  if (!signal) {
-    return new Promise((r) => setTimeout(r, ms));
-  }
-  return new Promise((resolve3, reject) => {
-    const cleanup = () => {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", onAbort);
-    };
-    const onAbort = () => {
-      cleanup();
-      reject(createAbortError());
-    };
-    const timer = setTimeout(() => {
-      cleanup();
-      resolve3();
-    }, ms);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-async function fetchWithTimeout(url, init, signal) {
-  if (signal?.aborted) {
-    throw createAbortError();
-  }
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), LLM_TIMEOUT_MS);
-  const onAbort = () => controller.abort();
-  signal?.addEventListener("abort", onAbort, { once: true });
-  try {
-    return await fetch(url, { ...init, signal: controller.signal });
-  } finally {
-    clearTimeout(timer);
-    signal?.removeEventListener("abort", onAbort);
-  }
-}
-async function fetchWithRetry(url, init, signal) {
-  for (let attempt = 0; ; attempt++) {
-    let res;
-    try {
-      res = await fetchWithTimeout(url, init, signal);
-    } catch (e) {
-      if (attempt >= MAX_RETRIES || e.name === "AbortError") {
-        throw e;
-      }
-      await sleepWithSignal(Math.min(1e3 * 2 ** attempt, 8e3), signal);
-      continue;
-    }
-    if (res.ok || attempt >= MAX_RETRIES || !RETRYABLE_STATUSES.has(res.status)) {
-      return res;
-    }
-    const retryAfter = res.headers.get("retry-after");
-    const delay = retryAfter ? Math.min(parseInt(retryAfter, 10) * 1e3 || 1e3 * 2 ** attempt, 3e4) : Math.min(1e3 * 2 ** attempt, 8e3);
-    await sleepWithSignal(delay, signal);
-  }
-}
-function isReasoningModel(model) {
-  return /^o\d/.test(model) || /^gpt-5(\b|[-.])/.test(model);
-}
-function createLlmClient(config) {
-  if (config.provider === "anthropic") {
-    return new AnthropicClient(config);
-  }
-  return new OpenAIClient(config);
-}
-async function verifyLlmApiKey(provider, apiKey, signal) {
-  const url = provider === "anthropic" ? "https://api.anthropic.com/v1/models?limit=1" : "https://api.openai.com/v1/models";
-  const headers = provider === "anthropic" ? { "x-api-key": apiKey, "anthropic-version": "2023-06-01" } : { Authorization: `Bearer ${apiKey}` };
-  try {
-    const res = await fetchWithTimeout(url, { method: "GET", headers }, signal);
-    if (res.ok) {
-      await res.body?.cancel().catch(() => void 0);
-      return { ok: true };
-    }
-    const body = (await res.text().catch(() => "")).slice(0, 500);
-    if (res.status === 401 || res.status === 403) {
-      return { ok: false, reason: "invalid", status: res.status, body };
-    }
-    return { ok: false, reason: "unavailable", error: `HTTP ${res.status}: ${body.slice(0, 200)}` };
-  } catch (e) {
-    return { ok: false, reason: "unavailable", error: e?.message ?? String(e) };
-  }
-}
-var AnthropicClient = class {
-  constructor(config) {
-    this.config = config;
-  }
-  totalIn = 0;
-  totalOut = 0;
-  logTokens(usage) {
-    if (this.config.logUsage && usage) {
-      this.totalIn += usage.input_tokens ?? 0;
-      this.totalOut += usage.output_tokens ?? 0;
-      console.log(
-        `  [LLM] ${this.config.model} tokens: in=${usage.input_tokens ?? 0} out=${usage.output_tokens ?? 0} (total: in=${this.totalIn} out=${this.totalOut})`
-      );
-    }
-  }
-  async complete(systemPrompt, userInput, signal) {
-    const res = await fetchWithRetry(
-      "https://api.anthropic.com/v1/messages",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": this.config.apiKey,
-          "anthropic-version": "2023-06-01"
-        },
-        body: JSON.stringify({
-          model: this.config.model,
-          max_tokens: this.config.maxTokens,
-          system: systemPrompt,
-          messages: [{ role: "user", content: userInput }]
-        })
-      },
-      signal
-    );
-    if (!res.ok) {
-      throw new Error(`Anthropic API error: ${res.status} ${await res.text()}`);
-    }
-    const data = await res.json();
-    this.logTokens(data.usage);
-    const textBlock = data.content?.find((b) => b.type === "text");
-    return textBlock?.text ?? "";
-  }
-  async completeWithTools(systemPrompt, messages, tools, signal) {
-    const anthropicTools = tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: {
-        type: "object",
-        properties: Object.fromEntries(
-          t.parameters.map((p) => [p.name, { type: "string", description: p.description }])
-        ),
-        required: t.parameters.filter((p) => p.required).map((p) => p.name)
-      }
-    }));
-    const res = await fetchWithRetry(
-      "https://api.anthropic.com/v1/messages",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": this.config.apiKey,
-          "anthropic-version": "2023-06-01"
-        },
-        body: JSON.stringify({
-          model: this.config.model,
-          max_tokens: this.config.maxTokens,
-          system: systemPrompt,
-          messages,
-          tools: anthropicTools
-        })
-      },
-      signal
-    );
-    if (!res.ok) {
-      throw new Error(`Anthropic API error: ${res.status} ${await res.text()}`);
-    }
-    const data = await res.json();
-    this.logTokens(data.usage);
-    const content = data.content ?? [];
-    const toolUses = content.filter((b) => b.type === "tool_use");
-    if (toolUses.length > 0) {
-      const calls = toolUses.map((t) => ({
-        id: t.id,
-        name: t.name,
-        arguments: t.input ?? {}
-      }));
-      return {
-        type: "tool_use",
-        calls,
-        assistantMessage: { role: "assistant", content }
-      };
-    }
-    const textBlock = content.find((b) => b.type === "text");
-    return { type: "text", text: textBlock?.text ?? "" };
-  }
-  formatToolResultMessages(results) {
-    return [
-      {
-        role: "user",
-        content: results.map((r) => ({
-          type: "tool_result",
-          tool_use_id: r.callId,
-          content: r.content
-        }))
-      }
-    ];
-  }
-};
-var OpenAIClient = class {
-  constructor(config) {
-    this.config = config;
-  }
-  totalIn = 0;
-  totalOut = 0;
-  logTokens(usage) {
-    if (this.config.logUsage && usage) {
-      this.totalIn += usage.prompt_tokens ?? 0;
-      this.totalOut += usage.completion_tokens ?? 0;
-      console.log(
-        `  [LLM] ${this.config.model} tokens: in=${usage.prompt_tokens ?? 0} out=${usage.completion_tokens ?? 0} (total: in=${this.totalIn} out=${this.totalOut})`
-      );
-    }
-  }
-  async complete(systemPrompt, userInput, signal) {
-    const isReasoning = isReasoningModel(this.config.model);
-    const res = await fetchWithRetry(
-      "https://api.openai.com/v1/chat/completions",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.config.apiKey}`
-        },
-        body: JSON.stringify({
-          model: this.config.model,
-          ...isReasoning ? { max_completion_tokens: this.config.maxTokens } : { max_tokens: this.config.maxTokens },
-          messages: [
-            { role: isReasoning ? "developer" : "system", content: systemPrompt },
-            { role: "user", content: userInput }
-          ]
-        })
-      },
-      signal
-    );
-    if (!res.ok) {
-      throw new Error(`OpenAI API error: ${res.status} ${await res.text()}`);
-    }
-    const data = await res.json();
-    this.logTokens(data.usage);
-    return data.choices?.[0]?.message?.content ?? "";
-  }
-  async completeWithTools(systemPrompt, messages, tools, signal) {
-    const openaiTools = tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: {
-          type: "object",
-          properties: Object.fromEntries(
-            t.parameters.map((p) => [p.name, { type: "string", description: p.description }])
-          ),
-          required: t.parameters.filter((p) => p.required).map((p) => p.name)
-        }
-      }
-    }));
-    const isReasoning = isReasoningModel(this.config.model);
-    const res = await fetchWithRetry(
-      "https://api.openai.com/v1/chat/completions",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.config.apiKey}`
-        },
-        body: JSON.stringify({
-          model: this.config.model,
-          ...isReasoning ? { max_completion_tokens: this.config.maxTokens } : { max_tokens: this.config.maxTokens },
-          messages: [
-            { role: isReasoning ? "developer" : "system", content: systemPrompt },
-            ...messages
-          ],
-          tools: openaiTools
-        })
-      },
-      signal
-    );
-    if (!res.ok) {
-      throw new Error(`OpenAI API error: ${res.status} ${await res.text()}`);
-    }
-    const data = await res.json();
-    this.logTokens(data.usage);
-    const message = data.choices?.[0]?.message;
-    if (message?.tool_calls?.length > 0) {
-      const calls = message.tool_calls.map((tc) => {
-        let args;
-        try {
-          args = JSON.parse(tc.function.arguments ?? "{}");
-        } catch {
-          args = {};
-        }
-        return { id: tc.id, name: tc.function.name, arguments: args };
-      });
-      return {
-        type: "tool_use",
-        calls,
-        assistantMessage: message
-      };
-    }
-    return { type: "text", text: message?.content ?? "" };
-  }
-  formatToolResultMessages(results) {
-    return results.map((r) => ({
-      role: "tool",
-      tool_call_id: r.callId,
-      content: r.content
-    }));
-  }
-};
+// src/commands/start.ts
+init_llm();
 
 // src/llm/resolve.ts
-var DEFAULT_MAX_TOKENS = 4096;
+var DEFAULT_MAX_TOKENS3 = 4096;
 function resolveSkillLlm(input, agentDefault) {
   const override = input.llmOverride;
   const overridePairSet = override?.provider !== void 0 && override.model !== void 0;
@@ -1208,7 +1528,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_TOKENS;
+  const maxTokens = override?.maxTokens ?? agentDefault?.max_tokens ?? DEFAULT_MAX_TOKENS3;
   return { provider, model, maxTokens };
 }
 
@@ -1234,34 +1554,32 @@ function resolveTripleForOverride(override, agentDefault) {
   if (!provider || !model) {
     return void 0;
   }
-  const maxTokens = override?.maxTokens ?? agentDefault?.max_tokens ?? DEFAULT_MAX_TOKENS;
+  const maxTokens = override?.maxTokens ?? agentDefault?.max_tokens ?? DEFAULT_MAX_TOKENS3;
   return { provider, model, maxTokens };
 }
 
 // src/llm/keys.ts
-var ENV_VAR_FOR_PROVIDER = {
-  anthropic: "ANTHROPIC_API_KEY",
-  openai: "OPENAI_API_KEY"
-};
-var SECRET_FIELD_FOR_PROVIDER = {
-  anthropic: "anthropic_api_key",
-  openai: "openai_api_key"
-};
+init_registry();
 function resolveProviderApiKey(input) {
   const { provider, secrets, dependentSkills } = input;
-  const perProviderField = SECRET_FIELD_FOR_PROVIDER[provider];
-  const perProviderValue = secrets[perProviderField];
-  if (perProviderValue) {
+  const descriptor = getLlmProvider(provider);
+  if (!descriptor) {
+    const skillList2 = dependentSkills.length > 0 ? dependentSkills.join(", ") : "<none>";
+    return {
+      error: `Provider "${provider}" is not registered (required by skill(s): ${skillList2}).`
+    };
+  }
+  const perProviderValue = secrets.llm_api_keys?.[provider];
+  if (typeof perProviderValue === "string" && perProviderValue.length > 0) {
     return { apiKey: perProviderValue, origin: "secrets-per-provider" };
   }
-  const envVar = ENV_VAR_FOR_PROVIDER[provider];
-  const envValue = process.env[envVar];
+  const envValue = process.env[descriptor.envVar];
   if (envValue) {
     return { apiKey: envValue, origin: "env" };
   }
   const skillList = dependentSkills.length > 0 ? dependentSkills.join(", ") : "<none>";
   return {
-    error: `Provider "${provider}" needs an API key (required by skill(s): ${skillList}). Set secrets.${perProviderField} via 'npx @elisym/cli profile <agent>' or export ${envVar}.`
+    error: `Provider "${provider}" needs an API key (required by skill(s): ${skillList}). Set secrets.llm_api_keys.${provider} via 'npx @elisym/cli profile <agent>' or export ${descriptor.envVar}.`
   };
 }
 function resolveLevel(options) {
@@ -1330,13 +1648,14 @@ var GLOBAL_MAX_JOBS_PER_WINDOW = 200;
 var MAX_TRACKED_CUSTOMERS = 1e3;
 var GLOBAL_LIMITER_KEY = "__global__";
 var AgentRuntime = class {
-  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}) {
+  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}, healthMonitor) {
     this.transport = transport;
     this.skills = skills;
     this.skillCtx = skillCtx;
     this.config = config;
     this.ledger = ledger;
     this.callbacks = callbacks;
+    this.healthMonitor = healthMonitor;
     this.limit = pLimit(config.maxConcurrentJobs);
     this.maxQueueSize = config.maxQueueSize ?? config.maxConcurrentJobs * 10;
   }
@@ -1361,6 +1680,13 @@ var AgentRuntime = class {
     maxPerWindow: GLOBAL_MAX_JOBS_PER_WINDOW,
     maxKeys: 1
   });
+  /**
+   * Two-tier limiter applied only to free LLM skills (mode='llm', price=0).
+   * Existing per-customer + global limiters above remain in effect for all
+   * jobs; this set adds tighter caps to prevent unpaid spam from draining
+   * the operator's API key.
+   */
+  freeLlmLimiters = createFreeLlmLimiterSet();
   /** Fetch on-chain protocol config (fee, treasury). Always fetches fresh to avoid stale treasury. */
   async fetchProtocolConfig() {
     if (this.config.network !== "devnet") {
@@ -1417,8 +1743,33 @@ var AgentRuntime = class {
         });
         return;
       }
+      const matched = this.skills.route(job.tags);
+      const isFreeLlm = matched?.mode === "llm" && matched.priceSubunits === 0;
+      let perCustomerLimiter;
+      let perSkillKey;
+      if (isFreeLlm && matched) {
+        if (!this.freeLlmLimiters.globalLimiter.peek(FREE_LLM_GLOBAL_KEY).allowed) {
+          this.transport.sendFeedback(job, { type: "error", message: "Rate limited, try again later" }).catch(() => {
+          });
+          return;
+        }
+        perCustomerLimiter = this.freeLlmLimiters.getPerCustomerLimiter(
+          matched.name,
+          matched.rateLimit
+        );
+        perSkillKey = freeLlmCustomerKey(job.customerId, matched.name);
+        if (!perCustomerLimiter.peek(perSkillKey).allowed) {
+          this.transport.sendFeedback(job, { type: "error", message: "Rate limited, try again later" }).catch(() => {
+          });
+          return;
+        }
+      }
       this.customerLimiter.check(job.customerId);
       this.globalLimiter.check(GLOBAL_LIMITER_KEY);
+      if (isFreeLlm && perCustomerLimiter && perSkillKey) {
+        this.freeLlmLimiters.globalLimiter.check(FREE_LLM_GLOBAL_KEY);
+        perCustomerLimiter.check(perSkillKey);
+      }
       this.callbacks.onJobReceived?.(job);
       this.inFlight.add(job.jobId);
       this.pending++;
@@ -1446,10 +1797,12 @@ var AgentRuntime = class {
       process.on("SIGTERM", onSignal);
     });
   }
-  /** Drop expired hits from both sliding-window limiters. */
+  /** Drop expired hits from every sliding-window limiter. */
   cleanupRateLimits() {
     this.customerLimiter.prune();
     this.globalLimiter.prune();
+    this.freeLlmLimiters.globalLimiter.prune();
+    this.freeLlmLimiters.prunePerCustomer();
   }
   stop() {
     if (this.stopped) {
@@ -1513,6 +1866,24 @@ var AgentRuntime = class {
     if (job.input.length > LIMITS.MAX_INPUT_LENGTH) {
       throw new Error(`Input too long: ${job.input.length} chars (max ${LIMITS.MAX_INPUT_LENGTH})`);
     }
+    const matched = this.skills.route(job.tags);
+    if (this.healthMonitor && matched && matched.mode === "llm" && matched.resolvedTriple) {
+      try {
+        await this.healthMonitor.assertReady(
+          matched.resolvedTriple.provider,
+          matched.resolvedTriple.model
+        );
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        log(`[${job.jobId.slice(0, 8)}] LLM health gate refused job: ${detail}`);
+        await this.transport.sendFeedback(job, {
+          type: "error",
+          message: "Service temporarily unavailable, try again later"
+        }).catch(() => {
+        });
+        return;
+      }
+    }
     const jobPrice = resolveJobPrice(job.tags, this.skills);
     const jobAsset = resolveJobAsset(job.tags, this.skills);
     let netAmount;
@@ -2109,9 +2480,10 @@ var ScriptSkill = class {
 
 // src/skill/loader.ts
 function buildCliSkill(parsed, entryPath) {
+  let skill;
   switch (parsed.mode) {
     case "llm":
-      return new ScriptSkill(
+      skill = new ScriptSkill(
         parsed.name,
         parsed.description,
         parsed.capabilities,
@@ -2125,6 +2497,7 @@ function buildCliSkill(parsed, entryPath) {
         parsed.maxToolRounds,
         parsed.llmOverride
       );
+      break;
     case "static-file": {
       if (parsed.outputFile === void 0) {
         throw new Error(
@@ -2137,7 +2510,7 @@ function buildCliSkill(parsed, entryPath) {
           `SKILL.md "${parsed.name}": "output_file" must stay inside the skill directory`
         );
       }
-      return new StaticFileSkill({
+      skill = new StaticFileSkill({
         name: parsed.name,
         description: parsed.description,
         capabilities: parsed.capabilities,
@@ -2148,6 +2521,7 @@ function buildCliSkill(parsed, entryPath) {
         imageFile: parsed.imageFile,
         dir: entryPath
       });
+      break;
     }
     case "static-script":
     case "dynamic-script": {
@@ -2161,7 +2535,7 @@ function buildCliSkill(parsed, entryPath) {
         throw new Error(`SKILL.md "${parsed.name}": "script" must stay inside the skill directory`);
       }
       const Ctor = parsed.mode === "static-script" ? StaticScriptSkill : DynamicScriptSkill;
-      return new Ctor({
+      skill = new Ctor({
         name: parsed.name,
         description: parsed.description,
         capabilities: parsed.capabilities,
@@ -2174,8 +2548,13 @@ function buildCliSkill(parsed, entryPath) {
         imageFile: parsed.imageFile,
         dir: entryPath
       });
+      break;
     }
   }
+  if (parsed.rateLimit) {
+    skill.rateLimit = parsed.rateLimit;
+  }
+  return skill;
 }
 function loadSkillsFromDir(skillsDir) {
   const skills = [];
@@ -2581,6 +2960,7 @@ async function cmdStart(nameArg, options = {}) {
   const dependentSkillsByProvider = /* @__PURE__ */ new Map();
   let agentDefaultCacheKey;
   const llmClientCache = /* @__PURE__ */ new Map();
+  const healthMonitor = new LlmHealthMonitor();
   if (llmSkills.length > 0) {
     const resolutionErrors = [];
     for (const skill of llmSkills) {
@@ -2595,6 +2975,11 @@ async function cmdStart(nameArg, options = {}) {
       }
       const cacheKey = cacheKeyFor(result);
       triplesByKey.set(cacheKey, result);
+      skill.resolvedTriple = {
+        provider: result.provider,
+        model: result.model,
+        maxTokens: result.maxTokens
+      };
       const list = dependentSkillsByProvider.get(result.provider) ?? [];
       list.push(skill.name);
       dependentSkillsByProvider.set(result.provider, list);
@@ -2638,28 +3023,47 @@ async function cmdStart(nameArg, options = {}) {
       console.error("");
       process.exit(1);
     }
-    for (const provider of keyByProvider.keys()) {
-      const apiKey = keyByProvider.get(provider);
+    for (const [, triple] of triplesByKey) {
+      const apiKey = keyByProvider.get(triple.provider);
       if (!apiKey) {
         continue;
       }
-      const envVar = provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
-      process.stdout.write(`  Verifying ${provider} API key... `);
-      const verification = await verifyLlmApiKey(provider, apiKey);
+      const envVar = getLlmProvider(triple.provider)?.envVar ?? `${triple.provider.toUpperCase()}_API_KEY`;
+      process.stdout.write(`  Verifying ${triple.provider} ${triple.model}... `);
+      const verification = await verifyLlmApiKeyDeep(triple.provider, apiKey, triple.model);
+      const descriptor = getLlmProvider(triple.provider);
+      const verifyFn = async (signal) => descriptor ? descriptor.verifyKeyDeep(apiKey, triple.model, signal) : { ok: false, reason: "unavailable", error: "no descriptor" };
+      healthMonitor.register({
+        provider: triple.provider,
+        model: triple.model,
+        verifyFn
+      });
+      healthMonitor.seed(triple.provider, triple.model, verification);
       if (verification.ok) {
         console.log("ok");
       } else if (verification.reason === "invalid") {
         console.log("INVALID");
-        console.error(`  ! ${provider} rejected the API key (HTTP ${verification.status}).`);
+        console.error(`  ! ${triple.provider} rejected the API key (HTTP ${verification.status}).`);
         console.error(
           `    Update it via \`npx @elisym/cli profile ${agentName}\` or set ${envVar} to a valid key.
+`
+        );
+        process.exit(1);
+      } else if (verification.reason === "billing") {
+        console.log("BILLING");
+        const detail = verification.body ? ` ${verification.body.slice(0, 200)}` : "";
+        console.error(
+          `  ! ${triple.provider} reports a billing/quota issue for ${triple.model}.${detail}`
+        );
+        console.error(
+          `    Top up the account at the provider console, or set ${envVar} to a key on a funded org.
 `
         );
         process.exit(1);
       } else {
         console.log("unavailable");
         console.warn(
-          `  ! Could not verify ${provider} API key (${verification.error}). Continuing - jobs will fail if the key is invalid.
+          `  ! Could not verify ${triple.provider} ${triple.model} (${verification.error}). Continuing - jobs will fail if the key is invalid.
 `
         );
       }
@@ -2877,28 +3281,45 @@ async function cmdStart(nameArg, options = {}) {
     log: diagLog,
     logger
   });
-  const runtime = new AgentRuntime(transport, registry, skillCtx, runtimeConfig, ledger, {
-    onJobReceived: (job) => {
-      const cap = job.tags.find((t) => t !== "elisym") ?? "unknown";
-      process.stdout.write(`  [job] ${job.jobId.slice(0, 16)} | cap=${cap}
+  let llmHeartbeat;
+  if (llmSkills.length > 0) {
+    llmHeartbeat = startLlmHeartbeat({
+      monitor: healthMonitor,
+      log: diagLog
+    });
+    diagLog("LLM health monitor armed (10min TTL, 10min heartbeat).");
+  }
+  const runtime = new AgentRuntime(
+    transport,
+    registry,
+    skillCtx,
+    runtimeConfig,
+    ledger,
+    {
+      onJobReceived: (job) => {
+        const cap = job.tags.find((t) => t !== "elisym") ?? "unknown";
+        process.stdout.write(`  [job] ${job.jobId.slice(0, 16)} | cap=${cap}
 `);
-      logger.info({ event: "job_received", jobId: job.jobId, capability: cap });
-    },
-    onJobCompleted: (jobId) => {
-      process.stdout.write(`  [job] ${jobId.slice(0, 16)} | delivered
+        logger.info({ event: "job_received", jobId: job.jobId, capability: cap });
+      },
+      onJobCompleted: (jobId) => {
+        process.stdout.write(`  [job] ${jobId.slice(0, 16)} | delivered
 `);
-      logger.info({ event: "job_delivered", jobId });
-    },
-    onJobError: (jobId, error) => {
-      process.stderr.write(`  [job] ${jobId.slice(0, 16)} | error: ${error}
+        logger.info({ event: "job_delivered", jobId });
+      },
+      onJobError: (jobId, error) => {
+        process.stderr.write(`  [job] ${jobId.slice(0, 16)} | error: ${error}
 `);
-      logger.error({ event: "job_error", jobId, error });
+        logger.error({ event: "job_error", jobId, error });
+      },
+      onLog: diagLog,
+      onStop: () => {
+        watchdog.stop();
+        llmHeartbeat?.stop();
+      }
     },
-    onLog: diagLog,
-    onStop: () => {
-      watchdog.stop();
-    }
-  });
+    healthMonitor
+  );
   console.log("  * Running. Press Ctrl+C to stop.\n");
   await runtime.run();
 }