agent-sh 0.11.0 → 0.12.1

package/dist/extensions/agent-backend.js

@@ -67,24 +67,6 @@ export default function agentBackend(ctx) {
         compositor: ctx.compositor,
         instanceId: ctx.instanceId,
     });
-    bus.emit("agent:register-backend", {
-        name: "ash",
-        kill: () => agentLoop.kill(),
-        start: async () => {
-            if (!resolved) {
-                bus.emit("ui:error", { message: "Agent backend not started — no LLM provider available. See earlier messages." });
-                return;
-            }
-            agentLoop.wire();
-            bus.emit("agent:info", {
-                name: "ash",
-                version: PACKAGE_VERSION,
-                model: llmClient.model,
-                provider: modes[initialModeIndex]?.provider,
-                contextWindow: modes[initialModeIndex]?.contextWindow,
-            });
-        },
-    });
     bus.on("core:extensions-loaded", () => {
         const settings = getSettings();
         // If the user didn't pick a default, fall back to the first registered
@@ -99,22 +81,49 @@ export default function agentBackend(ctx) {
         const effectiveApiKey = config.apiKey ?? activeProvider?.apiKey;
         const effectiveBaseURL = config.baseURL ?? activeProvider?.baseURL;
         const effectiveModel = config.model ?? persistedModelFor(providerName) ?? activeProvider?.defaultModel;
-        if (!effectiveApiKey) {
-            bus.emit("ui:error", { message: "No LLM provider configured. Export OPENROUTER_API_KEY or OPENAI_API_KEY (built-in providers auto-activate), pass --api-key, or run `agent-sh init` for a settings.json template." });
-            return;
-        }
-        if (!effectiveModel) {
-            bus.emit("ui:error", { message: "No model specified. Use --model or configure a provider with defaultModel in ~/.agent-sh/settings.json" });
+        // 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.
+        if (!effectiveApiKey || !effectiveModel)
             return;
-        }
         modes = buildModes();
         if (modes.length === 0)
             modes = [{ model: effectiveModel }];
-        initialModeIndex = Math.max(0, modes.findIndex((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id)));
+        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);
         llmClient.reconfigure({ apiKey: effectiveApiKey, baseURL: effectiveBaseURL, model: effectiveModel });
         bus.emit("config:set-modes", { modes, activeIndex: initialModeIndex });
         resolved = true;
-        // start() emits agent:info after wiring.
+        bus.emit("agent:register-backend", {
+            name: "ash",
+            kill: () => agentLoop.kill(),
+            start: async () => {
+                agentLoop.wire();
+                bus.emit("agent:info", {
+                    name: "ash",
+                    version: PACKAGE_VERSION,
+                    model: llmClient.model,
+                    provider: modes[initialModeIndex]?.provider,
+                    contextWindow: modes[initialModeIndex]?.contextWindow,
+                });
+            },
+        });
     });
     bus.on("provider:register", (p) => {
         const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);

package/dist/extensions/openrouter.js

@@ -1,10 +1,5 @@
 const BASE_URL = "https://openrouter.ai/api/v1";
-// First entry is the cold-start default — kept cheap so trial users don't
-// get a surprise bill. Persisted /model selection overrides this.
-const DEFAULT_MODELS = [
-    "deepseek/deepseek-v3.2",
-    "anthropic/claude-sonnet-4.6",
-];
+const DEFAULT_MODELS = ["anthropic/claude-sonnet-4.6"];
 export default function activate(ctx) {
     const apiKey = process.env.OPENROUTER_API_KEY;
     if (!apiKey)

package/dist/extensions/tui-renderer.js

@@ -50,6 +50,7 @@ function createRenderState() {
         spinnerStartTime: 0,
         openTool: null,
         pendingToolCompletes: new Map(),
+        orphanContHeaderKind: undefined,
         currentToolKind: undefined,
         toolStartTime: 0,
         toolExitCode: null,
@@ -178,11 +179,8 @@ export default function activate(ctx) {
                 stopCurrentSpinner();
                 if (!s.renderer)
                     startAgentResponse();
-                s.renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
-                drain();
             }
             else {
-                // Restart spinner with ctrl+t hint now that we know thinking is available
                 startThinkingSpinner();
             }
         }
@@ -256,6 +254,7 @@ export default function activate(ctx) {
             return;
         fencedTransform.flush();
         finalizeToolGroup();
+        s.orphanContHeaderKind = undefined;
         batchGroups = new Map();
         for (const group of e.groups) {
             batchGroups.set(group.kind, {
@@ -272,6 +271,7 @@ export default function activate(ctx) {
         stopCurrentSpinner();
         s.currentToolKind = e.kind;
         s.toolStartTime = Date.now();
+        s.orphanContHeaderKind = undefined;
         if (e.title === "user_shell") {
             finalizeToolGroup();
             closeToolLine();
@@ -315,10 +315,12 @@ export default function activate(ctx) {
                 showToolCall(e.title, "", { ...e, groupContinuation: true });
                 s.toolGroupRendered++;
             }
-            // Record identity so late completes (after a premature finalize
-            // from a cross-kind standalone start) can render as labeled ⎿ lines.
             if (e.toolCallId) {
-                s.pendingToolCompletes.set(e.toolCallId, { title: e.title });
+                s.pendingToolCompletes.set(e.toolCallId, {
+                    title: e.title,
+                    kind,
+                    displayDetail: e.displayDetail ?? extractDetail(e),
+                });
             }
         }
         else {
@@ -342,13 +344,25 @@ export default function activate(ctx) {
                 s.pendingToolCompletes.delete(e.toolCallId);
             s.toolGroupCompletedCount++;
             s.currentToolKind = undefined;
+            // Finalize as soon as all members return so aggregate lands right
+            // after its children, not below out-of-band renders from the next tool.
+            const batchGroup = batchGroups.get(s.toolGroupKind);
+            if (batchGroup && s.toolGroupCompletedCount >= batchGroup.total) {
+                finalizeToolGroup();
+            }
         }
         else {
-            // Route by callId — tools that lost the inline slot get a labeled ⎿ line.
+            // Tools that lost the inline slot render as a labeled ⎿. Orphans
+            // (group finalized before they returned) reroute via showOrphanedComplete.
             const pending = e.toolCallId ? s.pendingToolCompletes.get(e.toolCallId) : undefined;
             if (pending)
                 s.pendingToolCompletes.delete(e.toolCallId);
-            showToolComplete(e.exitCode, e.resultDisplay, pending?.title);
+            if (pending?.orphaned) {
+                showOrphanedComplete(e.exitCode, e.resultDisplay, pending.title, pending.kind, pending.displayDetail);
+            }
+            else {
+                showToolComplete(e.exitCode, e.resultDisplay, pending?.displayDetail ?? pending?.title);
+            }
             s.currentToolKind = undefined;
             s.spinnerStartTime = 0;
             startThinkingSpinner();
@@ -746,8 +760,14 @@ export default function activate(ctx) {
             }
             else {
                 out().write(`  ${batchPrefix}${lines[lines.length - 1]}`);
-                if (extra?.toolCallId)
-                    s.openTool = { callId: extra.toolCallId, title };
+                if (extra?.toolCallId) {
+                    s.openTool = {
+                        callId: extra.toolCallId,
+                        title,
+                        kind: extra.kind,
+                        displayDetail: extra.displayDetail ?? extractDetail(extra),
+                    };
+                }
             }
         }
         s.hadToolCalls = true;
@@ -775,6 +795,26 @@ export default function activate(ctx) {
         if (resultDisplay?.body)
             renderResultBody(resultDisplay.body);
     }
+    /** Late completion from a finalized group — re-emit the kind header
+     *  in muted "(cont.)" form so the ⎿ has a legitimate parent, then
+     *  render the completion as a normal labeled ⎿. Subsequent orphans
+     *  of the same kind reuse the existing (cont.) header. */
+    function showOrphanedComplete(exitCode, resultDisplay, title, kind, displayDetail) {
+        if (s.orphanContHeaderKind !== kind) {
+            stopCurrentSpinner();
+            closeToolLine();
+            flushCommandOutput();
+            if (!s.renderer)
+                startAgentResponse();
+            showCollapsedThinking();
+            const icon = (kind && KIND_ICONS[kind]) ?? "▶";
+            const label = kind ?? "tool";
+            s.renderer.writeLine(`${p.muted}${icon} ${label} (cont.)${p.reset}`);
+            drain();
+            s.orphanContHeaderKind = kind;
+        }
+        showToolComplete(exitCode, resultDisplay, displayDetail || title);
+    }
     function renderResultBody(body) {
         if (!s.renderer)
             return;
@@ -796,10 +836,7 @@ export default function activate(ctx) {
         stopCurrentSpinner();
         const thinking = hasThinkingMode();
         s.spinnerLabel = thinking ? "Thinking" : "Working";
-        const hint = thinking
-            ? (s.showThinkingText ? "(ctrl+t to collapse)" : "(ctrl+t to expand)")
-            : "";
-        s.spinnerOpts = { hint: hint || undefined, startTime: s.spinnerStartTime };
+        s.spinnerOpts = { startTime: s.spinnerStartTime };
         s.spinner = createSpinner({ startTime: s.spinnerStartTime });
         s.spinnerInterval = setInterval(() => {
             if (s.spinner) {
@@ -825,13 +862,25 @@ export default function activate(ctx) {
         if (s.openTool) {
             out().write("\n");
             // Stash identity so the completion renders as ⎿ labeled, not orphan ✓.
-            s.pendingToolCompletes.set(s.openTool.callId, { title: s.openTool.title });
+            s.pendingToolCompletes.set(s.openTool.callId, {
+                title: s.openTool.title,
+                kind: s.openTool.kind,
+                displayDetail: s.openTool.displayDetail,
+            });
             s.openTool = null;
         }
     }
     /** Render the group aggregate ⎿ line, or skip if no members have
      *  completed yet (late completes will render individually as ⎿ labeled). */
     function finalizeToolGroup() {
+        // Late completes from this group have lost their inline slot; mark
+        // them so showOrphanedComplete re-emits a (cont.) header for their ⎿.
+        if (s.toolGroupKind) {
+            for (const pending of s.pendingToolCompletes.values()) {
+                if (pending.kind === s.toolGroupKind)
+                    pending.orphaned = true;
+            }
+        }
         const skipAggregate = s.toolGroupCount > 1 && s.toolGroupCompletedCount === 0;
         if (s.toolGroupCount <= 1 || skipAggregate) {
             s.toolGroupKind = undefined;
@@ -842,6 +891,7 @@ export default function activate(ctx) {
             s.toolGroupSummaries = [];
             return;
         }
+        stopCurrentSpinner();
         closeToolLine();
         if (!s.renderer)
             startAgentResponse();
@@ -938,14 +988,10 @@ export default function activate(ctx) {
         if (s.spinner) {
             stopCurrentSpinner();
             if (s.showThinkingText) {
-                // Expanding: replace spinner with thinking text header
                 if (!s.renderer)
                     startAgentResponse();
-                s.renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
-                drain();
             }
             else {
-                // Collapsing: restart spinner with updated hint
                 startThinkingSpinner();
             }
             return;

package/dist/index.js

@@ -270,6 +270,16 @@ async function main() {
     // ── Activate agent backend ────────────────────────────────────
     // Extensions had their chance to register via agent:register-backend.
     // If none did, the built-in AgentLoop gets wired to bus events.
+    const { names: backendNames } = core.bus.emitPipe("config:get-backends", { names: [], active: null });
+    if (backendNames.length === 0) {
+        shell.kill();
+        console.error("\nagent-sh: no agent backend available.\n\n" +
+            "  Export OPENROUTER_API_KEY or OPENAI_API_KEY for zero-config launch, or\n" +
+            "  pass --api-key on the command line, or\n" +
+            "  run `agent-sh init` for a settings.json template.\n" +
+            "  Alternatively, install a bridge extension (claude-code-bridge, pi-bridge).\n");
+        process.exit(1);
+    }
     core.activateBackend();
     // ── Startup banner ───────────────────────────────────────────
     const settings = getSettings();

package/dist/shell/input-handler.js

@@ -253,6 +253,36 @@ export class InputHandler {
                             seq += data[i];
                         }
                     }
+                    else if (next === "]" || next === "P" || next === "_" || next === "^") {
+                        // String sequences terminated by BEL or ST (ESC \):
+                        //   OSC (ESC ]) — OSC 10/11 color-query responses
+                        //   DCS (ESC P) — tmux XTVERSION query response (iTerm2 etc.)
+                        //   APC (ESC _), PM (ESC ^) — rarer, same termination
+                        // Forward as a unit so the payload doesn't leak into lineBuffer
+                        // and onto the bash command line after a foreground app exits.
+                        let j = i + 2;
+                        let termEnd = -1;
+                        while (j < data.length) {
+                            const c = data[j];
+                            if (c === "\x07") {
+                                termEnd = j;
+                                break;
+                            }
+                            if (c === "\x1b" && j + 1 < data.length && data[j + 1] === "\\") {
+                                termEnd = j + 1;
+                                break;
+                            }
+                            j++;
+                        }
+                        if (termEnd !== -1) {
+                            seq = data.slice(i, termEnd + 1);
+                            i = termEnd;
+                        }
+                        else {
+                            seq += next;
+                            i++;
+                        }
+                    }
                     else {
                         // ESC + single char (alt-key, etc.)
                         seq += next;

package/examples/extensions/wire-log.ts

@@ -0,0 +1,35 @@
+/**
+ * Dumps every LLM request + streamed chunk to $AGENT_SH_WIRE_DIR
+ * (default ~/.agent-sh/wire) for offline replay via curl. Paired files
+ * per turn: <stamp>.request.json and <stamp>.chunks.jsonl.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { ExtensionContext } from "agent-sh/types";
+
+export default function activate(ctx: ExtensionContext): void {
+  const dir = process.env.AGENT_SH_WIRE_DIR
+    ?? path.join(os.homedir(), ".agent-sh", "wire");
+  fs.mkdirSync(dir, { recursive: true });
+
+  // llm:chunk has no back-pointer to its request, so anchor both on
+  // the timestamp set when llm:request fires.
+  let currentStamp: string | null = null;
+
+  ctx.bus.on("llm:request", (req) => {
+    currentStamp = new Date().toISOString().replace(/[:.]/g, "-");
+    fs.writeFileSync(
+      path.join(dir, `${currentStamp}.request.json`),
+      JSON.stringify(req, null, 2),
+    );
+  });
+
+  ctx.bus.on("llm:chunk", ({ chunk }) => {
+    if (!currentStamp) return;
+    fs.appendFileSync(
+      path.join(dir, `${currentStamp}.chunks.jsonl`),
+      JSON.stringify(chunk) + "\n",
+    );
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",
@@ -89,13 +89,19 @@
   },
   "files": [
     "dist",
-    "examples"
+    "examples/extensions/*.ts",
+    "examples/extensions/*/package.json",
+    "examples/extensions/*/tsconfig.json",
+    "examples/extensions/*/README.md",
+    "examples/extensions/*/src",
+    "examples/extensions/*/index.ts",
+    "examples/extensions/*/index.js"
   ],
   "scripts": {
     "dev": "tsx src/index.ts",
     "build": "tsc",
     "start": "node dist/index.js",
-    "prepublishOnly": "npm run build"
+    "prepare": "npm run build"
   },
   "keywords": [
     "terminal",