agent-sh 0.12.8 → 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

@@ -15,6 +15,7 @@ import { getSettings, updateSettings } from "../settings.js";
 import { createToolProtocol } from "./tool-protocol.js";
 // Core tool factories
 import { createBashTool } from "./tools/bash.js";
+import { createPwshTool } from "./tools/pwsh.js";
 import { createReadFileTool } from "./tools/read-file.js";
 import { createWriteFileTool } from "./tools/write-file.js";
 import { createEditFileTool } from "./tools/edit-file.js";
@@ -49,7 +50,7 @@ function summarizeDescription(desc) {
 export class AgentLoop {
     abortController = null;
     toolRegistry = new ToolRegistry();
-    historyFile;
+    history;
     conversation;
     fileReadCache = new Map();
     modes;
@@ -109,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).
@@ -179,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
@@ -460,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];
@@ -591,6 +603,9 @@ export class AgentLoop {
             return env;
         };
         this.toolRegistry.register(createBashTool({ getCwd, getEnv, bus: this.bus }));
+        if (process.platform === "win32") {
+            this.toolRegistry.register(createPwshTool({ getCwd, getEnv, bus: this.bus }));
+        }
         this.toolRegistry.register(createReadFileTool(getCwd, this.fileReadCache));
         this.toolRegistry.register(createWriteFileTool(getCwd));
         this.toolRegistry.register(createEditFileTool(getCwd));
@@ -818,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)
@@ -1521,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/agent/tools/glob.js

@@ -50,7 +50,7 @@ export function createGlobTool(getCwd) {
                 timeout: 10_000,
             });
             await done;
-            if (session.exitCode === -1 && session.output.startsWith("Failed to spawn")) {
+            if (session.spawnFailed) {
                 return {
                     content: "ripgrep not available — the bundled binary failed to load and `rg` is not on PATH. Reinstall agent-sh, or install ripgrep manually (https://github.com/BurntSushi/ripgrep#installation).",
                     exitCode: 1,

package/dist/agent/tools/grep.js

@@ -127,7 +127,7 @@ export function createGrepTool(getCwd) {
                 maxOutputBytes: 64 * 1024,
             });
             await done;
-            if (session.exitCode === -1 && session.output.startsWith("Failed to spawn")) {
+            if (session.spawnFailed) {
                 return {
                     content: "ripgrep not available — the bundled binary failed to load and `rg` is not on PATH. Reinstall agent-sh, or install ripgrep manually (https://github.com/BurntSushi/ripgrep#installation).",
                     exitCode: 1,

package/dist/agent/tools/pwsh.d.ts

@@ -0,0 +1,7 @@
+import type { EventBus } from "../../event-bus.js";
+import type { ToolDefinition } from "../types.js";
+export declare function createPwshTool(opts: {
+    getCwd: () => string;
+    getEnv: () => Record<string, string>;
+    bus: EventBus;
+}): ToolDefinition;

package/dist/agent/tools/pwsh.js

@@ -0,0 +1,90 @@
+import { executeArgv, killSession } from "../../executor.js";
+// Targets PowerShell 7+ (`pwsh`). Legacy `powershell.exe` is intentionally
+// not auto-fallback — its tool surface diverges enough that compatibility
+// shims aren't worth the maintenance.
+export function createPwshTool(opts) {
+    return {
+        name: "pwsh",
+        description: "Execute a PowerShell command in an isolated subprocess. " +
+            "Use this on Windows when the `bash` tool fails (no /bin/bash available). " +
+            "Use PowerShell syntax — e.g. `Get-ChildItem`, `Select-String`, `$env:HOME`. " +
+            "Does not affect the user's shell state. " +
+            "cwd is set to the working directory from the shell context. " +
+            "Do NOT use pwsh for file searching — use grep/glob instead. " +
+            "Do NOT use pwsh for reading files — use read_file instead.",
+        input_schema: {
+            type: "object",
+            properties: {
+                command: {
+                    type: "string",
+                    description: "The PowerShell command to execute",
+                },
+                timeout: {
+                    type: "number",
+                    description: "Timeout in seconds (default: 60)",
+                },
+                description: {
+                    type: "string",
+                    description: "Short description of what this command does (e.g., 'Install dependencies', 'Run test suite')",
+                },
+            },
+            required: ["command"],
+        },
+        showOutput: true,
+        modifiesFiles: true,
+        requiresPermission: true,
+        getDisplayInfo: () => ({
+            kind: "execute",
+            icon: "▶",
+            locations: [],
+        }),
+        async execute(args, onChunk, ctx) {
+            const command = args.command;
+            const timeout = (args.timeout ?? 60) * 1000;
+            const intercepted = opts.bus.emitPipe("agent:terminal-intercept", {
+                command,
+                cwd: opts.getCwd(),
+                intercepted: false,
+                output: "",
+            });
+            if (intercepted.intercepted) {
+                return {
+                    content: intercepted.output,
+                    exitCode: 0,
+                    isError: false,
+                };
+            }
+            const { session, done } = executeArgv({
+                file: "pwsh",
+                args: ["-NoProfile", "-NonInteractive", "-Command", command],
+                cwd: opts.getCwd(),
+                env: opts.getEnv(),
+                timeout,
+                onOutput: onChunk,
+            });
+            const onAbort = () => killSession(session);
+            ctx?.signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                await done;
+            }
+            finally {
+                ctx?.signal?.removeEventListener("abort", onAbort);
+            }
+            if (session.spawnFailed) {
+                return {
+                    content: "PowerShell (pwsh) not found on PATH. Install PowerShell 7: winget install Microsoft.PowerShell.",
+                    exitCode: 1,
+                    isError: true,
+                };
+            }
+            const content = session.truncated
+                ? `[output truncated, showing last portion]\n${session.output}`
+                : session.output;
+            return {
+                content: content || "(no output)",
+                exitCode: session.exitCode,
+                isError: session.exitCode !== 0,
+            };
+        },
+    };
+}

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/executor.d.ts

@@ -6,6 +6,9 @@ export interface ExecutorSession {
     exitCode: number | null;
     done: boolean;
     truncated: boolean;
+    /** True when the binary couldn't be launched (ENOENT, EACCES). Lets callers
+     *  distinguish "tool missing" from "tool ran and exited with -1". */
+    spawnFailed: boolean;
     process: ChildProcess | null;
     resolve?: () => void;
 }

package/dist/executor.js

@@ -16,6 +16,7 @@ export function executeCommand(opts) {
         exitCode: null,
         done: false,
         truncated: false,
+        spawnFailed: false,
         process: null,
     };
     const done = new Promise((resolve) => {
@@ -39,6 +40,7 @@ export function executeCommand(opts) {
     }
     catch (err) {
         session.exitCode = -1;
+        session.spawnFailed = true;
         session.output = `Failed to spawn: ${err instanceof Error ? err.message : String(err)}`;
         session.done = true;
         session.resolve?.();
@@ -79,6 +81,9 @@ export function executeCommand(opts) {
         cancelKill?.();
         if (!session.done) {
             session.exitCode = -1;
+            const code = err.code;
+            if (code === "ENOENT" || code === "EACCES")
+                session.spawnFailed = true;
             session.output += `\nProcess error: ${err.message}`;
             session.done = true;
             session.process = null;
@@ -102,6 +107,7 @@ export function executeArgv(opts) {
         exitCode: null,
         done: false,
         truncated: false,
+        spawnFailed: false,
         process: null,
     };
     const done = new Promise((resolve) => {
@@ -123,6 +129,7 @@ export function executeArgv(opts) {
     }
     catch (err) {
         session.exitCode = -1;
+        session.spawnFailed = true;
         session.output = `Failed to spawn ${opts.file}: ${err instanceof Error ? err.message : String(err)}`;
         session.done = true;
         session.resolve?.();
@@ -168,6 +175,9 @@ export function executeArgv(opts) {
         clearTimeout(timer);
         if (!session.done) {
             session.exitCode = -1;
+            const code = err.code;
+            if (code === "ENOENT" || code === "EACCES")
+                session.spawnFailed = true;
             session.output += `\nProcess error: ${err.message}`;
             session.done = true;
             session.process = null;
@@ -185,10 +195,17 @@ export function killSession(session) {
     const proc = session.process;
     if (!proc || !proc.pid)
         return () => { };
+    // Try process-group kill first (works for executeCommand's detached bash
+    // children); fall back to direct kill (executeArgv's non-detached spawn,
+    // and Windows where negative pids aren't supported).
     try {
         process.kill(-proc.pid, "SIGTERM");
     }
     catch { }
+    try {
+        proc.kill("SIGTERM");
+    }
+    catch { }
     let settled = false;
     const fallback = setTimeout(() => {
         if (!settled && !session.done && proc.pid) {
@@ -196,6 +213,10 @@ export function killSession(session) {
                 process.kill(-proc.pid, "SIGKILL");
             }
             catch { }
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch { }
         }
     }, 5000);
     fallback.unref();

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.8",
+  "version": "0.12.10",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",