agent-sh 0.15.5 → 0.15.7

package/src/agent/providers/openai-compatible.ts

@@ -28,17 +28,32 @@ export default function activate(ctx: AgentContext): void {
       id,
       apiKey,
       baseURL,
-      defaultModel: models[0],
+      defaultModel: models[0]!.id,
       models,
     });
   }).catch(() => { /* leave empty — user supplies via --model */ });
 }
 
-async function fetchModels(baseURL: string, apiKey: string): Promise<string[]> {
+export interface CatalogModel {
+  id: string;
+  meta?: { n_ctx?: number };
+  max_model_len?: number;
+}
+
+export function catalogContextWindow(m: CatalogModel): number | undefined {
+  if (typeof m.meta?.n_ctx === "number" && m.meta.n_ctx > 0) return m.meta.n_ctx;
+  if (typeof m.max_model_len === "number" && m.max_model_len > 0) return m.max_model_len;
+  return undefined;
+}
+
+async function fetchModels(
+  baseURL: string,
+  apiKey: string,
+): Promise<{ id: string; contextWindow?: number }[]> {
   const headers: Record<string, string> = {};
   if (apiKey && apiKey !== "no-key") headers.Authorization = `Bearer ${apiKey}`;
   const res = await fetch(`${baseURL.replace(/\/$/, "")}/models`, { headers });
   if (!res.ok) return [];
-  const data = await res.json() as { data?: { id: string }[] };
-  return (data.data ?? []).map((m) => m.id);
+  const data = await res.json() as { data?: CatalogModel[] };
+  return (data.data ?? []).map((m) => ({ id: m.id, contextWindow: catalogContextWindow(m) }));
 }

package/src/agent/store.ts

@@ -54,7 +54,11 @@ function escapeRegex(s: string): string {
 }
 
 function compileSearchRegex(query: string): RegExp {
-  return new RegExp(escapeRegex(query), "i");
+  try {
+    return new RegExp(query, "i");
+  } catch {
+    return new RegExp(escapeRegex(query), "i");
+  }
 }
 
 function matchEntry(entry: Entry, re: RegExp): SearchHit | null {

package/src/agent/token-budget.ts

@@ -8,5 +8,14 @@
 /** Response reserve — tokens reserved for the model's output. */
 export const RESPONSE_RESERVE = 8192;
 
+const FALLBACK_CONTEXT_WINDOW = 60_000;
+
+export function resolveDefaultContextWindow(
+  env: Record<string, string | undefined> = process.env,
+): number {
+  const n = Number(env.AGENT_SH_DEFAULT_CONTEXT_WINDOW);
+  return Number.isInteger(n) && n > 0 ? n : FALLBACK_CONTEXT_WINDOW;
+}
+
 /** Fallback when contextWindow is unknown. */
-export const DEFAULT_CONTEXT_WINDOW = 60_000;
+export const DEFAULT_CONTEXT_WINDOW = resolveDefaultContextWindow();

package/src/agent/types.ts

@@ -54,7 +54,10 @@ export type ToolResultBody =
   | { kind: "lines"; lines: string[]; maxLines?: number }
 
 export interface ToolDisplayInfo {
-  kind: "read" | "write" | "execute" | "search";
+  /** Verb shown next to the detail (e.g. "execute foo.py"). Omit when a custom
+   *  `icon` already makes the action self-evident — the renderer then shows
+   *  icon + detail with no verb. */
+  kind?: "read" | "write" | "execute" | "search";
   locations?: { path: string; line?: number | null }[];
   /** Custom icon character for TUI display (e.g., "◆", "⌕"). When set, the TUI shows
    *  icon + detail only. When absent, the tool name is shown alongside the detail. */

package/src/cli/index.ts

@@ -128,7 +128,6 @@ async function main(): Promise<void> {
   // Load before spawning the shell so PS1 lands below the banner.
   const settings = getSettings();
   await loadBuiltinExtensions(extCtx, settings.disabledBuiltins);
-  activateRollingHistory(extCtx);
   const loadExtensionsTimeoutMs = 10000;
   let loadedExtensions: string[] = [];
   await Promise.race([
@@ -197,6 +196,7 @@ async function main(): Promise<void> {
   }
 
   await core.activateBackend(config.backend);
+  activateRollingHistory(extCtx);
 
   // 100ms sidesteps macOS SIGTTOU during fg-pgrp handoff.
   await new Promise(resolve => setTimeout(resolve, 100));

package/src/core/event-bus.ts

@@ -1,5 +1,3 @@
-import { EventEmitter } from "node:events";
-
 export interface BackendRegistration {
   name: string;
   kill: () => void;
@@ -49,6 +47,15 @@ export interface BusMeta {
 
 export type AnyListener = (name: string, payload: unknown, meta: BusMeta) => void;
 
+/** A listener fault routed to the error reporter; `phase` is the callback site. */
+export interface BusFault {
+  phase: "on" | "any" | "pipe" | "pipe-async";
+  event: string;
+  err: unknown;
+}
+
+export type ErrorReporter = (fault: BusFault) => void;
+
 /**
  * Typed event bus with two modes:
  * - emit/on/off: fire-and-forget notifications
@@ -56,18 +63,54 @@ export type AnyListener = (name: string, payload: unknown, meta: BusMeta) => voi
  *   can modify the payload before passing to the next
  */
 export class EventBus {
-  private emitter = new EventEmitter().setMaxListeners(0);
+  private listeners = new Map<string, Listener<any>[]>();
   private pipeListeners = new Map<string, PipeListener<any>[]>();
   private asyncPipeListeners = new Map<string, AsyncPipeListener<any>[]>();
   private source = "0000";
   private nextSeq = 0;
   private anyListeners: AnyListener[] = [];
 
+  /** Default fault sink, overridable via setErrorReporter: silent unless DEBUG. */
+  private reportError: ErrorReporter = ({ phase, event, err }) => {
+    if (process.env.DEBUG) {
+      const msg = err instanceof Error ? (err.stack ?? err.message) : String(err);
+      process.stderr.write(`[event-bus] ${phase} fault on "${event}": ${msg}\n`);
+    }
+  };
+
   /** Set the source id stamped onto every emitted event. */
   setSource(src: string): void {
     this.source = src;
   }
 
+  /** Install a fault reporter. */
+  setErrorReporter(fn: ErrorReporter): void {
+    this.reportError = fn;
+  }
+
+  /** Report a fault; guarded so a broken reporter can't break dispatch. */
+  private fault(phase: BusFault["phase"], event: string, err: unknown): void {
+    try {
+      this.reportError({ phase, event, err });
+    } catch {
+      /* swallow */
+    }
+  }
+
+  /** Fire every listener for `name`, isolating faults. */
+  private notify(name: string, payload: unknown): void {
+    const arr = this.listeners.get(name);
+    if (!arr || arr.length === 0) return;
+    // snapshot so a listener that (un)subscribes mid-dispatch can't shift iteration
+    if (arr.length === 1) {
+      try { arr[0](payload); } catch (err) { this.fault("on", name, err); }
+      return;
+    }
+    for (const fn of arr.slice()) {
+      try { fn(payload); } catch (err) { this.fault("on", name, err); }
+    }
+  }
+
   /** Subscribe to every emitted event with full envelope. Returns unsubscribe. */
   onAny(fn: AnyListener): () => void {
     this.anyListeners.push(fn);
@@ -87,10 +130,10 @@ export class EventBus {
         name,
       };
       for (const fn of this.anyListeners) {
-        try { fn(name, payload, meta); } catch { /* swallow */ }
+        try { fn(name, payload, meta); } catch (err) { this.fault("any", name, err); }
       }
     }
-    this.emitter.emit(name, payload);
+    this.notify(name, payload);
   }
 
   /** Subscribe to a fire-and-forget event. */
@@ -98,7 +141,12 @@ export class EventBus {
     event: K,
     fn: Listener<BusEvents[K]>,
   ): void {
-    this.emitter.on(event, fn);
+    let arr = this.listeners.get(event);
+    if (!arr) {
+      arr = [];
+      this.listeners.set(event, arr);
+    }
+    arr.push(fn);
   }
 
   /** Unsubscribe from a fire-and-forget event. */
@@ -106,7 +154,10 @@ export class EventBus {
     event: K,
     fn: Listener<BusEvents[K]>,
   ): void {
-    this.emitter.off(event, fn);
+    const arr = this.listeners.get(event);
+    if (!arr) return;
+    const idx = arr.indexOf(fn);
+    if (idx !== -1) arr.splice(idx, 1);
   }
 
   /** Emit a fire-and-forget event. */
@@ -123,10 +174,10 @@ export class EventBus {
   relay(meta: BusMeta, payload: unknown): void {
     if (this.anyListeners.length > 0) {
       for (const fn of this.anyListeners) {
-        try { fn(meta.name, payload, meta); } catch { /* swallow */ }
+        try { fn(meta.name, payload, meta); } catch (err) { this.fault("any", meta.name, err); }
       }
     }
-    this.emitter.emit(meta.name, payload);
+    this.notify(meta.name, payload);
   }
 
   /**
@@ -191,12 +242,12 @@ export class EventBus {
       try {
         const out = fn(result);
         if (out && typeof (out as any).then === "function") {
-          console.error(`[event-bus] Warning: async handler in sync pipe "${String(event)}" — use onPipeAsync instead`);
+          this.fault("pipe", String(event), new Error("async handler in sync pipe — use onPipeAsync instead"));
           continue;
         }
         result = out;
       } catch (err) {
-        console.error(`[event-bus] Pipe handler error in "${String(event)}":`, err instanceof Error ? err.message : err);
+        this.fault("pipe", String(event), err);
       }
     }
     return result;
@@ -245,7 +296,11 @@ export class EventBus {
     if (!listeners) return payload;
     let result = payload;
     for (const fn of listeners) {
-      result = await fn(result);
+      try {
+        result = await fn(result);
+      } catch (err) {
+        this.fault("pipe-async", String(event), err);
+      }
     }
     return result;
   }

package/src/core/index.ts

@@ -48,6 +48,24 @@ export function createCore(config: AppConfig): AgentShellCore {
   // should accept ≥6 hex chars.
   const instanceId = crypto.randomBytes(3).toString("hex");
   bus.setSource(instanceId);
+
+  // Surface faults on ui:error; `surfacing` stops a faulting renderer from looping.
+  let surfacing = false;
+  bus.setErrorReporter(({ phase, event, err }) => {
+    const detail = err instanceof Error ? err.message : String(err);
+    if (process.env.DEBUG) {
+      const full = err instanceof Error ? (err.stack ?? err.message) : detail;
+      process.stderr.write(`[event-bus] ${phase} fault on "${event}": ${full}\n`);
+    }
+    if (surfacing) return;
+    surfacing = true;
+    try {
+      bus.emit("ui:error", { message: `Handler error on "${event}": ${detail}` });
+    } finally {
+      surfacing = false;
+    }
+  });
+
   handlers.define("config:get-app-config", () => config);
   handlers.define("cwd", () => process.cwd());