@elisym/cli 0.8.1 → 0.9.0

package/dist/index.js

@@ -1,13 +1,12 @@
 #!/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, NATIVE_SOL } from '@elisym/sdk';
+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 { 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 } from 'nostr-tools';
+import { generateSecretKey, getPublicKey, nip19, verifyEvent } from 'nostr-tools';
 import YAML from 'yaml';
 import { Command } from 'commander';
-import { isEncrypted } from '@elisym/sdk/node';
 import { createHash } from 'node:crypto';
 import { lookup } from 'node:dns/promises';
 import { Socket } from 'node:net';
@@ -140,16 +139,16 @@ async function cmdInit(nameArg, options = {}) {
     yaml = result.yaml;
     promptedApiKey = result.apiKey;
   }
-  let llmApiKey;
+  let defaultProviderKey;
   if (yaml.llm) {
     const envKey = yaml.llm.provider === "anthropic" ? process.env.ANTHROPIC_API_KEY : process.env.OPENAI_API_KEY;
     if (envKey) {
-      llmApiKey = envKey;
+      defaultProviderKey = envKey;
       console.log(
         `  Using ${yaml.llm.provider === "anthropic" ? "ANTHROPIC" : "OPENAI"}_API_KEY from environment.`
       );
     } else if (promptedApiKey) {
-      llmApiKey = promptedApiKey;
+      defaultProviderKey = promptedApiKey;
     } else {
       const { apiKey } = await inquirer.prompt([
         {
@@ -159,7 +158,38 @@ async function cmdInit(nameArg, options = {}) {
           mask: "*"
         }
       ]);
-      llmApiKey = apiKey || void 0;
+      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)
+      }
+    ]);
+    if (configureOther) {
+      if (otherEnvKey) {
+        otherProviderKey = otherEnvKey;
+        console.log(`  Using ${otherEnvVar} from environment.`);
+      } else {
+        const { promptedOther } = await inquirer.prompt([
+          {
+            type: "password",
+            name: "promptedOther",
+            message: `${otherProviderLabel} API key:`,
+            mask: "*"
+          }
+        ]);
+        otherProviderKey = promptedOther || void 0;
+      }
     }
   }
   let passphrase = "";
@@ -194,12 +224,15 @@ 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;
   await writeYaml(created.dir, yaml);
   await writeSecrets(
     created.dir,
     {
       nostr_secret_key: nostrSecretHex,
-      llm_api_key: llmApiKey
+      anthropic_api_key: anthropicKey,
+      openai_api_key: openaiKey
     },
     passphrase || void 0
   );
@@ -490,7 +523,7 @@ async function cmdProfile(name) {
         {
           type: "list",
           name: "llmProvider",
-          message: "LLM provider:",
+          message: "Default LLM provider (used by skills without a `provider:` override):",
           choices: [
             { name: "Anthropic (Claude)", value: "anthropic" },
             { name: "OpenAI (GPT)", value: "openai" }
@@ -498,16 +531,17 @@ async function cmdProfile(name) {
           default: loaded.yaml.llm?.provider ?? "anthropic"
         }
       ]);
+      const otherProvider = llmProvider === "anthropic" ? "openai" : "anthropic";
+      const defaultKeyStatus = describeKeyStatus(loaded.secrets, llmProvider);
       const { apiKey } = await inquirer.prompt([
         {
           type: "password",
           name: "apiKey",
-          message: "API key (leave empty to keep current):",
+          message: `${labelFor(llmProvider)} API key [${defaultKeyStatus}] (leave empty to keep current):`,
           mask: "*"
         }
       ]);
-      const currentKeyPlain = loaded.secrets.llm_api_key && !isEncrypted(loaded.secrets.llm_api_key) ? loaded.secrets.llm_api_key : "";
-      const probeKey = apiKey || currentKeyPlain;
+      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);
@@ -528,13 +562,37 @@ 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 nextLlm = { provider: llmProvider, model, max_tokens: maxTokens };
       const nextYaml = { ...loaded.yaml, llm: nextLlm };
       await writeYaml(loaded.dir, nextYaml);
       loaded.yaml = nextYaml;
-      if (apiKey) {
-        await writeSecrets(loaded.dir, { ...loaded.secrets, llm_api_key: apiKey }, passphrase);
-        loaded.secrets = { ...loaded.secrets, llm_api_key: apiKey };
+      if (apiKey || otherApiKey) {
+        const nextSecrets = { ...loaded.secrets };
+        if (apiKey) {
+          if (llmProvider === "anthropic") {
+            nextSecrets.anthropic_api_key = apiKey;
+          } else {
+            nextSecrets.openai_api_key = apiKey;
+          }
+        }
+        if (otherApiKey) {
+          if (otherProvider === "anthropic") {
+            nextSecrets.anthropic_api_key = otherApiKey;
+          } else {
+            nextSecrets.openai_api_key = otherApiKey;
+          }
+        }
+        await writeSecrets(loaded.dir, nextSecrets, passphrase);
+        loaded.secrets = nextSecrets;
       }
       console.log("  LLM updated.\n");
     }
@@ -548,6 +606,17 @@ 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 pickPlainKey(secrets, provider) {
+  const perProviderField = provider === "anthropic" ? "anthropic_api_key" : "openai_api_key";
+  return secrets[perProviderField] ?? "";
+}
 var TCP_PROBE_TIMEOUT_MS = 3e3;
 function parseRelayUrl(url) {
   try {
@@ -1095,6 +1164,82 @@ var OpenAIClient = class {
     }));
   }
 };
+
+// src/llm/resolve.ts
+var DEFAULT_MAX_TOKENS = 4096;
+function resolveSkillLlm(input, agentDefault) {
+  const override = input.llmOverride;
+  const overridePairSet = override?.provider !== void 0 && override.model !== void 0;
+  let provider;
+  let model;
+  if (overridePairSet) {
+    provider = override.provider;
+    model = override.model;
+  } else if (agentDefault) {
+    provider = agentDefault.provider;
+    model = agentDefault.model;
+  }
+  if (!provider || !model) {
+    return {
+      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;
+  return { provider, model, maxTokens };
+}
+
+// src/llm/cache.ts
+function cacheKeyFor(triple) {
+  return JSON.stringify({
+    provider: triple.provider,
+    model: triple.model,
+    maxTokens: triple.maxTokens
+  });
+}
+function resolveTripleForOverride(override, agentDefault) {
+  const overridePairSet = override?.provider !== void 0 && override.model !== void 0;
+  let provider;
+  let model;
+  if (overridePairSet) {
+    provider = override.provider;
+    model = override.model;
+  } else if (agentDefault) {
+    provider = agentDefault.provider;
+    model = agentDefault.model;
+  }
+  if (!provider || !model) {
+    return void 0;
+  }
+  const maxTokens = override?.maxTokens ?? agentDefault?.max_tokens ?? DEFAULT_MAX_TOKENS;
+  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"
+};
+function resolveProviderApiKey(input) {
+  const { provider, secrets, dependentSkills } = input;
+  const perProviderField = SECRET_FIELD_FOR_PROVIDER[provider];
+  const perProviderValue = secrets[perProviderField];
+  if (perProviderValue) {
+    return { apiKey: perProviderValue, origin: "secrets-per-provider" };
+  }
+  const envVar = ENV_VAR_FOR_PROVIDER[provider];
+  const envValue = process.env[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}.`
+  };
+}
 function resolveLevel(options) {
   if (options.level) {
     return options.level;
@@ -1146,6 +1291,7 @@ var payment = new SolanaPaymentStrategy();
 var LEDGER_GC_INTERVAL_MS = 60 * 60 * 1e3;
 var LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 var TOTAL_JOB_TIMEOUT_MS = 5 * 60 * 1e3;
+var SIG_PATH_TIMEOUT_MS = 60 * 1e3;
 function resolveJobPrice(tags, skills) {
   const skill = skills.route(tags);
   return skill?.priceSubunits ?? 0;
@@ -1424,33 +1570,124 @@ var AgentRuntime = class {
       chain: "solana"
     });
     const rpc = createSolanaRpc(getRpcUrl(this.config.network));
-    let result;
+    const verifyAbort = new AbortController();
+    const onOuterAbort = () => verifyAbort.abort();
     if (signal) {
-      let abortHandler;
-      const abortPromise = new Promise((_, reject) => {
-        abortHandler = () => {
+      if (signal.aborted) {
+        verifyAbort.abort();
+      } else {
+        signal.addEventListener("abort", onOuterAbort, { once: true });
+      }
+    }
+    const deadlineMs = this.config.paymentTimeoutSecs * 1e3;
+    const sigPathTimeoutMs = Math.min(deadlineMs, SIG_PATH_TIMEOUT_MS);
+    let result;
+    try {
+      result = await new Promise((resolve3, reject) => {
+        let settled = false;
+        let pending = 2;
+        let lastResult = { verified: false };
+        const win = (verified) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          clearTimeout(deadline);
+          resolve3(verified);
+        };
+        const lose = (verified, reason) => {
+          if (settled) {
+            return;
+          }
+          lastResult = verified;
+          pending -= 1;
+          log(`[${job.jobId.slice(0, 8)}] verify ${reason}`);
+          if (pending === 0) {
+            settled = true;
+            clearTimeout(deadline);
+            resolve3(lastResult);
+          }
+        };
+        this.transport.waitForPaymentSignature(job.jobId, job.customerId, verifyAbort.signal, sigPathTimeoutMs).then(async (sig) => {
+          if (settled) {
+            return;
+          }
+          if (!sig) {
+            lose({ verified: false }, "sig path: no payment-completed feedback");
+            return;
+          }
+          log(`[${job.jobId.slice(0, 8)}] verify sig path: got ${sig.slice(0, 8)}...`);
+          try {
+            const verified = await payment.verifyPayment(rpc, request, protocolConfig, {
+              txSignature: sig
+            });
+            if (verified.verified) {
+              win(verified);
+            } else {
+              const reason = verified.error ?? "unknown";
+              lose(verified, `sig path: not verified (${reason})`);
+            }
+          } catch (err) {
+            lose(
+              { verified: false },
+              `sig path error: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }).catch(
+          (err) => lose(
+            { verified: false },
+            `sig path error: ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+        payment.verifyPayment(rpc, request, protocolConfig).then((verified) => {
+          if (verified.verified) {
+            win(verified);
+          } else {
+            const reason = verified.error ?? "unknown";
+            lose(verified, `ref path: not verified (${reason})`);
+          }
+        }).catch(
+          (err) => lose(
+            { verified: false },
+            `ref path error: ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+        const deadline = setTimeout(() => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          log(`[${job.jobId.slice(0, 8)}] verify deadline (${deadlineMs}ms) hit`);
+          resolve3(lastResult);
+        }, deadlineMs);
+        if (signal?.aborted) {
+          settled = true;
+          clearTimeout(deadline);
           const err = new Error("The operation was aborted");
           err.name = "AbortError";
           reject(err);
-        };
-        if (signal.aborted) {
-          abortHandler();
           return;
         }
-        signal.addEventListener("abort", abortHandler, { once: true });
+        signal?.addEventListener(
+          "abort",
+          () => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            clearTimeout(deadline);
+            const err = new Error("The operation was aborted");
+            err.name = "AbortError";
+            reject(err);
+          },
+          { once: true }
+        );
       });
-      try {
-        result = await Promise.race([
-          payment.verifyPayment(rpc, request, protocolConfig),
-          abortPromise
-        ]);
-      } finally {
-        if (abortHandler) {
-          signal.removeEventListener("abort", abortHandler);
-        }
+    } finally {
+      verifyAbort.abort();
+      if (signal) {
+        signal.removeEventListener("abort", onOuterAbort);
       }
-    } else {
-      result = await payment.verifyPayment(rpc, request, protocolConfig);
     }
     if (result.verified) {
       return { netAmount, paymentRequest: requestJson };
@@ -1787,11 +2024,12 @@ var ScriptSkill = class {
   priceSubunits;
   asset;
   mode = "llm";
+  llmOverride;
   image;
   imageFile;
   dir;
   inner;
-  constructor(name, description, capabilities, priceSubunits, assetOrImage, imageOrImageFile, imageFileOrDir, dirOrPrompt, promptOrTools, toolsOrRounds, rounds) {
+  constructor(name, description, capabilities, priceSubunits, assetOrImage, imageOrImageFile, imageFileOrDir, dirOrPrompt, promptOrTools, toolsOrRounds, rounds, llmOverride) {
     let asset;
     let image;
     let imageFile;
@@ -1821,6 +2059,7 @@ var ScriptSkill = class {
     this.capabilities = capabilities;
     this.priceSubunits = priceSubunits;
     this.asset = asset;
+    this.llmOverride = llmOverride;
     this.image = image;
     this.imageFile = imageFile;
     this.dir = skillDir;
@@ -1834,6 +2073,7 @@ var ScriptSkill = class {
       systemPrompt,
       tools,
       maxToolRounds,
+      llmOverride,
       image,
       imageFile
     });
@@ -1858,7 +2098,8 @@ function buildCliSkill(parsed, entryPath) {
         entryPath,
         parsed.systemPrompt,
         parsed.tools,
-        parsed.maxToolRounds
+        parsed.maxToolRounds,
+        parsed.llmOverride
       );
     case "static-file": {
       if (parsed.outputFile === void 0) {
@@ -1944,7 +2185,7 @@ function loadSkillsFromDir(skillsDir) {
   }
   return skills;
 }
-function isEncrypted2(event) {
+function isEncrypted(event) {
   return event.tags.some((t) => t[0] === "encrypted" && t[1] === "nip44");
 }
 var HEALTH_CHECK_IDLE_MS = 30 * 60 * 1e3;
@@ -1978,7 +2219,7 @@ var NostrTransport = class {
         }
         const tags = event.tags.filter((t) => t[0] === "t").map((t) => t[1]);
         const bidTag = event.tags.find((t) => t[0] === "bid");
-        const encrypted = isEncrypted2(event);
+        const encrypted = isEncrypted(event);
         const iTag = event.tags.find((t) => t[0] === "i");
         let inputType = "text";
         if (iTag?.[2]) {
@@ -1998,6 +2239,76 @@ var NostrTransport = class {
       }
     );
   }
+  /**
+   * Wait for the customer's `payment-completed` feedback for a specific job
+   * and return the on-chain Solana tx signature it carries.
+   *
+   * The customer publishes this event right after `confirmTransaction(... 'confirmed')`
+   * succeeds (see packages/app/app/hooks/useBuyCapability.ts), so receiving it
+   * lets the provider verify the payment with a single targeted
+   * `getTransaction(sig, commitment: 'confirmed')` call instead of the
+   * heavyweight `getSignaturesForAddress(reference)` index lookup. This is
+   * dramatically more reliable on the public devnet RPC, which throttles and
+   * lags the address index.
+   *
+   * Resolves with `null` if `signal` aborts or `timeoutMs` elapses before a
+   * valid signature arrives. The timeout exists so a customer that disappears
+   * after job submission does not hold a `p-limit` slot for the full payment
+   * expiry window - without it this path waits forever on the relay.
+   */
+  waitForPaymentSignature(jobId, customerPubkey, signal, timeoutMs) {
+    return new Promise((resolve3) => {
+      let settled = false;
+      const filter = {
+        kinds: [KIND_JOB_FEEDBACK],
+        "#e": [jobId],
+        authors: [customerPubkey],
+        "#t": ["elisym"],
+        since: Math.floor(Date.now() / 1e3) - 5
+      };
+      const finish = (sig) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (timer) {
+          clearTimeout(timer);
+        }
+        signal.removeEventListener("abort", onAbort);
+        sub.close();
+        resolve3(sig);
+      };
+      const sub = this.client.pool.subscribe(filter, (event) => {
+        if (settled) {
+          return;
+        }
+        if (!verifyEvent(event)) {
+          return;
+        }
+        const status = event.tags.find((t) => t[0] === "status")?.[1];
+        if (status !== "payment-completed") {
+          return;
+        }
+        const txTag = event.tags.find((t) => t[0] === "tx");
+        const sig = txTag?.[1];
+        const chain = txTag?.[2];
+        if (typeof sig !== "string" || sig.length === 0) {
+          return;
+        }
+        if (chain !== void 0 && chain !== "solana") {
+          return;
+        }
+        finish(sig);
+      });
+      const onAbort = () => finish(null);
+      const timer = timeoutMs !== void 0 && timeoutMs > 0 ? setTimeout(() => finish(null), timeoutMs) : null;
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
   /** Send job feedback to customer. */
   async sendFeedback(job, status) {
     if (status.type === "payment-required") {
@@ -2237,53 +2548,124 @@ async function cmdStart(nameArg, options = {}) {
     );
     process.exit(1);
   }
-  const hasLlmSkill = allSkills.some((skill) => skill.mode === "llm");
-  let llm;
-  if (hasLlmSkill) {
-    if (!loaded.yaml.llm) {
-      console.error("  ! No LLM configured. Run `npx @elisym/cli init` to set up LLM.\n");
+  const llmSkills = allSkills.filter((skill) => skill.mode === "llm");
+  const triplesByKey = /* @__PURE__ */ new Map();
+  const dependentSkillsByProvider = /* @__PURE__ */ new Map();
+  let agentDefaultCacheKey;
+  const llmClientCache = /* @__PURE__ */ new Map();
+  if (llmSkills.length > 0) {
+    const resolutionErrors = [];
+    for (const skill of llmSkills) {
+      const skillMdPath = join(skillsDir, skill.name, "SKILL.md");
+      const result = resolveSkillLlm(
+        { skillName: skill.name, skillMdPath, llmOverride: skill.llmOverride },
+        loaded.yaml.llm
+      );
+      if ("error" in result) {
+        resolutionErrors.push(result.error);
+        continue;
+      }
+      const cacheKey = cacheKeyFor(result);
+      triplesByKey.set(cacheKey, result);
+      const list = dependentSkillsByProvider.get(result.provider) ?? [];
+      list.push(skill.name);
+      dependentSkillsByProvider.set(result.provider, list);
+    }
+    if (resolutionErrors.length > 0) {
+      for (const message of resolutionErrors) {
+        console.error(`  ! ${message}`);
+      }
+      console.error("");
       process.exit(1);
     }
-    if (!loaded.secrets.llm_api_key) {
-      console.error(
-        `  ! No LLM API key. Set ${loaded.yaml.llm.provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY"} env var or update the agent's secrets.
-`
-      );
+    if (loaded.yaml.llm) {
+      const agentDefaultTriple = {
+        provider: loaded.yaml.llm.provider,
+        model: loaded.yaml.llm.model,
+        maxTokens: loaded.yaml.llm.max_tokens
+      };
+      const agentKey = cacheKeyFor(agentDefaultTriple);
+      if (triplesByKey.has(agentKey)) {
+        agentDefaultCacheKey = agentKey;
+      }
+    }
+    const keyByProvider = /* @__PURE__ */ new Map();
+    const keyErrors = [];
+    for (const [provider, dependents] of dependentSkillsByProvider) {
+      const keyResult = resolveProviderApiKey({
+        provider,
+        secrets: loaded.secrets,
+        dependentSkills: dependents
+      });
+      if ("error" in keyResult) {
+        keyErrors.push(keyResult.error);
+        continue;
+      }
+      keyByProvider.set(provider, keyResult.apiKey);
+    }
+    if (keyErrors.length > 0) {
+      for (const message of keyErrors) {
+        console.error(`  ! ${message}`);
+      }
+      console.error("");
       process.exit(1);
     }
-    const llmProvider = loaded.yaml.llm.provider;
-    const keyEnvVar = llmProvider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
-    process.stdout.write(`  Verifying ${llmProvider} API key... `);
-    const verification = await verifyLlmApiKey(llmProvider, loaded.secrets.llm_api_key);
-    if (verification.ok) {
-      console.log("ok");
-    } else if (verification.reason === "invalid") {
-      console.log("INVALID");
-      console.error(`  ! ${llmProvider} rejected the API key (HTTP ${verification.status}).`);
-      console.error(
-        `    Update it via \`npx @elisym/cli profile\` or set ${keyEnvVar} to a valid key.
+    for (const provider of keyByProvider.keys()) {
+      const apiKey = keyByProvider.get(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);
+      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(
+          `    Update it via \`npx @elisym/cli profile ${agentName}\` or set ${envVar} to a valid key.
 `
-      );
-      process.exit(1);
-    } else {
-      console.log("unavailable");
-      console.warn(
-        `  ! Could not verify ${llmProvider} API key (${verification.error}). Continuing - jobs will fail if the key is invalid.
+        );
+        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.
 `
-      );
+        );
+      }
+    }
+    for (const [cacheKey, triple] of triplesByKey) {
+      const apiKey = keyByProvider.get(triple.provider);
+      if (!apiKey) {
+        console.error(`  ! Internal error: no API key for provider "${triple.provider}".
+`);
+        process.exit(1);
+      }
+      const config = {
+        provider: triple.provider,
+        apiKey,
+        model: triple.model,
+        maxTokens: triple.maxTokens,
+        logUsage: true
+      };
+      llmClientCache.set(cacheKey, createLlmClient(config));
     }
-    llm = createLlmClient({
-      provider: loaded.yaml.llm.provider,
-      apiKey: loaded.secrets.llm_api_key,
-      model: loaded.yaml.llm.model,
-      maxTokens: loaded.yaml.llm.max_tokens,
-      logUsage: true
-    });
   } else {
     console.log("  No LLM skills loaded; skipping LLM key check.\n");
   }
+  const agentDefaultClient = agentDefaultCacheKey !== void 0 ? llmClientCache.get(agentDefaultCacheKey) : void 0;
+  const getLlm = (override) => {
+    const triple = resolveTripleForOverride(override, loaded.yaml.llm);
+    if (!triple) {
+      return void 0;
+    }
+    return llmClientCache.get(cacheKeyFor(triple));
+  };
   const skillCtx = {
-    llm,
+    llm: agentDefaultClient,
+    getLlm,
     agentName,
     agentDescription: loaded.yaml.description ?? ""
   };
@@ -2583,9 +2965,9 @@ async function loadAgentWithPrompt(name, cwd) {
   try {
     return await loadAgent(name, cwd, envPassphrase);
   } catch (e) {
-    const isEncrypted3 = /encrypted secrets/i.test(e?.message ?? "");
+    const isEncrypted2 = /encrypted secrets/i.test(e?.message ?? "");
     const isWrongPassphrase = /Decryption failed/i.test(e?.message ?? "");
-    if (!isEncrypted3 && !isWrongPassphrase) {
+    if (!isEncrypted2 && !isWrongPassphrase) {
       throw e;
     }
     if (!process.stdin.isTTY) {