@elisym/cli 0.9.0 → 0.10.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S node --no-deprecation
 import { readFileSync, readdirSync, statSync, renameSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve, basename, relative, sep } from 'node:path';
-import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, ElisymClient, MediaService, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, USDC_SOLANA_DEVNET, makeCensor, DEFAULT_REDACT_PATHS, createSlidingWindowLimiter, getProtocolProgramId, getProtocolConfig, LIMITS, calculateProtocolFee, BoundedSet, KIND_JOB_FEEDBACK, NATIVE_SOL } from '@elisym/sdk';
+import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, ElisymClient, MediaService, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, makeCensor, DEFAULT_REDACT_PATHS, createSlidingWindowLimiter, getProtocolProgramId, getProtocolConfig, LIMITS, calculateProtocolFee, BoundedSet, KIND_JOB_FEEDBACK, NATIVE_SOL } from '@elisym/sdk';
 import { ElisymYamlSchema, resolveInHome, resolveInProject, createAgentDir, writeYaml, writeSecrets, listAgents, loadAgent, agentPaths, readMediaCache, lookupCachedUrl, newCacheEntry, writeMediaCache } from '@elisym/sdk/agent-store';
 import { isAddress, createSolanaRpc, address } from '@solana/kit';
 import { generateSecretKey, getPublicKey, nip19, verifyEvent } from 'nostr-tools';
@@ -25,42 +25,542 @@ 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 };
+  }
+}
+var DEFAULT_MODEL, DEFAULT_MAX_TOKENS, FALLBACK_MODELS, AnthropicClient, 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})`
+        );
+      }
+      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
+            }))
+          }
+        ];
       }
-      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;
+    };
+    ANTHROPIC_PROVIDER = {
+      id: "anthropic",
+      displayName: "Anthropic (Claude)",
+      envVar: "ANTHROPIC_API_KEY",
+      defaultModel: DEFAULT_MODEL,
+      fallbackModels: FALLBACK_MODELS,
+      fetchModels,
+      verifyKey,
+      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 };
     }
-    return ["gpt-4o"];
+    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 };
+  }
+}
+var DEFAULT_MODEL2, DEFAULT_MAX_TOKENS2, FALLBACK_MODELS2, OpenAIClient, 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
+        }));
+      }
+    };
+    OPENAI_PROVIDER = {
+      id: "openai",
+      displayName: "OpenAI (GPT)",
+      envVar: "OPENAI_API_KEY",
+      defaultModel: DEFAULT_MODEL2,
+      fallbackModels: FALLBACK_MODELS2,
+      fetchModels: fetchModels2,
+      verifyKey: verifyKey2,
+      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 verifyLlmApiKey(provider, apiKey, signal) {
+  const descriptor = getLlmProvider(provider);
+  if (!descriptor) {
+    return {
+      ok: false,
+      reason: "unavailable",
+      error: `Unknown LLM provider "${provider}"`
+    };
+  }
+  return descriptor.verifyKey(apiKey, 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 +640,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 +730,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 +842,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 +862,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 +903,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 +1032,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 +1088,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 +1139,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) {
@@ -712,6 +1241,30 @@ function getRpcUrl(_network) {
   }
   return "https://api.devnet.solana.com";
 }
+async function fetchUsdcBalance(rpc, owner) {
+  const mint = USDC_SOLANA_DEVNET.mint;
+  if (!mint) {
+    return 0n;
+  }
+  try {
+    const response = await rpc.getTokenAccountsByOwner(
+      owner,
+      { mint: address(mint) },
+      { encoding: "jsonParsed", commitment: "confirmed" }
+    ).send();
+    let total = 0n;
+    for (const entry of response.value) {
+      const parsed = entry.account.data;
+      const raw = parsed?.parsed?.info?.tokenAmount?.amount;
+      if (typeof raw === "string") {
+        total += BigInt(raw);
+      }
+    }
+    return total;
+  } catch {
+    return 0n;
+  }
+}
 var VALID_TRANSITIONS = {
   paid: ["executed", "failed"],
   executed: ["delivered", "failed"],
@@ -851,322 +1404,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;
@@ -1184,7 +1426,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 };
 }
 
@@ -1210,34 +1452,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) {
@@ -2505,7 +2745,10 @@ async function cmdStart(nameArg, options = {}) {
       const rpcUrl = getRpcUrl(walletNetwork);
       const rpc = createSolanaRpc(rpcUrl);
       const walletAddress = address(solanaAddress);
-      const { value: balanceLamports } = await rpc.getBalance(walletAddress).send();
+      const [{ value: balanceLamports }, usdcBalance] = await Promise.all([
+        rpc.getBalance(walletAddress).send(),
+        fetchUsdcBalance(rpc, walletAddress)
+      ]);
       const balance = Number(balanceLamports);
       console.log("  Wallet");
       console.log(`     Network  ${walletNetwork}`);
@@ -2513,7 +2756,8 @@ async function cmdStart(nameArg, options = {}) {
       if (process.env.SOLANA_RPC_URL) {
         console.log(`     RPC      ${process.env.SOLANA_RPC_URL} (custom)`);
       }
-      console.log(`     Balance  ${formatSol(balance)} (${balance} lamports)`);
+      console.log(`     SOL      ${formatSol(balance)} (${balance} lamports)`);
+      console.log(`     USDC     ${formatAssetAmount(USDC_SOLANA_DEVNET, usdcBalance)}`);
       if (balance === 0) {
         console.log("  ! Wallet is empty. Get devnet SOL: https://faucet.solana.com");
       }
@@ -2615,7 +2859,7 @@ async function cmdStart(nameArg, options = {}) {
       if (!apiKey) {
         continue;
       }
-      const envVar = provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+      const envVar = getLlmProvider(provider)?.envVar ?? `${provider.toUpperCase()}_API_KEY`;
       process.stdout.write(`  Verifying ${provider} API key... `);
       const verification = await verifyLlmApiKey(provider, apiKey);
       if (verification.ok) {
@@ -3000,30 +3244,6 @@ async function loadAgentWithPrompt(name, cwd) {
   }
   throw new Error("Unreachable");
 }
-async function fetchUsdcBalance(rpc, owner) {
-  const mint = USDC_SOLANA_DEVNET.mint;
-  if (!mint) {
-    return 0n;
-  }
-  try {
-    const response = await rpc.getTokenAccountsByOwner(
-      owner,
-      { mint: address(mint) },
-      { encoding: "jsonParsed", commitment: "confirmed" }
-    ).send();
-    let total = 0n;
-    for (const entry of response.value) {
-      const parsed = entry.account.data;
-      const raw = parsed?.parsed?.info?.tokenAmount?.amount;
-      if (typeof raw === "string") {
-        total += BigInt(raw);
-      }
-    }
-    return total;
-  } catch {
-    return 0n;
-  }
-}
 async function cmdWallet(name) {
   const cwd = process.cwd();
   if (!name) {