agent-sh 0.14.11 → 0.15.1

package/README.md

@@ -5,13 +5,9 @@
 
 A composable agent runtime — pair any frontend with any agent backend, over one shared extension layer.
 
-## Three example apps built on agent-sh
+## A shell with the agent one keystroke away
 
-agent-sh is small at its core and does its real work through extensions, so the same runtime drives very different apps. Three to start with — all sharing the same agent backends, tools, providers, and `~/.agent-sh/settings.json`:
-
-### 1. A shell with the agent one keystroke away — bundled with agent-sh
-
-A normal shell on top of node-pty — your rc config, your aliases, vim and tmux all just work. But at the start of any line, type `>` and you're talking to a small agent that already sees your cwd, your last command, and its output. Nothing to set up, no project to explain.
+The frontend bundled with agent-sh: a normal shell on top of node-pty — your rc config, your aliases, vim and tmux all just work. But at the start of any line, type `>` and you're talking to an agent that already sees your cwd, your last command, and its output. Nothing to set up, no project to explain.
 
 ![demo](assets/demo.gif)
 
@@ -23,42 +19,7 @@ A normal shell on top of node-pty — your rc config, your aliases, vim and tmux
 ~ $ > draft a commit message     # agent reads your diff and shell history
 ```
 
-```bash
-npm install -g agent-sh
-```
-
-[Quick Start ↓](#quick-start)
-
-### 2. ashi — a standalone coding agent
-
-[**`@guanyilun/ashi`**](examples/extensions/ashi/) is the same `ash` agent in a chat-style TUI, with no shell underneath — just the agent. Installed separately, it reuses agent-sh's backend, tools, slash commands, providers, and skills, and adds session history, in-session branching, and LLM-driven compaction.
-
-```bash
-npm install -g @guanyilun/ashi
-ashi
-```
-
-ashi makes the runtime's **decoupled rendering** concrete: the frontend is itself an extension, and even *how* it draws tool calls and results is a swappable render extension. Same agent backend, same conversation — load a different render extension and the whole TUI restyles, no code changes:
-
-| pi-style rendering | claude-code-style rendering |
-|---|---|
-| ![ashi rendering tool calls pi-style](assets/ashi-pi-style.png) | ![ashi rendering tool calls claude-code-style](assets/ashi-claude-code-style.png) |
-
-### 3. asHub — a GUI coding agent
-
-[**firslov/asHub**](https://github.com/firslov/asHub) is a third-party cross-platform desktop app (Electron) built on the agent-sh runtime: a multi-session sidebar, persistence across restarts, and a live-streaming interface with Markdown, syntax-highlighted code, diffs, and tool-call rendering. macOS / Windows / Linux.
-
-It pushes the same decoupling one step further — the frontend isn't a terminal at all, but a full desktop GUI on the same runtime, backends, and tools:
-
-![asHub desktop GUI](assets/ashub.png)
-
-## How it works
-
-agent-sh is a **composable agent runtime**. At its center is a pure kernel — a typed event bus, a named-handler registry, and an extension loader — that knows nothing about terminals, LLMs, shells, or rendering. Everything else plugs into it: the agent backend, its tools, provider management, and the frontend that drives it.
-
-The frontend and the agent backend are both just components on the bus, so you **mix and match** them freely — wire several frontends to one backend, or keep one frontend and swap the backend underneath — all sharing the **same extension layer** of tools, content transforms, slash commands, and themes. `import { createCore } from "agent-sh"` gives you the headless kernel; load the pieces you want and wire your own I/O.
-
-For the kernel design in full — the bus, handlers, the compositor, and the shell ↔ agent boundary — see [Architecture](docs/architecture.md). To embed the runtime in your own frontend, see the [Library Guide](docs/library.md). The rest of this README covers the bundled shell.
+**The agent behind `>` is swappable — the terminal stays the same.** Out of the box it's **`ash`**, agent-sh's own lightweight agent: it works with any OpenAI-compatible API and shares its tool surface with every extension you install. Already invested in another coding agent? The same `>` and the same shell-context wiring can host **pi**, **claude-code**, or **opencode** instead through in-the-box bridges — bring your own backend, keep the workflow. The Quick Start below walks through both.
 
 ## Quick Start
 
@@ -180,6 +141,41 @@ All three bridges receive agent-sh's per-query shell context (`<shell_events>`)
 
 **Caveat:** pi, claude-code, and opencode each manage their own tool surfaces, so agent-sh extensions that register tools (or skills, instructions, etc.) for the built-in `ash` agent generally won't be visible to a hosted backend. Frontend extensions (themes, content transforms, slash commands, the TUI renderer) keep working — only the agent-side capabilities differ. Use the bridges when you want that agent's toolset; stay on `ash` when you want agent-sh's extension ecosystem.
 
+## Same runtime, other frontends
+
+The shell is just one frontend. Because the frontend is itself an extension on the bus, the same runtime — same agent backends, tools, providers, and `~/.agent-sh/settings.json` — drives completely different apps.
+
+### ashi — a standalone coding agent
+
+[**`@guanyilun/ashi`**](examples/extensions/ashi/) is the same `ash` agent in a chat-style TUI, with no shell underneath — just the agent. Installed separately, it reuses agent-sh's backend, tools, slash commands, providers, and skills, and adds session history, in-session branching, and LLM-driven compaction.
+
+```bash
+npm install -g @guanyilun/ashi
+ashi
+```
+
+ashi makes the runtime's **decoupled rendering** concrete: the frontend is itself an extension, and even *how* it draws tool calls and results is a swappable render extension. Same agent backend, same conversation — load a different render extension and the whole TUI restyles, no code changes:
+
+| pi-style rendering | claude-code-style rendering |
+|---|---|
+| ![ashi rendering tool calls pi-style](assets/ashi-pi-style.png) | ![ashi rendering tool calls claude-code-style](assets/ashi-claude-code-style.png) |
+
+### asHub — a GUI coding agent
+
+[**firslov/asHub**](https://github.com/firslov/asHub) is a third-party cross-platform desktop app (Electron) built on the agent-sh runtime: a multi-session sidebar, persistence across restarts, and a live-streaming interface with Markdown, syntax-highlighted code, diffs, and tool-call rendering. macOS / Windows / Linux.
+
+It pushes the same decoupling one step further — the frontend isn't a terminal at all, but a full desktop GUI on the same runtime, backends, and tools:
+
+![asHub desktop GUI](assets/ashub.png)
+
+## How it works
+
+At agent-sh's center is a pure kernel — a typed event bus, a named-handler registry, and an extension loader — that knows nothing about terminals, LLMs, shells, or rendering. Everything else plugs into it: the agent backend, its tools, provider management, and the frontend that drives it.
+
+The frontend and the agent backend are both just components on the bus, so you **mix and match** them freely — wire several frontends to one backend, or keep one frontend and swap the backend underneath — all sharing the **same extension layer** of tools, content transforms, slash commands, and themes. The shell swapping `ash` for a bridged agent, and ashi/asHub putting a different UI on the same backend, are the same idea seen from two directions. `import { createCore } from "agent-sh"` gives you the headless kernel; load the pieces you want and wire your own I/O.
+
+For the kernel design in full — the bus, handlers, the compositor, and the shell ↔ agent boundary — see [Architecture](docs/architecture.md). To embed the runtime in your own frontend, see the [Library Guide](docs/library.md).
+
 ## Documentation
 
 Start with **Usage** to get running, then **Architecture** for the mental model.

package/dist/agent/agent-loop.d.ts

@@ -1,18 +1,10 @@
 /**
- * Internal agent backend — bus-driven, self-wiring.
- *
- * Subscribes to bus events in constructor:
- *   - agent:submit → run query through LLM tool loop
- *   - agent:cancel-request → abort current loop
- *
- * Emits bus events during execution:
- *   - agent:query, agent:processing-start/done, agent:response-chunk/done
- *   - agent:tool-started, agent:tool-call, agent:tool-output-chunk,
- *     agent:tool-completed, agent:tool-output
- *   - agent:thinking-chunk, agent:cancelled, agent:error
+ * Internal agent backend — bus-driven and self-wiring. wire() subscribes to
+ * agent:submit (run the LLM tool loop) and agent:cancel-request (abort it),
+ * and the loop emits the agent:* progress/response/tool event stream.
  */
 import type { EventBus } from "../core/event-bus.js";
-import type { AgentMode } from "./host-types.js";
+import type { Model } from "./host-types.js";
 import type { LlmClient } from "./llm-client.js";
 import type { HandlerFunctions } from "../utils/handler-registry.js";
 import { type AgentBackend, type ToolDefinition } from "./types.js";
@@ -21,7 +13,7 @@ export interface AgentLoopConfig {
     bus: EventBus;
     llmClient: LlmClient;
     handlers: HandlerFunctions;
-    initialMode?: AgentMode;
+    initialModel?: Model;
     compositor?: Compositor;
     /** Instance ID from core — ensures history entries match the ID in prompts. */
     instanceId?: string;
@@ -31,7 +23,8 @@ export declare class AgentLoop implements AgentBackend {
     private toolRegistry;
     private conversation;
     private fileReadCache;
-    private activeMode;
+    private activeModel;
+    private activeEndpoint;
     private boundListeners;
     private boundPipeListeners;
     private lastProjectSkillNames;
@@ -91,10 +84,9 @@ export declare class AgentLoop implements AgentBackend {
     kill(): void;
     private cancel;
     private reasoningParams;
-    private get currentMode();
-    private pullModes;
+    private resolveEndpoint;
+    private pullModels;
     private emitIdentity;
-    private get currentModel();
     /**
      * Run compaction via the `conversation:compact` handler. After any
      * compaction, emit `conversation:after-compact` so listeners