agent-sh 0.13.7 → 0.14.0

package/dist/agent/index.js

@@ -1,13 +1,28 @@
+/**
+ * Mode resolution is deferred to `core:extensions-loaded` so a persisted
+ * `defaultProvider: "openrouter"` doesn't lose to a cold-start race.
+ */
+import "./events.js";
 import { AgentLoop } from "./agent-loop.js";
-import { LlmClient } from "../utils/llm-client.js";
-import { createLlmFacade } from "../utils/llm-facade.js";
+import { LlmClient } from "./llm-client.js";
+import { createLlmFacade } from "./llm-facade.js";
+import { registerReadOnlyTool, unregisterReadOnlyTool } from "./nuclear-form.js";
 import { resolveProvider, getProviderNames, getSettings } from "../core/settings.js";
 import { discoverSkills } from "./skills.js";
-import { resolveApiKey } from "../cli/auth/keys.js";
 import activateOpenrouter from "./providers/openrouter.js";
 import activateOpenai from "./providers/openai.js";
 import activateOpenaiCompatible from "./providers/openai-compatible.js";
 import activateDeepseek from "./providers/deepseek.js";
+import { findBash } from "../utils/executor.js";
+import { createBashTool } from "./tools/bash.js";
+import { createPwshTool } from "./tools/pwsh.js";
+import { createReadFileTool } from "./tools/read-file.js";
+import { createWriteFileTool } from "./tools/write-file.js";
+import { createEditFileTool } from "./tools/edit-file.js";
+import { createGrepTool } from "./tools/grep.js";
+import { createGlobTool } from "./tools/glob.js";
+import { createLsTool } from "./tools/ls.js";
+import { createListSkillsTool } from "./tools/list-skills.js";
 function persistedModelFor(providerName) {
     if (!providerName)
         return undefined;
@@ -36,24 +51,142 @@ function mergeCaps(settingsCaps, payloadCaps, modelIds) {
     }
     return out.size > 0 ? out : undefined;
 }
+function splitRegistration(p) {
+    const raw = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
+    const ids = [];
+    const caps = new Map();
+    for (const m of raw) {
+        if (typeof m === "string") {
+            ids.push(m);
+        }
+        else {
+            ids.push(m.id);
+            caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, maxTokens: m.maxTokens, echoReasoning: m.echoReasoning });
+        }
+    }
+    return { ids, caps };
+}
 export default function agentBackend(ctx) {
     const { bus } = ctx;
     const config = ctx.call("config:get-app-config") ?? {};
+    const toolContribs = new Map();
+    const instructionContribs = new Map();
+    const skillContribs = new Map();
+    const providerContribs = new Map();
+    // Settings overlay — fields here win over contributing extensions' payloads.
+    const settingsProviders = new Map();
+    for (const name of getProviderNames()) {
+        const p = resolveProvider(name);
+        if (p)
+            settingsProviders.set(name, p);
+    }
+    const providerHooks = new Map();
+    // Bakes model id so AgentMode.buildReasoningParams keeps its (level) signature.
+    const bindReasoning = (shapeId, model) => {
+        const hook = providerHooks.get(shapeId)?.reasoningParams;
+        return hook ? (level) => hook(level, model) : defaultReasoningBuilder;
+    };
     const agentSurface = {
         llm: createLlmFacade({ list: ctx.list, call: ctx.call }),
         providers: {
+            register: (reg) => {
+                const existing = providerContribs.get(reg.id);
+                if (existing)
+                    bus.offPipe("agent:providers", existing);
+                const contrib = (acc) => {
+                    acc.providers.push(reg);
+                    return acc;
+                };
+                providerContribs.set(reg.id, contrib);
+                bus.onPipe("agent:providers", contrib);
+                bus.emit("agent:providers:changed", {});
+                return () => agentSurface.providers.unregister(reg.id);
+            },
+            unregister: (id) => {
+                const contrib = providerContribs.get(id);
+                if (!contrib)
+                    return;
+                bus.offPipe("agent:providers", contrib);
+                providerContribs.delete(id);
+                bus.emit("agent:providers:changed", {});
+            },
             configure: (id, configureOpts) => bus.emit("provider:configure", { id, ...configureOpts }),
         },
-        registerTool: (tool) => bus.emit("agent:register-tool", { tool, extensionName: "" }),
-        unregisterTool: (name) => bus.emit("agent:unregister-tool", { name }),
+        registerTool: (tool) => {
+            if (toolContribs.has(tool.name)) {
+                throw new Error(`Tool "${tool.name}" already registered. Use ctx.agent.adviseTool() to wrap it.`);
+            }
+            ctx.define(`tool:${tool.name}`, tool.execute.bind(tool));
+            ctx.define(`tool:${tool.name}:schema`, () => ({
+                description: tool.description,
+                parameters: tool.input_schema,
+            }));
+            if (tool.readOnly)
+                registerReadOnlyTool(tool.name);
+            else
+                unregisterReadOnlyTool(tool.name);
+            const contrib = (acc) => {
+                // Pull through schema so adviseToolSchema reflects.
+                const view = ctx.call(`tool:${tool.name}:schema`);
+                acc.tools.push({ ...tool, description: view.description, input_schema: view.parameters });
+                return acc;
+            };
+            toolContribs.set(tool.name, contrib);
+            bus.onPipe("agent:tools", contrib);
+        },
+        unregisterTool: (name) => {
+            const contrib = toolContribs.get(name);
+            if (!contrib)
+                return;
+            bus.offPipe("agent:tools", contrib);
+            toolContribs.delete(name);
+            unregisterReadOnlyTool(name);
+            // Handlers retained so external advisors survive a reload.
+        },
         adviseTool: (name, advisor) => ctx.advise(`tool:${name}`, advisor),
         adviseToolSchema: (name, advisor) => ctx.advise(`tool:${name}:schema`, advisor),
-        getTools: () => bus.emitPipe("agent:get-tools", { tools: [] }).tools,
-        registerInstruction: (name, text) => bus.emit("agent:register-instruction", { name, text, extensionName: "" }),
-        removeInstruction: (name) => bus.emit("agent:remove-instruction", { name }),
+        getTools: () => bus.emitPipe("agent:tools", { tools: [] }).tools,
+        registerInstruction: (name, text) => {
+            const existing = instructionContribs.get(name);
+            if (existing)
+                bus.offPipe("agent:instructions", existing);
+            ctx.define(`instruction:${name}`, () => text);
+            const contrib = (acc) => {
+                const current = ctx.call(`instruction:${name}`);
+                acc.instructions.push({ name, text: current });
+                return acc;
+            };
+            instructionContribs.set(name, contrib);
+            bus.onPipe("agent:instructions", contrib);
+        },
+        removeInstruction: (name) => {
+            const contrib = instructionContribs.get(name);
+            if (!contrib)
+                return;
+            bus.offPipe("agent:instructions", contrib);
+            instructionContribs.delete(name);
+        },
         adviseInstruction: (name, advisor) => ctx.advise(`instruction:${name}`, advisor),
-        registerSkill: (name, description, filePath) => bus.emit("agent:register-skill", { name, description, filePath, extensionName: "" }),
-        removeSkill: (name) => bus.emit("agent:remove-skill", { name }),
+        registerSkill: (name, description, filePath) => {
+            const existing = skillContribs.get(name);
+            if (existing)
+                bus.offPipe("agent:skills", existing);
+            ctx.define(`skill:${name}:view`, () => ({ description, filePath }));
+            const contrib = (acc) => {
+                const view = ctx.call(`skill:${name}:view`);
+                acc.skills.push({ name, description: view.description, filePath: view.filePath });
+                return acc;
+            };
+            skillContribs.set(name, contrib);
+            bus.onPipe("agent:skills", contrib);
+        },
+        removeSkill: (name) => {
+            const contrib = skillContribs.get(name);
+            if (!contrib)
+                return;
+            bus.offPipe("agent:skills", contrib);
+            skillContribs.delete(name);
+        },
         adviseSkill: (name, advisor) => ctx.advise(`skill:${name}:view`, advisor),
         registerContextProducer: (_name, producer, producerOpts) => {
             const handlerName = producerOpts?.mode === "per-query"
@@ -72,32 +205,80 @@ export default function agentBackend(ctx) {
         },
     };
     ctx.agent = agentSurface;
-    // Immutable settings snapshot; provider:register payloads merge against it.
-    const providerRegistry = new Map();
-    const settingsProviders = new Map();
-    for (const name of getProviderNames()) {
-        const p = resolveProvider(name);
-        if (p) {
-            providerRegistry.set(name, p);
-            settingsProviders.set(name, p);
+    // Core tools register at activate — before extensions load — so
+    // extensions that look them up at activate time (e.g. scheme.ts) find them.
+    // conversation_recall stays in AgentLoop (needs session state).
+    const fileReadCache = new Map();
+    ctx.define("agent:file-read-cache", () => fileReadCache);
+    const getCwd = () => ctx.call("cwd");
+    const getEnv = () => {
+        const env = {};
+        for (const [k, v] of Object.entries(process.env)) {
+            if (v !== undefined)
+                env[k] = v;
         }
+        return env;
+    };
+    if (findBash() !== null) {
+        agentSurface.registerTool(createBashTool({ getCwd, getEnv, bus }));
     }
-    const providerHooks = new Map();
-    // Bakes model id into the hook so AgentMode.buildReasoningParams keeps
-    // its (level) signature while the hook can branch on model.
-    const bindReasoning = (shapeId, model) => {
-        const hook = providerHooks.get(shapeId)?.reasoningParams;
-        return hook ? (level) => hook(level, model) : defaultReasoningBuilder;
+    if (process.platform === "win32") {
+        agentSurface.registerTool(createPwshTool({ getCwd, getEnv, bus }));
+    }
+    agentSurface.registerTool(createReadFileTool(getCwd, fileReadCache));
+    agentSurface.registerTool(createWriteFileTool(getCwd));
+    agentSurface.registerTool(createEditFileTool(getCwd));
+    agentSurface.registerTool(createGrepTool(getCwd));
+    agentSurface.registerTool(createGlobTool(getCwd));
+    agentSurface.registerTool(createLsTool(getCwd));
+    agentSurface.registerTool(createListSkillsTool(getCwd));
+    let resolvedProviders = new Map();
+    const resolveWithSettings = (id, p) => {
+        const s = settingsProviders.get(id);
+        const { ids: payloadIds, caps: payloadCaps } = p ? splitRegistration(p) : { ids: [], caps: new Map() };
+        const fallbackIds = s?.models ?? (s?.defaultModel ? [s.defaultModel] : []);
+        const modelIds = s?.modelsExplicit && s.models.length > 0
+            ? s.models
+            : payloadIds.length > 0 ? payloadIds : fallbackIds;
+        return {
+            id,
+            apiKey: s?.apiKey ?? p?.apiKey,
+            baseURL: s?.baseURL ?? p?.baseURL,
+            defaultModel: s?.defaultModel ?? p?.defaultModel ?? modelIds[0],
+            models: modelIds,
+            modelsExplicit: s?.modelsExplicit ?? false,
+            contextWindow: s?.contextWindow,
+            supportsReasoningEffort: s?.supportsReasoningEffort ?? p?.supportsReasoningEffort,
+            modelCapabilities: mergeCaps(s?.modelCapabilities, payloadCaps, modelIds),
+            reasoningShape: s?.reasoningShape,
+        };
+    };
+    const computeResolvedProviders = () => {
+        const out = new Map();
+        // Last contribution per id wins (openrouter's catalog-refresh replaces
+        // its curated default).
+        const { providers } = bus.emitPipe("agent:providers", { providers: [] });
+        const byId = new Map();
+        for (const p of providers)
+            byId.set(p.id, p);
+        for (const [id, p] of byId)
+            out.set(id, resolveWithSettings(id, p));
+        for (const [id] of settingsProviders) {
+            if (out.has(id))
+                continue;
+            out.set(id, resolveWithSettings(id, null));
+        }
+        return out;
     };
     const buildModes = () => {
-        const allModes = [];
-        for (const [id, p] of providerRegistry) {
+        const out = [];
+        for (const [id, p] of resolvedProviders) {
             if (!p.apiKey)
                 continue;
             const shapeId = p.reasoningShape ?? id;
             for (const model of p.models) {
                 const mc = p.modelCapabilities?.get(model);
-                allModes.push({
+                out.push({
                     model,
                     provider: id,
                     providerConfig: { apiKey: p.apiKey, baseURL: p.baseURL },
@@ -110,11 +291,10 @@ export default function agentBackend(ctx) {
                 });
             }
         }
-        return allModes;
+        return out;
     };
-    // Placeholder client — reconfigured at core:extensions-loaded. Any
-    // stream() call before then fails from the OpenAI SDK; start() won't
-    // wire the loop until we've resolved, so users never hit that path.
+    ctx.define("agent:get-modes", () => buildModes());
+    // Reconfigured at core:extensions-loaded; start() gates on `resolved`.
     const llmClient = new LlmClient({ apiKey: "not-configured", model: "not-configured" });
     ctx.define("llm:get-client", () => llmClient);
     ctx.define("llm:invoke", (messages, opts) => {
@@ -127,71 +307,59 @@ export default function agentBackend(ctx) {
             ...(clampedEffort && clampedEffort !== "off" ? { reasoning_effort: clampedEffort } : {}),
         });
     });
-    let modes = [];
-    let initialModeIndex = 0;
     let resolved = false;
-    // Gates late-registration reconcile so its config:switch-model emit doesn't misroute under a non-ash backend.
+    // Gates late-reconcile so config:switch-model doesn't misroute under a non-ash backend.
     let ashActive = false;
-    bus.onPipe("config:get-initial-modes", () => ({ modes, initialModeIndex }));
-    // AgentLoop must be constructed *before* user extensions activate,
-    // because its ctor defines handlers (history:append, etc.) that
-    // extensions like superash call synchronously during their own
-    // activate. Advise-before-define works for advisers, but plain calls
-    // would hit a no-op stub.
-    const agentLoop = new AgentLoop({
-        bus,
-        llmClient,
-        handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call, list: ctx.list },
-        modes,
-        initialModeIndex,
-        compositor: ctx.shell?.compositor,
-        instanceId: ctx.instanceId,
-        history: config.history,
-    });
+    let agentLoop = null;
     let loadedExtensionNames = [];
+    bus.on("agent:providers:changed", () => {
+        resolvedProviders = computeResolvedProviders();
+        if (!resolved)
+            return;
+        bus.emit("agent:modes-changed", {});
+        if (!ashActive)
+            return;
+        const pendingProvider = getSettings().defaultProvider;
+        if (!pendingProvider)
+            return;
+        const p = resolvedProviders.get(pendingProvider);
+        if (!p)
+            return;
+        const pendingModel = persistedModelFor(pendingProvider);
+        if (pendingModel && p.models.includes(pendingModel) && llmClient.model !== pendingModel) {
+            bus.emit("config:switch-model", { model: pendingModel });
+        }
+    });
+    bus.on("provider:configure", ({ id, reasoningParams }) => {
+        const prev = providerHooks.get(id) ?? {};
+        if (reasoningParams !== undefined)
+            prev.reasoningParams = reasoningParams;
+        providerHooks.set(id, prev);
+    });
     bus.on("core:extensions-loaded", ({ names }) => {
         loadedExtensionNames = names;
+        resolvedProviders = computeResolvedProviders();
         const settings = getSettings();
-        // If the user didn't pick a default, fall back to the first registered
-        // provider (built-in load order biases to openrouter → openai).
         const providerName = config.provider ?? settings.defaultProvider
-            ?? (providerRegistry.size > 0 ? providerRegistry.keys().next().value : undefined);
-        const activeProvider = providerName ? providerRegistry.get(providerName) ?? null : null;
-        // User's persisted defaultModel wins over the provider's declared
-        // default. Dynamic providers (openrouter) re-register with their
-        // hardcoded DEFAULT_MODELS[0] each startup, which would otherwise
-        // clobber the user's /model selection.
+            ?? (resolvedProviders.size > 0 ? resolvedProviders.keys().next().value : undefined);
+        const activeProvider = providerName ? resolvedProviders.get(providerName) ?? null : null;
+        // Persisted defaultModel wins over openrouter's hardcoded DEFAULT_MODELS[0].
         const effectiveApiKey = config.apiKey ?? activeProvider?.apiKey;
         const effectiveBaseURL = config.baseURL ?? activeProvider?.baseURL;
         const effectiveModel = config.model ?? persistedModelFor(providerName) ?? activeProvider?.defaultModel;
-        // No provider → don't register ash at all, so another backend (e.g.
-        // claude-code-bridge) can own activation. index.ts hard-fails only
-        // when no backend ended up registered.
+        // No provider → don't register ash; let another backend own activation.
         if (!effectiveApiKey || !effectiveModel)
             return;
-        modes = buildModes();
-        if (modes.length === 0)
-            modes = [{ model: effectiveModel }];
-        let foundIdx = modes.findIndex((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id));
-        // Persisted default may not be in the provider's curated list yet (e.g.
-        // openrouter's async catalog fetch hasn't returned). Prepend a stub so
-        // the initial config:set-modes activeIndex points at the real model —
-        // otherwise AgentLoop reconfigures llmClient back to modes[0].
-        if (foundIdx === -1 && activeProvider) {
-            modes = [
-                {
-                    model: effectiveModel,
-                    provider: activeProvider.id,
-                    providerConfig: { apiKey: effectiveApiKey, baseURL: effectiveBaseURL },
-                    supportsReasoningEffort: activeProvider.supportsReasoningEffort,
-                },
-                ...modes,
-            ];
-            foundIdx = 0;
-        }
-        initialModeIndex = Math.max(0, foundIdx);
+        const foundInModes = buildModes().find((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id));
+        // Stub when openrouter's async catalog hasn't returned yet; reconciled
+        // later via agent:providers:changed → config:switch-model.
+        const initialMode = foundInModes ?? (activeProvider ? {
+            model: effectiveModel,
+            provider: activeProvider.id,
+            providerConfig: { apiKey: effectiveApiKey, baseURL: effectiveBaseURL },
+            supportsReasoningEffort: activeProvider.supportsReasoningEffort,
+        } : { model: effectiveModel });
         llmClient.reconfigure({ apiKey: effectiveApiKey, baseURL: effectiveBaseURL, model: effectiveModel });
-        bus.emit("config:set-modes", { modes, activeIndex: initialModeIndex });
         resolved = true;
         bus.emit("agent:register-backend", {
             name: "ash",
@@ -199,9 +367,19 @@ export default function agentBackend(ctx) {
                 ashActive = false;
                 bus.emit("command:unregister", { name: "/compact" });
                 bus.emit("command:unregister", { name: "/context" });
-                agentLoop.kill();
+                agentLoop?.kill();
+                agentLoop = null;
             },
             start: async () => {
+                agentLoop = new AgentLoop({
+                    bus,
+                    llmClient,
+                    handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call, list: ctx.list },
+                    initialMode,
+                    compositor: ctx.shell?.compositor,
+                    instanceId: ctx.instanceId,
+                    history: config.history,
+                });
                 agentLoop.wire();
                 ashActive = true;
                 bus.emit("command:register", {
@@ -229,71 +407,8 @@ export default function agentBackend(ctx) {
             },
         });
     });
-    bus.on("provider:configure", ({ id, reasoningParams }) => {
-        const prev = providerHooks.get(id) ?? {};
-        if (reasoningParams !== undefined)
-            prev.reasoningParams = reasoningParams;
-        providerHooks.set(id, prev);
-    });
-    bus.on("provider:register", (p) => {
-        const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
-        const payloadModelIds = [];
-        const payloadCaps = new Map();
-        for (const m of rawModels) {
-            if (typeof m === "string") {
-                payloadModelIds.push(m);
-            }
-            else {
-                payloadModelIds.push(m.id);
-                payloadCaps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, maxTokens: m.maxTokens, echoReasoning: m.echoReasoning });
-            }
-        }
-        const settings = settingsProviders.get(p.id);
-        const modelIds = settings?.modelsExplicit && settings.models.length > 0 ? settings.models : payloadModelIds;
-        const mergedCaps = mergeCaps(settings?.modelCapabilities, payloadCaps, modelIds);
-        const merged = {
-            id: p.id,
-            apiKey: settings?.apiKey ?? p.apiKey,
-            baseURL: settings?.baseURL ?? p.baseURL,
-            defaultModel: settings?.defaultModel ?? p.defaultModel,
-            models: modelIds,
-            modelsExplicit: settings?.modelsExplicit ?? false,
-            contextWindow: settings?.contextWindow,
-            supportsReasoningEffort: settings?.supportsReasoningEffort ?? p.supportsReasoningEffort,
-            modelCapabilities: mergedCaps,
-            reasoningShape: settings?.reasoningShape,
-        };
-        providerRegistry.set(p.id, merged);
-        const addModes = modelIds.map((m) => {
-            const mc = mergedCaps?.get(m);
-            return {
-                model: m,
-                provider: p.id,
-                providerConfig: { apiKey: merged.apiKey ?? "", baseURL: merged.baseURL },
-                contextWindow: mc?.contextWindow,
-                maxTokens: mc?.maxTokens,
-                reasoning: mc?.reasoning,
-                supportsReasoningEffort: merged.supportsReasoningEffort,
-                echoReasoning: mc?.echoReasoning,
-                buildReasoningParams: bindReasoning(p.id, m),
-            };
-        });
-        bus.emit("config:add-modes", { modes: addModes });
-        // Late-registration reconcile: if this completes the user's persisted
-        // default (openrouter's async fetch delivers the full catalog after
-        // we've already fallen back to mode 0), quietly switch to it.
-        if (!resolved || !ashActive)
-            return;
-        const pendingProvider = getSettings().defaultProvider;
-        if (pendingProvider !== p.id)
-            return;
-        const pendingModel = persistedModelFor(pendingProvider);
-        if (pendingModel && modelIds.includes(pendingModel) && llmClient.model !== pendingModel) {
-            bus.emit("config:switch-model", { model: pendingModel });
-        }
-    });
     bus.on("config:switch-provider", ({ provider: name }) => {
-        const p = providerRegistry.get(name);
+        const p = resolvedProviders.get(name);
         if (!p) {
             bus.emit("ui:error", { message: `Unknown provider: ${name}` });
             return;
@@ -308,20 +423,8 @@ export default function agentBackend(ctx) {
             return;
         }
         llmClient.reconfigure({ apiKey: p.apiKey, baseURL: p.baseURL, model: switchModel });
-        const newModes = p.models.map((m) => {
-            const mc = p.modelCapabilities?.get(m);
-            return {
-                model: m,
-                provider: name,
-                providerConfig: { apiKey: p.apiKey, baseURL: p.baseURL },
-                contextWindow: mc?.contextWindow ?? p.contextWindow,
-                maxTokens: mc?.maxTokens ?? (mc?.contextWindow ? Math.min(Math.floor(mc.contextWindow * 0.4), 65536) : undefined),
-                reasoning: mc?.reasoning,
-                supportsReasoningEffort: p.supportsReasoningEffort,
-                echoReasoning: mc?.echoReasoning,
-            };
-        });
-        bus.emit("config:set-modes", { modes: newModes });
+        bus.emit("agent:modes-changed", {});
+        bus.emit("config:switch-model", { model: switchModel });
         bus.emit("ui:info", { message: `Switched to ${name} (${switchModel})` });
     });
     bus.onPipe("banner:collect", (e) => {
@@ -340,14 +443,13 @@ export default function agentBackend(ctx) {
 export { AgentLoop } from "./agent-loop.js";
 export { ToolRegistry } from "./tool-registry.js";
 export { runSubagent } from "./subagent.js";
-/** Activate the ash backend and any provider whose key is configured. */
+/** Built-in providers register unconditionally so `auth list` can
+ *  enumerate them; buildModes() skips entries without an apiKey. */
 export function activateAgent(ctx) {
     agentBackend(ctx);
     const agentCtx = ctx;
-    if (resolveApiKey("openrouter").key)
-        activateOpenrouter(agentCtx);
-    if (resolveApiKey("openai").key && !process.env.OPENAI_BASE_URL)
-        activateOpenai(agentCtx);
+    activateOpenrouter(agentCtx);
+    activateOpenai(agentCtx);
     if (process.env.OPENAI_BASE_URL)
         activateOpenaiCompatible(agentCtx);
     activateDeepseek(agentCtx);

package/dist/agent/llm-facade.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ctx.agent.llm facade — delegates to an `llm:invoke` handler defined
+ * by the ash backend. Other backends (claude-code, pi, opencode) bring
+ * their own LLM and do not define this handler; `available` is false
+ * under those backends and calls reject.
+ */
+import type { LlmInterface } from "./host-types.js";
+interface HandlerGate {
+    list: () => string[];
+    call: (name: string, ...args: unknown[]) => unknown;
+}
+export declare function createLlmFacade(handlers: HandlerGate): LlmInterface;
+export {};

package/dist/{utils → agent}/llm-facade.js

@@ -2,7 +2,7 @@ export function createLlmFacade(handlers) {
     const invoke = (messages, maxTokens, model, reasoningEffort) => {
         const result = handlers.call("llm:invoke", messages, { maxTokens, model, reasoningEffort });
         if (result === undefined)
-            return Promise.reject(new Error("ctx.llm: no LLM backend available"));
+            return Promise.reject(new Error("ctx.agent.llm: no LLM backend available"));
         return result;
     };
     return {

package/dist/agent/nuclear-form.d.ts

@@ -7,7 +7,7 @@
  *
  * Nuclear entries are the currency of Tier 2 and Tier 3.
  */
-import type { ChatCompletionMessageParam } from "../utils/llm-client.js";
+import type { ChatCompletionMessageParam } from "./llm-client.js";
 export interface NuclearEntry {
     /** Global sequence number. */
     seq: number;

package/dist/agent/providers/deepseek.js

@@ -11,12 +11,9 @@ function buildReasoningParams(level, _model) {
 }
 export default function activate(ctx) {
     ctx.agent.providers.configure("deepseek", { reasoningParams: buildReasoningParams });
-    const apiKey = resolveApiKey("deepseek").key;
-    if (!apiKey)
-        return;
-    ctx.bus.emit("provider:register", {
+    ctx.agent.providers.register({
         id: "deepseek",
-        apiKey,
+        apiKey: resolveApiKey("deepseek").key ?? undefined,
         baseURL: BASE_URL,
         defaultModel: DEFAULT_MODELS[0].id,
         models: DEFAULT_MODELS,

package/dist/agent/providers/openai-compatible.js

@@ -5,11 +5,11 @@ export default function activate(ctx) {
     // Local servers often need no key; SDK still wants a non-empty string.
     const apiKey = process.env.OPENAI_API_KEY || "no-key";
     const id = "openai-compatible";
-    ctx.bus.emit("provider:register", { id, apiKey, baseURL, models: [] });
+    ctx.agent.providers.register({ id, apiKey, baseURL, models: [] });
     fetchModels(baseURL, apiKey).then((models) => {
         if (models.length === 0)
             return;
-        ctx.bus.emit("provider:register", {
+        ctx.agent.providers.register({
             id,
             apiKey,
             baseURL,

package/dist/agent/providers/openai.js

@@ -32,15 +32,12 @@ function buildReasoningParams(level, model) {
     return off ? { reasoning_effort: off } : {};
 }
 export default function activate(ctx) {
-    const apiKey = resolveApiKey("openai").key;
-    if (!apiKey)
-        return;
     if (process.env.OPENAI_BASE_URL)
         return; // openai-compatible handles this
     ctx.agent.providers.configure("openai", { reasoningParams: buildReasoningParams });
-    ctx.bus.emit("provider:register", {
+    ctx.agent.providers.register({
         id: "openai",
-        apiKey,
+        apiKey: resolveApiKey("openai").key ?? undefined,
         defaultModel: CLOUD_MODELS[0].id,
         models: CLOUD_MODELS,
     });

package/dist/agent/providers/openrouter.js

@@ -16,22 +16,22 @@ function buildReasoningParams(level, _model) {
 }
 export default function activate(ctx) {
     const apiKey = resolveApiKey("openrouter").key;
-    if (!apiKey)
-        return;
     ctx.agent.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
-    ctx.bus.emit("provider:register", {
+    ctx.agent.providers.register({
         id: "openrouter",
-        apiKey,
+        apiKey: apiKey ?? undefined,
         baseURL: BASE_URL,
         defaultModel: DEFAULT_MODELS[0],
         models: DEFAULT_MODELS,
     });
+    if (!apiKey)
+        return;
     fetchModels(apiKey).then((models) => {
         if (models.length === 0)
             return;
         const userOverrides = readUserOverrides();
         const patterns = readEchoPatterns();
-        ctx.bus.emit("provider:register", {
+        ctx.agent.providers.register({
             id: "openrouter",
             apiKey,
             baseURL: BASE_URL,