agent-sh 0.12.20 → 0.12.22

package/dist/utils/box-frame.js

@@ -5,7 +5,7 @@
  * never writes to stdout. Supports multiple border styles and
  * optional title/footer sections with dividers.
  */
-import { visibleLen, truncateToWidth } from "./ansi.js";
+import { visibleLen, truncateToWidth, truncateAnsiToWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
 const BORDERS = {
     rounded: { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│", ml: "├", mr: "┤" },
@@ -32,14 +32,20 @@ export function renderBoxFrame(content, opts) {
     const output = [];
     // Top border (with optional left/right titles)
     if (opts.title || opts.titleRight) {
-        const leftPart = opts.title
-            ? `${p.reset} ${opts.title} ${bc}`
-            : "";
-        const leftVis = opts.title ? visibleLen(opts.title) + 2 : 0; // +2 for spaces
-        const rightPart = opts.titleRight
-            ? `${p.reset} ${opts.titleRight} ${bc}`
-            : "";
+        // Budget: 2 corners + 1 minimum dash + space-padding around each title.
+        // Truncate the left title first if combined widths overflow — titleRight
+        // is typically short metadata (model name, stats) worth preserving.
+        let title = opts.title;
         const rightVis = opts.titleRight ? visibleLen(opts.titleRight) + 2 : 0;
+        const leftBudget = width - 2 - 1 - rightVis; // total - corners - min dash - right
+        let leftVis = title ? visibleLen(title) + 2 : 0;
+        if (title && leftVis > leftBudget) {
+            const maxTitleVis = Math.max(1, leftBudget - 2);
+            title = truncateAnsiToWidth(title, maxTitleVis);
+            leftVis = visibleLen(title) + 2;
+        }
+        const leftPart = title ? `${p.reset} ${title} ${bc}` : "";
+        const rightPart = opts.titleRight ? `${p.reset} ${opts.titleRight} ${bc}` : "";
         const dashCount = Math.max(1, width - 2 - leftVis - rightVis);
         output.push(`${bc}${b.tl}${leftPart}${b.h.repeat(dashCount)}${rightPart}${b.tr}${p.reset}`);
     }

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

@@ -33,7 +33,8 @@ export declare class LlmClient {
         tools?: ChatCompletionTool[];
         model?: string;
         max_tokens?: number;
-        /** Reasoning effort level (e.g. "low", "medium", "high"). Provider-dependent. */
+        /** Reasoning effort: "off" | "low" | "medium" | "high". Provider-dependent;
+         *  "off" matches agent-loop's thinkingLevel and omits the field. */
         reasoning_effort?: string;
         signal?: AbortSignal;
     }): import("openai").APIPromise<import("openai/core/streaming.mjs").Stream<OpenAI.Chat.Completions.ChatCompletionChunk>>;
@@ -45,5 +46,8 @@ export declare class LlmClient {
         messages: ChatCompletionMessageParam[];
         model?: string;
         max_tokens?: number;
+        /** Reasoning effort: "off" | "low" | "medium" | "high". Provider-dependent;
+         *  "off" matches agent-loop's thinkingLevel and omits the field. */
+        reasoning_effort?: string;
     }): Promise<string>;
 }

package/dist/utils/llm-client.js

@@ -40,6 +40,7 @@ export class LlmClient {
      * Returns an async iterable of chunks.
      */
     stream(opts) {
+        const sendEffort = opts.reasoning_effort && opts.reasoning_effort !== "off";
         const body = {
             model: opts.model ?? this.model,
             messages: opts.messages,
@@ -47,7 +48,7 @@ export class LlmClient {
             max_tokens: opts.max_tokens ?? 65536,
             stream: true,
             stream_options: { include_usage: true },
-            ...(opts.reasoning_effort
+            ...(sendEffort
                 ? { reasoning_effort: opts.reasoning_effort }
                 : {}),
         };
@@ -58,10 +59,14 @@ export class LlmClient {
      * Returns the text content of the first choice.
      */
     async complete(opts) {
+        const sendEffort = opts.reasoning_effort && opts.reasoning_effort !== "off";
         const response = await this.client.chat.completions.create({
             model: opts.model ?? this.model,
             messages: opts.messages,
             max_tokens: opts.max_tokens ?? 1024,
+            ...(sendEffort
+                ? { reasoning_effort: opts.reasoning_effort }
+                : {}),
         });
         return response.choices[0]?.message?.content ?? "";
     }

package/dist/utils/llm-facade.js

@@ -1,18 +1,18 @@
 export function createLlmFacade(handlers) {
-    const invoke = (messages, maxTokens) => {
-        const result = handlers.call("llm:invoke", messages, { maxTokens });
+    const invoke = (messages, maxTokens, model, reasoningEffort) => {
+        const result = handlers.call("llm:invoke", messages, { maxTokens, model, reasoningEffort });
         if (result === undefined)
             return Promise.reject(new Error("ctx.llm: no LLM backend available"));
         return result;
     };
     return {
         get available() { return handlers.list().includes("llm:invoke"); },
-        ask: ({ query, system, maxTokens }) => {
+        ask: ({ query, system, maxTokens, model, reasoningEffort }) => {
             const messages = [];
             if (system)
                 messages.push({ role: "system", content: system });
             messages.push({ role: "user", content: query });
-            return invoke(messages, maxTokens);
+            return invoke(messages, maxTokens, model, reasoningEffort);
         },
         session: (opts = {}) => {
             const messages = [];
@@ -21,7 +21,7 @@ export function createLlmFacade(handlers) {
             const session = {
                 async send(message) {
                     messages.push({ role: "user", content: message });
-                    const reply = await invoke(messages, opts.maxTokens);
+                    const reply = await invoke(messages, opts.maxTokens, opts.model, opts.reasoningEffort);
                     messages.push({ role: "assistant", content: reply });
                     return reply;
                 },

package/examples/extensions/pi-bridge/README.md

@@ -1,14 +1,11 @@
 # pi-bridge
 
-Runs [pi](https://github.com/nickarora/pi)'s full coding agent as an agent-sh backend. Uses pi's own configuration, models, tools, and extensions — agent-sh just provides the terminal.
+Runs [pi](https://github.com/badlogic/pi-mono) (`@mariozechner/pi-coding-agent`) as an agent-sh backend. Pi brings its own configuration, models, tools, and extensions — agent-sh just provides the terminal.
 
 ## Install
 
 ```bash
-# Copy or symlink into your extensions directory
 cp -r examples/extensions/pi-bridge ~/.agent-sh/extensions/pi-bridge
-
-# Install dependencies
 cd ~/.agent-sh/extensions/pi-bridge
 npm install
 ```
@@ -26,26 +23,22 @@ Set as default backend in `~/.agent-sh/settings.json`:
 Or switch at runtime:
 
 ```
-? /backend pi
+> /backend pi
 ```
 
-## Requirements
-
-- pi must be configured separately (`~/.pi/settings.json`) with API keys and model preferences
-- agent-sh does not override pi's configuration — it uses whatever pi is set up with
+Pi reads its own settings from `~/.pi/agent/settings.json`. Configure API keys and model preferences there (or run `pi` directly to set up auth) — agent-sh does not override pi's configuration.
 
-## What this bridge is
+## What works under pi
 
-A pure protocol translator between pi's event stream and agent-sh's bus events. Pi's built-in tools (command execution, file ops, etc.) are used exactly as pi ships them. The bridge adds no tools of its own.
+These slash commands are routed to pi's SDK when pi is the active backend:
 
-## What this bridge intentionally does NOT bundle
+- `/model` — lists/switches pi's available models (`session.setModel`)
+- `/thinking` — sets pi's thinking level (`off/minimal/low/medium/high/xhigh`)
+- `/compact` — runs `session.compact()` on pi's session
+- `/context` — reports pi's token usage (`session.getContextUsage()`)
 
-Three PTY-access tools are left out on purpose:
+agent-sh's per-query context producers (e.g. `<shell_events>` from `shell-context`) are inlined into pi's prompt before each query, so pi sees the user's recent shell activity even though it doesn't subscribe to agent-sh's shell bus directly.
 
-- `terminal_read` — observe the user's live terminal screen
-- `terminal_keys` — send keystrokes to the user's PTY
-- `user_shell` — run commands in the user's live shell with lasting `cd`/`export`/`source` effects
-
-These are opt-in capabilities that belong in their own extensions. If you want any of them with pi, write a small companion extension that registers the tool as a pi `ToolDefinition` (TypeBox schema, wired to the relevant bus event: `shell:pty-write`, `shell:exec-request`, or `ctx.terminalBuffer.readScreen()`) and load it alongside pi-bridge.
+## What this bridge is
 
-Keeping this split means the bridge stays narrow — only translating events — and the capability surface is composable per-backend.
+A pure protocol translator between pi's event stream and agent-sh's bus events. Pi's built-in tools (command execution, file ops, etc.) are used exactly as pi ships them. The bridge adds no tools of its own.

package/examples/extensions/pi-bridge/index.ts

@@ -1,16 +1,6 @@
 /**
  * Pi bridge — runs pi's full coding agent in-process as agent-sh's backend.
- *
- * Uses pi's own AgentSession with its full configuration: model registry,
- * provider settings, extensions, session management, and tool system.
- * Agent-sh provides the shell frontend and TUI rendering.
- *
- * The bridge is a pure protocol translator between pi's event stream and
- * agent-sh's bus events. Pi brings its own tools for command execution,
- * file ops, etc. PTY-access tools (`terminal_read`, `terminal_keys`,
- * `user_shell`) are intentionally NOT bundled here — if you want pi to
- * observe or mutate the user's live terminal, load a companion extension
- * that registers those tools in pi's ToolDefinition format.
+ * Pure protocol translator between pi's event stream and agent-sh's bus.
  *
  * Setup:
  *   npm install @mariozechner/pi-agent-core @mariozechner/pi-ai @mariozechner/pi-coding-agent
@@ -26,25 +16,127 @@ import {
   SessionManager,
 } from "@mariozechner/pi-coding-agent";
 import type { ExtensionContext } from "agent-sh/types";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { diffLines } from "diff";
+
+const TOOL_KINDS: Record<string, string> = {
+  bash: "execute",
+  read: "read",
+  ls: "read",
+  find: "read",
+  grep: "search",
+  edit: "execute",
+  write: "execute",
+};
+const kindForTool = (name: string): string => TOOL_KINDS[name] ?? "execute";
+
+type DiffLineRecord = { type: "context" | "added" | "removed"; oldNo: number | null; newNo: number | null; text: string };
+type DiffHunkRecord = { lines: DiffLineRecord[] };
+type DiffResultRecord = { hunks: DiffHunkRecord[]; added: number; removed: number; isIdentical: boolean; isNewFile: boolean };
+
+function buildDiffFromTexts(oldText: string, newText: string, isNewFile: boolean): DiffResultRecord | null {
+  if (oldText === newText) return null;
+  const changes = diffLines(oldText, newText);
+  const allLines: DiffLineRecord[] = [];
+  let oldNo = 0;
+  let newNo = 0;
+  let added = 0;
+  let removed = 0;
+  for (const change of changes) {
+    const lines = change.value.replace(/\n$/, "").split("\n");
+    for (const text of lines) {
+      if (change.added) {
+        newNo++;
+        allLines.push({ type: "added", oldNo: null, newNo, text });
+        added++;
+      } else if (change.removed) {
+        oldNo++;
+        allLines.push({ type: "removed", oldNo, newNo: null, text });
+        removed++;
+      } else {
+        oldNo++;
+        newNo++;
+        allLines.push({ type: "context", oldNo, newNo, text });
+      }
+    }
+  }
+  if (allLines.length === 0) return null;
+  return {
+    hunks: [{ lines: allLines }],
+    added,
+    removed,
+    isIdentical: false,
+    isNewFile,
+  };
+}
+
+// Pi's edit returns a custom diff string: prefix(+/-/space) + lineNum + " " + text, "..." between hunks.
+function parsePiDiff(raw: unknown): DiffResultRecord | null {
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  const hunks: DiffHunkRecord[] = [];
+  let current: DiffLineRecord[] = [];
+  let added = 0;
+  let removed = 0;
+  let hasOriginal = false;
+  let delta = 0;
+
+  const flush = () => {
+    if (current.length > 0) hunks.push({ lines: current });
+    current = [];
+  };
+
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) continue;
+    const prefix = line[0];
+    const rest = line.slice(1);
+    if (prefix === " " && rest.trim() === "...") { flush(); continue; }
+    const m = rest.match(/^\s*(\d+)\s(.*)$/);
+    if (!m) continue;
+    const num = parseInt(m[1]!, 10);
+    const text = m[2]!;
+    if (prefix === "+") {
+      current.push({ type: "added", oldNo: null, newNo: num, text });
+      added++;
+      delta++;
+    } else if (prefix === "-") {
+      current.push({ type: "removed", oldNo: num, newNo: null, text });
+      removed++;
+      delta--;
+      hasOriginal = true;
+    } else if (prefix === " ") {
+      current.push({ type: "context", oldNo: num, newNo: num + delta, text });
+      hasOriginal = true;
+    }
+  }
+  flush();
+
+  if (hunks.length === 0) return null;
+  return { hunks, added, removed, isIdentical: added + removed === 0, isNewFile: !hasOriginal };
+}
 
-// ── Extension entry point ─────────────────────────────────────────
 export default function activate(ctx: ExtensionContext): void {
-  const { bus } = ctx;
+  const { bus, call } = ctx;
   const cwd = process.cwd();
 
-  // ── Boot pi session (async — register backend synchronously first) ──
   let session: any = null;
   let runtime: any = null;
+  let modelRegistry: any = null;
   let booting = true;
 
+  const PI_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+  // Pi's tool_execution_end omits `args` — cache from start so the end handler can use the path.
+  const pendingArgs = new Map<string, any>();
+  // Snapshot disk content before pi writes; diffed against args.content at end.
+  const pendingWriteSnapshot = new Map<string, { oldContent: string; isNewFile: boolean }>();
+
   const boot = async () => {
     try {
-      // Pi loads its own config: ~/.pi/agent/settings.json, models, extensions
       const services = await createAgentSessionServices({ cwd });
+      modelRegistry = services.modelRegistry;
       const sessionManager = SessionManager.inMemory(cwd);
 
-      // createRuntime factory — returns { session, services, ... } as expected
-      // by createAgentSessionRuntime
       const createRuntime = async (opts: any) => {
         const result = await createAgentSessionFromServices({
           services,
@@ -59,7 +151,6 @@ export default function activate(ctx: ExtensionContext): void {
       });
       session = runtime.session;
 
-      // Subscribe to pi events → agent-sh bus
       let fullResponseText = "";
 
       session.subscribe((event: AgentEvent) => {
@@ -81,13 +172,46 @@ export default function activate(ctx: ExtensionContext): void {
             break;
           }
 
-          case "tool_execution_start":
+          case "message_end": {
+            // Synthesize agent:tool-batch so tui-renderer groups parallel tool calls under one header.
+            const msg = (event as any).message;
+            if (msg?.role === "assistant" && Array.isArray(msg.content)) {
+              const groupMap = new Map<string, Array<{ name: string }>>();
+              for (const block of msg.content) {
+                if (block?.type === "toolCall" && typeof block.name === "string") {
+                  const kind = kindForTool(block.name);
+                  if (!groupMap.has(kind)) groupMap.set(kind, []);
+                  groupMap.get(kind)!.push({ name: block.name });
+                }
+              }
+              if (groupMap.size > 0) {
+                const groups = Array.from(groupMap.entries()).map(([kind, tools]) => ({ kind, tools }));
+                bus.emit("agent:tool-batch", { groups });
+              }
+            }
+            break;
+          }
+
+          case "tool_execution_start": {
+            const ev = event as any;
+            if (ev.toolCallId) pendingArgs.set(ev.toolCallId, ev.args);
+            if (ev.toolName === "write" && ev.toolCallId && typeof ev.args?.path === "string") {
+              const abs = resolvePath(cwd, ev.args.path);
+              let oldContent = "";
+              let isNewFile = true;
+              if (existsSync(abs)) {
+                try { oldContent = readFileSync(abs, "utf8"); isNewFile = false; } catch {}
+              }
+              pendingWriteSnapshot.set(ev.toolCallId, { oldContent, isNewFile });
+            }
             bus.emit("agent:tool-started", {
-              title: (event as any).toolName,
-              toolCallId: (event as any).toolCallId,
-              kind: (event as any).toolName === "bash" ? "execute" : "read",
+              title: ev.toolName,
+              toolCallId: ev.toolCallId,
+              kind: kindForTool(ev.toolName),
+              rawInput: ev.args,
             });
             break;
+          }
 
           case "tool_execution_update": {
             const pr = (event as any).partialResult as
@@ -103,13 +227,41 @@ export default function activate(ctx: ExtensionContext): void {
             break;
           }
 
-          case "tool_execution_end":
+          case "tool_execution_end": {
+            const ev = event as any;
+            const args = ev.toolCallId ? pendingArgs.get(ev.toolCallId) : undefined;
+            if (ev.toolCallId) pendingArgs.delete(ev.toolCallId);
+            let resultDisplay: { body?: { kind: "diff"; diff: unknown; filePath: string } } | undefined;
+            if (ev.toolName === "edit" && typeof args?.path === "string") {
+              const rawDiff = ev.result?.details?.diff;
+              const parsed = parsePiDiff(rawDiff);
+              if (parsed) {
+                resultDisplay = {
+                  body: { kind: "diff", diff: parsed, filePath: args.path },
+                };
+              }
+            } else if (ev.toolName === "write" && typeof args?.path === "string" && !ev.isError) {
+              const snap = ev.toolCallId ? pendingWriteSnapshot.get(ev.toolCallId) : undefined;
+              if (ev.toolCallId) pendingWriteSnapshot.delete(ev.toolCallId);
+              if (snap) {
+                const newContent = typeof args.content === "string" ? args.content : "";
+                const built = buildDiffFromTexts(snap.oldContent, newContent, snap.isNewFile);
+                if (built) {
+                  resultDisplay = {
+                    body: { kind: "diff", diff: built, filePath: args.path },
+                  };
+                }
+              }
+            }
             bus.emit("agent:tool-completed", {
-              toolCallId: (event as any).toolCallId,
-              exitCode: (event as any).isError ? 1 : 0,
-              kind: (event as any).toolName === "bash" ? "execute" : "read",
+              toolCallId: ev.toolCallId,
+              exitCode: ev.isError ? 1 : 0,
+              kind: kindForTool(ev.toolName),
+              rawOutput: ev.result,
+              resultDisplay,
             });
             break;
+          }
 
           case "agent_end":
             bus.emitTransform("agent:response-done", {
@@ -120,7 +272,6 @@ export default function activate(ctx: ExtensionContext): void {
         }
       });
 
-      // Report model info
       const model = session.model;
       bus.emit("agent:info", {
         name: "pi",
@@ -137,8 +288,10 @@ export default function activate(ctx: ExtensionContext): void {
     }
   };
 
-  // ── Bus listeners (wired on start, unwired on kill) ────────────
-  const listeners: Array<{ event: string; fn: Function }> = [];
+  type ListenerEntry =
+    | { kind: "on"; event: string; fn: Function }
+    | { kind: "pipe"; event: string; fn: Function };
+  const listeners: ListenerEntry[] = [];
 
   const wireListeners = () => {
     const onSubmit = async ({ query }: any) => {
@@ -153,8 +306,12 @@ export default function activate(ctx: ExtensionContext): void {
       bus.emit("agent:query", { query });
       bus.emit("agent:processing-start", {});
 
+      // Inline producers raw — outputs already self-tag (<shell_events>...).
+      const ctxText = String(call("query-context:build") ?? "").trim();
+      const final = ctxText ? `${ctxText}\n\n${query}` : query;
+
       try {
-        await session.prompt(query);
+        await session.prompt(final);
       } catch (err) {
         bus.emit("agent:error", {
           message: err instanceof Error ? err.message : String(err),
@@ -169,33 +326,148 @@ export default function activate(ctx: ExtensionContext): void {
       session = runtime?.session;
     };
 
+    const onListModels = () => {
+      if (!session || !modelRegistry) return { models: [], active: null };
+      const all = modelRegistry.getAvailable() as Array<{ id: string; provider: string }>;
+      const cur = session.model;
+      return {
+        models: all.map((m) => ({ model: m.id, provider: m.provider })),
+        active: cur ? { model: cur.id, provider: cur.provider } : null,
+      };
+    };
+
+    // Slash command emits `model@provider` for disambiguation; pi looks up by (provider, id).
+    const onSwitchModel = async ({ model: target }: { model: string }) => {
+      if (!session || !modelRegistry) return;
+      const atIdx = target.lastIndexOf("@");
+      const modelId = atIdx > 0 ? target.slice(0, atIdx) : target;
+      const providerHint = atIdx > 0 ? target.slice(atIdx + 1) : undefined;
+
+      const candidates = (modelRegistry.getAvailable() as Array<{ id: string; provider: string }>)
+        .filter((m) => m.id === modelId && (!providerHint || m.provider === providerHint));
+
+      if (candidates.length === 0) {
+        bus.emit("ui:error", { message: `Unknown model: ${target}` });
+        return;
+      }
+      if (candidates.length > 1) {
+        const opts = candidates.map((m) => `${m.id}@${m.provider}`).join(", ");
+        bus.emit("ui:error", { message: `Ambiguous model "${modelId}". Use one of: ${opts}` });
+        return;
+      }
+      const picked = candidates[0]!;
+      const full = modelRegistry.find(picked.provider, picked.id);
+      if (!full) {
+        bus.emit("ui:error", { message: `Model not found: ${target}` });
+        return;
+      }
+      try {
+        await session.setModel(full);
+        bus.emit("agent:info", {
+          name: "pi",
+          version: "0.66",
+          model: `${picked.provider}/${picked.id}`,
+        });
+        bus.emit("ui:info", { message: `Model: ${picked.provider}: ${picked.id}` });
+        bus.emit("config:changed", {});
+      } catch (err) {
+        bus.emit("ui:error", {
+          message: `Failed to switch model: ${err instanceof Error ? err.message : String(err)}`,
+        });
+      }
+    };
+
+    const onGetThinking = () => {
+      const level = session?.thinkingLevel ?? "off";
+      return { level, levels: [...PI_THINKING_LEVELS], supported: true };
+    };
+
+    const onSetThinking = ({ level }: { level: string }) => {
+      if (!session) return;
+      if (!PI_THINKING_LEVELS.includes(level as any)) {
+        bus.emit("ui:error", {
+          message: `Unknown thinking level: ${level}. Use: ${PI_THINKING_LEVELS.join(", ")}`,
+        });
+        return;
+      }
+      session.setThinkingLevel(level);
+      bus.emit("ui:info", { message: `Thinking: ${level}` });
+      bus.emit("config:changed", {});
+    };
+
     bus.on("agent:submit", onSubmit);
     bus.on("agent:cancel-request", onCancel);
     bus.on("agent:reset-session", onReset);
+    bus.on("config:switch-model", onSwitchModel as any);
+    bus.on("config:set-thinking", onSetThinking as any);
+    bus.onPipe("config:get-models", onListModels as any);
+    bus.onPipe("config:get-thinking", onGetThinking as any);
     listeners.push(
-      { event: "agent:submit", fn: onSubmit },
-      { event: "agent:cancel-request", fn: onCancel },
-      { event: "agent:reset-session", fn: onReset },
+      { kind: "on", event: "agent:submit", fn: onSubmit },
+      { kind: "on", event: "agent:cancel-request", fn: onCancel },
+      { kind: "on", event: "agent:reset-session", fn: onReset },
+      { kind: "on", event: "config:switch-model", fn: onSwitchModel },
+      { kind: "on", event: "config:set-thinking", fn: onSetThinking },
+      { kind: "pipe", event: "config:get-models", fn: onListModels },
+      { kind: "pipe", event: "config:get-thinking", fn: onGetThinking },
     );
   };
 
   const unwireListeners = () => {
-    for (const { event, fn } of listeners) bus.off(event as any, fn as any);
+    for (const { kind, event, fn } of listeners) {
+      if (kind === "pipe") bus.offPipe(event as any, fn as any);
+      else bus.off(event as any, fn as any);
+    }
     listeners.length = 0;
   };
 
-  // ── Register as backend ───────────────────────────────────────
   bus.emit("agent:register-backend", {
     name: "pi",
     start: async () => {
       await boot();
       wireListeners();
+      bus.emit("command:register", {
+        name: "/compact",
+        description: "Compact pi's session context",
+        handler: async () => {
+          if (!session) return;
+          try {
+            await session.compact();
+            bus.emit("ui:info", { message: "(compacted)" });
+          } catch (err) {
+            bus.emit("ui:info", {
+              message: `(${err instanceof Error ? err.message : String(err)})`,
+            });
+          }
+        },
+      });
+      bus.emit("command:register", {
+        name: "/context",
+        description: "Show pi's context budget usage",
+        handler: () => {
+          if (!session) return;
+          const usage = session.getContextUsage() as { tokens: number; contextWindow: number } | undefined;
+          if (!usage) {
+            bus.emit("ui:info", { message: "Context: not available yet" });
+            return;
+          }
+          const pct = usage.contextWindow > 0
+            ? Math.round((usage.tokens / usage.contextWindow) * 100)
+            : 0;
+          bus.emit("ui:info", {
+            message: `Active context: ~${usage.tokens.toLocaleString()} tokens / ${usage.contextWindow.toLocaleString()} budget (${pct}%)`,
+          });
+        },
+      });
     },
     kill: () => {
+      bus.emit("command:unregister", { name: "/compact" });
+      bus.emit("command:unregister", { name: "/context" });
       unwireListeners();
       runtime?.dispose();
       session = null;
       runtime = null;
+      modelRegistry = null;
       booting = true;
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.12.20",
+  "version": "0.12.22",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",

package/dist/extensions/openai.d.ts

@@ -1,9 +0,0 @@
-/**
- * Built-in OpenAI-compatible provider. Two activation paths:
- *   - OPENAI_API_KEY only       → cloud OpenAI, ships a curated catalog.
- *   - OPENAI_BASE_URL (any key) → local/3rd-party server (Ollama, LM Studio,
- *                                  vLLM, llama.cpp); the catalog is fetched
- *                                  from the server's /models endpoint.
- */
-import type { ExtensionContext } from "../types.js";
-export default function activate(ctx: ExtensionContext): void;