agent-sh 0.13.7 → 0.14.0

package/dist/agent/subagent.d.ts

@@ -10,7 +10,7 @@
  * Used by the subagent extension to delegate tasks from the main agent.
  */
 import type { EventBus } from "../core/event-bus.js";
-import type { LlmClient } from "../utils/llm-client.js";
+import type { LlmClient } from "./llm-client.js";
 import type { ToolDefinition } from "./types.js";
 export interface SubagentOptions {
     /** LLM client to use. */

package/dist/agent/tool-protocol.d.ts

@@ -9,7 +9,7 @@
  * The agent loop uses this interface uniformly so the rest of the code
  * doesn't need to know which mode is active.
  */
-import type { ChatCompletionTool } from "../utils/llm-client.js";
+import type { ChatCompletionTool } from "./llm-client.js";
 import type { ToolDefinition } from "./types.js";
 import type { ConversationState } from "./conversation-state.js";
 export interface PendingToolCall {

package/dist/agent/tool-registry.d.ts

@@ -1,5 +1,5 @@
 import type { ToolDefinition, ToolResult } from "./types.js";
-import type { ChatCompletionTool } from "../utils/llm-client.js";
+import type { ChatCompletionTool } from "./llm-client.js";
 import type { HandlerFunctions } from "../utils/handler-registry.js";
 /**
  * Registry for agent tools. Execution is routed through the named-handler

package/dist/cli/auth/cli.js

@@ -1,6 +1,6 @@
 import * as readline from "node:readline";
 import { palette as p } from "../../utils/palette.js";
-import { KNOWN_PROVIDERS, KEYS_PATH, loadKeysFile, saveKeysFile, resolveApiKey, listAllProviders, findProvider as findProviderById, } from "./keys.js";
+import { KNOWN_PROVIDERS, KEYS_PATH, loadKeysFile, saveKeysFile, resolveApiKey, listAllProvidersWithDiscovery, findProvider as findProviderById, } from "./keys.js";
 export async function runAuth(args) {
     const sub = args[0];
     if (!sub || sub === "--help" || sub === "-h") {
@@ -16,7 +16,7 @@ export async function runAuth(args) {
         return;
     }
     if (sub === "list" || sub === "ls" || sub === "status") {
-        runList();
+        await runList();
         return;
     }
     console.error(`agent-sh auth: unknown subcommand "${sub}"`);
@@ -90,8 +90,8 @@ function runLogout(providerArg) {
     saveKeysFile(keys);
     console.log(`${p.success}✓${p.reset} Removed ${id} key from ${KEYS_PATH}`);
 }
-function runList() {
-    const providers = listAllProviders();
+async function runList() {
+    const providers = await listAllProvidersWithDiscovery();
     console.log("Provider key status:\n");
     const idWidth = Math.max(...providers.map((p) => p.id.length));
     for (const info of providers) {
@@ -105,6 +105,9 @@ function runList() {
         if (resolved.key) {
             console.log(`  ${p.success}●${p.reset} ${padded}  ${p.dim}(${sourceLabel(resolved.source, info)})${p.reset}${marker}`);
         }
+        else if (info.noAuth) {
+            console.log(`  ${p.success}●${p.reset} ${padded}  ${p.dim}(no auth required)${p.reset}${marker}`);
+        }
         else {
             console.log(`  ${p.muted}○${p.reset} ${padded}  ${p.dim}(not configured)${p.reset}${marker}`);
         }
@@ -117,13 +120,15 @@ async function pickProvider() {
         console.error("agent-sh auth: no provider specified and stdin is not a TTY.");
         return null;
     }
-    const providers = listAllProviders();
+    const providers = await listAllProvidersWithDiscovery();
     console.log("Select a provider:");
     providers.forEach((info, i) => {
         const resolved = resolveApiKey(info.id);
         const tag = resolved.key
             ? `${p.dim}(currently from ${sourceLabel(resolved.source, info)})${p.reset}`
-            : `${p.dim}(not configured)${p.reset}`;
+            : info.noAuth
+                ? `${p.dim}(no auth required)${p.reset}`
+                : `${p.dim}(not configured)${p.reset}`;
         const labelStr = info.custom
             ? `${p.dim}custom${p.reset}`
             : info.unattached

package/dist/cli/auth/discover.d.ts

@@ -0,0 +1,5 @@
+export interface DiscoveredProvider {
+    id: string;
+    noAuth?: boolean;
+}
+export declare function discoverExtensionProviders(): Promise<DiscoveredProvider[]>;

package/dist/cli/auth/discover.js

@@ -0,0 +1,25 @@
+/** Bootstrap a throwaway core to enumerate provider ids extensions
+ *  would register, so `auth list` shows ids the user hasn't keyed yet. */
+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";
+let cached = null;
+export async function discoverExtensionProviders() {
+    if (cached)
+        return cached;
+    const core = createCore({});
+    try {
+        const ctx = core.extensionContext({ quit: () => { } });
+        activateAgent(ctx);
+        await loadBuiltinExtensions(ctx, getSettings().disabledBuiltins);
+        await loadExtensions(ctx).catch(() => { });
+        const { providers } = core.bus.emitPipe("agent:providers", { providers: [] });
+        cached = providers.map((p) => ({ id: p.id, noAuth: p.noAuth }));
+        return cached;
+    }
+    finally {
+        core.kill();
+    }
+}

package/dist/cli/auth/keys.d.ts

@@ -9,11 +9,14 @@ export interface ProviderAuthInfo {
     /** True for ids only present in keys.json — likely owned by an extension
      *  that registers a provider at runtime. */
     unattached?: boolean;
+    /** Auth UI shows "no auth required" instead of "not configured". */
+    noAuth?: boolean;
 }
 export declare const KNOWN_PROVIDERS: ProviderAuthInfo[];
-/** Built-ins merged with settings-declared providers, plus any ids that only
- *  appear in keys.json (likely registered by an extension at runtime). */
+/** Built-ins + settings + keys.json. Sync, no extension load. */
 export declare function listAllProviders(): ProviderAuthInfo[];
+/** Augments listAllProviders with extension-registered ids. */
+export declare function listAllProvidersWithDiscovery(): Promise<ProviderAuthInfo[]>;
 /** Resolve an id against known + settings entries only. Returns null for
  *  unattached or unknown ids — callers decide whether to accept them. */
 export declare function findProvider(id: string): ProviderAuthInfo | null;

package/dist/cli/auth/keys.js

@@ -8,8 +8,7 @@ export const KNOWN_PROVIDERS = [
     { id: "openrouter", label: "OpenRouter", envVar: "OPENROUTER_API_KEY" },
     { id: "deepseek", label: "DeepSeek", envVar: "DEEPSEEK_API_KEY" },
 ];
-/** Built-ins merged with settings-declared providers, plus any ids that only
- *  appear in keys.json (likely registered by an extension at runtime). */
+/** Built-ins + settings + keys.json. Sync, no extension load. */
 export function listAllProviders() {
     const out = [...KNOWN_PROVIDERS];
     const seen = new Set(out.map((p) => p.id));
@@ -28,6 +27,27 @@ export function listAllProviders() {
     }
     return out;
 }
+/** Augments listAllProviders with extension-registered ids. */
+export async function listAllProvidersWithDiscovery() {
+    const out = listAllProviders();
+    const byId = new Map(out.map((p) => [p.id, p]));
+    const { discoverExtensionProviders } = await import("./discover.js");
+    try {
+        for (const d of await discoverExtensionProviders()) {
+            const existing = byId.get(d.id);
+            if (existing) {
+                if (d.noAuth && !existing.noAuth)
+                    existing.noAuth = true;
+                continue;
+            }
+            const entry = { id: d.id, label: d.id, custom: true, noAuth: d.noAuth };
+            out.push(entry);
+            byId.set(d.id, entry);
+        }
+    }
+    catch { }
+    return out;
+}
 /** Resolve an id against known + settings entries only. Returns null for
  *  unattached or unknown ids — callers decide whether to accept them. */
 export function findProvider(id) {

package/dist/cli/index.d.ts

@@ -1,2 +1,18 @@
 #!/usr/bin/env node
+declare module "../core/event-bus.js" {
+    interface BusEvents {
+        /** Startup banner collection (sync pipe). Extensions contribute
+         *  labeled item lists; the CLI renders them between the product
+         *  name and the help hint. */
+        "banner:collect": {
+            sections: Array<{
+                label: string;
+                items: string[];
+            }>;
+            /** Name of the backend being launched. Extensions should gate
+             *  per-backend sections on this rather than settings.defaultBackend. */
+            activeBackend?: string;
+        };
+    }
+}
 export {};

package/dist/cli/index.js

@@ -60,9 +60,18 @@ async function main() {
     // ── Core (frontend-agnostic) ──────────────────────────────────
     const core = createCore(config);
     const { bus } = core;
-    // Track agent info from bus events (populated by extension backends)
     let agentInfo = null;
-    bus.on("agent:info", (info) => { agentInfo = info; });
+    bus.on("agent:info", (info) => {
+        agentInfo = info;
+        // Redraw so late agent:info emits (opencode-bridge after session.create) reach the prompt.
+        bus.emit("config:changed", {});
+    });
+    // tui-renderer subscribes to ui:error inside activateShell, after backend
+    // activation — pipe to stderr until the shell is up so boot failures surface.
+    const bootUiError = (e) => {
+        process.stderr.write(`agent-sh: ${e.message}\n`);
+    };
+    bus.on("ui:error", bootUiError);
     // ── Interactive frontend ──────────────────────────────────────
     if (process.env.DEBUG) {
         console.error('[agent-sh] Setting up interactive frontend...');
@@ -157,6 +166,7 @@ async function main() {
             return { info: "" };
         },
     });
+    bus.off("ui:error", bootUiError);
     bus.emit("input-mode:register", {
         id: "agent",
         trigger: ">",

package/dist/core/event-bus.d.ts

@@ -1,181 +1,17 @@
-import type { AgentMode } from "../agent/host-types.js";
-import type { ToolResultDisplay } from "../agent/types.js";
-/**
- * Typed event map — every event has a known payload shape.
- */
-export interface ShellEvents {
-    "shell:command-start": {
-        command: string;
-        cwd: string;
-    };
-    "shell:command-done": {
-        command: string;
-        output: string;
-        cwd: string;
-        exitCode: number | null;
-    };
-    "shell:cwd-change": {
-        cwd: string;
-    };
-    "shell:foreground-busy": {
-        busy: boolean;
-    };
-    "shell:agent-exec-start": Record<string, never>;
-    "shell:agent-exec-done": Record<string, never>;
-    "shell:pty-data": {
-        raw: string;
-    };
-    "shell:pty-write": {
-        data: string;
-    };
-    "shell:pty-resize": {
-        cols: number;
-        rows: number;
-    };
-    "shell:buffer-request": Record<string, never>;
-    "shell:buffer-snapshot": {
-        text: string;
-        altScreen: boolean;
-        cursor: {
-            x: number;
-            y: number;
-        };
-    };
-    "agent:submit": {
-        query: string;
-    };
-    "agent:cancel-request": {
-        silent?: boolean;
-    };
-    "agent:append-user-message": {
-        text: string;
-    };
-    "input-mode:register": import("../shell/host-types.js").InputModeConfig;
-    "agent:query": {
-        query: string;
-    };
-    "agent:thinking-chunk": {
-        text: string;
-    };
-    "agent:response-chunk": {
-        blocks: ContentBlock[];
-    };
-    "agent:response-done": {
-        response: string;
-    };
-    "agent:usage": {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-    "llm:request": {
-        messages: unknown[];
-        tools?: unknown;
-        model?: string;
-        max_tokens?: number;
-        reasoning_effort?: string;
-    };
-    "llm:chunk": {
-        chunk: unknown;
-    };
-    "agent:processing-start": Record<string, never>;
-    "agent:processing-done": Record<string, never>;
-    "agent:cancelled": Record<string, never>;
-    "agent:error": {
-        message: string;
-    };
-    "agent:tool-call": {
-        tool: string;
-        args: Record<string, unknown>;
-    };
-    "agent:tool-output": {
-        tool: string;
-        output: string;
-        exitCode: number | null;
-    };
-    "agent:tool-batch": {
-        groups: Array<{
-            kind: string;
-            tools: Array<{
-                name: string;
-                displayDetail?: string;
-            }>;
-        }>;
-    };
-    "agent:tool-batch-complete": {
-        results: Array<{
-            name: string;
-            isError: boolean;
-            errorSummary?: string;
-        }>;
-    };
-    "conversation:message-appended": {
-        role: "user" | "assistant" | "tool" | "system";
-        content: string;
-        /** For role="tool": name of the tool whose result this is. */
-        toolName?: string;
-        /** For role="tool": parsed arguments passed to the tool. */
-        toolArgs?: Record<string, unknown>;
-        /** For role="tool": whether the tool errored. */
-        isError?: boolean;
-    };
-    "conversation:after-compact": {
-        beforeTokens: number;
-        afterTokens: number;
-        evictedCount: number;
-    };
-    "agent:tool-started": {
-        title: string;
-        toolCallId?: string;
-        kind?: string;
-        icon?: string;
-        locations?: {
-            path: string;
-            line?: number | null;
-        }[];
-        rawInput?: unknown;
-        /** Pre-formatted display detail from tool's formatCall(). */
-        displayDetail?: string;
-        /** highlight.js-style identifier for syntax-highlighting `rawInput.source`. */
-        sourceLanguage?: string;
-        batchIndex?: number;
-        batchTotal?: number;
-    };
-    "agent:tool-completed": {
-        toolCallId?: string;
-        exitCode: number | null;
-        rawOutput?: unknown;
-        kind?: string;
-        /** Structured result display — set by formatResult or defaults, overridable via onPipe. */
-        resultDisplay?: ToolResultDisplay;
-    };
-    "agent:tool-output-chunk": {
-        chunk: string;
-    };
-    "agent:subagent-started": {
-        taskId: string;
-        task: string;
-    };
-    "agent:subagent-completed": {
-        taskId: string;
-        task: string;
-        result: string;
-        isError: boolean;
-    };
-    "tool:interactive-start": Record<string, never>;
-    "tool:interactive-end": Record<string, never>;
-    "command:register": {
-        name: string;
-        description: string;
-        handler: (args: string) => Promise<void> | void;
-    };
-    "command:unregister": {
-        name: string;
-    };
-    "command:execute": {
-        name: string;
-        args: string;
+export interface BackendRegistration {
+    name: string;
+    kill: () => void;
+    start?: () => Promise<void>;
+}
+/** Typed event map — every event has a known payload shape. */
+export interface BusEvents {
+    "core:extensions-loaded": {
+        names: string[];
     };
+    /** Cross-cutting "config might have changed, repaint" signal. */
+    "config:changed": Record<string, never>;
+    /** Universal UI feedback channel (any frontend may render; silently
+     *  ignored without one). */
     "ui:info": {
         message: string;
     };
@@ -185,196 +21,17 @@ export interface ShellEvents {
     "ui:suggestion": {
         text: string;
     };
-    "compositor:write": {
-        stream: string;
-        text: string;
-    };
-    "input:keypress": {
-        key: string;
-    };
-    "input:intercept": {
-        data: string;
-        consumed: boolean;
-    };
-    "shell:stdout-hold": Record<string, never>;
-    "shell:stdout-release": Record<string, never>;
-    "shell:stdout-show": Record<string, never>;
-    "shell:stdout-hide": Record<string, never>;
-    "agent:terminal-intercept": {
-        command: string;
-        cwd: string;
-        intercepted: boolean;
-        output: string;
-    };
-    "shell:redraw-prompt": {
-        cwd: string;
-        kind: "fresh" | "redraw";
-        handled: boolean;
-    };
-    "shell:exec-request": {
-        command: string;
-        output: string;
-        cwd: string;
-        exitCode: number | null;
-        done: boolean;
-    };
-    "agent:info": {
-        name: string;
-        version: string;
-        model?: string;
-        provider?: string;
-        contextWindow?: number;
-    };
-    "agent:reset-session": Record<string, never>;
-    "agent:compact-request": Record<string, never>;
-    "context:get-stats": {
-        activeTokens: number;
-        totalTokens: number;
-        budgetTokens: number;
-    };
-    "context:snapshot": {
-        messages: unknown[];
-        contextWindow: number;
-        activeTokens: number;
-    };
-    "context:compact": {
-        strategy?: {
-            kind: "two-tier-pin";
-            target: number;
-            keepRecent?: number;
-            force?: boolean;
-        } | {
-            kind: "rewind";
-            toIndex: number;
-        } | {
-            kind: "replace";
-            messages: unknown[];
-        };
-        stats?: {
-            before: number;
-            after: number;
-            evictedCount: number;
-        };
-    };
-    "agent:register-backend": {
-        name: string;
-        kill: () => void;
-        start?: () => Promise<void>;
-    };
-    "config:switch-backend": {
-        name: string;
-    };
-    "config:list-backends": Record<string, never>;
+    /** Backend registry — core owns these; every backend (ash, bridges)
+     *  emits register, switch/list flow through here too. */
+    "agent:register-backend": BackendRegistration;
     "config:get-backends": {
         names: string[];
         active: string | null;
     };
-    "config:changed": Record<string, never>;
-    "config:switch-model": {
-        model: string;
-    };
-    "config:get-models": {
-        models: {
-            model: string;
-            provider: string;
-        }[];
-        active: {
-            model: string;
-            provider: string;
-        } | null;
-    };
-    "config:set-thinking": {
-        level: string;
-    };
-    "config:get-thinking": {
-        level: string;
-        levels: string[];
-        supported: boolean;
-    };
-    "config:switch-provider": {
-        provider: string;
-    };
-    "config:get-initial-modes": {
-        modes: AgentMode[];
-        initialModeIndex: number;
-    };
-    "config:set-modes": {
-        modes: AgentMode[];
-        activeIndex?: number;
-    };
-    "config:add-modes": {
-        modes: AgentMode[];
-    };
-    "core:extensions-loaded": {
-        names: string[];
-    };
-    "provider:register": {
-        id: string;
-        apiKey?: string;
-        baseURL?: string;
-        /** Optional — providers for custom endpoints may not know the catalog
-         *  at registration time. Falls back to models[0] when absent. */
-        defaultModel?: string;
-        models?: (string | {
-            id: string;
-            reasoning?: boolean;
-            contextWindow?: number;
-            maxTokens?: number;
-            echoReasoning?: boolean;
-        })[];
-        /** Provider supports the reasoning_effort parameter. Default: true. */
-        supportsReasoningEffort?: boolean;
-    };
-    "provider:configure": {
-        id: string;
-        reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
-    };
-    "agent:register-tool": {
-        tool: import("../agent/types.js").ToolDefinition;
-        extensionName?: string;
-    };
-    "agent:unregister-tool": {
-        name: string;
-    };
-    "agent:get-tools": {
-        tools: import("../agent/types.js").ToolDefinition[];
-    };
-    "agent:register-instruction": {
-        name: string;
-        text: string;
-        extensionName: string;
-    };
-    "agent:remove-instruction": {
-        name: string;
-    };
-    "agent:register-skill": {
-        name: string;
-        description: string;
-        filePath: string;
-        extensionName: string;
-    };
-    "agent:remove-skill": {
+    "config:switch-backend": {
         name: string;
     };
-    "banner:collect": {
-        sections: Array<{
-            label: string;
-            items: string[];
-        }>;
-        /** Name of the backend being launched. Extensions should gate per-backend sections on this rather than settings.defaultBackend. */
-        activeBackend?: string;
-    };
-    "autocomplete:request": {
-        buffer: string;
-        /** Parsed slash command name (e.g. "/backend"), or null if not a command. */
-        command: string | null;
-        /** Text after the command name (e.g. "clau" for "/backend clau"), or null. */
-        commandArgs: string | null;
-        items: {
-            name: string;
-            description: string;
-        }[];
-    };
+    "config:list-backends": Record<string, never>;
 }
 export type ContentBlock = {
     type: "text";
@@ -421,11 +78,11 @@ export declare class EventBus {
     /** Stamp + dispatch — used by every emit path. */
     private dispatch;
     /** Subscribe to a fire-and-forget event. */
-    on<K extends keyof ShellEvents>(event: K, fn: Listener<ShellEvents[K]>): void;
+    on<K extends keyof BusEvents>(event: K, fn: Listener<BusEvents[K]>): void;
     /** Unsubscribe from a fire-and-forget event. */
-    off<K extends keyof ShellEvents>(event: K, fn: Listener<ShellEvents[K]>): void;
+    off<K extends keyof BusEvents>(event: K, fn: Listener<BusEvents[K]>): void;
     /** Emit a fire-and-forget event. */
-    emit<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): void;
+    emit<K extends keyof BusEvents>(event: K, payload: BusEvents[K]): void;
     /** Re-dispatch an event with externally-supplied meta. Used by bridges
      *  and replay tools to preserve the original source/ts/id of remote or
      *  recorded events instead of restamping them as locally originated. */
@@ -436,21 +93,21 @@ export declare class EventBus {
      * listeners (renderers). This enables content pipelines where extensions
      * modify data (e.g. render LaTeX → terminal image) before renderers see it.
      */
-    emitTransform<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): void;
+    emitTransform<K extends keyof BusEvents>(event: K, payload: BusEvents[K]): void;
     /** Register a transform listener for a pipeline event. */
-    onPipe<K extends keyof ShellEvents>(event: K, fn: PipeListener<ShellEvents[K]>): void;
+    onPipe<K extends keyof BusEvents>(event: K, fn: PipeListener<BusEvents[K]>): void;
     /** Remove a transform listener from a pipeline event. */
-    offPipe<K extends keyof ShellEvents>(event: K, fn: PipeListener<ShellEvents[K]>): void;
+    offPipe<K extends keyof BusEvents>(event: K, fn: PipeListener<BusEvents[K]>): void;
     /**
      * Emit a pipeline event — each registered pipe listener receives the
      * output of the previous one. Returns the final transformed payload.
      * If no listeners are registered, returns the original payload unchanged.
      */
-    emitPipe<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): ShellEvents[K];
+    emitPipe<K extends keyof BusEvents>(event: K, payload: BusEvents[K]): BusEvents[K];
     /** Remove an async transform listener from a pipeline event. */
-    offPipeAsync<K extends keyof ShellEvents>(event: K, fn: AsyncPipeListener<ShellEvents[K]>): void;
+    offPipeAsync<K extends keyof BusEvents>(event: K, fn: AsyncPipeListener<BusEvents[K]>): void;
     /** Register an async transform listener for a pipeline event. */
-    onPipeAsync<K extends keyof ShellEvents>(event: K, fn: AsyncPipeListener<ShellEvents[K]>): void;
+    onPipeAsync<K extends keyof BusEvents>(event: K, fn: AsyncPipeListener<BusEvents[K]>): void;
     /**
      * Emit an async pipeline event. Two phases:
      * 1. Notify — fire regular `on` listeners synchronously (e.g., TUI flushes state)
@@ -460,6 +117,6 @@ export declare class EventBus {
      * Returns the final transformed payload. If no pipe listeners are registered,
      * returns the original payload unchanged (with safe defaults).
      */
-    emitPipeAsync<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): Promise<ShellEvents[K]>;
+    emitPipeAsync<K extends keyof BusEvents>(event: K, payload: BusEvents[K]): Promise<BusEvents[K]>;
 }
 export {};