agent-sh 0.14.6 → 0.14.8

package/dist/agent/agent-loop.js

@@ -98,7 +98,9 @@ export class AgentLoop {
         this.conversation = new ConversationState(this.handlers, this.instanceId);
         this.activeMode = config.initialMode ?? { model: config.llmClient.model };
         // Tool protocol — controls how tools are presented to the LLM
-        this.toolProtocol = createToolProtocol(getSettings().toolMode ?? "api", getSettings().coreTools ?? []);
+        const { names: fromExtensions } = this.bus.emitPipe("agent:core-tools:collect", { names: [] });
+        const coreTools = Array.from(new Set([...(getSettings().coreTools ?? []), ...fromExtensions]));
+        this.toolProtocol = createToolProtocol(getSettings().toolMode ?? "api", coreTools);
         // Register core tools
         this.registerCoreTools();
         // Register any protocol-provided tools (e.g. load_tool for deferred-lookup).

package/dist/agent/events.d.ts

@@ -9,6 +9,10 @@ export interface AgentIdentity {
 }
 declare module "../core/event-bus.js" {
     interface BusEvents {
+        /** Sync pipe: extensions append core tool names; unioned with settings.coreTools. */
+        "agent:core-tools:collect": {
+            names: string[];
+        };
         "agent:providers": {
             providers: ProviderRegistration[];
         };

package/dist/agent/index.js

@@ -8,6 +8,7 @@ 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 { resolveApiKey } from "../cli/auth/keys.js";
 import { discoverSkills } from "./skills.js";
 import activateOpenrouter from "./providers/openrouter.js";
 import activateOpenai from "./providers/openai.js";
@@ -205,6 +206,7 @@ export default function agentBackend(ctx) {
         },
     };
     ctx.agent = agentSurface;
+    ctx.define("provider:resolve-api-key", (id) => resolveApiKey(id));
     // 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).
@@ -343,8 +345,12 @@ export default function agentBackend(ctx) {
         loadedExtensionNames = names;
         resolvedProviders = computeResolvedProviders();
         const settings = getSettings();
-        const providerName = config.provider ?? settings.defaultProvider
-            ?? (resolvedProviders.size > 0 ? resolvedProviders.keys().next().value : undefined);
+        // Built-ins register unconditionally so `auth list` can enumerate them;
+        // the fallback must skip keyless entries or it lands on openrouter and
+        // bails at the `!effectiveApiKey` guard below.
+        const providerName = config.provider
+            ?? settings.defaultProvider
+            ?? [...resolvedProviders].find(([, p]) => p.apiKey)?.[0];
         const activeProvider = providerName ? resolvedProviders.get(providerName) ?? null : null;
         // Persisted defaultModel wins over openrouter's hardcoded DEFAULT_MODELS[0].
         const effectiveApiKey = config.apiKey ?? activeProvider?.apiKey;

package/dist/cli/auth/discover.js

@@ -1,15 +1,20 @@
 /** Bootstrap a throwaway core to enumerate provider ids extensions
  *  would register, so `auth list` shows ids the user hasn't keyed yet. */
+import * as path from "node:path";
 import { createCore } from "../../core/index.js";
 import { activateAgent } from "../../agent/index.js";
 import { loadExtensions } from "../../core/extension-loader.js";
 import { loadBuiltinExtensions } from "../../extensions/index.js";
-import { getSettings } from "../../core/settings.js";
+import { CONFIG_DIR, getSettings } from "../../core/settings.js";
+const EXT_DIR = path.join(CONFIG_DIR, "extensions");
+const BARE_IMPORT_RE = /Cannot find (?:package|module) ['"]agent-sh\/[^'"]+['"]/;
 let cached = null;
 export async function discoverExtensionProviders() {
     if (cached)
         return cached;
     const core = createCore({});
+    const errors = [];
+    core.bus.on("ui:error", ({ message }) => { errors.push(message); });
     try {
         const ctx = core.extensionContext({ quit: () => { } });
         activateAgent(ctx);
@@ -17,6 +22,18 @@ export async function discoverExtensionProviders() {
         await loadExtensions(ctx).catch(() => { });
         const { providers } = core.bus.emitPipe("agent:providers", { providers: [] });
         cached = providers.map((p) => ({ id: p.id, noAuth: p.noAuth }));
+        if (errors.length > 0) {
+            process.stderr.write(`\n[agent-sh] extension load errors during provider discovery:\n`);
+            for (const msg of errors) {
+                process.stderr.write(`  - ${msg}\n`);
+                if (BARE_IMPORT_RE.test(msg) && msg.includes(EXT_DIR)) {
+                    process.stderr.write(`      ↳ Single-file extensions can't runtime-import agent-sh modules from ${EXT_DIR}.\n` +
+                        `        Use ctx.call(...) for runtime needs, or convert to a directory extension\n` +
+                        `        with its own package.json + node_modules.\n`);
+                }
+            }
+            process.stderr.write(`\n`);
+        }
         return cached;
     }
     finally {

package/dist/core/extension-loader.js

@@ -153,7 +153,7 @@ export async function loadExtensions(ctx, cliExtensions) {
     if (settings.extensions.length > 0) {
         specifiers.push(...settings.extensions);
     }
-    const userSpecifiers = await discoverUserExtensions();
+    const userSpecifiers = await discoverUserExtensions(ctx);
     specifiers.push(...userSpecifiers);
     const seen = new Set();
     const unique = specifiers.filter((s) => {
@@ -165,19 +165,30 @@ export async function loadExtensions(ctx, cliExtensions) {
     const loaded = await loadSpecifiers(unique, ctx, false);
     return loaded;
 }
-async function discoverUserExtensions() {
+async function discoverUserExtensions(ctx) {
     const specifiers = [];
     const disabled = new Set(getSettings().disabledExtensions ?? []);
+    let entries;
     try {
-        const entries = await fs.readdir(EXT_DIR, { withFileTypes: true });
-        for (const entry of entries) {
-            // Disable check: directory name for dir-extensions, or basename sans
-            // extension for file-extensions. Lets settings.json turn one off
-            // without renaming it.
-            const nameForDisable = entry.name.replace(/\.[^.]+$/, "");
-            if (disabled.has(nameForDisable))
-                continue;
-            const fullPath = path.join(EXT_DIR, entry.name);
+        entries = await fs.readdir(EXT_DIR, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return specifiers;
+        ctx.bus.emit("ui:error", {
+            message: `Failed to read extensions directory ${EXT_DIR}: ${err instanceof Error ? err.message : String(err)}`,
+        });
+        return specifiers;
+    }
+    for (const entry of entries) {
+        // Disable check: directory name for dir-extensions, or basename sans
+        // extension for file-extensions. Lets settings.json turn one off
+        // without renaming it.
+        const nameForDisable = entry.name.replace(/\.[^.]+$/, "");
+        if (disabled.has(nameForDisable))
+            continue;
+        const fullPath = path.join(EXT_DIR, entry.name);
+        try {
             const isDir = entry.isDirectory() ||
                 (entry.isSymbolicLink() && (await fs.stat(fullPath)).isDirectory());
             if (isDir) {
@@ -189,9 +200,11 @@ async function discoverUserExtensions() {
                 specifiers.push(fullPath);
             }
         }
-    }
-    catch {
-        // Directory doesn't exist — no user extensions
+        catch (err) {
+            ctx.bus.emit("ui:error", {
+                message: `Failed to inspect extension ${fullPath}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
     }
     return specifiers;
 }
@@ -240,7 +253,7 @@ async function loadSpecifiers(specifiers, ctx, bustCache) {
  * Tears down old registrations, busts the module cache, and re-activates.
  */
 export async function reloadExtensions(ctx) {
-    const specifiers = await discoverUserExtensions();
+    const specifiers = await discoverUserExtensions(ctx);
     return loadSpecifiers(specifiers, ctx, true);
 }
 /**

package/dist/shell/strategies/bash.js

@@ -30,8 +30,12 @@ export const bashStrategy = {
             `PROMPT_COMMAND="\${PROMPT_COMMAND:+\$PROMPT_COMMAND;}__agent_sh_precmd"`,
             "",
             "# Preexec hook via DEBUG trap: emit actual command text so agent-sh",
-            "# can track history-recalled and tab-completed commands accurately",
-            "__agent_sh_preexec_ran=0",
+            "# can track history-recalled and tab-completed commands accurately.",
+            "# Start latched (=1) so the trap stays inert through the rest of",
+            "# rcfile sourcing — readline/history aren't loaded yet, and the case",
+            "# + bind statements below would otherwise fire a phantom preexec with",
+            "# an empty body. __agent_sh_precmd resets it to 0 before user input.",
+            "__agent_sh_preexec_ran=1",
             "__agent_sh_emit_preexec() {",
             '  [[ $__agent_sh_preexec_ran == 1 ]] && return',
             '  [[ -n $COMP_LINE ]] && return',

package/examples/extensions/ash-scheme/index.ts

@@ -2058,6 +2058,10 @@ export default function activate(ctx: AgentContext): void {
     for (const name of HIDDEN_IN_SCHEME_ONLY) {
       try { ctx.agent.unregisterTool(name); } catch { /* not registered — fine */ }
     }
+    ctx.bus.onPipe("agent:core-tools:collect", (ev) => ({
+      ...ev,
+      names: [...ev.names, "scheme_eval"],
+    }));
   }
 
   ctx.agent.registerTool({

package/examples/extensions/ashi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanyilun/ashi",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Ash in an interactive TUI — agent-sh's built-in agent without the shell underneath",
   "type": "module",
   "main": "dist/cli.js",
@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.74.0",
-    "agent-sh": "^0.14.0",
+    "agent-sh": "^0.14.7",
     "chalk": "^5.5.0",
     "cli-highlight": "^2.1.11"
   },

package/examples/extensions/ashi/src/frontend.ts

@@ -636,6 +636,9 @@ export function mountAshi(
   let activeUserShell: { pair: ToolPair; command: string; isPrivate: boolean } | null = null;
   bus.on("shell:command-start", ({ command }) => {
     if (agentShellActive) return;
+    // Defensive: bash DEBUG-trap integrations have been observed firing
+    // before any user input, with an empty command body.
+    if (!command.trim()) return;
     finalizeThinking();
     if (activeAssistant) { activeAssistant.finalize(); activeAssistant = null; }
     const isPrivate = pendingUserBlockPrivacy.shift() ?? false;

package/examples/extensions/ollama.ts

@@ -3,7 +3,6 @@
  * `agent-sh auth login ollama-cloud` or OLLAMA_API_KEY). Local host
  * overridable via OLLAMA_HOST.
  */
-import { resolveApiKey } from "agent-sh/auth";
 import type { AgentContext } from "agent-sh/types";
 
 const ECHO_REASONING_PATTERNS: RegExp[] = [/deepseek/i];
@@ -14,7 +13,9 @@ function reasoningParams(level: string): Record<string, unknown> {
 }
 
 export default function activate(ctx: AgentContext): void {
-  const cloudKey = resolveApiKey("ollama-cloud").key ?? process.env.OLLAMA_API_KEY;
+  const cloudKey =
+    (ctx.call("provider:resolve-api-key", "ollama-cloud") as { key: string | null }).key ??
+    process.env.OLLAMA_API_KEY;
   const cloudHost = "https://ollama.com";
   const cloudBaseURL = `${cloudHost}/v1`;
   ctx.agent.providers.configure("ollama-cloud", { reasoningParams });

package/examples/extensions/opencode-provider.ts

@@ -31,7 +31,6 @@
  */
 
 import type { AgentContext } from "agent-sh/types";
-import { resolveApiKey } from "agent-sh/auth";
 
 // ── Constants ──────────────────────────────────────────────────────
 
@@ -180,7 +179,7 @@ function buildReasoningParams(level: string): Record<string, unknown> {
 export default function activate(ctx: AgentContext): void {
   const apiKey =
     process.env.OPENCODE_API_KEY ??
-    resolveApiKey("opencode").key ?? undefined;
+    (ctx.call("provider:resolve-api-key", "opencode") as { key: string | null }).key ?? undefined;
 
   // ── Phase 1: register both providers synchronously with fallback models ──
 

package/examples/extensions/zai-coding-plan.ts

@@ -4,7 +4,6 @@
  * Auth:  agent-sh auth login zai-coding-plan
  * Usage: agent-sh -e ./examples/extensions/zai-coding-plan.ts
  */
-import { resolveApiKey } from "agent-sh/auth";
 import type { AgentContext } from "agent-sh/types";
 
 const BASE_URL = "https://api.z.ai/api/coding/paas/v4";
@@ -24,7 +23,7 @@ function buildReasoningParams(level: string, _model?: string): Record<string, un
 }
 
 export default function activate(ctx: AgentContext): void {
-  const { key } = resolveApiKey(ID);
+  const { key } = ctx.call("provider:resolve-api-key", ID) as { key: string | null };
   ctx.agent.providers.configure(ID, { reasoningParams: buildReasoningParams });
   ctx.agent.providers.register({
     id: ID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.14.6",
+  "version": "0.14.8",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "workspaces": [