agent-sh 0.12.10 → 0.12.11

package/dist/agent/agent-loop.js

@@ -226,7 +226,10 @@ export class AgentLoop {
             this.abortController?.abort(e.silent ? "silent" : undefined);
         });
         on("config:switch-model", ({ model: target }) => {
-            const idx = this.modes.findIndex((m) => m.model === target);
+            const atIdx = target.lastIndexOf("@");
+            const modelId = atIdx > 0 ? target.slice(0, atIdx) : target;
+            const providerHint = atIdx > 0 ? target.slice(atIdx + 1) : undefined;
+            const idx = this.modes.findIndex((m) => m.model === modelId && (!providerHint || m.provider === providerHint));
             if (idx === -1) {
                 this.bus.emit("ui:error", { message: `Unknown model: ${target}` });
                 return;
@@ -259,7 +262,8 @@ export class AgentLoop {
         });
         this.bus.onPipe("config:get-models", (payload) => {
             const models = this.modes.map((m) => ({ model: m.model, provider: m.provider ?? "" }));
-            const active = this.modes[this.currentModeIndex]?.model ?? null;
+            const cur = this.modes[this.currentModeIndex];
+            const active = cur ? { model: cur.model, provider: cur.provider ?? "" } : null;
             return { models, active };
         });
         on("config:set-thinking", ({ level }) => {

package/dist/event-bus.d.ts

@@ -279,7 +279,10 @@ export interface ShellEvents {
             model: string;
             provider: string;
         }[];
-        active: string | null;
+        active: {
+            model: string;
+            provider: string;
+        } | null;
     };
     "config:set-thinking": {
         level: string;

package/dist/extensions/slash-commands.js

@@ -37,11 +37,10 @@ export default function activate(ctx) {
         handler: (args) => {
             const name = args.trim();
             if (!name) {
-                const { models, active } = bus.emitPipe("config:get-models", { models: [], active: null });
-                const current = models.find((m) => m.model === active);
-                const label = current
-                    ? `${current.model}${current.provider ? ` [${current.provider}]` : ""}`
-                    : active ?? "none";
+                const { active } = bus.emitPipe("config:get-models", { models: [], active: null });
+                const label = active
+                    ? `${active.model}${active.provider ? ` [${active.provider}]` : ""}`
+                    : "none";
                 bus.emit("ui:info", { message: `Model: ${label}` });
             }
             else {
@@ -180,13 +179,20 @@ export default function activate(ctx) {
             return payload;
         const partial = (payload.commandArgs ?? "").toLowerCase();
         const { models, active } = bus.emitPipe("config:get-models", { models: [], active: null });
+        const counts = new Map();
+        for (const m of models)
+            counts.set(m.model, (counts.get(m.model) ?? 0) + 1);
         const items = models
             .filter((m) => m.model.toLowerCase().includes(partial))
             .slice(0, 15)
-            .map((m) => ({
-            name: `/model ${m.model}`,
-            description: `${m.provider ? `[${m.provider}]` : ""}${m.model === active ? " (active)" : ""}`,
-        }));
+            .map((m) => {
+            const ambiguous = (counts.get(m.model) ?? 0) > 1 && m.provider;
+            const qualified = ambiguous ? `${m.model}@${m.provider}` : m.model;
+            return {
+                name: `/model ${qualified}`,
+                description: `${m.provider ? `[${m.provider}]` : ""}${active && m.model === active.model && m.provider === active.provider ? " (active)" : ""}`,
+            };
+        });
         if (items.length === 0)
             return payload;
         return { ...payload, items: [...payload.items, ...items] };

package/dist/init.js

@@ -37,9 +37,7 @@ const EXAMPLE_SETTINGS = {
             defaultModel: "llama3.3",
         },
     },
-    extensions: [
-        "./examples/extensions/openrouter.ts",
-    ],
+    extensions: [],
     disabledBuiltins: [],
     disabledExtensions: [],
 };

package/examples/extensions/ollama.ts

@@ -0,0 +1,96 @@
+/**
+ * Ollama provider extension — local daemon and Ollama Cloud.
+ *
+ *   OLLAMA_API_KEY  → Ollama Cloud (https://ollama.com)
+ *   OLLAMA_HOST     → local host override (default http://localhost:11434)
+ *
+ * Catalog comes from /api/tags; per-model context length is fetched
+ * from /api/show (model_info["${arch}.context_length"]). Chat goes
+ * through the OpenAI-compatible /v1/chat/completions shim.
+ *
+ * Setup (cloud):
+ *   export OLLAMA_API_KEY="your-key"
+ *
+ * Setup (local):
+ *   ollama serve   # default http://localhost:11434
+ *
+ * Usage:
+ *   agent-sh -e ./examples/extensions/ollama.ts
+ *
+ *   # Or add to settings.json:
+ *   { "extensions": ["./examples/extensions/ollama.ts"] }
+ */
+import type { ExtensionContext } from "agent-sh/types";
+
+const ECHO_REASONING_PATTERNS: RegExp[] = [/deepseek/i];
+
+export default function activate(ctx: ExtensionContext): void {
+  const apiKey = process.env.OLLAMA_API_KEY;
+  const host = apiKey
+    ? "https://ollama.com"
+    : (process.env.OLLAMA_HOST ?? "http://localhost:11434").replace(/\/$/, "");
+  const id = apiKey ? "ollama-cloud" : "ollama";
+
+  // OpenAI SDK rejects an empty apiKey; the local daemon ignores the value.
+  const sdkKey = apiKey || "no-key";
+  const baseURL = `${host}/v1`;
+  const headers: Record<string, string> = {};
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+
+  ctx.bus.emit("provider:register", { id, apiKey: sdkKey, baseURL, models: [] });
+
+  fetchCatalog(host, headers).then((models) => {
+    if (models.length === 0) return;
+    ctx.bus.emit("provider:register", {
+      id,
+      apiKey: sdkKey,
+      baseURL,
+      defaultModel: models[0]!.id,
+      models,
+    });
+  }).catch(() => { /* leave empty — user supplies via --model */ });
+}
+
+async function fetchCatalog(
+  host: string,
+  headers: Record<string, string>,
+): Promise<{ id: string; contextWindow?: number; echoReasoning: boolean }[]> {
+  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 === 0) return [];
+
+  const ctxs = await Promise.all(
+    names.map((name) => fetchContextLength(host, headers, name).catch(() => undefined)),
+  );
+  return names.map((name, i) => ({
+    id: name,
+    contextWindow: ctxs[i],
+    echoReasoning: ECHO_REASONING_PATTERNS.some((re) => re.test(name)),
+  }));
+}
+
+async function fetchContextLength(
+  host: string,
+  headers: Record<string, string>,
+  name: string,
+): Promise<number | undefined> {
+  const res = await fetch(`${host}/api/show`, {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: JSON.stringify({ name }),
+  });
+  if (!res.ok) return undefined;
+  const data = await res.json() as { model_info?: Record<string, unknown> };
+  const info = data.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;
+}

package/examples/extensions/peer-mesh.ts

@@ -1,27 +1,13 @@
 /**
- * Peer mesh — cross-instance communication for agent-sh.
+ * Peer mesh — cross-instance discovery + RPC over Unix sockets.
  *
- * Lets all running ash instances discover each other and communicate.
- * Inspired by Ray's @ray.remote: opt-in exposure of named handlers,
- * transparent network calls, automatic discovery.
- *
- * What this extension provides:
- *   1. PeerServer — Unix socket server + peer file registry + client
- *   2. Standard exposed handlers — terminal read, context, search
- *   3. Agent tools — peers, peer_terminal, peer_history, peer_search
- *   4. Handler registry API — peer:call, peer:discover, peer:expose
- *      for other extensions to use
+ * Each running ash exposes a small set of named handlers; tools let the
+ * agent enumerate peers, read another peer's terminal, drive its keys,
+ * send messages, and ask synchronous questions.
  *
  * Usage:
  *   ash -e ./examples/extensions/peer-mesh.ts
- *
- *   # Or install permanently
  *   cp examples/extensions/peer-mesh.ts ~/.agent-sh/extensions/
- *
- * Other extensions can depend on this via the handler registry:
- *   ctx.define("my:data", () => computeData());
- *   ctx.call("peer:expose", "my:data");
- *   const result = await ctx.call("peer:call", peerId, "my:data");
  */
 import * as fs from "node:fs";
 import * as net from "node:net";
@@ -29,8 +15,6 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionContext } from "agent-sh/types";
 
-// ── Types ──────────────────────────────────────────────────────
-
 interface PeerInfo {
   id: string;
   pid: number;
@@ -39,20 +23,19 @@ interface PeerInfo {
   startTime: number;
 }
 
-interface RpcRequest {
-  method: string;
-  args: unknown[];
-}
-
-interface RpcResponse {
-  ok: boolean;
-  result?: unknown;
-  error?: string;
-}
-
-// ── Paths ──────────────────────────────────────────────────────
+interface RpcRequest { method: string; args: unknown[]; }
+interface RpcResponse { ok: boolean; result?: unknown; error?: string; }
+interface InboxEntry { from: string; text: string; at: number; }
 
 const PEERS_DIR = path.join(os.homedir(), ".agent-sh", "peers");
+const MAX_SEND_BYTES = 2048;
+const DEFAULT_TIMEOUT_MS = 5_000;
+const ASK_TIMEOUT_MS = 120_000;
+const ASK_QUEUE_MAX = 3;
+const SETTLE_MS = 400;
+const IDLE_GUARD_MS = 500;
+const INBOX_MAX = 100;
+const LONG_TIMEOUT_METHODS = new Set<string>(["peer:ask"]);
 
 function peerFilePath(id: string): string {
   return path.join(PEERS_DIR, `${id}.json`);
@@ -62,7 +45,18 @@ function socketPath(pid: number): string {
   return path.join(os.tmpdir(), `agent-sh-peer-${pid}.sock`);
 }
 
-// ── PeerServer ─────────────────────────────────────────────────
+// Expand backslash escapes so callers can send Enter / Ctrl-keys via JSON.
+function interpretEscapes(s: string): string {
+  return s.replace(/\\(x[0-9a-fA-F]{2}|r|n|t|\\|0)/g, (_, seq: string) => {
+    if (seq === "r") return "\r";
+    if (seq === "n") return "\n";
+    if (seq === "t") return "\t";
+    if (seq === "\\") return "\\";
+    if (seq === "0") return "\0";
+    if (seq.startsWith("x")) return String.fromCharCode(parseInt(seq.slice(1), 16));
+    return seq;
+  });
+}
 
 class PeerServer {
   private server: net.Server | null = null;
@@ -85,24 +79,13 @@ class PeerServer {
     };
   }
 
-  // ── Lifecycle ──────────────────────────────────────────────
-
   start(): void {
-    // Ensure peers directory exists
     fs.mkdirSync(PEERS_DIR, { recursive: true });
-
-    // Clean up stale socket
     try { fs.unlinkSync(this.info.socketPath); } catch {}
-
-    // Start Unix socket server
     this.server = net.createServer((conn) => this.handleConnection(conn));
-    this.server.on("error", () => {}); // swallow server errors
+    this.server.on("error", () => {});
     this.server.listen(this.info.socketPath);
-
-    // Register peer file
     fs.writeFileSync(peerFilePath(this.info.id), JSON.stringify(this.info));
-
-    // Cleanup on exit
     const cleanup = () => this.stop();
     process.on("exit", cleanup);
     process.on("SIGTERM", () => { cleanup(); process.exit(0); });
@@ -110,89 +93,68 @@ class PeerServer {
   }
 
   stop(): void {
-    if (this.server) {
-      try { this.server.close(); } catch {}
-      this.server = null;
-    }
+    if (this.server) { try { this.server.close(); } catch {} this.server = null; }
     try { fs.unlinkSync(this.info.socketPath); } catch {}
     try { fs.unlinkSync(peerFilePath(this.info.id)); } catch {}
   }
 
-  // ── Expose / discover / call ───────────────────────────────
+  expose(name: string): void { this.exposed.add(name); }
 
-  expose(name: string): void {
-    this.exposed.add(name);
+  updateCwd(cwd: string): void {
+    this.info.cwd = cwd;
+    try { fs.writeFileSync(peerFilePath(this.info.id), JSON.stringify(this.info)); } catch {}
   }
 
   discover(): PeerInfo[] {
     const peers: PeerInfo[] = [];
     let entries: string[];
     try { entries = fs.readdirSync(PEERS_DIR); } catch { return []; }
-
     for (const entry of entries) {
       if (!entry.endsWith(".json")) continue;
       try {
-        const raw = fs.readFileSync(path.join(PEERS_DIR, entry), "utf-8");
-        const info: PeerInfo = JSON.parse(raw);
-        // Skip self
+        const info: PeerInfo = JSON.parse(fs.readFileSync(path.join(PEERS_DIR, entry), "utf-8"));
         if (info.id === this.info.id) continue;
-        // Check if process is alive
         try { process.kill(info.pid, 0); } catch {
-          // Stale — prune
           try { fs.unlinkSync(path.join(PEERS_DIR, entry)); } catch {}
           continue;
         }
         peers.push(info);
-      } catch {
-        // Malformed file — skip
-      }
+      } catch { /* skip */ }
     }
     return peers;
   }
 
   async call(peerId: string, method: string, ...args: unknown[]): Promise<unknown> {
-    // Find peer socket path
-    const peers = this.discover();
-    const peer = peers.find((p) => p.id === peerId);
+    const peer = this.discover().find((p) => p.id === peerId);
     if (!peer) throw new Error(`Peer "${peerId}" not found`);
-
     return this.callSocket(peer.socketPath, method, args);
   }
 
-  // ── Private ────────────────────────────────────────────────
-
   private handleConnection(conn: net.Socket): void {
     let buffer = "";
-    conn.on("data", (data) => {
+    conn.on("data", async (data) => {
       buffer += data.toString();
       const newlineIdx = buffer.indexOf("\n");
       if (newlineIdx === -1) return;
-
       const line = buffer.slice(0, newlineIdx);
       buffer = buffer.slice(newlineIdx + 1);
-
       let response: RpcResponse;
       try {
         const req: RpcRequest = JSON.parse(line);
         if (!this.exposed.has(req.method)) {
           response = { ok: false, error: `Handler "${req.method}" is not exposed` };
         } else {
-          const result = this.callHandler(req.method, ...(req.args ?? []));
+          const result = await this.callHandler(req.method, ...(req.args ?? []));
           response = { ok: true, result };
         }
       } catch (e) {
         response = { ok: false, error: e instanceof Error ? e.message : String(e) };
       }
-
-      try {
-        conn.write(JSON.stringify(response) + "\n");
-      } catch {}
+      try { conn.write(JSON.stringify(response) + "\n"); } catch {}
       conn.end();
     });
-
     conn.on("error", () => {});
-    // Timeout in case client hangs
-    conn.setTimeout(5000, () => conn.destroy());
+    conn.setTimeout(ASK_TIMEOUT_MS + 5_000, () => conn.destroy());
   }
 
   private callSocket(sockPath: string, method: string, args: unknown[]): Promise<unknown> {
@@ -200,44 +162,33 @@ class PeerServer {
       const conn = net.createConnection(sockPath);
       let buffer = "";
       let settled = false;
-
-      const settle = (fn: () => void) => {
-        if (settled) return;
-        settled = true;
-        fn();
-      };
-
+      const settle = (fn: () => void) => { if (!settled) { settled = true; fn(); } };
       conn.on("connect", () => {
         const req: RpcRequest = { method, args };
         conn.write(JSON.stringify(req) + "\n");
       });
-
       conn.on("data", (data) => {
         buffer += data.toString();
         const newlineIdx = buffer.indexOf("\n");
         if (newlineIdx === -1) return;
-
-        const line = buffer.slice(0, newlineIdx);
         try {
-          const resp: RpcResponse = JSON.parse(line);
+          const resp: RpcResponse = JSON.parse(buffer.slice(0, newlineIdx));
           settle(() => resp.ok ? resolve(resp.result) : reject(new Error(resp.error)));
         } catch (e) {
           settle(() => reject(e));
         }
         conn.end();
       });
-
       conn.on("error", (e) => settle(() => reject(e)));
-      conn.setTimeout(5000, () => settle(() => {
-        reject(new Error("Peer call timed out"));
+      const timeout = LONG_TIMEOUT_METHODS.has(method) ? ASK_TIMEOUT_MS : DEFAULT_TIMEOUT_MS;
+      conn.setTimeout(timeout, () => settle(() => {
+        reject(new Error(`Peer call timed out after ${timeout}ms`));
         conn.destroy();
       }));
     });
   }
 }
 
-// ── Extension ──────────────────────────────────────────────────
-
 export default function activate(ctx: ExtensionContext): void {
   const { bus, contextManager, registerCommand, registerTool, registerInstruction, define } = ctx;
   const startTime = Date.now();
@@ -245,7 +196,9 @@ export default function activate(ctx: ExtensionContext): void {
   const server = new PeerServer(ctx.instanceId, contextManager.getCwd(), (...args) => ctx.call(...args));
   server.start();
 
-  // ── Standard handlers (define + expose) ────────────────────
+  // Track PTY idle window so peer:terminal-send doesn't stomp on a busy shell.
+  let lastPtyOutputTs = startTime;
+  bus.on("shell:pty-data", () => { lastPtyOutputTs = Date.now(); });
 
   define("peer:info", () => ({
     id: ctx.instanceId,
@@ -262,69 +215,111 @@ export default function activate(ctx: ExtensionContext): void {
   });
   server.expose("peer:terminal-read");
 
+  define("peer:terminal-send", async (keys: string, requireIdleMs?: number, settleMs?: number) => {
+    if (typeof keys !== "string" || keys.length === 0) {
+      throw new Error("peer:terminal-send requires non-empty keys string");
+    }
+    if (Buffer.byteLength(keys, "utf-8") > MAX_SEND_BYTES) {
+      throw new Error(`keys payload exceeds ${MAX_SEND_BYTES} bytes`);
+    }
+    const threshold = typeof requireIdleMs === "number" ? requireIdleMs : IDLE_GUARD_MS;
+    const idleMs = Date.now() - lastPtyOutputTs;
+    if (idleMs < threshold) {
+      return { sent: false, reason: "not_idle", idle_ms: idleMs, required_ms: threshold };
+    }
+    bus.emit("shell:pty-write", { data: interpretEscapes(keys) });
+    await new Promise((r) => setTimeout(r, typeof settleMs === "number" ? settleMs : SETTLE_MS));
+    const tb = ctx.terminalBuffer;
+    return { sent: true, screen: tb ? tb.readScreen({ includeScrollback: false }) : null };
+  });
+  server.expose("peer:terminal-send");
+
   define("peer:context-recent", (n: number = 15) => contextManager.getRecentSummary(n));
   server.expose("peer:context-recent");
 
   define("peer:context-search", (query: string) => contextManager.search(query));
   server.expose("peer:context-search");
 
-  // ── Inter-peer messaging ───────────────────────────────────
-
-  interface InboxEntry { from: string; text: string; at: number; }
+  // ── Inbox + drained turn ──────────────────────────────────────
   const inbox: InboxEntry[] = [];
-  const INBOX_MAX = 100;
-
   const pending: InboxEntry[] = [];
+  let busy = false;
+
+  function drainPending(): void {
+    if (busy || pending.length === 0) return;
+    const batch = pending.splice(0, pending.length);
+    const lines = batch.map((e) => `[from peer ${e.from}] ${e.text}`);
+    busy = true;
+    bus.emit("agent:submit", {
+      query: [
+        "You received message(s) from other peer(s) in the mesh:",
+        "",
+        ...lines,
+        "",
+        "Decide whether to reply (via `peer_send`), act on the request, or note and continue.",
+      ].join("\n"),
+    });
+  }
+
+  bus.on("agent:processing-done", () => { busy = false; setTimeout(drainPending, 100); });
 
   define("peer:message", (from: string, text: string) => {
     if (typeof from !== "string" || typeof text !== "string") {
       throw new Error("peer:message requires (from: string, text: string)");
     }
+    if (Buffer.byteLength(text, "utf-8") > MAX_SEND_BYTES) {
+      throw new Error(`text payload exceeds ${MAX_SEND_BYTES} bytes`);
+    }
     const entry: InboxEntry = { from, text, at: Date.now() };
     inbox.push(entry);
     if (inbox.length > INBOX_MAX) inbox.splice(0, inbox.length - INBOX_MAX);
     pending.push(entry);
-    bus.emit("peer:message-received", entry);
     bus.emit("ui:info", { message: `[peer ${from}] ${text}` });
     setTimeout(drainPending, 100);
     return { ok: true };
   });
   server.expose("peer:message");
 
-  // Drain pending peer messages by injecting a synthetic user turn.
-  // Only one submission per processing cycle — wait for agent:processing-done
-  // before releasing the next batch.
-  let busy = false;
-
-  function drainPending(): void {
-    if (busy || pending.length === 0) return;
-    const batch = pending.splice(0, pending.length);
-    const lines = batch.map((e) => `[from peer ${e.from}] ${e.text}`);
-    const query = [
-      "You received message(s) from other peer(s) in the mesh:",
-      "",
-      ...lines,
-      "",
-      "Decide whether to reply (via `peer_send`), act on the request, or note and continue.",
-    ].join("\n");
-    busy = true;
-    bus.emit("agent:submit", { query });
-  }
+  // ── Synchronous Q&A: peer A asks B, blocks until B's next turn answers ──
+  interface AskSlot { resolve: (answer: string) => void; reject: (e: Error) => void; from: string; question: string; }
+  const askQueue: AskSlot[] = [];
 
-  bus.on("agent:processing-done", () => {
-    busy = false;
-    setTimeout(drainPending, 100);
+  define("peer:ask", (from: string, question: string) => {
+    if (typeof from !== "string" || typeof question !== "string") {
+      throw new Error("peer:ask requires (from: string, question: string)");
+    }
+    if (askQueue.length >= ASK_QUEUE_MAX) {
+      throw new Error(`peer:ask queue full (max ${ASK_QUEUE_MAX})`);
+    }
+    if (Buffer.byteLength(question, "utf-8") > MAX_SEND_BYTES) {
+      throw new Error(`question payload exceeds ${MAX_SEND_BYTES} bytes`);
+    }
+    return new Promise<string>((resolve, reject) => {
+      const slot: AskSlot = { resolve, reject, from, question };
+      askQueue.push(slot);
+      const timer = setTimeout(() => {
+        const idx = askQueue.indexOf(slot);
+        if (idx >= 0) askQueue.splice(idx, 1);
+        reject(new Error("peer:ask timed out"));
+      }, ASK_TIMEOUT_MS);
+      bus.emit("ui:info", { message: `[peer ${from} asks] ${question}` });
+      bus.emit("agent:submit", {
+        query: [
+          `Peer ${from} asks: ${question}`,
+          "",
+          "Answer with `peer_answer` (your reply will be returned synchronously).",
+        ].join("\n"),
+      });
+      // Once resolved/rejected by peer_answer, clear the timer.
+      const origResolve = slot.resolve;
+      const origReject = slot.reject;
+      slot.resolve = (a) => { clearTimeout(timer); origResolve(a); };
+      slot.reject = (e) => { clearTimeout(timer); origReject(e); };
+    });
   });
+  server.expose("peer:ask");
 
-  // ── Handler registry API (for other extensions) ────────────
-
-  define("peer:discover", () => server.discover());
-  define("peer:call", (peerId: string, method: string, ...args: unknown[]) =>
-    server.call(peerId, method, ...args));
-  define("peer:expose", (name: string) => server.expose(name));
-
-  // ── Agent tools ────────────────────────────────────────────
-
+  // ── Tools ─────────────────────────────────────────────────────
   registerTool({
     name: "peers",
     description: "List all running agent-sh instances that can be communicated with.",
@@ -332,63 +327,85 @@ export default function activate(ctx: ExtensionContext): void {
     showOutput: false,
     getDisplayInfo: () => ({ kind: "search" as const }),
     formatCall: () => "discovering peers",
-
     async execute() {
       const peers = server.discover();
       if (peers.length === 0) {
         return { content: "No other agent-sh instances found.", exitCode: 0, isError: false };
       }
       const lines = peers.map((p) =>
-        `- id: ${p.id}, pid: ${p.pid}, cwd: ${p.cwd}, uptime: ${Math.round((Date.now() - p.startTime) / 1000)}s`
+        `- id: ${p.id}, pid: ${p.pid}, cwd: ${p.cwd}, uptime: ${Math.round((Date.now() - p.startTime) / 1000)}s`,
       );
-      return {
-        content: `Found ${peers.length} peer(s):\n${lines.join("\n")}`,
-        exitCode: 0,
-        isError: false,
-      };
+      return { content: `Found ${peers.length} peer(s):\n${lines.join("\n")}`, exitCode: 0, isError: false };
     },
-
-    formatResult: (_args, result) => ({
-      summary: result.content.startsWith("No") ? "none found" : result.content.split("\n")[0],
-    }),
+    formatResult: (_a, r) => ({ summary: r.content.startsWith("No") ? "none found" : r.content.split("\n")[0] }),
   });
 
   registerTool({
     name: "peer_terminal",
-    description: "Read the terminal screen content of another running agent-sh instance. Shows what is currently visible on their terminal.",
+    description: "Read the terminal screen content of another running agent-sh instance.",
     input_schema: {
       type: "object",
-      properties: {
-        peer_id: { type: "string", description: "The instance ID of the peer (from the peers tool)." },
-      },
+      properties: { peer_id: { type: "string", description: "Instance ID of the peer (from `peers`)." } },
       required: ["peer_id"],
     },
     showOutput: false,
     getDisplayInfo: () => ({ kind: "read" as const }),
-    formatCall: (args) => `peer ${args.peer_id}`,
-
+    formatCall: (a) => `peer ${a.peer_id}`,
     async execute(args) {
       try {
         const screen = await server.call(args.peer_id as string, "peer:terminal-read") as any;
         const text = screen?.text?.trim() || "(empty screen)";
         const alt = screen?.altScreen ? " [alternate screen active]" : "";
-        return {
-          content: `Terminal content from peer ${args.peer_id}${alt}:\n\n${text}`,
-          exitCode: 0,
-          isError: false,
-        };
+        return { content: `Terminal content from peer ${args.peer_id}${alt}:\n\n${text}`, exitCode: 0, isError: false };
       } catch (e) {
-        return {
-          content: `Failed to read peer terminal: ${e instanceof Error ? e.message : String(e)}`,
-          exitCode: 1,
-          isError: true,
-        };
+        return { content: `Failed to read peer terminal: ${e instanceof Error ? e.message : String(e)}`, exitCode: 1, isError: true };
       }
     },
+    formatResult: (_a, r) => ({ summary: r.isError ? "failed" : `${r.content.split("\n").length - 2} lines` }),
+  });
 
-    formatResult: (_args, result) => ({
-      summary: result.isError ? "failed" : `${result.content.split("\n").length - 2} lines`,
-    }),
+  registerTool({
+    name: "peer_terminal_send",
+    description:
+      "Type keys into another peer's terminal PTY. Supports backslash escapes " +
+      "(`\\r` for Enter, `\\n`, `\\t`, `\\xNN` for raw bytes, `\\\\` for literal backslash). " +
+      "Refuses to send if the peer's PTY produced output within the idle threshold (default 500ms).",
+    input_schema: {
+      type: "object",
+      properties: {
+        peer_id: { type: "string", description: "Instance ID of the peer." },
+        keys: { type: "string", description: "Key sequence to send. Append `\\r` to submit a command." },
+        require_idle_ms: { type: "number", description: "Refuse if peer was active within this many ms (default 500)." },
+        settle_ms: { type: "number", description: "Wait this long after sending before reading the screen back (default 400)." },
+      },
+      required: ["peer_id", "keys"],
+    },
+    showOutput: false,
+    getDisplayInfo: () => ({ kind: "write" as const }),
+    formatCall: (a) => `peer ${a.peer_id}: ${JSON.stringify(String(a.keys).slice(0, 40))}`,
+    async execute(args) {
+      try {
+        const result = await server.call(
+          args.peer_id as string,
+          "peer:terminal-send",
+          args.keys,
+          args.require_idle_ms,
+          args.settle_ms,
+        ) as { sent: boolean; reason?: string; idle_ms?: number; required_ms?: number; screen?: { text: string } | null };
+        if (!result.sent) {
+          return {
+            content: `Refused to send: peer is busy (${result.reason}; idle ${result.idle_ms}ms / required ${result.required_ms}ms).`,
+            exitCode: 1,
+            isError: true,
+          };
+        }
+        const screen = result.screen?.text?.trim() ?? "(no screen capture)";
+        return { content: `Sent. Screen after settle:\n\n${screen}`, exitCode: 0, isError: false };
+      } catch (e) {
+        return { content: `Failed to send keys: ${e instanceof Error ? e.message : String(e)}`, exitCode: 1, isError: true };
+      }
+    },
+    formatResult: (_a, r) => ({ summary: r.isError ? "failed" : "sent" }),
   });
 
   registerTool({
@@ -397,32 +414,23 @@ export default function activate(ctx: ExtensionContext): void {
     input_schema: {
       type: "object",
       properties: {
-        peer_id: { type: "string", description: "The instance ID of the peer." },
-        count: { type: "number", description: "Number of recent exchanges to return (default: 15)." },
+        peer_id: { type: "string" },
+        count: { type: "number", description: "Number of recent exchanges (default 15)." },
       },
       required: ["peer_id"],
     },
     showOutput: false,
     getDisplayInfo: () => ({ kind: "read" as const }),
-    formatCall: (args) => `peer ${args.peer_id}`,
-
+    formatCall: (a) => `peer ${a.peer_id}`,
     async execute(args) {
       try {
-        const n = (args.count as number) || 15;
-        const summary = await server.call(args.peer_id as string, "peer:context-recent", n) as string;
+        const summary = await server.call(args.peer_id as string, "peer:context-recent", (args.count as number) || 15) as string;
         return { content: summary || "(no history)", exitCode: 0, isError: false };
       } catch (e) {
-        return {
-          content: `Failed to read peer history: ${e instanceof Error ? e.message : String(e)}`,
-          exitCode: 1,
-          isError: true,
-        };
+        return { content: `Failed to read peer history: ${e instanceof Error ? e.message : String(e)}`, exitCode: 1, isError: true };
       }
     },
-
-    formatResult: (_args, result) => ({
-      summary: result.isError ? "failed" : `${result.content.split("\n").length} lines`,
-    }),
+    formatResult: (_a, r) => ({ summary: r.isError ? "failed" : `${r.content.split("\n").length} lines` }),
   });
 
   registerTool({
@@ -430,67 +438,43 @@ export default function activate(ctx: ExtensionContext): void {
     description: "Search another agent-sh instance's shell context by keyword or regex.",
     input_schema: {
       type: "object",
-      properties: {
-        peer_id: { type: "string", description: "The instance ID of the peer." },
-        query: { type: "string", description: "Search query (keyword or regex)." },
-      },
+      properties: { peer_id: { type: "string" }, query: { type: "string" } },
       required: ["peer_id", "query"],
     },
     showOutput: false,
     getDisplayInfo: () => ({ kind: "search" as const }),
-    formatCall: (args) => `peer ${args.peer_id}: "${args.query}"`,
-
+    formatCall: (a) => `peer ${a.peer_id}: "${a.query}"`,
     async execute(args) {
       try {
-        const results = await server.call(
-          args.peer_id as string, "peer:context-search", args.query as string,
-        ) as string;
+        const results = await server.call(args.peer_id as string, "peer:context-search", args.query as string) as string;
         return { content: results || "(no matches)", exitCode: 0, isError: false };
       } catch (e) {
-        return {
-          content: `Failed to search peer context: ${e instanceof Error ? e.message : String(e)}`,
-          exitCode: 1,
-          isError: true,
-        };
+        return { content: `Failed to search peer context: ${e instanceof Error ? e.message : String(e)}`, exitCode: 1, isError: true };
       }
     },
-
-    formatResult: (_args, result) => ({
-      summary: result.isError ? "failed" : `${result.content.split("\n").length} lines`,
-    }),
+    formatResult: (_a, r) => ({ summary: r.isError ? "failed" : `${r.content.split("\n").length} lines` }),
   });
 
   registerTool({
     name: "peer_send",
-    description: "Send a text message to another running agent-sh peer. The peer will see it in their UI and on their next turn.",
+    description: "Send a text message to another peer. Appears in their UI and is queued for their next turn.",
     input_schema: {
       type: "object",
-      properties: {
-        peer_id: { type: "string", description: "The instance ID of the peer (from the peers tool)." },
-        text: { type: "string", description: "Message body." },
-      },
+      properties: { peer_id: { type: "string" }, text: { type: "string" } },
       required: ["peer_id", "text"],
     },
     showOutput: false,
     getDisplayInfo: () => ({ kind: "write" as const }),
-    formatCall: (args) => `peer ${args.peer_id}: "${String(args.text).slice(0, 40)}"`,
-
+    formatCall: (a) => `peer ${a.peer_id}: "${String(a.text).slice(0, 40)}"`,
     async execute(args) {
       try {
         await server.call(args.peer_id as string, "peer:message", ctx.instanceId, args.text as string);
         return { content: `Sent to peer ${args.peer_id}.`, exitCode: 0, isError: false };
       } catch (e) {
-        return {
-          content: `Failed to send: ${e instanceof Error ? e.message : String(e)}`,
-          exitCode: 1,
-          isError: true,
-        };
+        return { content: `Failed to send: ${e instanceof Error ? e.message : String(e)}`, exitCode: 1, isError: true };
       }
     },
-
-    formatResult: (_args, result) => ({
-      summary: result.isError ? "failed" : "sent",
-    }),
+    formatResult: (_a, r) => ({ summary: r.isError ? "failed" : "sent" }),
   });
 
   registerTool({
@@ -498,41 +482,76 @@ export default function activate(ctx: ExtensionContext): void {
     description: "Read recent messages received from other peers via peer_send.",
     input_schema: {
       type: "object",
-      properties: {
-        count: { type: "number", description: "Number of recent messages to return (default: 20)." },
-      },
+      properties: { count: { type: "number", description: "Max messages to return (default 20)." } },
       required: [],
     },
     showOutput: false,
     getDisplayInfo: () => ({ kind: "read" as const }),
     formatCall: () => "reading inbox",
-
     async execute(args) {
-      const n = (args.count as number) || 20;
-      const recent = inbox.slice(-n);
-      if (recent.length === 0) {
-        return { content: "(inbox empty)", exitCode: 0, isError: false };
-      }
-      const lines = recent.map((e) => {
-        const ago = Math.round((Date.now() - e.at) / 1000);
-        return `[${ago}s ago] ${e.from}: ${e.text}`;
-      });
+      const recent = inbox.slice(-((args.count as number) || 20));
+      if (recent.length === 0) return { content: "(inbox empty)", exitCode: 0, isError: false };
+      const lines = recent.map((e) => `[${Math.round((Date.now() - e.at) / 1000)}s ago] ${e.from}: ${e.text}`);
       return { content: lines.join("\n"), exitCode: 0, isError: false };
     },
+    formatResult: (_a, r) => ({ summary: r.content === "(inbox empty)" ? "empty" : `${r.content.split("\n").length} msg` }),
+  });
 
-    formatResult: (_args, result) => ({
-      summary: result.content === "(inbox empty)" ? "empty" : `${result.content.split("\n").length} msg`,
-    }),
+  registerTool({
+    name: "peer_ask",
+    description:
+      "Ask another peer a question and wait synchronously for their answer. " +
+      "Blocks for up to 2 minutes; the peer responds via peer_answer.",
+    input_schema: {
+      type: "object",
+      properties: {
+        peer_id: { type: "string" },
+        question: { type: "string" },
+      },
+      required: ["peer_id", "question"],
+    },
+    showOutput: false,
+    getDisplayInfo: () => ({ kind: "search" as const }),
+    formatCall: (a) => `peer ${a.peer_id}: "${String(a.question).slice(0, 40)}"`,
+    async execute(args) {
+      try {
+        const answer = await server.call(args.peer_id as string, "peer:ask", ctx.instanceId, args.question as string) as string;
+        return { content: `Answer from peer ${args.peer_id}:\n\n${answer}`, exitCode: 0, isError: false };
+      } catch (e) {
+        return { content: `Ask failed: ${e instanceof Error ? e.message : String(e)}`, exitCode: 1, isError: true };
+      }
+    },
+    formatResult: (_a, r) => ({ summary: r.isError ? "failed" : "answered" }),
   });
 
-  // ── Slash command ──────────────────────────────────────────
+  registerTool({
+    name: "peer_answer",
+    description:
+      "Resolve the oldest pending peer:ask question with this answer. " +
+      "Use only when responding to a peer-asked question received this turn.",
+    input_schema: {
+      type: "object",
+      properties: { answer: { type: "string" } },
+      required: ["answer"],
+    },
+    showOutput: false,
+    getDisplayInfo: () => ({ kind: "write" as const }),
+    formatCall: (a) => `"${String(a.answer).slice(0, 40)}"`,
+    async execute(args) {
+      const slot = askQueue.shift();
+      if (!slot) {
+        return { content: "No pending peer:ask question to answer.", exitCode: 1, isError: true };
+      }
+      slot.resolve(args.answer as string);
+      return { content: `Answered peer ${slot.from}.`, exitCode: 0, isError: false };
+    },
+    formatResult: (_a, r) => ({ summary: r.isError ? "no pending" : "answered" }),
+  });
 
+  // ── Slash command + system prompt + cwd sync ────────────────
   registerCommand("peers", "List running agent-sh peer instances", () => {
     const peers = server.discover();
-    if (peers.length === 0) {
-      bus.emit("ui:info", { message: "No peers found." });
-      return;
-    }
+    if (peers.length === 0) { bus.emit("ui:info", { message: "No peers found." }); return; }
     const lines = peers.map((p) => {
       const uptime = Math.round((Date.now() - p.startTime) / 1000);
       return `  ${p.id}  pid=${p.pid}  cwd=${p.cwd}  ${uptime}s`;
@@ -540,26 +559,19 @@ export default function activate(ctx: ExtensionContext): void {
     bus.emit("ui:info", { message: `Peers:\n${lines.join("\n")}` });
   });
 
-  // ── System prompt instruction ──────────────────────────────
-
   registerInstruction("Peer Mesh", [
     "You have access to a peer mesh — other running agent-sh instances on this machine.",
-    "Use the `peers` tool to discover them, then:",
+    "Use `peers` to discover them, then:",
     "- `peer_terminal` to see what's on another terminal's screen",
-    "- `peer_history` to see what commands they ran recently",
-    "- `peer_search` to search their shell context by keyword",
-    "- `peer_send` to deliver a text message to another peer (appears in their UI)",
-    "- `peer_inbox` to read messages other peers have sent you",
+    "- `peer_terminal_send` to type keys into their PTY (use `\\r` for Enter)",
+    "- `peer_history` to see recent commands they ran",
+    "- `peer_search` to search their shell context",
+    "- `peer_send` to deliver a one-way message",
+    "- `peer_inbox` to read messages others sent you",
+    "- `peer_ask` to ask a question and wait for their answer",
+    "- `peer_answer` to respond when another peer has asked you a question this turn",
     "When the user references 'the other terminal' or 'my other shell', use these tools.",
   ].join("\n"));
 
-  // ── Update CWD in peer file on directory change ────────────
-
-  bus.on("shell:cwd-change", ({ cwd }) => {
-    try {
-      const info: PeerInfo = JSON.parse(fs.readFileSync(peerFilePath(ctx.instanceId), "utf-8"));
-      info.cwd = cwd;
-      fs.writeFileSync(peerFilePath(ctx.instanceId), JSON.stringify(info));
-    } catch {}
-  });
+  bus.on("shell:cwd-change", ({ cwd }) => server.updateCwd(cwd));
 }

package/examples/extensions/rtk-proxy.ts

@@ -0,0 +1,143 @@
+/**
+ * rtk-proxy — transparently rewrites bash commands to `rtk <command>`
+ * so the LLM sees rtk's compressed output (60-90% token reduction on
+ * common dev commands: git, cargo, npm, jest, pytest, ls, grep, …).
+ *
+ * Demonstrates: `ctx.advise("tool:execute", …)` wrapping + line-buffered
+ * stream scrub.
+ *
+ * Compound commands like `cd X && pytest` rewrite the last segment only.
+ * Pipes, subshells, and redirects are skipped (unsafe to wrap).
+ *
+ * Requires the `rtk` binary on PATH (https://github.com/rtk-ai/rtk).
+ *
+ * Settings (~/.agent-sh/settings.json):
+ *   { "rtk-proxy": { "enabled": true, "ultraCompact": false,
+ *                    "extraPrefixes": [], "excludePrefixes": [] } }
+ *
+ * Usage:
+ *   ash -e ./examples/extensions/rtk-proxy.ts
+ *   cp examples/extensions/rtk-proxy.ts ~/.agent-sh/extensions/
+ */
+import { execSync } from "node:child_process";
+import type { ExtensionContext } from "agent-sh/types";
+
+const DEFAULT_PREFIXES = new Set([
+  "git", "gh",
+  "ls", "tree", "find", "grep", "rg", "cat",
+  "cargo", "npm", "pnpm", "yarn",
+  "jest", "vitest", "pytest", "playwright",
+  "go", "ruff", "tsc", "eslint", "prettier", "biome",
+  "docker", "kubectl",
+  "aws",
+  "pip", "bundle", "rake", "rspec", "rubocop",
+  "golangci-lint", "next",
+  "prisma",
+]);
+
+// Pipes, subshells, redirections — unsafe to wrap. Compound operators
+// (&&, ||, ;) are handled by splitting and rewriting only the last segment.
+const UNSAFE_SEGMENT_RE = /[|`()$><]/;
+
+function firstToken(cmd: string): string {
+  const m = cmd.trimStart().match(/^(\S+)/);
+  return m ? m[1] : "";
+}
+
+// Caveat: textual split, no quoting awareness. A literal `&&` inside a
+// quoted argument will split there. Acceptable today because no current
+// prefix-token command takes args containing `&&`/`||`/`;`. If that
+// changes, switch to a proper shell tokenizer.
+function splitLastSegment(cmd: string): [string, string, string] | null {
+  const match = cmd.match(/^(.*)(&&|\|\||;)\s*(\S.*)$/s);
+  if (!match) return null;
+  return [match[1].trimEnd(), match[2], match[3]];
+}
+
+function rewriteForRtk(cmd: string, prefixes: Set<string>, flag: string): string | null {
+  const tok = firstToken(cmd);
+  if (!tok || tok === "rtk") return null;
+  // Escape hatch: `command foo` forces raw passthrough.
+  if (tok === "command") return null;
+
+  const parts = splitLastSegment(cmd);
+  if (parts) {
+    const [prefix, sep, lastSeg] = parts;
+    if (UNSAFE_SEGMENT_RE.test(lastSeg)) return null;
+    if (!prefixes.has(firstToken(lastSeg))) return null;
+    return `${prefix} ${sep} RTK_TELEMETRY_DISABLED=1 rtk ${flag}${lastSeg}`;
+  }
+
+  if (UNSAFE_SEGMENT_RE.test(cmd)) return null;
+  if (!prefixes.has(tok)) return null;
+  return `RTK_TELEMETRY_DISABLED=1 rtk ${flag}${cmd}`;
+}
+
+export default function activate(ctx: ExtensionContext) {
+  const config = ctx.getExtensionSettings("rtk-proxy", {
+    enabled: true,
+    ultraCompact: false,
+    extraPrefixes: [] as string[],
+    excludePrefixes: [] as string[],
+  });
+  if (!config.enabled) return;
+
+  try {
+    execSync("command -v rtk", { stdio: "ignore" });
+  } catch {
+    ctx.bus.emit("ui:info", {
+      message: "rtk-proxy: `rtk` binary not on PATH — extension inactive.",
+    });
+    return;
+  }
+
+  const prefixes = new Set([...DEFAULT_PREFIXES, ...config.extraPrefixes]);
+  for (const p of config.excludePrefixes) prefixes.delete(p);
+  const flag = config.ultraCompact ? "--ultra-compact " : "";
+
+  ctx.registerInstruction("rtk-proxy",
+    "The rtk-proxy extension transparently rewrites bash commands like " +
+    "`git status`, `cargo test`, `pytest` to their rtk-compressed equivalents " +
+    "before execution. Output will be condensed (errors/failures first, " +
+    "boilerplate stripped). For raw unfiltered output, prefix with `command ` " +
+    "(e.g. `command git log`) or pipe (`git log | cat`) — both skip the rewrite.",
+  );
+
+  // rtk prints a nag line when it sees ~/.claude/ but no hook. We're doing
+  // the rewrite ourselves, so strip the advisory from streamed + final output.
+  const NAG_RE = /^\[(?:rtk|warn)\][^\n]*No hook installed[^\n]*\n?/gm;
+  const scrub = (s: string) => s.replace(NAG_RE, "");
+
+  ctx.advise("tool:execute", async (next, toolCtx) => {
+    if (toolCtx.name !== "bash") return next(toolCtx);
+    const command = toolCtx.args?.command;
+    if (typeof command !== "string") return next(toolCtx);
+
+    const rewritten = rewriteForRtk(command, prefixes, flag);
+    if (rewritten === null) return next(toolCtx);
+
+    toolCtx.args = { ...toolCtx.args, command: rewritten };
+
+    // Line-buffer the stream so the nag-line scrub works across chunks.
+    const origOnChunk = toolCtx.onChunk;
+    if (origOnChunk) {
+      let buf = "";
+      toolCtx.onChunk = (chunk: string) => {
+        buf += chunk;
+        const lastNl = buf.lastIndexOf("\n");
+        if (lastNl !== -1) {
+          origOnChunk(scrub(buf.slice(0, lastNl + 1)));
+          buf = buf.slice(lastNl + 1);
+        }
+      };
+      const result = await next(toolCtx);
+      if (buf) origOnChunk(scrub(buf));
+      return { ...result, content: scrub(result.content) };
+    }
+    return next(toolCtx);
+  });
+
+  ctx.bus.emit("ui:info", {
+    message: `rtk-proxy active (${prefixes.size} command prefixes).`,
+  });
+}

package/package.json

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

package/examples/extensions/openrouter.ts

@@ -1,87 +0,0 @@
-/**
- * OpenRouter provider extension.
- *
- * Registers OpenRouter as a provider and fetches its full model catalog
- * at startup. Models appear in /model autocomplete as "model [openrouter]"
- * and are available for cycling with Shift+Tab.
- *
- * Model capabilities (reasoning, context window) are read from the
- * OpenRouter API response — no hardcoded model lists.
- *
- * Setup:
- *   export OPENROUTER_API_KEY="your-key"
- *
- * Usage:
- *   agent-sh -e ./examples/extensions/openrouter.ts
- *
- *   # Or add to settings.json:
- *   { "extensions": ["./examples/extensions/openrouter.ts"] }
- */
-import type { ExtensionContext } from "agent-sh/types";
-
-const BASE_URL = "https://openrouter.ai/api/v1";
-const API_KEY = process.env.OPENROUTER_API_KEY ?? "";
-
-/** Curated default models — used immediately while the full catalog loads. */
-const DEFAULT_MODELS = [
-  "anthropic/claude-sonnet-4",
-  "google/gemini-2.5-pro-preview",
-  "openai/gpt-4.1",
-  "deepseek/deepseek-r1",
-  "meta-llama/llama-4-maverick",
-];
-
-interface OpenRouterModel {
-  id: string;
-  name: string;
-  context_length?: number;
-  supported_parameters?: string[];
-  pricing?: { prompt: string; completion: string };
-}
-
-export default function activate({ bus }: ExtensionContext): void {
-  if (!API_KEY) {
-    bus.emit("ui:error", {
-      message: "OpenRouter extension: OPENROUTER_API_KEY not set. Skipping.",
-    });
-    return;
-  }
-
-  // Register provider immediately with curated defaults
-  bus.emit("provider:register", {
-    id: "openrouter",
-    apiKey: API_KEY,
-    baseURL: BASE_URL,
-    defaultModel: DEFAULT_MODELS[0],
-    models: DEFAULT_MODELS,
-  });
-
-  // Fetch full model catalog in background, re-register with capabilities
-  fetchModels().then((models) => {
-    if (models.length > 0) {
-      bus.emit("provider:register", {
-        id: "openrouter",
-        apiKey: API_KEY,
-        baseURL: BASE_URL,
-        defaultModel: DEFAULT_MODELS[0],
-        supportsReasoningEffort: true,
-        models: models.map((m) => ({
-          id: m.id,
-          reasoning: m.supported_parameters?.includes("reasoning") ?? false,
-          contextWindow: m.context_length,
-        })),
-      });
-    }
-  }).catch(() => {
-    // Silently fall back to curated defaults
-  });
-}
-
-async function fetchModels(): Promise<OpenRouterModel[]> {
-  const res = await fetch(`${BASE_URL}/models`, {
-    headers: { Authorization: `Bearer ${API_KEY}` },
-  });
-  if (!res.ok) return [];
-  const data = await res.json();
-  return (data.data ?? []) as OpenRouterModel[];
-}