agent-sh 0.12.1 → 0.12.3

package/README.md

@@ -23,16 +23,22 @@ I still use Claude Code and pi for serious coding work — this doesn't replace
 
 ## Quick Start
 
-Install the latest from GitHub (recommended — development moves faster than npm releases):
+Install from npm:
 
 ```bash
-npm install -g github:guanyilun/agent-sh
+npm install -g agent-sh
 ```
 
-Or the last published npm release:
+Re-run the same command to update. Patch releases ship frequently; `npm update -g agent-sh` works too.
+
+For unreleased changes on `main`, clone and link locally — this avoids `npm install -g github:...`, which builds on your machine and requires a working TypeScript toolchain:
 
 ```bash
-npm install -g agent-sh
+git clone https://github.com/guanyilun/agent-sh.git
+cd agent-sh
+npm install        # installs devDependencies (typescript, etc.)
+npm run build      # produces dist/
+npm link           # exposes `agent-sh` globally
 ```
 
 Pick one of the zero-config paths below — no settings file needed. agent-sh auto-activates a built-in provider when it sees a known key.

package/dist/agent/agent-loop.js

@@ -29,6 +29,16 @@ import { discoverGlobalSkills, discoverProjectSkills } from "./skills.js";
  * the LLM via the API `tools` param (or via load_tool in deferred-
  * lookup mode) — this only trims the always-visible catalog.
  */
+/** Reject on abort; orphaned `p` keeps running but its result is dropped. */
+function raceAbort(p, signal) {
+    if (signal.aborted)
+        return Promise.reject(new Error("cancelled"));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(new Error("cancelled"));
+        signal.addEventListener("abort", onAbort, { once: true });
+        p.then((v) => { signal.removeEventListener("abort", onAbort); resolve(v); }, (e) => { signal.removeEventListener("abort", onAbort); reject(e); });
+    });
+}
 function summarizeDescription(desc) {
     const firstLine = desc.split("\n", 1)[0];
     const sentenceEnd = firstLine.search(/[.!?](\s|$)/);
@@ -817,12 +827,11 @@ export class AgentLoop {
             this.conversation.addSystemNote(text);
             this.bus.emit("conversation:message-appended", { role: "system", content: text });
         });
+        // Fires on user-abort; extensions advise per tool name for cleanup.
+        h.define("tool:cancel", (_ctx) => { });
         // Wraps each tool call: permission → execute → emit events.
-        // Extensions advise to add safe-mode, logging, metrics, custom policies.
-        // The ctx.onChunk callback is exposed so advisors can wrap it to
-        // intercept/transform streamed tool output (e.g. secret redaction).
         h.define("tool:execute", async (ctx) => {
-            const { name, id, args, tool } = ctx;
+            const { name, id, args, tool, signal } = ctx;
             // Validate required input fields before display/permission/execute.
             // Some models emit wrong arg names (e.g. `file_path` instead of `path`),
             // and downstream helpers assume required strings are present.
@@ -918,16 +927,21 @@ export class AgentLoop {
             const onChunk = (tool.showOutput !== false && !diffShown)
                 ? ctx.onChunk
                 : undefined;
-            const toolCtx = this.compositor
-                ? { ui: createToolUI(this.bus, this.compositor.surface("agent")) }
-                : undefined;
-            // Surface thrown errors as tool results so the agent can self-correct
-            // instead of the throw killing the whole turn.
+            const toolCtx = { signal };
+            if (this.compositor) {
+                toolCtx.ui = createToolUI(this.bus, this.compositor.surface("agent"));
+            }
             let result;
             try {
-                result = await tool.execute(args, onChunk, toolCtx);
+                result = await raceAbort(tool.execute(args, onChunk, toolCtx), signal);
             }
             catch (err) {
+                if (signal.aborted) {
+                    try {
+                        this.handlers.call("tool:cancel", { name, args, reason: "user-aborted" });
+                    }
+                    catch { }
+                }
                 const message = err instanceof Error ? err.message : String(err);
                 result = { content: message, exitCode: 1, isError: true };
             }
@@ -1169,7 +1183,8 @@ export class AgentLoop {
                     this.bus.emit("agent:tool-output-chunk", { chunk });
                 };
                 const result = await this.handlers.call("tool:execute", { name: tc.name, id: tc.id, args, tool, onChunk: defaultOnChunk,
-                    batchIndex, batchTotal: batchTotal > 1 ? batchTotal : undefined });
+                    batchIndex, batchTotal: batchTotal > 1 ? batchTotal : undefined,
+                    signal });
                 // Truncate large outputs to avoid blowing context
                 let content = result.content;
                 const maxBytes = 16_384; // ~4k tokens
@@ -1584,12 +1599,15 @@ export class AgentLoop {
                 tc.argumentsJson = "{}";
             }
         }
+        // Echo reasoning only for modes that opt in (e.g. DeepSeek-R1).
         const extras = {};
-        if (reasoning && reasoningField)
-            extras[reasoningField] = reasoning;
-        if (reasoningDetailsByIndex.size > 0) {
-            extras.reasoning_details = [...reasoningDetailsByIndex.entries()]
-                .sort((a, b) => a[0] - b[0]).map(([, v]) => v);
+        if (this.currentMode.echoReasoning) {
+            if (reasoning && reasoningField)
+                extras[reasoningField] = reasoning;
+            if (reasoningDetailsByIndex.size > 0) {
+                extras.reasoning_details = [...reasoningDetailsByIndex.entries()]
+                    .sort((a, b) => a[0] - b[0]).map(([, v]) => v);
+            }
         }
         return {
             text,

package/dist/agent/conversation-state.d.ts

@@ -38,6 +38,7 @@ export declare class ConversationState {
     private nextSeq;
     private lastApiTokenCount;
     private lastApiMessageCount;
+    private pendingNotes;
     constructor(handlers?: HandlerFunctions, instanceId?: string);
     /** Get JSON.stringify of messages, cached until next mutation. */
     private getMessagesJson;
@@ -53,7 +54,10 @@ export declare class ConversationState {
     addToolResult(toolCallId: string, content: string, isError?: boolean): void;
     /** Add tool results as a user message (for inline tool protocol). */
     addToolResultInline(content: string): void;
+    /** Safe from any context: queues if mid-tool-pair, appends otherwise. */
     addSystemNote(text: string): void;
+    private hasOpenToolCalls;
+    private flushPendingNotes;
     getMessages(): ChatCompletionMessageParam[];
     /**
      * If a stream was interrupted mid-tool-execution, an assistant message

package/dist/agent/conversation-state.js

@@ -56,6 +56,10 @@ export class ConversationState {
     nextSeq = 1;
     lastApiTokenCount = null;
     lastApiMessageCount = 0;
+    // Notes queued when addSystemNote fires mid-tool-pair; flushed once
+    // the trailing tool_result lands. Splicing into the gap breaks
+    // reasoning_content pairing and is rejected by strict providers.
+    pendingNotes = [];
     constructor(handlers, instanceId = "0000") {
         this.handlers = handlers ?? null;
         this.instanceId = instanceId;
@@ -100,16 +104,54 @@ export class ConversationState {
         if (isError)
             this.toolErrors.add(toolCallId);
         this.invalidateMessagesCache();
+        this.flushPendingNotes();
     }
     /** Add tool results as a user message (for inline tool protocol). */
     addToolResultInline(content) {
         this.messages.push({ role: "user", content });
         this.invalidateMessagesCache();
+        this.flushPendingNotes();
     }
+    /** Safe from any context: queues if mid-tool-pair, appends otherwise. */
     addSystemNote(text) {
+        if (this.hasOpenToolCalls()) {
+            this.pendingNotes.push(text);
+            return;
+        }
         this.messages.push({ role: "user", content: text });
         this.invalidateMessagesCache();
     }
+    hasOpenToolCalls() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const msg = this.messages[i];
+            if (msg.role === "tool")
+                continue;
+            if (msg.role !== "assistant")
+                return false;
+            if (!("tool_calls" in msg) || !msg.tool_calls)
+                return false;
+            const answered = new Set();
+            for (let j = i + 1; j < this.messages.length; j++) {
+                const m = this.messages[j];
+                if (m.role !== "tool")
+                    break;
+                answered.add(m.tool_call_id);
+            }
+            return msg.tool_calls.some((tc) => !answered.has(tc.id));
+        }
+        return false;
+    }
+    flushPendingNotes() {
+        if (this.pendingNotes.length === 0)
+            return;
+        if (this.hasOpenToolCalls())
+            return;
+        for (const text of this.pendingNotes) {
+            this.messages.push({ role: "user", content: text });
+        }
+        this.pendingNotes = [];
+        this.invalidateMessagesCache();
+    }
     getMessages() {
         return this.normalizeReasoningConsistency(this.stubDanglingToolCalls(this.messages));
     }
@@ -175,6 +217,7 @@ export class ConversationState {
         this.invalidateMessagesCache();
         this.lastApiTokenCount = null;
         this.lastApiMessageCount = 0;
+        this.flushPendingNotes();
     }
     pruneToolErrors() {
         if (this.toolErrors.size === 0)
@@ -474,6 +517,7 @@ export class ConversationState {
         this.nuclearEntries = [];
         this.nuclearBySeq.clear();
         this.recallArchive.clear();
+        this.pendingNotes = [];
         this.invalidateMessagesCache();
         this.lastApiTokenCount = null;
         this.lastApiMessageCount = 0;

package/dist/agent/skills.js

@@ -13,7 +13,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-import { getSettings } from "../settings.js";
+import { CONFIG_DIR, getSettings } from "../settings.js";
 /** Parse YAML frontmatter from a SKILL.md file. */
 function parseFrontmatter(content) {
     const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
@@ -133,7 +133,7 @@ export function discoverGlobalSkills() {
         return _cachedGlobalSkills;
     const seen = new Set();
     const skills = [];
-    addUnique(skills, scanDir(path.join(os.homedir(), ".agent-sh", "skills")), seen);
+    addUnique(skills, scanDir(path.join(CONFIG_DIR, "skills")), seen);
     const settings = getSettings();
     for (const p of settings.skillPaths ?? []) {
         addUnique(skills, scanDir(path.resolve(expandHome(p))), seen);

package/dist/agent/system-prompt.js

@@ -14,9 +14,8 @@ export function formatSkillsBlock(skills) {
         + "Load a skill's full content with read_file on its file path when needed.\n\n"
         + skills.map(s => `- **${s.name}**: ${s.description}\n  Path: ${s.filePath}`).join("\n\n");
 }
-// Resolve to the user's home-based config dir — user's standing instructions to the agent
-import * as os from "node:os";
-const GLOBAL_AGENTS_MD = path.join(os.homedir(), ".agent-sh", "AGENTS.md");
+import { CONFIG_DIR } from "../settings.js";
+const GLOBAL_AGENTS_MD = path.join(CONFIG_DIR, "AGENTS.md");
 // ── File caches ─────────────────────────────────────────────────────
 // Convention files (CLAUDE.md/AGENT.md) are walked synchronously from
 // CWD to root on every query. In practice they almost never change,

package/dist/agent/tools/bash.js

@@ -1,4 +1,4 @@
-import { executeCommand } from "../../executor.js";
+import { executeCommand, killSession } from "../../executor.js";
 export function createBashTool(opts) {
     return {
         name: "bash",
@@ -33,7 +33,7 @@ export function createBashTool(opts) {
             icon: "▶",
             locations: [],
         }),
-        async execute(args, onChunk) {
+        async execute(args, onChunk, ctx) {
             const command = args.command;
             const timeout = (args.timeout ?? 60) * 1000;
             // Let extensions intercept before execution
@@ -57,7 +57,14 @@ export function createBashTool(opts) {
                 timeout,
                 onOutput: onChunk,
             });
-            await done;
+            const onAbort = () => killSession(session);
+            ctx?.signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                await done;
+            }
+            finally {
+                ctx?.signal?.removeEventListener("abort", onAbort);
+            }
             const content = session.truncated
                 ? `[output truncated, showing last portion]\n${session.output}`
                 : session.output;

package/dist/agent/types.d.ts

@@ -64,7 +64,9 @@ export interface ToolUI {
 }
 /** Context passed to tool execute() as optional third parameter. */
 export interface ToolExecutionContext {
-    ui: ToolUI;
+    ui?: ToolUI;
+    /** Aborted on Ctrl-C — tools with subprocess work should listen and clean up. */
+    signal?: AbortSignal;
 }
 export interface ToolDefinition {
     name: string;

package/dist/core.d.ts

@@ -33,6 +33,8 @@ export interface AgentShellCore {
     contextManager: ContextManager;
     /** Handler registry for define/advise/call. */
     handlers: HandlerRegistry;
+    /** Unique id for this agent process; used for shell-marker tagging and lineage tracking. */
+    instanceId: string;
     /** Activate the agent backend (call after extensions load). */
     activateBackend(): void;
     /** Convenience: emit agent:submit and await the response. */

package/dist/core.js

@@ -27,9 +27,8 @@ import { TerminalBuffer } from "./utils/terminal-buffer.js";
 import crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as os from "node:os";
 import { DefaultCompositor, StdoutSurface } from "./utils/compositor.js";
-const STORAGE_ROOT = path.join(os.homedir(), ".agent-sh");
+import { CONFIG_DIR } from "./settings.js";
 // Re-export types that library consumers need
 export { EventBus } from "./event-bus.js";
 export { palette, setPalette, resetPalette } from "./utils/palette.js";
@@ -43,6 +42,7 @@ export function createCore(config) {
     // short enough to read/remember. Legacy content may have 16-char iids; any
     // parsers should accept ≥6 hex chars.
     const instanceId = crypto.randomBytes(3).toString("hex");
+    bus.setSource(instanceId);
     const settings = settingsMod.getSettings();
     // Expose raw CLI config so the agent backend extension can resolve
     // providers and create the LLM client.
@@ -107,6 +107,7 @@ export function createCore(config) {
         bus,
         contextManager,
         handlers,
+        instanceId,
         activateBackend() {
             // Silent — backend info is shown in the startup banner.
             // Runtime switches (config:switch-backend) still emit ui:info.
@@ -169,7 +170,7 @@ export function createCore(config) {
                 createFencedBlockTransform: (o) => streamTransform.createFencedBlockTransform(bus, o),
                 getExtensionSettings: settingsMod.getExtensionSettings,
                 getStoragePath: (namespace) => {
-                    const dir = path.join(STORAGE_ROOT, namespace);
+                    const dir = path.join(CONFIG_DIR, namespace);
                     fs.mkdirSync(dir, { recursive: true });
                     return dir;
                 },
@@ -187,6 +188,7 @@ export function createCore(config) {
                 list: () => handlers.list(),
                 get terminalBuffer() { return getTerminalBuffer(); },
                 compositor,
+                onDispose: () => { },
                 createRemoteSession: (opts) => {
                     const { surface } = opts;
                     const cleanups = [];

package/dist/event-bus.d.ts

@@ -291,6 +291,7 @@ export interface ShellEvents {
             id: string;
             reasoning?: boolean;
             contextWindow?: number;
+            echoReasoning?: boolean;
         })[];
         /** Provider supports the reasoning_effort parameter. Default: true. */
         supportsReasoningEffort?: boolean;
@@ -357,6 +358,14 @@ export type ContentBlock = {
 type Listener<T> = (payload: T) => void;
 type PipeListener<T> = (payload: T) => T;
 type AsyncPipeListener<T> = (payload: T) => T | Promise<T>;
+/** Envelope stamped on every emitted event. */
+export interface BusMeta {
+    source: string;
+    ts: number;
+    id: string;
+    name: string;
+}
+export type AnyListener = (name: string, payload: unknown, meta: BusMeta) => void;
 /**
  * Typed event bus with two modes:
  * - emit/on/off: fire-and-forget notifications
@@ -367,12 +376,25 @@ export declare class EventBus {
     private emitter;
     private pipeListeners;
     private asyncPipeListeners;
+    private source;
+    private nextSeq;
+    private anyListeners;
+    /** Set the source id stamped onto every emitted event. */
+    setSource(src: string): void;
+    /** Subscribe to every emitted event with full envelope. Returns unsubscribe. */
+    onAny(fn: AnyListener): () => void;
+    /** Stamp + dispatch — used by every emit path. */
+    private dispatch;
     /** Subscribe to a fire-and-forget event. */
     on<K extends keyof ShellEvents>(event: K, fn: Listener<ShellEvents[K]>): void;
     /** Unsubscribe from a fire-and-forget event. */
     off<K extends keyof ShellEvents>(event: K, fn: Listener<ShellEvents[K]>): void;
     /** Emit a fire-and-forget event. */
     emit<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): void;
+    /** Re-dispatch an event with externally-supplied meta. Used by bridges
+     *  and replay tools to preserve the original source/ts/id of remote or
+     *  recorded events instead of restamping them as locally originated. */
+    relay(meta: BusMeta, payload: unknown): void;
     /**
      * Transform-then-notify: run the payload through any registered pipe
      * listeners (transforms), then emit the final result to regular `on`

package/dist/event-bus.js

@@ -9,6 +9,40 @@ export class EventBus {
     emitter = new EventEmitter().setMaxListeners(0);
     pipeListeners = new Map();
     asyncPipeListeners = new Map();
+    source = "0000";
+    nextSeq = 0;
+    anyListeners = [];
+    /** Set the source id stamped onto every emitted event. */
+    setSource(src) {
+        this.source = src;
+    }
+    /** Subscribe to every emitted event with full envelope. Returns unsubscribe. */
+    onAny(fn) {
+        this.anyListeners.push(fn);
+        return () => {
+            const i = this.anyListeners.indexOf(fn);
+            if (i !== -1)
+                this.anyListeners.splice(i, 1);
+        };
+    }
+    /** Stamp + dispatch — used by every emit path. */
+    dispatch(name, payload) {
+        if (this.anyListeners.length > 0) {
+            const meta = {
+                source: this.source,
+                ts: Date.now(),
+                id: `${this.source}:${this.nextSeq++}`,
+                name,
+            };
+            for (const fn of this.anyListeners) {
+                try {
+                    fn(name, payload, meta);
+                }
+                catch { /* swallow */ }
+            }
+        }
+        this.emitter.emit(name, payload);
+    }
     /** Subscribe to a fire-and-forget event. */
     on(event, fn) {
         this.emitter.on(event, fn);
@@ -19,7 +53,21 @@ export class EventBus {
     }
     /** Emit a fire-and-forget event. */
     emit(event, payload) {
-        this.emitter.emit(event, payload);
+        this.dispatch(event, payload);
+    }
+    /** Re-dispatch an event with externally-supplied meta. Used by bridges
+     *  and replay tools to preserve the original source/ts/id of remote or
+     *  recorded events instead of restamping them as locally originated. */
+    relay(meta, payload) {
+        if (this.anyListeners.length > 0) {
+            for (const fn of this.anyListeners) {
+                try {
+                    fn(meta.name, payload, meta);
+                }
+                catch { /* swallow */ }
+            }
+        }
+        this.emitter.emit(meta.name, payload);
     }
     /**
      * Transform-then-notify: run the payload through any registered pipe
@@ -38,7 +86,7 @@ export class EventBus {
             }
             transformed = payload; // fall back to untransformed
         }
-        this.emitter.emit(event, transformed);
+        this.dispatch(event, transformed);
     }
     /** Register a transform listener for a pipeline event. */
     onPipe(event, fn) {
@@ -103,7 +151,7 @@ export class EventBus {
      */
     async emitPipeAsync(event, payload) {
         // Phase 1: notify (lets renderers prepare for interactive I/O)
-        this.emitter.emit(event, payload);
+        this.dispatch(event, payload);
         // Phase 2: transform (extensions provide decisions)
         const listeners = this.asyncPipeListeners.get(event);
         if (!listeners)

package/dist/extension-loader.js

@@ -96,6 +96,7 @@ function createScopedContext(ctx, extensionName) {
         registerTool: scopedRegisterTool,
         unregisterTool: ctx.unregisterTool,
         registerCommand: scopedRegisterCommand,
+        onDispose: (fn) => { cleanups.push(fn); },
     };
     const dispose = () => {
         for (const fn of cleanups) {

package/dist/extensions/agent-backend.js

@@ -32,6 +32,7 @@ export default function agentBackend(ctx) {
                     contextWindow: mc?.contextWindow ?? p.contextWindow,
                     reasoning: mc?.reasoning,
                     supportsReasoningEffort: p.supportsReasoningEffort,
+                    echoReasoning: mc?.echoReasoning,
                 });
             }
         }
@@ -135,7 +136,7 @@ export default function agentBackend(ctx) {
             }
             else {
                 modelIds.push(m.id);
-                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow });
+                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, echoReasoning: m.echoReasoning });
             }
         }
         providerRegistry.set(p.id, {
@@ -156,6 +157,7 @@ export default function agentBackend(ctx) {
                 contextWindow: mc?.contextWindow,
                 reasoning: mc?.reasoning,
                 supportsReasoningEffort: p.supportsReasoningEffort,
+                echoReasoning: mc?.echoReasoning,
             };
         });
         bus.emit("config:add-modes", { modes: addModes });
@@ -197,6 +199,7 @@ export default function agentBackend(ctx) {
                 contextWindow: mc?.contextWindow ?? p.contextWindow,
                 reasoning: mc?.reasoning,
                 supportsReasoningEffort: p.supportsReasoningEffort,
+                echoReasoning: mc?.echoReasoning,
             };
         });
         bus.emit("config:set-modes", { modes: newModes });

package/dist/extensions/openrouter.js

@@ -1,5 +1,11 @@
+import { getSettings } from "../settings.js";
 const BASE_URL = "https://openrouter.ai/api/v1";
 const DEFAULT_MODELS = ["anthropic/claude-sonnet-4.6"];
+// Built-in defaults for models requiring reasoning_content echoed back
+// (server 400s without it). Extend or override in settings.json:
+//   providers.openrouter.echoReasoningPatterns = ["deepseek", "..."]
+//   providers.openrouter.models[*].echoReasoning = true | false
+const BUILTIN_ECHO_REASONING_PATTERNS = [/deepseek/i];
 export default function activate(ctx) {
     const apiKey = process.env.OPENROUTER_API_KEY;
     if (!apiKey)
@@ -14,6 +20,8 @@ export default function activate(ctx) {
     fetchModels(apiKey).then((models) => {
         if (models.length === 0)
             return;
+        const userOverrides = readUserOverrides();
+        const patterns = readEchoPatterns();
         ctx.bus.emit("provider:register", {
             id: "openrouter",
             apiKey,
@@ -24,10 +32,34 @@ export default function activate(ctx) {
                 id: m.id,
                 reasoning: m.supported_parameters?.includes("reasoning") ?? false,
                 contextWindow: m.context_length,
+                echoReasoning: userOverrides.get(m.id) ?? patterns.some((re) => re.test(m.id)),
             })),
         });
     }).catch(() => { });
 }
+function readEchoPatterns() {
+    const userPatterns = getSettings().providers?.openrouter?.echoReasoningPatterns ?? [];
+    const compiled = [];
+    for (const src of userPatterns) {
+        try {
+            compiled.push(new RegExp(src, "i"));
+        }
+        catch { /* skip invalid pattern */ }
+    }
+    return [...BUILTIN_ECHO_REASONING_PATTERNS, ...compiled];
+}
+function readUserOverrides() {
+    const out = new Map();
+    const models = getSettings().providers?.openrouter?.models;
+    if (!Array.isArray(models))
+        return out;
+    for (const m of models) {
+        if (typeof m === "object" && m && m.echoReasoning !== undefined) {
+            out.set(m.id, m.echoReasoning);
+        }
+    }
+    return out;
+}
 async function fetchModels(apiKey) {
     const res = await fetch(`${BASE_URL}/models`, {
         headers: { Authorization: `Bearer ${apiKey}` },

package/dist/index.js

@@ -218,6 +218,7 @@ async function main() {
         rows,
         shell: config.shell || process.env.SHELL || "/bin/bash",
         cwd: process.cwd(),
+        instanceId: core.instanceId,
         onShowAgentInfo: () => {
             if (agentInfo) {
                 return { info: `${p.dim}${agentInfo.name}${agentInfo.model ? ` (${agentInfo.model})` : ""}${p.reset}` };

package/dist/init.js

@@ -1,7 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as os from "node:os";
-const CONFIG_DIR = path.join(os.homedir(), ".agent-sh");
+import { CONFIG_DIR } from "./settings.js";
 const EXTENSIONS_DIR = path.join(CONFIG_DIR, "extensions");
 const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const EXAMPLE_PATH = path.join(CONFIG_DIR, "settings.example.json");

package/dist/settings.d.ts

@@ -1,3 +1,5 @@
+/** Root config directory. Override via AGENT_SH_HOME for isolated instances
+ *  (testing, multi-agent setups). Path is resolved at module load. */
 export declare const CONFIG_DIR: string;
 /** Per-model capability overrides. */
 export interface ModelCapabilityConfig {
@@ -7,6 +9,8 @@ export interface ModelCapabilityConfig {
     reasoning?: boolean;
     /** Context window size in tokens for this specific model. */
     contextWindow?: number;
+    /** Echo reasoning_content back on assistant turns. Required by DeepSeek. */
+    echoReasoning?: boolean;
 }
 /** Provider profile — a named LLM configuration. */
 export interface ProviderConfig {
@@ -20,6 +24,9 @@ export interface ProviderConfig {
     models?: (string | ModelCapabilityConfig)[];
     /** Context window size in tokens (e.g. 128000). Used for usage display. */
     contextWindow?: number;
+    /** Case-insensitive regex sources matched against model id; matches default
+     *  to echoReasoning=true. Per-model echoReasoning still wins. */
+    echoReasoningPatterns?: string[];
 }
 export interface Settings {
     /** Extensions to load (npm packages or file paths). */
@@ -136,6 +143,7 @@ export interface ResolvedProvider {
     modelCapabilities?: Map<string, {
         reasoning?: boolean;
         contextWindow?: number;
+        echoReasoning?: boolean;
     }>;
 }
 /**

package/dist/settings.js

@@ -7,7 +7,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-export const CONFIG_DIR = path.join(os.homedir(), ".agent-sh");
+/** Root config directory. Override via AGENT_SH_HOME for isolated instances
+ *  (testing, multi-agent setups). Path is resolved at module load. */
+export const CONFIG_DIR = process.env.AGENT_SH_HOME
+    ? path.resolve(process.env.AGENT_SH_HOME)
+    : path.join(os.homedir(), ".agent-sh");
 const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const DEFAULTS = {
     extensions: [],
@@ -143,8 +147,8 @@ export function resolveProvider(name) {
         }
         else {
             modelIds.push(m.id);
-            if (m.reasoning !== undefined || m.contextWindow !== undefined) {
-                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow });
+            if (m.reasoning !== undefined || m.contextWindow !== undefined || m.echoReasoning !== undefined) {
+                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, echoReasoning: m.echoReasoning });
             }
         }
     }