agent-sh 0.12.9 → 0.12.10

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

@@ -17,6 +17,7 @@ import type { ContextManager } from "../context-manager.js";
 import type { LlmClient } from "../utils/llm-client.js";
 import type { HandlerFunctions } from "../utils/handler-registry.js";
 import type { AgentBackend, ToolDefinition } from "./types.js";
+import { type HistoryAdapter } from "./history-file.js";
 import type { Compositor } from "../utils/compositor.js";
 export interface AgentLoopConfig {
     bus: EventBus;
@@ -28,11 +29,12 @@ export interface AgentLoopConfig {
     compositor?: Compositor;
     /** Instance ID from core — ensures history entries match the ID in prompts. */
     instanceId?: string;
+    history?: HistoryAdapter;
 }
 export declare class AgentLoop implements AgentBackend {
     private abortController;
     private toolRegistry;
-    private historyFile;
+    private history;
     private conversation;
     private fileReadCache;
     private modes;
@@ -100,8 +102,7 @@ export declare class AgentLoop implements AgentBackend {
     buildExtensionSections(): string[];
     kill(): void;
     private cancel;
-    /** Check if reasoning_effort should be sent for the current model/provider. */
-    private shouldSendReasoningEffort;
+    private reasoningParams;
     private get currentMode();
     private get currentModel();
     /**

package/dist/agent/agent-loop.js

@@ -50,7 +50,7 @@ function summarizeDescription(desc) {
 export class AgentLoop {
     abortController = null;
     toolRegistry = new ToolRegistry();
-    historyFile;
+    history;
     conversation;
     fileReadCache = new Map();
     modes;
@@ -110,7 +110,7 @@ export class AgentLoop {
         // `history:append` handler registered below; extensions swap the
         // backend without touching this wiring.
         const filePath = process.env.AGENT_SH_HISTORY_FILE || getSettings().historyFilePath;
-        this.historyFile = new HistoryFile({ instanceId: this.instanceId, filePath });
+        this.history = config.history ?? new HistoryFile({ instanceId: this.instanceId, filePath });
         this.conversation = new ConversationState(this.handlers, this.instanceId);
         // Fall back to a single-mode placeholder if the caller passed an
         // empty array (agent-backend does this pre-resolution).
@@ -180,6 +180,16 @@ export class AgentLoop {
                     message: `${prev.provider}:${prev.model} is not in the refreshed catalog — keeping it active until you /model to another.`,
                 });
             }
+            const active = this.modes[this.currentModeIndex];
+            if (active && active.contextWindow !== prev?.contextWindow) {
+                this.bus.emit("agent:info", {
+                    name: "ash",
+                    version: PACKAGE_VERSION,
+                    model: active.model,
+                    provider: active.provider,
+                    contextWindow: active.contextWindow,
+                });
+            }
             this.bus.emit("config:changed", {});
         });
         // Fires before wire() too — agent-backend emits this from
@@ -461,16 +471,17 @@ export class AgentLoop {
     cancel() {
         this.abortController?.abort();
     }
-    /** Check if reasoning_effort should be sent for the current model/provider. */
-    shouldSendReasoningEffort() {
-        if (this.thinkingLevel === "off")
-            return false;
+    reasoningParams() {
         const mode = this.currentMode;
         if (mode.reasoning === false)
-            return false;
+            return {};
         if (mode.supportsReasoningEffort === false)
-            return false;
-        return true;
+            return {};
+        if (mode.buildReasoningParams)
+            return mode.buildReasoningParams(this.thinkingLevel);
+        if (this.thinkingLevel === "off")
+            return {};
+        return { reasoning_effort: this.thinkingLevel };
     }
     get currentMode() {
         return this.modes[this.currentModeIndex];
@@ -822,11 +833,11 @@ export class AgentLoop {
                 return;
             const writable = entries.filter((e) => !isReadOnly(e));
             if (writable.length > 0)
-                this.historyFile.append(writable).catch(() => { });
+                this.history.append(writable).catch(() => { });
         });
-        h.define("history:search", async (query) => this.historyFile.search(query));
-        h.define("history:find-by-seq", async (seq) => this.historyFile.findBySeq(seq));
-        h.define("history:read-recent", async (max) => this.historyFile.readRecent(max));
+        h.define("history:search", async (query) => this.history.search(query));
+        h.define("history:find-by-seq", async (seq) => this.history.findBySeq(seq));
+        h.define("history:read-recent", async (max) => this.history.readRecent(max));
         // Prior-session preamble renderer. Default: flat chronological list.
         h.define("conversation:format-prior-history", (entries) => {
             if (!entries || entries.length === 0)
@@ -1525,7 +1536,7 @@ export class AgentLoop {
             messages,
             tools: apiTools,
             model: this.currentModel,
-            reasoning_effort: this.shouldSendReasoningEffort() ? this.thinkingLevel : undefined,
+            ...this.reasoningParams(),
         };
         this.bus.emit("llm:request", requestParams);
         const stream = await this.llmClient.stream({ ...requestParams, signal });

package/dist/agent/history-file.d.ts

@@ -1,5 +1,34 @@
 import { type NuclearEntry } from "./nuclear-form.js";
-export declare class HistoryFile {
+export interface HistoryAdapter {
+    append(entries: NuclearEntry[]): Promise<void>;
+    readRecent(maxEntries?: number): Promise<NuclearEntry[]>;
+    search(query: string): Promise<{
+        entry: NuclearEntry;
+        line: string;
+    }[]>;
+    findBySeq(seq: number): Promise<NuclearEntry | null>;
+}
+export declare class InMemoryHistory implements HistoryAdapter {
+    private entries;
+    constructor(initial?: NuclearEntry[]);
+    append(entries: NuclearEntry[]): Promise<void>;
+    readRecent(maxEntries?: number): Promise<NuclearEntry[]>;
+    search(query: string): Promise<{
+        entry: NuclearEntry;
+        line: string;
+    }[]>;
+    findBySeq(seq: number): Promise<NuclearEntry | null>;
+}
+export declare class NoopHistory implements HistoryAdapter {
+    append(): Promise<void>;
+    readRecent(): Promise<NuclearEntry[]>;
+    search(): Promise<{
+        entry: NuclearEntry;
+        line: string;
+    }[]>;
+    findBySeq(): Promise<NuclearEntry | null>;
+}
+export declare class HistoryFile implements HistoryAdapter {
     readonly instanceId: string;
     private filePath;
     private lockPath;

package/dist/agent/history-file.js

@@ -10,9 +10,43 @@ import * as fss from "node:fs";
 import * as path from "node:path";
 import * as crypto from "node:crypto";
 import { CONFIG_DIR, getSettings } from "../settings.js";
-import { serializeEntry, deserializeEntry, formatNuclearLine, isReadOnly, } from "./nuclear-form.js";
+import { serializeEntry, deserializeEntry, isReadOnly, compileSearchRegex, matchEntry, } from "./nuclear-form.js";
 const HISTORY_PATH = path.join(CONFIG_DIR, "history");
 const LOCK_STALE_MS = 10_000; // consider lock stale after 10s
+export class InMemoryHistory {
+    entries;
+    constructor(initial = []) {
+        this.entries = [...initial];
+    }
+    async append(entries) {
+        this.entries.push(...entries);
+    }
+    async readRecent(maxEntries) {
+        const filtered = this.entries.filter((e) => !isReadOnly(e));
+        return maxEntries ? filtered.slice(-maxEntries) : filtered;
+    }
+    async search(query) {
+        if (!query.trim())
+            return [];
+        const re = compileSearchRegex(query);
+        const out = [];
+        for (let i = this.entries.length - 1; i >= 0; i--) {
+            const m = matchEntry(this.entries[i], re);
+            if (m)
+                out.push(m);
+        }
+        return out;
+    }
+    async findBySeq(seq) {
+        return this.entries.find((e) => e.seq === seq) ?? null;
+    }
+}
+export class NoopHistory {
+    async append() { }
+    async readRecent() { return []; }
+    async search() { return []; }
+    async findBySeq() { return null; }
+}
 export class HistoryFile {
     instanceId;
     filePath;
@@ -65,16 +99,7 @@ export class HistoryFile {
     async search(query) {
         if (!query.trim())
             return [];
-        let regex;
-        try {
-            regex = new RegExp(query, "i");
-        }
-        catch {
-            const words = query.split(/\s+/).filter((w) => w.length > 0);
-            const escaped = words.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-            const lookaheads = escaped.map((w) => `(?=.*${w})`).join("");
-            regex = new RegExp(lookaheads, "i");
-        }
+        const regex = compileSearchRegex(query);
         const budgetBytes = 20 * 1024 * 1024;
         let scanned = 0;
         const results = [];
@@ -83,13 +108,11 @@ export class HistoryFile {
             if (scanned > budgetBytes)
                 break;
             const entry = deserializeEntry(line);
-            if (!entry || isReadOnly(entry))
+            if (!entry)
                 continue;
-            // Body can hold ~4000 chars the summary truncates — search both.
-            const searchText = [entry.sum, entry.body].filter(Boolean).join("\n");
-            if (regex.test(searchText)) {
-                results.push({ entry, line: formatNuclearLine(entry) });
-            }
+            const m = matchEntry(entry, regex);
+            if (m)
+                results.push(m);
         }
         return results;
     }

package/dist/agent/nuclear-form.d.ts

@@ -66,3 +66,10 @@ export declare function serializeEntry(entry: NuclearEntry): string;
 export declare function deserializeEntry(line: string): NuclearEntry | null;
 /** Check if a nuclear entry represents a read-only action (should be dropped). */
 export declare function isReadOnly(entry: NuclearEntry): boolean;
+/** Compile a search query, falling back to whitespace-split AND-of-words on invalid regex. */
+export declare function compileSearchRegex(query: string): RegExp;
+/** Match a writable entry against a search regex; null if filtered or no match. */
+export declare function matchEntry(entry: NuclearEntry, re: RegExp): {
+    entry: NuclearEntry;
+    line: string;
+} | null;

package/dist/agent/nuclear-form.js

@@ -200,6 +200,25 @@ export function isReadOnly(entry) {
         return false;
     return READ_ONLY_TOOLS.has(entry.tool) || extraReadOnlyTools.has(entry.tool);
 }
+/** Compile a search query, falling back to whitespace-split AND-of-words on invalid regex. */
+export function compileSearchRegex(query) {
+    try {
+        return new RegExp(query, "i");
+    }
+    catch {
+        const words = query.split(/\s+/).filter((w) => w.length > 0);
+        const escaped = words.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+        const lookaheads = escaped.map((w) => `(?=.*${w})`).join("");
+        return new RegExp(lookaheads, "i");
+    }
+}
+/** Match a writable entry against a search regex; null if filtered or no match. */
+export function matchEntry(entry, re) {
+    if (isReadOnly(entry))
+        return null;
+    const text = [entry.sum, entry.body].filter(Boolean).join("\n");
+    return re.test(text) ? { entry, line: formatNuclearLine(entry) } : null;
+}
 // ── Internal helpers ──────────────────────────────────────────────
 function truncate(text, maxLen) {
     const oneLine = text.replace(/\n/g, " ").trim();

package/dist/core.d.ts

@@ -28,6 +28,8 @@ export type { ColorPalette } from "./utils/palette.js";
 export type { AgentBackend, ToolDefinition } from "./agent/types.js";
 export { runSubagent, type SubagentOptions } from "./agent/subagent.js";
 export { LlmClient } from "./utils/llm-client.js";
+export { HistoryFile, InMemoryHistory, NoopHistory, type HistoryAdapter } from "./agent/history-file.js";
+export type { NuclearEntry } from "./agent/nuclear-form.js";
 export interface AgentShellCore {
     bus: EventBus;
     contextManager: ContextManager;

package/dist/core.js

@@ -34,6 +34,7 @@ export { EventBus } from "./event-bus.js";
 export { palette, setPalette, resetPalette } from "./utils/palette.js";
 export { runSubagent } from "./agent/subagent.js";
 export { LlmClient } from "./utils/llm-client.js";
+export { HistoryFile, InMemoryHistory, NoopHistory } from "./agent/history-file.js";
 export function createCore(config) {
     const bus = new EventBus();
     const handlers = new HandlerRegistry();
@@ -164,6 +165,9 @@ export function createCore(config) {
                 contextManager,
                 instanceId,
                 llm: createLlmFacade(handlers),
+                providers: {
+                    configure: (id, opts) => bus.emit("provider:configure", { id, ...opts }),
+                },
                 quit: opts.quit,
                 setPalette,
                 createBlockTransform: (o) => streamTransform.createBlockTransform(bus, o),

package/dist/event-bus.d.ts

@@ -320,6 +320,10 @@ export interface ShellEvents {
         /** Provider supports the reasoning_effort parameter. Default: true. */
         supportsReasoningEffort?: boolean;
     };
+    "provider:configure": {
+        id: string;
+        reasoningParams?: (level: string) => Record<string, unknown>;
+    };
     "agent:register-tool": {
         tool: import("./agent/types.js").ToolDefinition;
         extensionName?: string;

package/dist/extensions/agent-backend.js

@@ -8,6 +8,9 @@ function persistedModelFor(providerName) {
         return undefined;
     return getSettings().providers?.[providerName]?.defaultModel;
 }
+function defaultReasoningBuilder(level) {
+    return level === "off" ? {} : { reasoning_effort: level };
+}
 export default function agentBackend(ctx) {
     const { bus } = ctx;
     const config = ctx.call("config:get-shell-config") ?? {};
@@ -18,11 +21,14 @@ export default function agentBackend(ctx) {
         if (p)
             providerRegistry.set(name, p);
     }
+    const providerHooks = new Map();
     const buildModes = () => {
         const allModes = [];
         for (const [id, p] of providerRegistry) {
             if (!p.apiKey)
                 continue;
+            const shapeId = p.reasoningShape ?? id;
+            const buildReasoningParams = providerHooks.get(shapeId)?.reasoningParams ?? defaultReasoningBuilder;
             for (const model of p.models) {
                 const mc = p.modelCapabilities?.get(model);
                 allModes.push({
@@ -33,6 +39,7 @@ export default function agentBackend(ctx) {
                     reasoning: mc?.reasoning,
                     supportsReasoningEffort: p.supportsReasoningEffort,
                     echoReasoning: mc?.echoReasoning,
+                    buildReasoningParams,
                 });
             }
         }
@@ -67,6 +74,7 @@ export default function agentBackend(ctx) {
         initialModeIndex,
         compositor: ctx.compositor,
         instanceId: ctx.instanceId,
+        history: config.history,
     });
     bus.on("core:extensions-loaded", () => {
         const settings = getSettings();
@@ -126,6 +134,12 @@ export default function agentBackend(ctx) {
             },
         });
     });
+    bus.on("provider:configure", ({ id, reasoningParams }) => {
+        const prev = providerHooks.get(id) ?? {};
+        if (reasoningParams !== undefined)
+            prev.reasoningParams = reasoningParams;
+        providerHooks.set(id, prev);
+    });
     bus.on("provider:register", (p) => {
         const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
         const modelIds = [];
@@ -148,6 +162,7 @@ export default function agentBackend(ctx) {
             supportsReasoningEffort: p.supportsReasoningEffort,
             modelCapabilities: caps.size > 0 ? caps : undefined,
         });
+        const buildReasoningParams = providerHooks.get(p.id)?.reasoningParams ?? defaultReasoningBuilder;
         const addModes = modelIds.map((m) => {
             const mc = caps.get(m);
             return {
@@ -158,6 +173,7 @@ export default function agentBackend(ctx) {
                 reasoning: mc?.reasoning,
                 supportsReasoningEffort: p.supportsReasoningEffort,
                 echoReasoning: mc?.echoReasoning,
+                buildReasoningParams,
             };
         });
         bus.emit("config:add-modes", { modes: addModes });

package/dist/extensions/openai.d.ts

@@ -1,7 +1,9 @@
 /**
- * Built-in OpenAI-compatible provider — auto-activates when OPENAI_API_KEY
- * is set. OPENAI_BASE_URL redirects to local servers (Ollama, LM Studio,
- * vLLM, llama.cpp) which then get their catalog via /models.
+ * 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;

package/dist/extensions/openai.js

@@ -1,34 +1,36 @@
-const DEFAULT_MODELS = [
-    "gpt-5",
-    "gpt-4.1",
-    "gpt-4o",
-    "gpt-4o-mini",
-    "o3",
-    "o3-mini",
+const OPENAI_CLOUD_MODELS = [
+    { id: "gpt-5", reasoning: true },
+    { id: "gpt-4.1", reasoning: false },
+    { id: "gpt-4o", reasoning: false },
+    { id: "gpt-4o-mini", reasoning: false },
+    { id: "o3", reasoning: true },
+    { id: "o3-mini", reasoning: true },
 ];
 export default function activate(ctx) {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey)
-        return;
+    const apiKey = process.env.OPENAI_API_KEY ?? "";
     const baseURL = process.env.OPENAI_BASE_URL;
-    const id = baseURL ? "openai-compatible" : "openai";
     if (!baseURL) {
+        if (!apiKey)
+            return;
         ctx.bus.emit("provider:register", {
-            id,
+            id: "openai",
             apiKey,
-            defaultModel: DEFAULT_MODELS[0],
-            models: DEFAULT_MODELS,
+            defaultModel: OPENAI_CLOUD_MODELS[0].id,
+            models: OPENAI_CLOUD_MODELS,
         });
         return;
     }
-    // Register empty immediately so the provider resolves; refill from /models.
-    ctx.bus.emit("provider:register", { id, apiKey, baseURL, models: [] });
+    const id = "openai-compatible";
+    // Local servers (Ollama, llama.cpp) often need no key; the SDK still
+    // requires a non-empty string for construction.
+    const sdkKey = apiKey || "no-key";
+    ctx.bus.emit("provider:register", { id, apiKey: sdkKey, baseURL, models: [] });
     fetchModels(baseURL, apiKey).then((models) => {
         if (models.length === 0)
             return;
         ctx.bus.emit("provider:register", {
             id,
-            apiKey,
+            apiKey: sdkKey,
             baseURL,
             defaultModel: models[0],
             models,
@@ -36,9 +38,10 @@ export default function activate(ctx) {
     }).catch(() => { });
 }
 async function fetchModels(baseURL, apiKey) {
-    const res = await fetch(`${baseURL.replace(/\/$/, "")}/models`, {
-        headers: { Authorization: `Bearer ${apiKey}` },
-    });
+    const headers = {};
+    if (apiKey)
+        headers.Authorization = `Bearer ${apiKey}`;
+    const res = await fetch(`${baseURL.replace(/\/$/, "")}/models`, { headers });
     if (!res.ok)
         return [];
     const data = await res.json();

package/dist/extensions/openrouter.js

@@ -6,10 +6,16 @@ const DEFAULT_MODELS = ["deepseek/deepseek-v4-flash"];
 //   providers.openrouter.echoReasoningPatterns = ["deepseek", "..."]
 //   providers.openrouter.models[*].echoReasoning = true | false
 const BUILTIN_ECHO_REASONING_PATTERNS = [/deepseek/i];
+function buildReasoningParams(level) {
+    return level === "off"
+        ? { reasoning: { enabled: false } }
+        : { reasoning: { effort: level } };
+}
 export default function activate(ctx) {
     const apiKey = process.env.OPENROUTER_API_KEY;
     if (!apiKey)
         return;
+    ctx.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
     ctx.bus.emit("provider:register", {
         id: "openrouter",
         apiKey,

package/dist/settings.d.ts

@@ -27,6 +27,9 @@ export interface ProviderConfig {
     /** Case-insensitive regex sources matched against model id; matches default
      *  to echoReasoning=true. Per-model echoReasoning still wins. */
     echoReasoningPatterns?: string[];
+    /** Borrow another registered provider's reasoning request shape by id
+     *  (e.g. "openrouter"). Defaults to OpenAI-compat. */
+    reasoningShape?: string;
 }
 export interface Settings {
     /** Extensions to load (npm packages or file paths). */
@@ -145,6 +148,8 @@ export interface ResolvedProvider {
         contextWindow?: number;
         echoReasoning?: boolean;
     }>;
+    /** Borrow another registered provider's reasoning request shape by id. */
+    reasoningShape?: string;
 }
 /**
  * Resolve a provider config by name from settings.

package/dist/settings.js

@@ -161,6 +161,7 @@ export function resolveProvider(name) {
         models: modelIds.length ? modelIds : (defaultModel ? [defaultModel] : []),
         contextWindow: provider.contextWindow,
         modelCapabilities: caps.size > 0 ? caps : undefined,
+        reasoningShape: provider.reasoningShape,
     };
 }
 /** Get all configured provider names. */

package/dist/types.d.ts

@@ -5,6 +5,7 @@ import type { BlockTransformOptions, FencedBlockTransformOptions } from "./utils
 import type { ToolDefinition } from "./agent/types.js";
 import type { TerminalBuffer } from "./utils/terminal-buffer.js";
 import type { Compositor } from "./utils/compositor.js";
+import type { HistoryAdapter } from "./agent/history-file.js";
 export type { ContentBlock } from "./event-bus.js";
 export type { BlockTransformOptions, FencedBlockTransformOptions } from "./utils/stream-transform.js";
 export type { RenderSurface } from "./utils/compositor.js";
@@ -51,6 +52,7 @@ export interface AgentMode {
     /** Echo reasoning_content back on assistant turns. Required by DeepSeek;
      *  default off (leaky shims may forward it to the model as OOD input). */
     echoReasoning?: boolean;
+    buildReasoningParams?: (level: string) => Record<string, unknown>;
 }
 /**
  * Backend-agnostic LLM interface exposed via `ctx.llm`. Backends fulfill it
@@ -87,6 +89,8 @@ export interface AgentShellConfig {
     baseURL?: string;
     /** Named provider to use from settings.json. */
     provider?: string;
+    /** Conversation history backend. Defaults to the on-disk HistoryFile. */
+    history?: HistoryAdapter;
 }
 /**
  * Context passed to user/third-party extensions.
@@ -130,6 +134,11 @@ export interface ExtensionContext {
     registerSkill: (name: string, description: string, filePath: string) => void;
     /** Remove a registered skill by name. */
     removeSkill: (name: string) => void;
+    providers: {
+        configure: (id: string, opts: {
+            reasoningParams?: (level: string) => Record<string, unknown>;
+        }) => void;
+    };
     llm: LlmInterface;
     /** Register a named handler. */
     define: (name: string, fn: (...args: any[]) => any) => void;

package/package.json

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