agent-sh 0.13.1 → 0.13.3

package/dist/agent/agent-loop.js

@@ -91,7 +91,7 @@ export class AgentLoop {
     bus;
     llmClient;
     handlers;
-    thinkingLevel = "off";
+    thinkingLevel = getSettings().thinkingLevel ?? "off";
     compositor = null;
     toolProtocol;
     instanceId;
@@ -289,6 +289,7 @@ export class AgentLoop {
                 return;
             }
             this.thinkingLevel = level;
+            updateSettings({ thinkingLevel: level });
             this.bus.emit("config:changed", {});
         });
         onPipe("config:get-thinking", () => {
@@ -998,10 +999,7 @@ export class AgentLoop {
             responseText = await this.executeLoop(signal);
         }
         catch (e) {
-            if (signal.aborted && signal.reason !== "silent") {
-                this.bus.emit("agent:cancelled", {});
-            }
-            else if (!signal.aborted) {
+            if (!signal.aborted) {
                 if (e instanceof Error)
                     console.error("[agent-sh] query failed:\n" + e.stack);
                 const msg = this.formatError(e);
@@ -1009,6 +1007,9 @@ export class AgentLoop {
             }
         }
         finally {
+            if (signal.aborted && signal.reason !== "silent") {
+                this.bus.emit("agent:cancelled", {});
+            }
             // Ensure any buffered text in the stream transform pipeline gets
             // flushed as a complete line before response-done closes the box.
             if (responseText && !responseText.endsWith("\n")) {
@@ -1200,7 +1201,7 @@ export class AgentLoop {
                     signal });
                 // Truncate large outputs to avoid blowing context.
                 let content = result.content;
-                const maxBytes = tool.maxResultBytes ?? 16_384; // ~4k tokens
+                const maxBytes = tool.maxResultBytes ?? 100_000; // ~25k tokens
                 if (content.length > maxBytes) {
                     const headBytes = Math.floor(maxBytes * 0.6);
                     const tailBytes = maxBytes - headBytes;

package/dist/cli/install.js

@@ -130,11 +130,6 @@ function normalizeBin(pkg) {
 function maybeNpmBuild(target, pkg) {
     if (!pkg.scripts?.build)
         return;
-    const binPaths = Object.values(normalizeBin(pkg)).map((p) => path.join(target, p));
-    if (binPaths.length === 0)
-        return;
-    if (binPaths.every((p) => fs.existsSync(p)))
-        return;
     console.log(`Running npm run build in ${target}...`);
     const result = spawnSync("npm", ["run", "build"], { cwd: target, stdio: "inherit" });
     if (result.status !== 0) {

package/dist/core/settings.d.ts

@@ -44,6 +44,8 @@ export interface Settings {
     defaultProvider?: string;
     /** Preferred agent backend (extension name, e.g. "pi", "claude-code"). */
     defaultBackend?: string;
+    /** Default thinking/reasoning effort level for new sessions ("off"|"low"|"medium"|"high"). */
+    thinkingLevel?: string;
     /** Shell output lines before spill-to-tempfile kicks in. */
     shellTruncateThreshold?: number;
     /** Lines kept from start of spilled shell output. */

package/dist/core/settings.js

@@ -19,6 +19,7 @@ const DEFAULTS = {
     providers: {},
     defaultProvider: undefined,
     defaultBackend: "ash",
+    thinkingLevel: undefined,
     toolMode: "api",
     coreTools: [],
     shellTruncateThreshold: 20,

package/dist/utils/diff-renderer.d.ts

@@ -14,6 +14,12 @@ export interface DiffRenderOptions {
     /** Enable syntax highlighting on diff lines. Default true. */
     syntaxHighlight?: boolean;
 }
+export declare function detectLanguage(filePath?: string): string | undefined;
+/**
+ * Syntax-highlight a single line of code.
+ * Returns the original text if highlighting fails or no language detected.
+ */
+export declare function highlightLine(text: string, language?: string): string;
 /** Select display mode based on available terminal width. */
 export declare function selectMode(width: number): DiffDisplayMode;
 /** Render a diff result as an array of ANSI-formatted terminal lines. */

package/dist/utils/diff-renderer.js

@@ -25,7 +25,7 @@ const EXT_TO_LANG = {
     ".hs": "haskell", ".ml": "ocaml", ".clj": "clojure",
     ".vim": "vim", ".dockerfile": "dockerfile",
 };
-function detectLanguage(filePath) {
+export function detectLanguage(filePath) {
     if (!filePath)
         return undefined;
     const dot = filePath.lastIndexOf(".");
@@ -44,7 +44,7 @@ function detectLanguage(filePath) {
  * Syntax-highlight a single line of code.
  * Returns the original text if highlighting fails or no language detected.
  */
-function highlightLine(text, language) {
+export function highlightLine(text, language) {
     if (!language || text.trim() === "")
         return text;
     try {
@@ -275,14 +275,14 @@ function renderUnifiedHunk(hunk, layout) {
                 removedText = lang ? highlightLine(raw, lang) : raw;
             }
             if (useTrueColor) {
-                out.push(padToWidth(`${p.errorBg}${p.error}- ${no} │ ${preserveBg(removedText, p.errorBg)}${p.reset}`, textWidth));
+                out.push(padToWidth(`${p.errorBg}${p.error}- ${no} │ ${preserveBg(removedText, p.errorBg)}`, textWidth) + p.reset);
             }
             else {
                 out.push(`${p.error}- ${no} │ ${removedText}${p.reset}`);
             }
             if (addedText !== null && addedNo !== null) {
                 if (useTrueColor) {
-                    out.push(padToWidth(`${p.successBg}${p.success}+ ${addedNo} │ ${preserveBg(addedText, p.successBg)}${p.reset}`, textWidth));
+                    out.push(padToWidth(`${p.successBg}${p.success}+ ${addedNo} │ ${preserveBg(addedText, p.successBg)}`, textWidth) + p.reset);
                 }
                 else {
                     out.push(`${p.success}+ ${addedNo} │ ${addedText}${p.reset}`);
@@ -296,7 +296,7 @@ function renderUnifiedHunk(hunk, layout) {
             const raw = truncateText(line.text, lineTextW);
             const text = lang ? highlightLine(raw, lang) : raw;
             if (useTrueColor) {
-                out.push(padToWidth(`${p.successBg}${p.success}+ ${no} │ ${preserveBg(text, p.successBg)}${p.reset}`, textWidth));
+                out.push(padToWidth(`${p.successBg}${p.success}+ ${no} │ ${preserveBg(text, p.successBg)}`, textWidth) + p.reset);
             }
             else {
                 out.push(`${p.success}+ ${no} │ ${text}${p.reset}`);
@@ -368,7 +368,7 @@ function renderSplitHunk(hunk, layout) {
         }
         else if (row.left.type === "removed") {
             if (useTrueColor) {
-                leftCol = padToWidth(`${p.errorBg}${p.error}${leftNo} │ ${preserveBg(leftText, p.errorBg)}${p.reset}`, colWidth);
+                leftCol = padToWidth(`${p.errorBg}${p.error}${leftNo} │ ${preserveBg(leftText, p.errorBg)}`, colWidth) + p.reset;
             }
             else {
                 leftCol = padToWidth(`${p.error}${leftNo} │ ${leftText}${p.reset}`, colWidth);
@@ -382,7 +382,7 @@ function renderSplitHunk(hunk, layout) {
         }
         else if (row.right.type === "added") {
             if (useTrueColor) {
-                rightCol = padToWidth(`${p.successBg}${p.success}${rightNo} │ ${preserveBg(rightText, p.successBg)}${p.reset}`, colWidth);
+                rightCol = padToWidth(`${p.successBg}${p.success}${rightNo} │ ${preserveBg(rightText, p.successBg)}`, colWidth) + p.reset;
             }
             else {
                 rightCol = padToWidth(`${p.success}${rightNo} │ ${rightText}${p.reset}`, colWidth);

package/dist/utils/llm-client.d.ts

@@ -8,6 +8,9 @@
 import OpenAI from "openai";
 import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources/chat/completions.js";
 export type { ChatCompletionMessageParam, ChatCompletionTool };
+export type AgentShMessage = ChatCompletionMessageParam & {
+    meta?: Record<string, unknown>;
+};
 export interface LlmClientConfig {
     apiKey: string;
     baseURL?: string;

package/dist/utils/llm-client.js

@@ -6,6 +6,12 @@
  * (command suggestions, completions).
  */
 import OpenAI from "openai";
+function stripMeta(m) {
+    if (!("meta" in m))
+        return m;
+    const { meta: _meta, ...rest } = m;
+    return rest;
+}
 function attributionHeaders(config) {
     return {
         "HTTP-Referer": config.appUrl ?? "https://agent-sh.dev",
@@ -40,7 +46,7 @@ export class LlmClient {
         const body = {
             ...rest,
             model: model ?? this.model,
-            messages,
+            messages: messages.map(stripMeta),
             tools: tools?.length ? tools : undefined,
             max_tokens: max_tokens ?? 65536,
             stream: true,
@@ -53,7 +59,7 @@ export class LlmClient {
         const body = {
             ...rest,
             model: model ?? this.model,
-            messages,
+            messages: messages.map(stripMeta),
             max_tokens: max_tokens ?? 1024,
         };
         const response = await this.client.chat.completions.create(body);

package/examples/extensions/ash-acp-bridge/src/index.ts

@@ -11,7 +11,7 @@
  * In agent-shell (Emacs):
  *   (setq agent-shell-agentsh-acp-command '("agent-sh-acp"))
  */
-import { createCore, type AgentShellCore } from "agent-sh";
+import { createCore, NoopHistory, type AgentShellCore } from "agent-sh";
 import { loadExtensions } from "agent-sh/extension-loader";
 import { loadBuiltinExtensions } from "agent-sh/extensions";
 import { activateAgent } from "agent-sh/agent";
@@ -483,6 +483,7 @@ async function handleSessionNew(id: number | string, params: Record<string, unkn
     core = createCore({
       model: cliArgs.model,
       provider: cliArgs.provider,
+      history: new NoopHistory(),
     });
     wireEvents(core);
 

package/examples/extensions/ashi/README.md

@@ -1,71 +1,90 @@
 # ashi
 
-`ash` (agent-sh's built-in agent) running inside pi's TUI substrate, with no shell underneath.
+[![npm version](https://img.shields.io/npm/v/@guanyilun/ashi.svg)](https://www.npmjs.com/package/@guanyilun/ashi)
+[![license](https://img.shields.io/npm/l/@guanyilun/ashi.svg)](https://github.com/guanyilun/agent-sh/blob/main/LICENSE)
 
-A test of agent-sh's claim that the kernel is a frontend-agnostic communication layer: `ashi`
-uses `createCore()` from agent-sh, skips `activateShell()`, disables the shell-coupled built-ins
-(`shell-context`, `tui-renderer`, `file-autocomplete`), and mounts `@earendil-works/pi-tui` as
-the only frontend. Backend, tools, slash commands, providers, and skills come along unchanged.
+`ash` (the built-in agent of [agent-sh](https://github.com/guanyilun/agent-sh)) running as a standalone interactive TUI — no shell underneath, just the agent.
+
+Same backend, tools, slash commands, providers, and skills as `agent-sh`, mounted in a chat-style interface with session history, branching, and LLM-driven compaction.
 
 ## Install
 
 ```bash
-agent-sh install ashi
-export PATH="$HOME/.agent-sh/bin:$PATH"
+npm install -g @guanyilun/ashi
 ashi
 ```
 
-`agent-sh install` copies this directory into `~/.agent-sh/extensions/ashi/`, runs
-`npm install` and `npm run build` there, and symlinks the built bin into `~/.agent-sh/bin/`.
+Reads `~/.agent-sh/settings.json` for provider profiles and defaults, same file as `agent-sh`. The quickest path is exporting `OPENROUTER_API_KEY` or `OPENAI_API_KEY` and running `ashi`.
 
-## Configure
+To scaffold the config directory from scratch:
 
-Reads `~/.agent-sh/settings.json` for providers and defaults, same as `agent-sh` itself. The
-quickest path is exporting `OPENROUTER_API_KEY` or `OPENAI_API_KEY` and running `ashi`.
+```bash
+ashi init          # creates ~/.agent-sh/settings.json and AGENTS.md
+ashi auth login    # store an API key interactively
+```
 
-See the agent-sh [Usage Guide](https://github.com/guanyilun/agent-sh/blob/main/docs/usage.md)
-for the full `settings.json` schema, provider profiles, and model selection details.
+## Usage
 
-CLI flags mirror `agent-sh`:
+```bash
+ashi                                   # launch with defaults
+ashi --provider openrouter             # pick a provider profile
+ashi --model anthropic/claude-sonnet-4 # override model
+ashi -e claude-code-bridge --backend claude-code  # swap the agent backend
+```
+
+### CLI flags
 
 ```
 --provider <name>    Provider profile from ~/.agent-sh/settings.json
 --model <id>         Override model
 --api-key <key>      Direct API key
 --base-url <url>     OpenAI-compatible base URL
---backend <name>     Agent backend (default: ash)
+--backend <name>     Agent backend (default: ash). Requires the matching
+                     backend extension to be loaded, e.g. via -e.
 -e, --extensions     Extra extensions to load (comma-separated)
 ```
 
-Extensions loaded via `-e` follow the standard agent-sh extension contract — see
-[Extensions](https://github.com/guanyilun/agent-sh/blob/main/docs/extensions.md) for the
-`ExtensionContext` API, event bus, content transforms, and custom backends.
+The built-in backend is `ash`. To use a different one (claude-code, opencode, pi), load the corresponding bridge extension with `-e` and pass `--backend <name>`.
 
-## Keybindings
+### Management subcommands
 
-Match pi-coding-agent's convention:
+```
+ashi install <name> [--force]   Install an extension into ~/.agent-sh/extensions/
+ashi uninstall <name>           Remove an installed extension
+ashi list                       List installed extensions
+ashi auth login [provider]      Store an API key (interactive)
+ashi auth logout <provider>     Remove a stored key
+ashi auth list                  Show configured providers
+ashi init [--force]             Scaffold ~/.agent-sh/ (settings, AGENTS.md)
+```
+
+These mirror `agent-sh`'s management commands so `ashi` works as a standalone CLI without needing the full `agent-sh` install.
+
+### Keybindings
 
 ```
-Esc      Cancel active turn
-Ctrl+C   Clear editor
-Ctrl+D   Quit (when editor is empty)
-Ctrl+T   Toggle thinking-block visibility
-Ctrl+O   Expand/collapse the most recent tool result
+Esc          Cancel active turn
+Ctrl+C       Clear editor
+Ctrl+D       Quit (when editor is empty)
+Ctrl+T       Toggle thinking-block visibility (hidden by default)
+Shift+Tab    Cycle thinking level (off → low → medium → high → …)
+Ctrl+O       Expand/collapse the most recent tool result
 ```
 
+The current thinking level is shown in the footer as `[level]` next to the model name.
+
 ## Sessions
 
-ashi mirrors pi's session model: many sessions per cwd, fresh by default.
+Many sessions per cwd, fresh by default:
 
 ```
-/resume      Browse past sessions in this cwd (interactive picker)
-/new         Start a fresh session (discards in-memory context)
-/name <text> Set a display name for the current session
-/sessions    Text dump of all sessions in this cwd
+/resume       Browse past sessions in this cwd (interactive picker)
+/new          Start a fresh session (discards in-memory context)
+/name <text>  Set a display name for the current session
+/sessions     Text dump of all sessions in this cwd
 ```
 
-Each session is its own tree (one JSONL file per session). Every entry has an `id` and
-`parentId`; sibling branches stay on disk; you can rewind and branch within a session.
+Each session is its own tree (one JSONL file per session). Every entry has an `id` and `parentId`; sibling branches stay on disk; you can rewind and branch within a session.
 
 ```
 /fork              Interactive in-session tree picker
@@ -73,8 +92,7 @@ Each session is its own tree (one JSONL file per session). Every entry has an `i
 /branch            Text dump of the active branch (root → leaf)
 ```
 
-Storage: `~/.agent-sh/extensions/ashi/history/<cwd-slug>/sessions/<id>.jsonl`. Each line
-is a `SessionEntry`:
+Storage: `~/.agent-sh/extensions/ashi/history/<cwd-slug>/sessions/<id>.jsonl`. Each line is a `SessionEntry`:
 
 ```typescript
 type SessionEntry =
@@ -83,65 +101,56 @@ type SessionEntry =
   | { type: "compaction"; id; parentId; timestamp; summary; firstKeptId; tokensBefore };
 ```
 
-Raw `AgentMessage` objects are stored verbatim (full tool call arguments, tool results,
-etc.) so `/resume` and `/fork` faithfully reconstruct the original conversation — same
-shape as pi's session format.
-
-The kernel side adds three small handlers:
-optional `parentSeq`/`getBranch`/`getTree`/`setLeaf` on `NuclearEntry`/`HistoryAdapter`
-(useful for tree-aware HistoryAdapters in general — not used by this extension);
-`conversation:allocate-seq` and `conversation:reset-for-session` so multi-session adapters
-can swap context without nuclear-state bleed-through.
-
-ashi itself bypasses agent-sh's `NuclearEntry` pipeline entirely by installing a
-`NoopHistory` adapter — raw messages are captured directly via `agent:processing-done`
-and the `conversation:get-messages` handler.
+Raw `AgentMessage` objects are stored verbatim (full tool call arguments, tool results, etc.) so `/resume` and `/fork` faithfully reconstruct the original conversation.
 
 ## Compaction
 
-ashi replaces agent-sh's default deterministic two-tier-pin compaction with a pi-style
-LLM-driven path:
+LLM-driven structured compaction, triggered automatically when prompt tokens cross the threshold or manually with `/compact`:
 
-1. Cut point: walk back from the newest message until ~20K tokens are kept; never cut at
-   tool results or in the middle of an assistant→tool call group.
-2. LLM summarizes the older span into the pi structured format (Goal / Constraints /
-   Progress / Decisions / Next Steps / Critical Context).
+1. Walk back from the newest message until ~20K tokens are kept; never cut at tool results or mid–assistant-tool-call group.
+2. LLM summarizes the older span into a structured format (Goal / Constraints / Progress / Decisions / Next Steps / Critical Context).
 3. The live message array becomes `[summary, ...kept messages]`.
-4. The summary lands in the session as a `CompactionEntry` carrying `summary`,
-   `firstKeptId`, and `tokensBefore` — same shape as pi's compaction. Subsequent
-   compactions reference the previous one's summary so chains stay coherent.
+4. The summary is persisted as a `CompactionEntry` carrying `summary`, `firstKeptId`, and `tokensBefore`. Subsequent compactions reference the previous one's summary so chains stay coherent.
 
-Triggered automatically when prompt tokens cross agent-sh's threshold, or manually with
-`/compact`. If the LLM call fails or the conversation is too short, falls through to the
-default eviction.
+If the LLM call fails or the conversation is too short, falls through to the default eviction.
 
-The cut-point walker, prompt template, serialization, and LLM call all live in this
-extension. The kernel side is just the advisable `conversation:compact` seam.
+## Display configuration
 
-## What's intentionally missing
+Per-tool compactness lives under `ashi.display` in `~/.agent-sh/settings.json`:
 
-This is a spike, not a clone of pi's full UI. The MVP renders:
+```json
+{
+  "ashi": {
+    "display": {
+      "default": { "result": "preview", "previewLines": 8 },
+      "read":    { "result": "hidden" },
+      "ls":      { "result": "hidden" },
+      "grep":    { "result": "summary" },
+      "bash":    { "result": "preview", "previewLines": 12 },
+      "edit":    { "result": "preview" },
+      "write":   { "result": "preview" }
+    }
+  }
+}
+```
 
-- User submissions, streaming assistant Markdown
-- Tool invocations with start/complete state
-- Slash commands with autocomplete (`/help`, `/model`, `/backend`, `/resume`, `/new`, `/fork`, …)
-- Multi-session tree history with `/resume` and `/fork` pickers
-- LLM compaction with summaries that survive across `/resume`
-- Loader, errors, info messages
-- Inline images via the `image` ContentBlock and the `render:image` handler — the
-  bundled `latex-images` extension works against ashi without modification
-  (terminal must support iTerm2 or Kitty graphics)
+`result` modes:
 
-Out of scope for v0: branch summaries on `/fork` navigation (pi has this), `/clone`
-(duplicate active branch into a new session), permission dialogs, diff renderer, file-path
-autocomplete, session search/rename/delete inside the `/resume` picker, theme selector.
-Each can be added by writing a pi-tui Component and subscribing to the corresponding
-bus event.
+- `"hidden"` — call line only while streaming; line count (`↳ 42 lines`) after completion.
+- `"summary"` — 2-line tail while streaming; line count after completion.
+- `"preview"` — last `previewLines` lines of output (default 8), with a `... (N more lines)` hint when content overflows.
+
+For `edit_file` / `write_file`, the diff frame is treated as the output and follows the same gating: shown for `preview`, hidden for `hidden`/`summary` (the call line already carries `+12 -3` stats). The line-count hint is suppressed for diff-producing tools so edits stay quiet.
+
+Hit `Ctrl+O` to expand the most recent tool result inline regardless of mode. Press again to collapse.
+
+Each tool inherits from `default` and is overridden by its own block. Unknown tool names fall through to `default`.
 
 ## Extension surface
 
-Other extensions can override how chat entries render without forking ashi.
-Hooks are exposed via `ctx.define` (defaults) + `ctx.advise` (override).
+Other extensions can override how chat entries and tool results render without forking ashi. Hooks are exposed via `ctx.define` (defaults) + `ctx.advise` (override).
+
+Components returned from these hooks are widgets from [`@earendil-works/pi-tui`](https://www.npmjs.com/package/@earendil-works/pi-tui) — the TUI framework ashi is built on.
 
 ### Chat hooks
 
@@ -153,9 +162,7 @@ Hooks are exposed via `ctx.define` (defaults) + `ctx.advise` (override).
 
 ### Tool hooks (per-tool)
 
-Tool rendering is split into a call line (the input header) and a result body
-(streaming output + final state). Each side is dispatched by tool name with a
-`:default` fallback:
+Tool rendering is split into a call line (the input header) and a result body (streaming output + final state). Each side is dispatched by tool name with a `:default` fallback:
 
 | Hook | Args | Returns |
 |---|---|---|
@@ -169,9 +176,7 @@ Tool rendering is split into a call line (the input header) and a result body
 - `ToolCallView` extends `Component` with `setStatus({ exitCode, elapsedMs, summary })` — called once on completion.
 - `ToolResultView` extends `Component` with `appendChunk(chunk)`, `setDiff(lines)`, `finalize({ exitCode, summary })`, and `toggleExpanded()` — ashi mutates the result view as output streams in and when the user hits `Ctrl+O`.
 
-`mode` and `previewLines` on result args come from `ashi.display.{name}` config
-(see below) so renderers can honor the user's compactness preference without
-re-implementing the resolution logic.
+`mode` and `previewLines` on result args come from `ashi.display.{name}` config so renderers can honor the user's compactness preference without re-implementing the resolution logic.
 
 Example: override how `bash` calls render.
 
@@ -183,52 +188,22 @@ export default function activate(ctx) {
 }
 ```
 
-For non-render concerns (commands, settings, tools, providers) use the standard
-agent-sh extension API.
+For non-render concerns (commands, settings, tools, providers) use the standard `agent-sh` extension API. See the [agent-sh extension docs](https://github.com/guanyilun/agent-sh/blob/main/docs/extensions.md).
 
-## Display configuration
+## Install from source
 
-Per-tool compactness lives under `ashi.display` in `~/.agent-sh/settings.json`:
+Alternative to the npm install, useful for hacking on ashi itself:
 
-```json
-{
-  "ashi": {
-    "display": {
-      "default": { "result": "preview", "previewLines": 8 },
-      "read":    { "result": "hidden" },
-      "ls":      { "result": "hidden" },
-      "grep":    { "result": "summary" },
-      "bash":    { "result": "preview", "previewLines": 12 },
-      "edit":    { "result": "preview" },
-      "write":   { "result": "preview" }
-    }
-  }
-}
+```bash
+agent-sh install ashi          # copies examples/extensions/ashi → ~/.agent-sh/extensions/ashi
+export PATH="$HOME/.agent-sh/bin:$PATH"
 ```
 
-`result` modes:
-
-- `"hidden"` — call line only while streaming; line count (`↳ 42 lines`) after completion.
-- `"summary"` — 2-line tail while streaming; line count after completion.
-- `"preview"` — last `previewLines` lines of output (default 8), with a `... (N more lines)` hint when content overflows.
-
-For `edit_file` / `write_file`, the diff frame is treated as the output and
-follows the same gating: shown for `preview`, hidden for `hidden`/`summary`
-(the call line already carries `+12 -3` stats). The line-count hint is
-suppressed for diff-producing tools so edits stay quiet.
-
-Hit `Ctrl+O` to expand the most recent tool result inline — shows the full
-output buffer and the full diff regardless of mode. Press again to collapse.
-
-Each tool inherits from `default` and is overridden by its own block. Unknown
-tool names fall through to `default`. Built-in defaults aim for compactness
-(`read`/`ls` hidden, `grep` summarized) — override under `default` to widen
-everything, or under a specific tool to tune one.
+`agent-sh install` runs `npm install` and `npm run build` in the copied directory and symlinks the built bin into `~/.agent-sh/bin/`.
 
 ## Development
 
-`@guanyilun/ashi` depends on the published `agent-sh` package. To iterate against
-the parent checkout instead, use `npm link`:
+`@guanyilun/ashi` depends on the published `agent-sh` package. To iterate against a local checkout, use `npm link`:
 
 ```bash
 # one-time: register the local agent-sh checkout
@@ -245,6 +220,8 @@ npm run dev      # tsx-driven, no compile step
 # or: npm run build && node dist/cli.js
 ```
 
-Rebuild agent-sh (`npm run build` at the repo root) whenever you change the
-kernel — the link picks up `dist/` directly. To go back to the published
-version, run `npm unlink agent-sh && npm install` inside `examples/extensions/ashi`.
+Rebuild agent-sh (`npm run build` at the repo root) whenever you change the kernel — the link picks up `dist/` directly. To go back to the published version, run `npm unlink agent-sh && npm install` inside `examples/extensions/ashi`.
+
+## License
+
+MIT

package/examples/extensions/ashi/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@guanyilun/ashi",
-  "version": "0.1.0",
-  "description": "Ash with a pi-tui frontend — agent-sh's kernel without the shell, rendered through pi's TUI library",
+  "version": "0.1.1",
+  "description": "Ash in an interactive TUI — agent-sh's built-in agent without the shell underneath",
   "type": "module",
   "main": "dist/cli.js",
   "bin": {
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.74.0",
-    "agent-sh": "^0.13.1",
+    "agent-sh": "^0.13.2",
     "chalk": "^5.5.0",
     "cli-highlight": "^2.1.11"
   },

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

@@ -15,11 +15,27 @@ export function registerCapture(
   getStore: () => MultiSessionStore,
 ): Capture {
   let liveEntryIds: (string | null)[] = [];
+  const diffMeta = new Map<string, { diff: unknown; filePath: string }>();
+
+  ctx.bus.on("agent:tool-completed", (e) => {
+    const id = e.toolCallId;
+    const body = e.resultDisplay?.body;
+    if (id && body?.kind === "diff") {
+      diffMeta.set(id, { diff: body.diff, filePath: body.filePath });
+    }
+  });
+
+  const enrich = (m: AgentMessage): AgentMessage => {
+    if (m.role !== "tool" || !m.tool_call_id) return m;
+    const meta = diffMeta.get(m.tool_call_id);
+    if (!meta) return m;
+    return { ...m, meta: { ...m.meta, diff: meta.diff, filePath: meta.filePath } };
+  };
 
   const flush = async (): Promise<void> => {
     const messages = ctx.call("conversation:get-messages") as AgentMessage[] | undefined;
     if (!messages || messages.length <= liveEntryIds.length) return;
-    const newMessages = messages.slice(liveEntryIds.length);
+    const newMessages = messages.slice(liveEntryIds.length).map(enrich);
     const newIds = await getStore().current().appendMessages(newMessages);
     liveEntryIds = [...liveEntryIds, ...newIds];
   };

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

@@ -1,11 +1,6 @@
 #!/usr/bin/env node
 /**
- * ashi — agent-sh's ash backend with a pi-tui frontend, no shell.
- *
- * Boots the agent-sh kernel directly, skips the PTY shell and the
- * default streaming tui-renderer, and mounts pi-tui as the sole
- * frontend. Demonstrates that the kernel is frontend-agnostic — same
- * backend, tools, slash commands, providers; different presentation.
+ * ashi — ash (agent-sh's built-in agent) in an interactive TUI.
  */
 import { createCore, NoopHistory } from "agent-sh/core";
 import { loadBuiltinExtensions } from "agent-sh/extensions";
@@ -43,10 +38,7 @@ function parseArgs(argv: string[]): AppConfig & { extensions?: string[] } {
     else if ((a === "-e" || a === "--extensions") && argv[i + 1]) {
       extensions.push(...argv[++i]!.split(",").map(s => s.trim()).filter(Boolean));
     } else if (a === "-h" || a === "--help") {
-      process.stdout.write(`ashi — ash backend, pi-tui frontend\n\n` +
-        `Usage: ashi [--provider <name>] [--model <id>] [--api-key <key>] [--base-url <url>]\n` +
-        `            [--backend <name>] [-e <ext>[,<ext>...]]\n\n` +
-        `Reads ~/.agent-sh/settings.json for providers and defaults.\n`);
+      process.stdout.write(MANAGEMENT_HELP + "\n");
       process.exit(0);
     }
   }
@@ -54,7 +46,7 @@ function parseArgs(argv: string[]): AppConfig & { extensions?: string[] } {
   return { shell: "/bin/sh", model, apiKey, baseURL, provider, backend, extensions };
 }
 
-const MANAGEMENT_HELP = `ashi — ash backend, pi-tui frontend
+const MANAGEMENT_HELP = `ashi — ash (agent-sh's built-in agent) in an interactive TUI
 
 Management:
   ashi install <name> [--force]   Install an extension
@@ -153,7 +145,7 @@ async function main(): Promise<void> {
   registerDefaultToolRenderers(ctx);
 
   ctx.advise("conversation:format-prior-history", () => null);
-  ctx.advise("system-prompt:build", (base) => `${base}\n\n<cwd>${process.cwd()}</cwd>`);
+  ctx.advise("system-prompt:build", (next) => `${next()}\n\n<cwd>${process.cwd()}</cwd>`);
 
   const handle = mountAshi(ctx, getStore, capture);
   stopFrontend = handle.stop;

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

@@ -98,7 +98,8 @@ export class ToolResultBody extends Container {
   private outputText: Text;
   private bodyText: Text;
   private outputBuffer = "";
-  private diffLines: string[] = [];
+  private diffRenderer: ((width: number) => string[]) | null = null;
+  private lastDiffWidth = -1;
   private mode: ToolResultMode;
   private previewLines: number;
   private finalized = false;
@@ -120,8 +121,9 @@ export class ToolResultBody extends Container {
     this.repaint();
   }
 
-  setDiff(lines: string[]): void {
-    this.diffLines = lines;
+  setDiffRenderer(fn: (width: number) => string[]): void {
+    this.diffRenderer = fn;
+    this.lastDiffWidth = -1;
     this.repaint();
   }
 
@@ -136,12 +138,23 @@ export class ToolResultBody extends Container {
     this.repaint();
   }
 
+  override render(width: number): string[] {
+    if (this.diffRenderer && width !== this.lastDiffWidth) {
+      this.lastDiffWidth = width;
+      const showDiff = this.expanded || this.mode === "preview";
+      this.bodyText.setText(showDiff ? this.diffRenderer(width).join("\n") : "");
+    }
+    return super.render(width);
+  }
+
   private repaint(): void {
-    // Hide the framed diff in hidden/summary modes — the stats already live
-    // on the call line so showing it again is noise.
-    const hasDiff = this.diffLines.length > 0;
+    const hasDiff = this.diffRenderer !== null;
     const showDiff = hasDiff && (this.expanded || this.mode === "preview");
-    this.bodyText.setText(showDiff ? this.diffLines.join("\n") : "");
+    if (showDiff && this.lastDiffWidth >= 0 && this.diffRenderer) {
+      this.bodyText.setText(this.diffRenderer(this.lastDiffWidth).join("\n"));
+    } else if (!showDiff) {
+      this.bodyText.setText("");
+    }
 
     // When a diff exists, the textual output ("Edited /path (+12 -3)") just
     // restates the call line — suppress its line-count hint to keep edits quiet.
@@ -190,7 +203,7 @@ function lineCountHint(buffer: string, exitCode: number | null | undefined): str
   return `${arrow}${theme.fg("muted", label)}`;
 }
 
-const GROUP_ICONS: Record<string, string> = { read: "◆", search: "⌕" };
+export const GROUP_ICONS: Record<string, string> = { read: "◆", search: "⌕" };
 
 interface GroupChild {
   name: string;

package/examples/extensions/ashi/src/default-renderers.ts

@@ -1,8 +1,26 @@
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import type { ExtensionContext } from "agent-sh/types";
 import { theme } from "./theme.js";
+import { GROUP_ICONS } from "./components.js";
 import type { ToolCallArgs, ToolCallView } from "./hooks.js";
 
+const TOOL_ICON: Record<string, string> = {
+  read_file: GROUP_ICONS.read!,
+  read: GROUP_ICONS.read!,
+  ls: GROUP_ICONS.read!,
+  grep: GROUP_ICONS.search!,
+  glob: GROUP_ICONS.search!,
+  edit: "✎",
+  edit_file: "✎",
+  write: "✎",
+  write_file: "✎",
+};
+
+function iconPrefix(name: string): string {
+  const icon = TOOL_ICON[name] ?? "⚙";
+  return `${theme.fg("warning", icon)} `;
+}
+
 interface StatusOpts { exitCode: number | null; elapsedMs: number; summary?: string }
 
 function fmtElapsed(ms: number): string {
@@ -92,7 +110,7 @@ function readLabel(args: ToolCallArgs): string {
     const to = limit !== undefined ? from + limit - 1 : undefined;
     range = theme.fg("warning", to ? `:${from}-${to}` : `:${from}`);
   }
-  return `${bold("read")} ${accent(path ? relativize(path) : "…")}${range}`;
+  return `${iconPrefix("read")}${bold("read")} ${accent(path ? relativize(path) : "…")}${range}`;
 }
 
 function grepLabel(args: ToolCallArgs): string {
@@ -103,31 +121,31 @@ function grepLabel(args: ToolCallArgs): string {
   const limit = num(r.limit);
   const extras = [glob ? `(${glob})` : "", limit !== undefined ? `limit ${limit}` : ""].filter(Boolean).join(" ");
   const tail = extras ? muted(` ${extras}`) : "";
-  return `${bold("grep")} ${accent(`/${pattern}/`)} ${muted(`in ${scope}`)}${tail}`;
+  return `${iconPrefix("grep")}${bold("grep")} ${accent(`/${pattern}/`)} ${muted(`in ${scope}`)}${tail}`;
 }
 
 function globLabel(args: ToolCallArgs): string {
   const r = parseRaw(args.rawInput);
   const pattern = str(r.pattern) ?? "…";
   const scope = relativize(str(r.path) ?? ".");
-  return `${bold("glob")} ${accent(pattern)} ${muted(`in ${scope}`)}`;
+  return `${iconPrefix("glob")}${bold("glob")} ${accent(pattern)} ${muted(`in ${scope}`)}`;
 }
 
 function lsLabel(args: ToolCallArgs): string {
   const r = parseRaw(args.rawInput);
   const p = str(r.path) ?? ".";
-  return `${bold("ls")} ${accent(relativize(p))}`;
+  return `${iconPrefix("ls")}${bold("ls")} ${accent(relativize(p))}`;
 }
 
 function pathOnlyLabel(name: string, args: ToolCallArgs): string {
   const r = parseRaw(args.rawInput);
   const path = str(r.file_path) ?? str(r.path);
-  return `${bold(name)} ${accent(path ? relativize(path) : "…")}`;
+  return `${iconPrefix(name)}${bold(name)} ${accent(path ? relativize(path) : "…")}`;
 }
 
 function genericLabel(args: ToolCallArgs): string {
   const detail = args.displayDetail ? ` ${muted(args.displayDetail)}` : "";
-  return `${bold(args.title)}${detail}`;
+  return `${iconPrefix(args.name)}${bold(args.title)}${detail}`;
 }
 
 export function registerDefaultToolRenderers(ctx: ExtensionContext): void {

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

@@ -40,11 +40,52 @@ import { resumeSession } from "./session-commands.js";
 import { applyBranchMessages } from "./commands.js";
 import type { Capture } from "./capture.js";
 import { execSync } from "node:child_process";
-import { renderDiff } from "agent-sh/utils/diff-renderer.js";
+import { renderDiff, detectLanguage, highlightLine } from "agent-sh/utils/diff-renderer.js";
 import { renderBoxFrame } from "agent-sh/utils/box-frame.js";
 
 interface DiffStats { added: number; removed: number; isNewFile: boolean; isIdentical: boolean }
 
+function buildDiffRenderer(
+  diff: DiffStats & Parameters<typeof renderDiff>[0],
+  filePath: string,
+): (width: number) => string[] {
+  return (width) => {
+    const boxW = Math.max(40, width);
+    const contentW = Math.max(20, boxW - 4);
+    const inner = diff.isNewFile
+      ? renderNewFilePreview(diff, 30, filePath)
+      : ((): string[] => {
+          const lines = renderDiff(diff, {
+            width: contentW, filePath, trueColor: true, maxLines: Number.MAX_SAFE_INTEGER, mode: "unified",
+          });
+          return lines.length > 1 ? ["", ...lines.slice(1), ""] : lines;
+        })();
+    return renderBoxFrame(inner, {
+      width: boxW,
+      style: "rounded",
+      title: diffFrameTitle(filePath, diff),
+    });
+  };
+}
+
+function renderNewFilePreview(
+  diff: { hunks?: { lines: { type: string; text: string }[] }[] },
+  maxLines: number,
+  filePath: string,
+): string[] {
+  const lines = diff.hunks?.[0]?.lines.filter((l) => l.type === "added") ?? [];
+  const shown = lines.slice(0, maxLines);
+  const overflow = lines.length - shown.length;
+  const noW = String(shown.length).length || 1;
+  const lang = detectLanguage(filePath);
+  const body = shown.map((l, i) => {
+    const no = String(i + 1).padStart(noW);
+    return `${theme.fg("muted", `${no} │`)} ${highlightLine(l.text, lang)}`;
+  });
+  if (overflow > 0) body.push(theme.fg("muted", `… ${overflow} more lines`));
+  return ["", ...body, ""];
+}
+
 function diffFrameTitle(filePath: string, diff: DiffStats): string {
   const stats = diff.isNewFile
     ? theme.fg("success", `+${diff.added}`)
@@ -334,7 +375,13 @@ export function mountAshi(
       if (found.kind === "group") {
         found.group.recordCompletion(id, 0, summary);
       } else {
-        if (text) found.pair.result.appendChunk(text);
+        const meta = m.meta as { diff?: unknown; filePath?: string } | undefined;
+        if (meta?.diff && typeof meta.filePath === "string") {
+          const diff = meta.diff as DiffStats & Parameters<typeof renderDiff>[0];
+          if (!diff.isIdentical) {
+            found.pair.result.setDiffRenderer(buildDiffRenderer(diff, meta.filePath));
+          }
+        }
         found.pair.result.finalize({ exitCode: 0, summary });
         found.pair.call.setStatus({ exitCode: 0, elapsedMs: 0, summary });
       }
@@ -485,27 +532,10 @@ export function mountAshi(
     }
     const pair = entry.pair;
     const body = e.resultDisplay?.body;
-    const ok = e.exitCode === null || e.exitCode === 0;
     if (body?.kind === "diff") {
       const diff = body.diff as DiffStats & Parameters<typeof renderDiff>[0];
       if (!diff.isIdentical) {
-        const termW = process.stdout.columns ?? 80;
-        const boxW = Math.max(40, termW);
-        const contentW = Math.max(20, boxW - 4);
-        const diffLines = renderDiff(diff, {
-          width: contentW,
-          filePath: body.filePath,
-          trueColor: true,
-          maxLines: 30,
-        });
-        const inner = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
-        const framed = renderBoxFrame(inner, {
-          width: boxW,
-          style: "rounded",
-          title: diffFrameTitle(body.filePath, diff),
-          bgColor: theme.bgCode(ok ? "toolSuccessBg" : "toolErrorBg"),
-        });
-        pair.result.setDiff(framed);
+        pair.result.setDiffRenderer(buildDiffRenderer(diff, body.filePath));
       }
     }
     pair.call.setStatus({ exitCode: e.exitCode, elapsedMs: Date.now() - pair.startedAt, summary });

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

@@ -45,11 +45,13 @@ export interface ToolCallView extends Component {
 }
 
 /** Mutated by ashi as output streams in and when the tool completes.
- *  setDiff is optional behavior — renderers may no-op if they don't show diffs.
- *  toggleExpanded flips the view's internal expansion state (Ctrl+O). */
+ *  setDiffRenderer is optional behavior — renderers may no-op if they don't
+ *  show diffs. The renderer is called on each terminal-width change so diffs
+ *  reflow on resize. toggleExpanded flips the view's internal expansion state
+ *  (Ctrl+O). */
 export interface ToolResultView extends Component {
   appendChunk(chunk: string): void;
-  setDiff(lines: string[]): void;
+  setDiffRenderer(fn: (width: number) => string[]): void;
   finalize(opts: { exitCode: number | null; summary?: string }): void;
   toggleExpanded(): void;
 }

package/examples/extensions/ashi/src/session-store.ts

@@ -14,6 +14,7 @@ export interface AgentMessage {
   tool_calls?: ToolCall[];
   tool_call_id?: string;
   name?: string;
+  meta?: Record<string, unknown>;
 }
 
 export interface SessionHeaderEntry {

package/examples/extensions/ollama-cloud.ts

@@ -0,0 +1,78 @@
+/**
+ * Ollama Cloud — hosted Ollama models (https://ollama.com).
+ *
+ * Auth:  agent-sh auth login ollama-cloud
+ * Usage: agent-sh -e ./examples/extensions/ollama-cloud.ts
+ */
+import { resolveApiKey } from "agent-sh/auth";
+import type { AgentContext } from "agent-sh/types";
+
+const HOST = "https://ollama.com";
+const BASE_URL = `${HOST}/v1`;
+const ID = "ollama-cloud";
+
+function buildReasoningParams(level: string, _model?: string): Record<string, unknown> {
+  return { reasoning_effort: level === "off" ? "none" : level };
+}
+
+async function fetchModels(apiKey: string) {
+  const headers: Record<string, string> = { Authorization: `Bearer ${apiKey}` };
+  const tagsRes = await fetch(`${HOST}/api/tags`, { headers });
+  if (!tagsRes.ok) return [];
+  const tagsData = await tagsRes.json() as { models?: { name: string }[] };
+  const names = (tagsData.models ?? []).map((m) => m.name);
+  if (!names.length) return [];
+
+  const ctxs = await Promise.all(
+    names.map((name) =>
+      fetch(`${HOST}/api/show`, {
+        method: "POST",
+        headers: { ...headers, "Content-Type": "application/json" },
+        body: JSON.stringify({ name }),
+      })
+        .then((r) => r.ok ? r.json() as Promise<{ model_info?: Record<string, unknown> }> : null)
+        .then((d) => {
+          if (!d?.model_info) return undefined;
+          const info = d.model_info;
+          const arch = info["general.architecture"] as string | undefined;
+          if (arch) {
+            const ctx = info[`${arch}.context_length`];
+            if (typeof ctx === "number") return ctx;
+          }
+          for (const [k, v] of Object.entries(info)) {
+            if (k.endsWith(".context_length") && typeof v === "number") return v;
+          }
+          return undefined;
+        })
+        .catch(() => undefined),
+    ),
+  );
+
+  return names.map((name, i) => ({
+    id: name,
+    contextWindow: ctxs[i],
+    echoReasoning: /deepseek/i.test(name),
+  }));
+}
+
+export default function activate(ctx: AgentContext): void {
+  const { key } = resolveApiKey(ID);
+  const apiKey = key ?? process.env.OLLAMA_API_KEY;
+  if (!apiKey) return;
+
+  ctx.agent.providers.configure(ID, { reasoningParams: buildReasoningParams });
+
+  // Register placeholder while catalog loads
+  ctx.bus.emit("provider:register", { id: ID, apiKey, baseURL: BASE_URL, models: [] });
+
+  fetchModels(apiKey).then((models) => {
+    if (!models.length) return;
+    ctx.bus.emit("provider:register", {
+      id: ID,
+      apiKey,
+      baseURL: BASE_URL,
+      defaultModel: models[0]!.id,
+      models,
+    });
+  }).catch(() => { /* keep placeholder */ });
+}

package/examples/extensions/ollama.ts

@@ -37,6 +37,10 @@ export default function activate(ctx: ExtensionContext): void {
   const headers: Record<string, string> = {};
   if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
 
+  ctx.agent.providers.configure(id, {
+    reasoningParams: (level) => ({ reasoning_effort: level === "off" ? "none" : level }),
+  });
+
   ctx.bus.emit("provider:register", { id, apiKey: sdkKey, baseURL, models: [] });
 
   fetchCatalog(host, headers).then((models) => {

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

@@ -0,0 +1,39 @@
+/**
+ * Z.AI Coding Plan — Zhipu AI's subscription GLM models for coding tools.
+ *
+ * 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";
+const ID = "zai-coding-plan";
+
+const DEFAULT_MODELS = [
+  { id: "glm-5.1",     reasoning: true, contextWindow: 200_000 },
+  { id: "glm-5-turbo", reasoning: true, contextWindow: 200_000 },
+  { id: "glm-4.7",     reasoning: true, contextWindow: 204_800 },
+  { id: "glm-4.5-air", reasoning: true, contextWindow: 131_072 },
+];
+
+function buildReasoningParams(level: string, _model?: string): Record<string, unknown> {
+  if (level === "off") return { thinking: { type: "disabled" } };
+  return { thinking: { type: "enabled" }, reasoning_effort: level };
+}
+
+export default function activate(ctx: AgentContext): void {
+  const { key } = resolveApiKey(ID);
+  const apiKey = key ?? process.env.ZAI_API_KEY ?? process.env.ZHIPU_API_KEY;
+  if (!apiKey) return;
+
+  ctx.agent.providers.configure(ID, { reasoningParams: buildReasoningParams });
+
+  ctx.bus.emit("provider:register", {
+    id: ID,
+    apiKey: apiKey,
+    baseURL: BASE_URL,
+    defaultModel: DEFAULT_MODELS[0].id,
+    models: DEFAULT_MODELS,
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core/index.js",
@@ -101,6 +101,10 @@
     "./cli/auth": {
       "types": "./dist/cli/auth/cli.d.ts",
       "default": "./dist/cli/auth/cli.js"
+    },
+    "./auth": {
+      "types": "./dist/cli/auth/keys.d.ts",
+      "default": "./dist/cli/auth/keys.js"
     }
   },
   "files": [