mini-coder 0.0.11 → 0.0.13

package/dist/mc.js

@@ -931,6 +931,8 @@ function fmtTokens(n) {
 function renderStatusBar(opts) {
   const cols = process.stdout.columns ?? 80;
   const left = [c5.cyan(opts.model)];
+  if (opts.thinkingEffort)
+    left.push(c5.dim(`\u2726 ${opts.thinkingEffort}`));
   if (opts.provider && opts.provider !== "zen")
     left.push(c5.dim(opts.provider));
   left.push(c5.dim(opts.sessionId.slice(0, 8)));
@@ -976,7 +978,7 @@ function renderError(err, context = "render") {
 
 // src/cli/output.ts
 var HOME2 = homedir3();
-var PACKAGE_VERSION = "0.0.11";
+var PACKAGE_VERSION = "0.0.12";
 function tildePath(p) {
   return p.startsWith(HOME2) ? `~${p.slice(HOME2.length)}` : p;
 }
@@ -1347,6 +1349,87 @@ var CONTEXT_WINDOW_TABLE = [
   [/^glm-/, 128000],
   [/^qwen3-/, 131000]
 ];
+var REASONING_MODELS = [
+  /^claude-3-5-sonnet/,
+  /^claude-3-7/,
+  /^claude-sonnet-4/,
+  /^claude-opus-4/,
+  /^o1/,
+  /^o3/,
+  /^o4/,
+  /^gpt-5/,
+  /^gemini-2\.5/,
+  /^gemini-3/
+];
+function supportsThinking(modelString) {
+  const { modelId } = parseModelString(modelString);
+  return REASONING_MODELS.some((p) => p.test(modelId));
+}
+var ANTHROPIC_BUDGET = {
+  low: 4096,
+  medium: 8192,
+  high: 16384,
+  xhigh: 32768
+};
+function clampEffort(effort, max) {
+  const ORDER = ["low", "medium", "high", "xhigh"];
+  const i = ORDER.indexOf(effort);
+  const m = ORDER.indexOf(max);
+  return ORDER[Math.min(i, m)];
+}
+function getThinkingProviderOptions(modelString, effort) {
+  if (!supportsThinking(modelString))
+    return null;
+  const { provider, modelId } = parseModelString(modelString);
+  if (provider === "anthropic" || provider === "zen" && modelId.startsWith("claude-")) {
+    const isAdaptive = /^claude-3-7/.test(modelId) || /^claude-sonnet-4/.test(modelId) || /^claude-opus-4/.test(modelId);
+    if (isAdaptive) {
+      const isOpus = /^claude-opus-4/.test(modelId);
+      const mapped = effort === "xhigh" ? isOpus ? "max" : "high" : effort;
+      return { anthropic: { thinking: { type: "adaptive" }, effort: mapped } };
+    }
+    const budget = ANTHROPIC_BUDGET[effort];
+    return {
+      anthropic: {
+        thinking: { type: "enabled", budgetTokens: budget },
+        betas: ["interleaved-thinking-2025-05-14"]
+      }
+    };
+  }
+  if (provider === "openai" || provider === "zen" && (modelId.startsWith("o") || modelId.startsWith("gpt-5"))) {
+    const supportsXhigh = /^gpt-5\.[2-9]/.test(modelId) || /^o4/.test(modelId);
+    const clamped = supportsXhigh ? effort : clampEffort(effort, "high");
+    return { openai: { reasoningEffort: clamped } };
+  }
+  if (provider === "google" || provider === "zen" && modelId.startsWith("gemini-")) {
+    if (/^gemini-3/.test(modelId)) {
+      const level = clampEffort(effort, "high");
+      return {
+        google: {
+          thinkingConfig: {
+            includeThoughts: true,
+            thinkingLevel: level
+          }
+        }
+      };
+    }
+    const GEMINI_BUDGET = {
+      low: 4096,
+      medium: 8192,
+      high: 16384,
+      xhigh: 24575
+    };
+    return {
+      google: {
+        thinkingConfig: {
+          includeThoughts: true,
+          thinkingBudget: GEMINI_BUDGET[effort]
+        }
+      }
+    };
+  }
+  return null;
+}
 function getContextWindow(modelString) {
   const { modelId } = parseModelString(modelString);
   for (const [pattern, tokens] of CONTEXT_WINDOW_TABLE) {
@@ -1698,6 +1781,19 @@ function getPreferredModel() {
 function setPreferredModel(model) {
   setSetting("preferred_model", model);
 }
+function getPreferredThinkingEffort() {
+  const v = getSetting("preferred_thinking_effort");
+  if (v === "low" || v === "medium" || v === "high" || v === "xhigh")
+    return v;
+  return null;
+}
+function setPreferredThinkingEffort(effort) {
+  if (effort === null) {
+    getDb().run("DELETE FROM settings WHERE key = 'preferred_thinking_effort'");
+  } else {
+    setSetting("preferred_thinking_effort", effort);
+  }
+}
 // src/session/db/mcp-repo.ts
 function listMcpServers() {
   return getDb().query("SELECT name, transport, url, command, args, env FROM mcp_servers ORDER BY name").all();
@@ -1786,7 +1882,15 @@ function isOpenAIGPT(modelString) {
   return (provider === "openai" || provider === "zen") && modelId.startsWith("gpt-");
 }
 async function* runTurn(options) {
-  const { model, modelString, messages, tools, systemPrompt, signal } = options;
+  const {
+    model,
+    modelString,
+    messages,
+    tools,
+    systemPrompt,
+    signal,
+    thinkingEffort
+  } = options;
   let stepCount = 0;
   let warningClaimed = false;
   function claimWarning() {
@@ -1805,6 +1909,18 @@ async function* runTurn(options) {
   try {
     const useInstructions = systemPrompt !== undefined && isOpenAIGPT(modelString);
     logApiEvent("turn start", { modelString, messageCount: messages.length });
+    const thinkingOpts = thinkingEffort ? getThinkingProviderOptions(modelString, thinkingEffort) : null;
+    const mergedProviderOptions = {
+      ...useInstructions ? { openai: { instructions: systemPrompt, store: false } } : {},
+      ...thinkingOpts ?? {},
+      ...useInstructions && thinkingOpts?.openai ? {
+        openai: {
+          instructions: systemPrompt,
+          store: false,
+          ...thinkingOpts.openai
+        }
+      } : {}
+    };
     const streamOpts = {
       model,
       messages,
@@ -1829,14 +1945,7 @@ async function* runTurn(options) {
         return;
       },
       ...systemPrompt ? { system: systemPrompt } : {},
-      ...useInstructions ? {
-        providerOptions: {
-          openai: {
-            instructions: systemPrompt,
-            store: false
-          }
-        }
-      } : {},
+      ...Object.keys(mergedProviderOptions).length > 0 ? { providerOptions: mergedProviderOptions } : {},
       ...signal ? { abortSignal: signal } : {}
     };
     const result = streamText(streamOpts);
@@ -2885,7 +2994,7 @@ function buildReadOnlyToolSet(opts) {
 }
 
 // src/agent/subagent-runner.ts
-function createSubagentRunner(cwd, reporter, getCurrentModel) {
+function createSubagentRunner(cwd, reporter, getCurrentModel, getThinkingEffort) {
   let nextLaneId = 1;
   const activeLanes = new Set;
   const runSubagent = async (prompt, depth = 0, agentName, modelOverride, parentLabel) => {
@@ -2913,12 +3022,14 @@ function createSubagentRunner(cwd, reporter, getCurrentModel) {
     let result = "";
     let inputTokens = 0;
     let outputTokens = 0;
+    const effort = getThinkingEffort();
     const events = runTurn({
       model: subLlm,
       modelString: model,
       messages: subMessages,
       tools: subTools,
-      systemPrompt
+      systemPrompt,
+      ...effort ? { thinkingEffort: effort } : {}
     });
     for await (const event of events) {
       reporter.stopSpinner();
@@ -3375,20 +3486,50 @@ async function expandTemplate(template, args, cwd) {
 
 // src/cli/commands.ts
 async function handleModel(ctx, args) {
-  if (args) {
-    let modelId = args;
-    if (!args.includes("/")) {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  if (parts.length > 0) {
+    if (parts[0] === "effort") {
+      const effortArg2 = parts[1] ?? "";
+      if (effortArg2 === "off") {
+        ctx.setThinkingEffort(null);
+        writeln(`${PREFIX.success} thinking effort disabled`);
+      } else if (["low", "medium", "high", "xhigh"].includes(effortArg2)) {
+        ctx.setThinkingEffort(effortArg2);
+        writeln(`${PREFIX.success} thinking effort \u2192 ${c10.cyan(effortArg2)}`);
+      } else {
+        writeln(`${PREFIX.error} usage: /model effort <low|medium|high|xhigh|off>`);
+      }
+      return;
+    }
+    const idArg = parts[0] ?? "";
+    let modelId = idArg;
+    if (!idArg.includes("/")) {
       const models2 = await fetchAvailableModels();
-      const match = models2.find((m) => m.id.split("/").slice(1).join("/") === args || m.id === args);
+      const match = models2.find((m) => m.id.split("/").slice(1).join("/") === idArg || m.id === idArg);
       if (match) {
         modelId = match.id;
       } else {
-        writeln(`${PREFIX.error} unknown model ${c10.cyan(args)}  ${c10.dim("\u2014 run /models for the full list")}`);
+        writeln(`${PREFIX.error} unknown model ${c10.cyan(idArg)}  ${c10.dim("\u2014 run /models for the full list")}`);
         return;
       }
     }
     ctx.setModel(modelId);
-    writeln(`${PREFIX.success} model \u2192 ${c10.cyan(modelId)}`);
+    const effortArg = parts[1];
+    if (effortArg) {
+      if (effortArg === "off") {
+        ctx.setThinkingEffort(null);
+        writeln(`${PREFIX.success} model \u2192 ${c10.cyan(modelId)} ${c10.dim("(thinking disabled)")}`);
+      } else if (["low", "medium", "high", "xhigh"].includes(effortArg)) {
+        ctx.setThinkingEffort(effortArg);
+        writeln(`${PREFIX.success} model \u2192 ${c10.cyan(modelId)} ${c10.dim(`(\u2726 ${effortArg})`)}`);
+      } else {
+        writeln(`${PREFIX.success} model \u2192 ${c10.cyan(modelId)}`);
+        writeln(`${PREFIX.error} unknown effort level ${c10.cyan(effortArg)} (use low, medium, high, xhigh, off)`);
+      }
+    } else {
+      const e = ctx.thinkingEffort ? c10.dim(` (\u2726 ${ctx.thinkingEffort})`) : "";
+      writeln(`${PREFIX.success} model \u2192 ${c10.cyan(modelId)}${e}`);
+    }
     return;
   }
   writeln(`${c10.dim("  fetching models\u2026")}`);
@@ -3415,13 +3556,15 @@ async function handleModel(ctx, args) {
       const isCurrent = ctx.currentModel === m.id;
       const freeTag = m.free ? c10.green(" free") : "";
       const ctxTag = m.context ? c10.dim(` ${Math.round(m.context / 1000)}k`) : "";
+      const effortTag = isCurrent && ctx.thinkingEffort ? c10.dim(` \u2726 ${ctx.thinkingEffort}`) : "";
       const cur = isCurrent ? c10.cyan(" \u25C0") : "";
-      writeln(`    ${c10.dim("\xB7")} ${m.displayName}${freeTag}${ctxTag}${cur}`);
+      writeln(`    ${c10.dim("\xB7")} ${m.displayName}${freeTag}${ctxTag}${cur}${effortTag}`);
       writeln(`      ${c10.dim(m.id)}`);
     }
   }
   writeln();
   writeln(c10.dim("  /model <id>  to switch  \xB7  e.g. /model zen/claude-sonnet-4-6"));
+  writeln(c10.dim("  /model effort <low|medium|high|xhigh|off>  to set thinking effort"));
 }
 function handlePlan(ctx) {
   ctx.setPlanMode(!ctx.planMode);
@@ -4288,6 +4431,7 @@ class SessionRunner {
   tools;
   mcpTools;
   currentModel;
+  currentThinkingEffort;
   session;
   coreHistory;
   turnIndex = 1;
@@ -4303,6 +4447,7 @@ class SessionRunner {
     this.tools = opts.tools;
     this.mcpTools = opts.mcpTools;
     this.currentModel = opts.initialModel;
+    this.currentThinkingEffort = opts.initialThinkingEffort;
     this.initSession(opts.sessionId);
   }
   initSession(sessionId) {
@@ -4385,7 +4530,8 @@ class SessionRunner {
         messages: this.coreHistory,
         tools: this.planMode ? [...buildReadOnlyToolSet({ cwd: this.cwd }), ...this.mcpTools] : this.tools,
         systemPrompt,
-        signal: abortController.signal
+        signal: abortController.signal,
+        ...this.currentThinkingEffort ? { thinkingEffort: this.currentThinkingEffort } : {}
       });
       const { inputTokens, outputTokens, contextTokens, newMessages } = await this.reporter.renderTurn(events);
       if (newMessages.length > 0) {
@@ -4431,7 +4577,8 @@ class SessionRunner {
 async function runAgent(opts) {
   const cwd = opts.cwd;
   let currentModel = opts.model;
-  const runSubagent = createSubagentRunner(cwd, opts.reporter, () => currentModel);
+  let currentThinkingEffort = opts.initialThinkingEffort;
+  const runSubagent = createSubagentRunner(cwd, opts.reporter, () => currentModel, () => currentThinkingEffort);
   const agents = loadAgents(cwd);
   const tools = buildToolSet({
     cwd,
@@ -4472,6 +4619,7 @@ async function runAgent(opts) {
     tools,
     mcpTools,
     initialModel: currentModel,
+    initialThinkingEffort: opts.initialThinkingEffort,
     sessionId: opts.sessionId
   });
   const cmdCtx = {
@@ -4484,6 +4632,14 @@ async function runAgent(opts) {
       setPreferredModel(m);
       currentModel = m;
     },
+    get thinkingEffort() {
+      return runner.currentThinkingEffort;
+    },
+    setThinkingEffort: (e) => {
+      runner.currentThinkingEffort = e;
+      setPreferredThinkingEffort(e);
+      currentThinkingEffort = e;
+    },
     get planMode() {
       return runner.planMode;
     },
@@ -4527,7 +4683,8 @@ async function runAgent(opts) {
       outputTokens: runner.totalOut,
       contextTokens: runner.lastContextTokens,
       contextWindow: getContextWindow(runner.currentModel) ?? 0,
-      ralphMode: runner.ralphMode
+      ralphMode: runner.ralphMode,
+      thinkingEffort: runner.currentThinkingEffort
     });
   }
   if (opts.initialPrompt) {
@@ -4703,6 +4860,7 @@ async function main() {
     const agentOpts = {
       model,
       cwd: args.cwd,
+      initialThinkingEffort: getPreferredThinkingEffort(),
       reporter: new CliReporter
     };
     if (sessionId)

package/docs/configs.md

@@ -65,7 +65,7 @@ Custom subagents are configured in `.agents`:
 - `./.agents/agents/*.md`
 - `~/.agents/agents/*.md`
 
-(There is no `.claude` compatibility path for agents.)
+(There is no `.claude` compatibility path for agents. Claude doesn't have custom subagents)
 
 ## Precedence and conflicts
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mini-coder",
-	"version": "0.0.11",
+	"version": "0.0.13",
 	"description": "A small, fast CLI coding agent",
 	"module": "src/index.ts",
 	"type": "module",

package/hanging-bug.md

@@ -1,79 +0,0 @@
-# Hanging Bug Investigation
-
-## Symptoms
-
-After a shell tool call completes successfully, **SOMETIMES** the app hangs indefinitely instead of
-returning to the prompt. Two observed states:
-
-```
-  $ $ rm src/session/db.ts && bun run test
-⠇ shell
-```
-
-Stayed spinning with shell label for well over the timeout time. I had to kill the app.
-
-Another example with a different shell command:
-```
-  $ $ git diff
-    ✔ 0
-    │ diff --git a/src/cli/tool-render.ts b/src/cli/tool-render.ts
-    │ index f8d33af..e224932 100644
-    │ --- a/src/cli/tool-render.ts
-    │ +++ b/src/cli/tool-render.ts
-    │ @@ -148,21 +148,25 @@ export function renderToolResultInline(
-    │   }
-    │
-    │   if (toolName === "glob") {
-    │ -         const r = result as { files: string[]; truncated: boolean };
-    │ -         const n = r.files.length;
-    │ -         writeln(
-    │ -                 `${indent}${G.info} ${c.dim(n === 0 ? "no matches" : `${n} file${n === 1 ? "" : "s"}${r.truncated ? " (capped)" : ""}`)}`,
-    │ -         );
-    │ -         return;
-    │ +         const r = result as { files?: string[]; truncated?: boolean };
-    │ +         if (Array.isArray(r.files)) {
-    │ +                 const n = r.files.length;
-    │ +                 writeln(
-    │ +                         `${indent}${G.info} ${c.dim(n === 0 ? "no matches" : `${n} file${n === 1 ? "" : "s"}${r.truncated ? " (capped)" : ""}`)}`,
-    │ +                 );
-    │ … +150 lines
-⠦ thinking
-```
-User also had to kill the app.
-
-Only seen with Gemini/Google models.
-Only happens after shell tool calls.
-Other tools calls worked just fine during the same session with the same model and mini-coder version.
-There are no shell tool related hooks configured anywhere.
-
-The expectation was the turn to continue as normal since the tool calls succeded.
-
-Find the root cause, show proof.
-
-## Findings:
-
-Here is the concrete proof I just ran, no edits:
-- I executed renderTurn with an event stream that does:
-  1) tool-call-start(shell)
-  2) tool-result(shell success)
-  3) then never yields again
-- Result: the promise did not resolve within 700ms (timed_out_700ms).
-Then I ran the same sequence but added turn-complete:
-- Result: it resolved immediately (resolved).
-So this is now proven in your codepath:
-- renderTurn waits forever when the upstream async stream goes silent after a shell tool result.
-- This exactly matches the visible hang states.
-
-### Root Cause 1: Hangs spinning on `"shell"`
-**Proof in code:** `src/tools/shell.ts`
-*   When a command times out, `proc.kill("SIGTERM")` only kills the parent process (e.g., `bash`). Any child processes (e.g., `bun`) become orphaned but stay alive, holding the write end of the `stdout`/`stderr` pipes open. 
-*   Because the pipe never closes, `await reader.read()` inside `collectStream()` hangs indefinitely. 
-*   Because `collectStream()` never resolves, the tool execution never finishes, `tool-result` is never yielded, and the stream goes completely silent while the spinner stays stuck on "shell".
-   - **FIXED**
-
-### Root Cause 2: Hangs spinning on `"thinking"`
-**Proof in code:** `src/llm-api/turn.ts`
-*   After `git diff` completes, the tool resolves and `renderTurn` switches the spinner to `"thinking"`.
-*   The AI SDK automatically makes a new HTTP request to the Gemini API containing the tool result to generate the next step.
-*   Gemini's API occasionally hangs indefinitely or silently drops connections when receiving certain payloads (like large tool outputs or ANSI color codes, which `git diff` outputs).
-*   Because there is no timeout configured on the `streamText` call in `runTurn` (unless the user manually aborts), the underlying fetch request waits forever. The `result.fullStream` never yields the next chunk, but also never closes or errors.