@llmist/cli 15.11.0 → 15.13.0

package/dist/cli.js

@@ -51,7 +51,11 @@ var OPTION_FLAGS = {
   maxRetries: "--max-retries <count>",
   retryMinTimeout: "--retry-min-timeout <ms>",
   retryMaxTimeout: "--retry-max-timeout <ms>",
-  noRetry: "--no-retry"
+  noRetry: "--no-retry",
+  // Reasoning options
+  reasoning: "--reasoning [effort]",
+  noReasoning: "--no-reasoning",
+  reasoningBudget: "--reasoning-budget <tokens>"
 };
 var OPTION_DESCRIPTIONS = {
   model: "Model identifier, e.g. openai:gpt-5-nano or anthropic:claude-sonnet-4-5.",
@@ -88,7 +92,11 @@ var OPTION_DESCRIPTIONS = {
   maxRetries: "Maximum retry attempts for failed API calls.",
   retryMinTimeout: "Initial retry delay in milliseconds.",
   retryMaxTimeout: "Maximum retry delay in milliseconds.",
-  noRetry: "Disable retry logic for API calls."
+  noRetry: "Disable retry logic for API calls.",
+  // Reasoning descriptions
+  reasoning: "Enable reasoning mode. Optional effort: none, low, medium, high, maximum (default: medium).",
+  noReasoning: "Disable auto-enabled reasoning for reasoning-capable models.",
+  reasoningBudget: "Explicit reasoning token budget (Anthropic/Gemini 2.5). Overrides effort level."
 };
 var SUMMARY_PREFIX = "[llmist]";
 
@@ -98,7 +106,7 @@ import { Command, InvalidArgumentError as InvalidArgumentError2 } from "commande
 // package.json
 var package_default = {
   name: "@llmist/cli",
-  version: "15.11.0",
+  version: "15.13.0",
   description: "CLI for llmist - run LLM agents from the command line",
   type: "module",
   main: "dist/cli.js",
@@ -154,7 +162,7 @@ var package_default = {
     node: ">=22.0.0"
   },
   dependencies: {
-    llmist: "^15.11.0",
+    llmist: "^15.13.0",
     "@unblessed/node": "^1.0.0-alpha.23",
     chalk: "^5.6.2",
     commander: "^12.1.0",
@@ -168,7 +176,7 @@ var package_default = {
     zod: "^4.1.12"
   },
   devDependencies: {
-    "@llmist/testing": "^15.11.0",
+    "@llmist/testing": "^15.13.0",
     "@types/diff": "^8.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/marked-terminal": "^6.1.1",
@@ -180,7 +188,7 @@ var package_default = {
 };
 
 // src/agent-command.ts
-import { AgentBuilder, GadgetRegistry, isAbortError, text } from "llmist";
+import { AgentBuilder, GadgetRegistry, HookPresets, isAbortError, text } from "llmist";
 
 // src/builtin-gadgets.ts
 import { createGadget, HumanInputRequiredException, TaskCompletionSignal } from "llmist";
@@ -420,6 +428,7 @@ var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "log-llm-requests",
   "rate-limits",
   "retry",
+  "reasoning",
   "type"
   // Allowed for inheritance compatibility, ignored for built-in commands
 ]);
@@ -452,6 +461,7 @@ var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "log-llm-requests",
   "rate-limits",
   "retry",
+  "reasoning",
   "type"
   // Allowed for inheritance compatibility, ignored for built-in commands
 ]);
@@ -684,6 +694,39 @@ function validateRetryConfig(value, section) {
   }
   return result;
 }
+var REASONING_CONFIG_KEYS = /* @__PURE__ */ new Set(["enabled", "effort", "budget-tokens"]);
+var VALID_REASONING_EFFORTS = /* @__PURE__ */ new Set(["none", "low", "medium", "high", "maximum"]);
+function validateReasoningConfig(value, section) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const raw = value;
+  const result = {};
+  for (const [key, val] of Object.entries(raw)) {
+    if (!REASONING_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}] has unknown key: ${key}`);
+    }
+    switch (key) {
+      case "enabled":
+        result.enabled = validateBoolean(val, key, section);
+        break;
+      case "effort": {
+        const effort = validateString(val, key, section);
+        if (!VALID_REASONING_EFFORTS.has(effort)) {
+          throw new ConfigError(
+            `[${section}].effort must be one of: none, low, medium, high, maximum (got "${effort}")`
+          );
+        }
+        result.effort = effort;
+        break;
+      }
+      case "budget-tokens":
+        result["budget-tokens"] = validateNumber(val, key, section, { integer: true, min: 1 });
+        break;
+    }
+  }
+  return result;
+}
 function validateGlobalSubagentConfig(value, section) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new ConfigError(`[${section}] must be a table`);
@@ -850,6 +893,9 @@ function validateCompleteConfig(raw, section) {
   if ("retry" in rawObj) {
     result.retry = validateRetryConfig(rawObj.retry, `${section}.retry`);
   }
+  if ("reasoning" in rawObj) {
+    result.reasoning = validateReasoningConfig(rawObj.reasoning, `${section}.reasoning`);
+  }
   return result;
 }
 function validateAgentConfig(raw, section) {
@@ -947,6 +993,9 @@ function validateAgentConfig(raw, section) {
   if ("retry" in rawObj) {
     result.retry = validateRetryConfig(rawObj.retry, `${section}.retry`);
   }
+  if ("reasoning" in rawObj) {
+    result.reasoning = validateReasoningConfig(rawObj.reasoning, `${section}.reasoning`);
+  }
   return result;
 }
 function validateImageConfig(raw, section) {
@@ -2800,27 +2849,6 @@ async function loadGadgets(specifiers, cwd, importer = createTypeScriptImporter(
   return gadgets;
 }
 
-// src/llm-logging.ts
-import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import { join as join2 } from "path";
-import { extractMessageText } from "llmist";
-function formatLlmRequest(messages) {
-  const lines = [];
-  for (const msg of messages) {
-    lines.push(`=== ${msg.role.toUpperCase()} ===`);
-    lines.push(msg.content ? extractMessageText(msg.content) : "");
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-async function writeLogFile(dir, filename, content) {
-  await mkdir(dir, { recursive: true });
-  await writeFile2(join2(dir, filename), content, "utf-8");
-}
-function formatCallNumber(n) {
-  return n.toString().padStart(4, "0");
-}
-
 // src/utils.ts
 import chalk2 from "chalk";
 import { InvalidArgumentError } from "commander";
@@ -3185,6 +3213,8 @@ var StreamProgress = class {
   // Cache token tracking for live cost estimation during streaming
   callCachedInputTokens = 0;
   callCacheCreationInputTokens = 0;
+  // Reasoning token tracking for live cost estimation during streaming
+  callReasoningTokens = 0;
   // Cumulative stats (cumulative mode)
   totalStartTime = Date.now();
   totalTokens = 0;
@@ -3303,6 +3333,7 @@ var StreamProgress = class {
       if (info.cachedInputTokens !== void 0) agent.cachedInputTokens = info.cachedInputTokens;
       if (info.cacheCreationInputTokens !== void 0)
         agent.cacheCreationInputTokens = info.cacheCreationInputTokens;
+      if (info.reasoningTokens !== void 0) agent.reasoningTokens = info.reasoningTokens;
       if (info.finishReason !== void 0) agent.finishReason = info.finishReason;
       if (info.cost !== void 0) {
         agent.cost = info.cost;
@@ -3314,7 +3345,8 @@ var StreamProgress = class {
             agent.inputTokens ?? 0,
             agent.outputTokens,
             agent.cachedInputTokens,
-            agent.cacheCreationInputTokens
+            agent.cacheCreationInputTokens,
+            agent.reasoningTokens
           );
           agent.cost = costResult?.totalCost;
         } catch {
@@ -3428,6 +3460,7 @@ var StreamProgress = class {
     this.isStreaming = false;
     this.callCachedInputTokens = 0;
     this.callCacheCreationInputTokens = 0;
+    this.callReasoningTokens = 0;
     this.start();
   }
   /**
@@ -3446,7 +3479,8 @@ var StreamProgress = class {
             usage.inputTokens,
             usage.outputTokens,
             usage.cachedInputTokens ?? 0,
-            usage.cacheCreationInputTokens ?? 0
+            usage.cacheCreationInputTokens ?? 0,
+            usage.reasoningTokens ?? 0
           );
           if (cost) {
             this.totalCost += cost.totalCost;
@@ -3505,6 +3539,14 @@ var StreamProgress = class {
     this.callCachedInputTokens = cachedInputTokens;
     this.callCacheCreationInputTokens = cacheCreationInputTokens;
   }
+  /**
+   * Sets reasoning token count for the current call (from stream metadata).
+   * Used for live cost estimation during streaming.
+   * @param reasoningTokens - Number of reasoning/thinking tokens (subset of outputTokens)
+   */
+  setReasoningTokens(reasoningTokens) {
+    this.callReasoningTokens = reasoningTokens;
+  }
   /**
    * Get total elapsed time in seconds since the first call started.
    * @returns Elapsed time in seconds with 1 decimal place
@@ -3746,7 +3788,8 @@ var StreamProgress = class {
         this.callInputTokens,
         outputTokens,
         this.callCachedInputTokens,
-        this.callCacheCreationInputTokens
+        this.callCacheCreationInputTokens,
+        this.callReasoningTokens
       );
       return cost?.totalCost ?? 0;
     } catch {
@@ -3967,7 +4010,11 @@ function addCompleteOptions(cmd, defaults) {
     OPTION_DESCRIPTIONS.retryMaxTimeout,
     createNumericParser({ label: "Max timeout", integer: true, min: 0 }),
     defaults?.retry?.["max-timeout"]
-  ).option(OPTION_FLAGS.noRetry, OPTION_DESCRIPTIONS.noRetry);
+  ).option(OPTION_FLAGS.noRetry, OPTION_DESCRIPTIONS.noRetry).option(OPTION_FLAGS.reasoning, OPTION_DESCRIPTIONS.reasoning).option(OPTION_FLAGS.noReasoning, OPTION_DESCRIPTIONS.noReasoning).option(
+    OPTION_FLAGS.reasoningBudget,
+    OPTION_DESCRIPTIONS.reasoningBudget,
+    createNumericParser({ label: "Reasoning budget", integer: true, min: 1 })
+  );
 }
 function addAgentOptions(cmd, defaults) {
   const gadgetAccumulator = (value, previous = []) => [
@@ -4030,7 +4077,11 @@ function addAgentOptions(cmd, defaults) {
     OPTION_DESCRIPTIONS.retryMaxTimeout,
     createNumericParser({ label: "Max timeout", integer: true, min: 0 }),
     defaults?.retry?.["max-timeout"]
-  ).option(OPTION_FLAGS.noRetry, OPTION_DESCRIPTIONS.noRetry);
+  ).option(OPTION_FLAGS.noRetry, OPTION_DESCRIPTIONS.noRetry).option(OPTION_FLAGS.reasoning, OPTION_DESCRIPTIONS.reasoning).option(OPTION_FLAGS.noReasoning, OPTION_DESCRIPTIONS.noReasoning).option(
+    OPTION_FLAGS.reasoningBudget,
+    OPTION_DESCRIPTIONS.reasoningBudget,
+    createNumericParser({ label: "Reasoning budget", integer: true, min: 1 })
+  );
 }
 function configToCompleteOptions(config) {
   const result = {};
@@ -4055,6 +4106,9 @@ function configToCompleteOptions(config) {
     if (r["max-timeout"] !== void 0) result.retryMaxTimeout = r["max-timeout"];
     if (r.enabled === false) result.noRetry = true;
   }
+  if (config.reasoning) {
+    result.profileReasoning = config.reasoning;
+  }
   return result;
 }
 function configToAgentOptions(config) {
@@ -4094,6 +4148,9 @@ function configToAgentOptions(config) {
     if (r["max-timeout"] !== void 0) result.retryMaxTimeout = r["max-timeout"];
     if (r.enabled === false) result.noRetry = true;
   }
+  if (config.reasoning) {
+    result.profileReasoning = config.reasoning;
+  }
   if (config["show-hints"] !== void 0) result.showHints = config["show-hints"];
   return result;
 }
@@ -4348,6 +4405,9 @@ function formatLLMCallCollapsed(node, selected) {
     if (d.outputTokens && d.outputTokens > 0) {
       parts.push(chalk3.dim("\u2193") + chalk3.green(` ${formatTokens(d.outputTokens)}`));
     }
+    if (d.reasoningTokens && d.reasoningTokens > 0) {
+      parts.push(chalk3.dim("\u{1F4AD}") + chalk3.magenta(` ${formatTokens(d.reasoningTokens)}`));
+    }
     if (d.elapsedSeconds !== void 0) {
       parts.push(chalk3.dim(`${d.elapsedSeconds.toFixed(1)}s`));
     }
@@ -4395,6 +4455,11 @@ function formatLLMCallExpanded(node) {
       `${indent}${chalk3.dim(BOX.vertical)} Output:  ${chalk3.green(formatTokens(d.outputTokens))} tokens`
     );
   }
+  if (d.reasoningTokens !== void 0 && d.reasoningTokens > 0) {
+    lines.push(
+      `${indent}${chalk3.dim(BOX.vertical)} Reason:  ${chalk3.magenta(formatTokens(d.reasoningTokens))} tokens`
+    );
+  }
   if (d.contextPercent !== void 0) {
     let contextColor = chalk3.green;
     if (d.contextPercent >= 80) contextColor = chalk3.red;
@@ -4654,6 +4719,8 @@ var BlockRenderer = class _BlockRenderer {
   nodeIdCounter = 0;
   /** Current LLM call node (for adding gadget children) */
   currentLLMCallId = null;
+  /** Current thinking block (accumulates chunks during streaming) */
+  currentThinkingId = null;
   /** Persisted expanded states (survives rebuildBlocks) */
   expandedStates = /* @__PURE__ */ new Map();
   /** Whether to auto-scroll to bottom on new content ("follow mode") */
@@ -4889,6 +4956,66 @@ var BlockRenderer = class _BlockRenderer {
     this.rebuildBlocks();
     return id;
   }
+  /**
+   * Add thinking content from a reasoning model.
+   * Creates a new thinking block on first chunk, appends to existing on subsequent chunks.
+   * The block lives as a child of the current LLM call.
+   *
+   * @param content - Thinking text chunk
+   * @param thinkingType - Whether this is actual thinking or redacted content
+   */
+  addThinking(content, thinkingType) {
+    if (this.currentThinkingId) {
+      const node2 = this.getNode(this.currentThinkingId);
+      if (node2 && node2.type === "thinking") {
+        node2.content += content;
+        this.updateBlock(this.currentThinkingId);
+        return;
+      }
+    }
+    const id = this.generateId("thinking");
+    const parentLLMCallId = this.currentLLMCallId;
+    let depth = 0;
+    if (parentLLMCallId) {
+      const parent = this.getNode(parentLLMCallId);
+      if (parent) {
+        depth = parent.depth + 1;
+      }
+    }
+    const node = {
+      id,
+      type: "thinking",
+      depth,
+      parentId: parentLLMCallId,
+      sessionId: this.currentSessionId,
+      content,
+      thinkingType,
+      isComplete: false,
+      children: []
+    };
+    this.nodes.set(id, node);
+    if (parentLLMCallId) {
+      const parent = this.getNode(parentLLMCallId);
+      parent.children.push(id);
+    } else {
+      this.rootIds.push(id);
+    }
+    this.currentThinkingId = id;
+    this.rebuildBlocks();
+  }
+  /**
+   * Complete the current thinking block.
+   * Called when the LLM call finishes to mark thinking as complete.
+   */
+  completeThinking() {
+    if (!this.currentThinkingId) return;
+    const node = this.getNode(this.currentThinkingId);
+    if (node && node.type === "thinking") {
+      node.isComplete = true;
+      this.updateBlock(this.currentThinkingId);
+    }
+    this.currentThinkingId = null;
+  }
   /**
    * Add a user message block (for REPL mid-session input).
    *
@@ -4972,6 +5099,7 @@ var BlockRenderer = class _BlockRenderer {
     this.selectableIds = [];
     this.selectedIndex = -1;
     this.currentLLMCallId = null;
+    this.currentThinkingId = null;
     for (const child of [...this.container.children]) {
       child.detach();
     }
@@ -5301,6 +5429,25 @@ ${fullContent}
         }
         return this.abbreviateToLines(fullContent, 2, selected);
       }
+      case "thinking": {
+        const DIM2 = "\x1B[2m";
+        const RED_DIM = "\x1B[2;31m";
+        const RESET3 = "\x1B[0m";
+        const contIndent = getContinuationIndent(node.depth);
+        if (node.thinkingType === "redacted") {
+          const header2 = `${indent}${RED_DIM}\u{1F512} [Redacted thinking block]${RESET3}`;
+          return header2;
+        }
+        if (!expanded) {
+          const firstLine = node.content.split("\n")[0]?.slice(0, 60) ?? "";
+          const suffix = node.isComplete ? "" : "...";
+          return `${indent}${DIM2}\u{1F4AD} Thinking${suffix} ${firstLine}${RESET3}`;
+        }
+        const tokenInfo = node.isComplete ? ` (${Math.ceil(node.content.length / 4)} tokens est.)` : "";
+        const header = `${indent}${DIM2}\u25BC \u{1F4AD} Thinking${tokenInfo}${RESET3}`;
+        const contentLines = node.content.split("\n").map((line) => `${contIndent}${DIM2}${line}${RESET3}`);
+        return [header, ...contentLines].join("\n");
+      }
       case "system_message": {
         const icon = this.getSystemMessageIcon(node.category);
         const color = this.getSystemMessageColor(node.category);
@@ -5640,6 +5787,8 @@ ${indicator}`;
         return true;
       case "llm_call":
         return false;
+      case "thinking":
+        return false;
       case "gadget": {
         const name = node.name;
         return name === "TellUser" || name === "AskUser" || name === "Finish";
@@ -5701,6 +5850,7 @@ ${indicator}`;
   handleTreeEvent(event, tree) {
     switch (event.type) {
       case "llm_call_start": {
+        this.currentThinkingId = null;
         let parentBlockId;
         if (event.parentId) {
           parentBlockId = this.treeNodeToBlockId.get(event.parentId);
@@ -5719,12 +5869,14 @@ ${indicator}`;
         break;
       }
       case "llm_call_complete": {
+        this.completeThinking();
         const blockId = this.treeNodeToBlockId.get(event.nodeId);
         if (blockId) {
           this.completeLLMCall(blockId, {
             inputTokens: event.usage?.inputTokens,
             cachedInputTokens: event.usage?.cachedInputTokens,
             outputTokens: event.usage?.outputTokens,
+            reasoningTokens: event.usage?.reasoningTokens,
             cost: event.cost,
             finishReason: event.finishReason ?? void 0
           });
@@ -5735,6 +5887,10 @@ ${indicator}`;
         }
         break;
       }
+      case "thinking": {
+        this.addThinking(event.content, event.thinkingType);
+        break;
+      }
       case "gadget_call": {
         let parentBlockId;
         if (event.parentId) {
@@ -6154,10 +6310,10 @@ var HintsBar = class {
 import { spawnSync as spawnSync2 } from "child_process";
 import { readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 function openEditorSync(initialContent = "") {
   const editor = process.env.VISUAL || process.env.EDITOR || "vi";
-  const tmpFile = join3(tmpdir(), `llmist-input-${Date.now()}.txt`);
+  const tmpFile = join2(tmpdir(), `llmist-input-${Date.now()}.txt`);
   writeFileSync2(tmpFile, initialContent, "utf-8");
   try {
     const parts = editor.split(/\s+/);
@@ -7425,6 +7581,7 @@ var StatusBar = class {
       inputTokens: 0,
       outputTokens: 0,
       cachedTokens: 0,
+      reasoningTokens: 0,
       cost: 0,
       startTime: Date.now(),
       iteration: 0,
@@ -7458,10 +7615,11 @@ var StatusBar = class {
    * Called when an LLM call completes.
    * Replaces streaming estimates with actual values.
    */
-  endCall(inputTokens, outputTokens, cachedTokens, cost) {
+  endCall(inputTokens, outputTokens, cachedTokens, cost, reasoningTokens = 0) {
     this.metrics.inputTokens += inputTokens;
     this.metrics.outputTokens += outputTokens;
     this.metrics.cachedTokens += cachedTokens;
+    this.metrics.reasoningTokens += reasoningTokens;
     this.metrics.cost += cost;
     this.streamingInputTokens = 0;
     this.streamingOutputTokens = 0;
@@ -7661,7 +7819,8 @@ var StatusBar = class {
               event.usage?.inputTokens ?? 0,
               event.usage?.outputTokens ?? 0,
               event.usage?.cachedInputTokens ?? 0,
-              event.cost ?? 0
+              event.cost ?? 0,
+              event.usage?.reasoningTokens ?? 0
             );
           }
           this.nodeIdToLabel.delete(event.nodeId);
@@ -7826,6 +7985,9 @@ var StatusBar = class {
       const outputPrefix = this.isStreaming ? "~" : "";
       parts.push(`${GREEN2}\u2193${outputPrefix}${formatTokens(displayOutputTokens)}${RESET3}`);
     }
+    if (this.metrics.reasoningTokens > 0) {
+      parts.push(`${MAGENTA2}\u{1F4AD}${formatTokens(this.metrics.reasoningTokens)}${RESET3}`);
+    }
     const earliestStart = this.getEarliestLLMCallStartTime();
     if (earliestStart !== null) {
       const elapsedSeconds = (Date.now() - earliestStart) / 1e3;
@@ -8069,6 +8231,8 @@ var TUIApp = class _TUIApp {
   handleEvent(event) {
     if (event.type === "text") {
       this.blockRenderer.addText(event.content);
+    } else if (event.type === "thinking") {
+      this.blockRenderer.addThinking(event.content, event.thinkingType);
     }
   }
   /**
@@ -8561,40 +8725,20 @@ async function executeAgent(promptArg, options, env, commandName) {
   let iterations = 0;
   const llmLogsEnabled = options.logLlmRequests === true;
   const llmLogDir = llmLogsEnabled ? env.session?.logDir : void 0;
-  let llmCallCounter = 0;
-  const _countGadgetOutputTokens = async (output) => {
-    if (!output) return void 0;
-    try {
-      const messages = [{ role: "assistant", content: output }];
-      return await client.countTokens(options.model, messages);
-    } catch {
-      return void 0;
-    }
-  };
   const resolvedSubagentConfig = buildSubagentConfigMap(
     options.model,
     options.subagents,
     options.globalSubagents
   );
-  const builder = new AgentBuilder(client).withModel(options.model).withSubagentConfig(resolvedSubagentConfig).withLogger(env.createLogger("llmist:cli:agent")).withHooks({
+  const tuiHooks = {
     observers: {
       // onLLMCallStart: Track iteration for status bar label formatting
       onLLMCallStart: async (context) => {
         if (context.subagentContext) return;
-        llmCallCounter++;
         if (tui) {
           tui.showLLMCallStart(iterations + 1);
         }
       },
-      // onLLMCallReady: Log the exact request being sent to the LLM
-      onLLMCallReady: async (context) => {
-        if (context.subagentContext) return;
-        if (llmLogDir) {
-          const filename = `${formatCallNumber(llmCallCounter)}.request`;
-          const content = formatLlmRequest(context.options.messages);
-          await writeLogFile(llmLogDir, filename, content);
-        }
-      },
       // onStreamChunk: Update status bar with real-time output token estimate
       onStreamChunk: async (context) => {
         if (context.subagentContext) return;
@@ -8602,15 +8746,11 @@ async function executeAgent(promptArg, options, env, commandName) {
         const estimatedOutputTokens = StatusBar.estimateTokens(context.accumulatedText);
         tui.updateStreamingTokens(estimatedOutputTokens);
       },
-      // onLLMCallComplete: Capture metadata for final summary and file logging
+      // onLLMCallComplete: Capture metadata for final summary
       onLLMCallComplete: async (context) => {
         if (context.subagentContext) return;
         _usage = context.usage;
         iterations = Math.max(iterations, context.iteration + 1);
-        if (llmLogDir) {
-          const filename = `${formatCallNumber(llmCallCounter)}.response`;
-          await writeLogFile(llmLogDir, filename, context.rawResponse);
-        }
         if (tui) {
           tui.clearRetry();
         }
@@ -8718,7 +8858,9 @@ ${ctx.gadgetName} requires interactive approval. Run in a terminal to approve.`
         };
       }
     }
-  });
+  };
+  const finalHooks = llmLogDir ? HookPresets.merge(HookPresets.fileLogging({ directory: llmLogDir }), tuiHooks) : tuiHooks;
+  const builder = new AgentBuilder(client).withModel(options.model).withSubagentConfig(resolvedSubagentConfig).withLogger(env.createLogger("llmist:cli:agent")).withHooks(finalHooks);
   const rateLimitConfig = resolveRateLimitConfig(
     options,
     options.globalRateLimits,
@@ -8741,6 +8883,27 @@ ${ctx.gadgetName} requires interactive approval. Run in a terminal to approve.`
   if (options.temperature !== void 0) {
     builder.withTemperature(options.temperature);
   }
+  if (options.reasoning === false) {
+    builder.withoutReasoning();
+  } else if (options.reasoning !== void 0 || options.reasoningBudget !== void 0) {
+    const effort = typeof options.reasoning === "string" ? options.reasoning : void 0;
+    builder.withReasoning({
+      enabled: true,
+      ...effort && { effort },
+      ...options.reasoningBudget && { budgetTokens: options.reasoningBudget }
+    });
+  } else if (options.profileReasoning) {
+    const cfg = options.profileReasoning;
+    if (cfg.enabled === false) {
+      builder.withoutReasoning();
+    } else {
+      builder.withReasoning({
+        enabled: true,
+        ...cfg.effort && { effort: cfg.effort },
+        ...cfg["budget-tokens"] && { budgetTokens: cfg["budget-tokens"] }
+      });
+    }
+  }
   if (tui) {
     builder.onHumanInput(async (question) => {
       return tui.waitForInput(question, "AskUser");
@@ -8831,6 +8994,11 @@ ${ctx.gadgetName} requires interactive approval. Run in a terminal to approve.`
       } else {
         if (event.type === "text") {
           env.stdout.write(event.content);
+        } else if (event.type === "thinking") {
+          const stderrTTY = env.stderr.isTTY === true;
+          if (stderrTTY && !options.quiet) {
+            env.stderr.write(`\x1B[2m${event.content}\x1B[0m`);
+          }
         } else if (event.type === "gadget_result" && event.result.gadgetName === "TellUser" && event.result.result) {
           env.stdout.write(`${event.result.result}
 `);
@@ -8897,6 +9065,7 @@ function registerAgentCommand(program, env, config, globalSubagents, globalRateL
         globalRetry,
         profileRateLimits: config?.["rate-limits"],
         profileRetry: config?.retry,
+        profileReasoning: config?.reasoning,
         showHints: config?.["show-hints"]
       };
       return executeAgent(prompt, mergedOptions, env, "agent");
@@ -8905,7 +9074,24 @@ function registerAgentCommand(program, env, config, globalSubagents, globalRateL
 }
 
 // src/complete-command.ts
-import { FALLBACK_CHARS_PER_TOKEN as FALLBACK_CHARS_PER_TOKEN2, LLMMessageBuilder, resolveModel as resolveModel2, text as text2 } from "llmist";
+import {
+  FALLBACK_CHARS_PER_TOKEN as FALLBACK_CHARS_PER_TOKEN2,
+  formatLlmRequest as formatLlmRequest2,
+  LLMMessageBuilder,
+  resolveModel as resolveModel2,
+  text as text2
+} from "llmist";
+
+// src/llm-logging.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { formatCallNumber, formatLlmRequest } from "llmist";
+async function writeLogFile(dir, filename, content) {
+  await mkdir(dir, { recursive: true });
+  await writeFile2(join3(dir, filename), content, "utf-8");
+}
+
+// src/complete-command.ts
 async function executeComplete(promptArg, options, env) {
   const prompt = await resolvePrompt(promptArg, env);
   const client = env.createClient();
@@ -8931,14 +9117,37 @@ async function executeComplete(promptArg, options, env) {
   const llmLogDir = llmLogsEnabled ? env.session?.logDir : void 0;
   if (llmLogDir) {
     const filename = "0001.request";
-    const content = formatLlmRequest(messages);
+    const content = formatLlmRequest2(messages);
     await writeLogFile(llmLogDir, filename, content);
   }
+  let reasoning;
+  if (options.reasoning === false) {
+    reasoning = { enabled: false };
+  } else if (options.reasoning !== void 0 || options.reasoningBudget !== void 0) {
+    const effort = typeof options.reasoning === "string" ? options.reasoning : void 0;
+    reasoning = {
+      enabled: true,
+      ...effort && { effort },
+      ...options.reasoningBudget && { budgetTokens: options.reasoningBudget }
+    };
+  } else if (options.profileReasoning) {
+    const cfg = options.profileReasoning;
+    if (cfg.enabled === false) {
+      reasoning = { enabled: false };
+    } else {
+      reasoning = {
+        enabled: true,
+        ...cfg.effort && { effort: cfg.effort },
+        ...cfg["budget-tokens"] && { budgetTokens: cfg["budget-tokens"] }
+      };
+    }
+  }
   const stream = client.stream({
     model,
     messages,
     temperature: options.temperature,
-    maxTokens: options.maxTokens
+    maxTokens: options.maxTokens,
+    ...reasoning && { reasoning }
   });
   const printer = new StreamPrinter(env.stdout);
   const stderrTTY = env.stderr.isTTY === true;
@@ -8958,6 +9167,12 @@ async function executeComplete(promptArg, options, env) {
         progress.setOutputTokens(chunk.usage.outputTokens, false);
       }
     }
+    if (chunk.thinking?.content) {
+      if (stderrTTY && !options.quiet) {
+        progress.pause();
+        env.stderr.write(`\x1B[2m${chunk.thinking.content}\x1B[0m`);
+      }
+    }
     if (chunk.text) {
       progress.pause();
       accumulatedResponse += chunk.text;
@@ -8991,7 +9206,8 @@ function registerCompleteCommand(program, env, config, globalRateLimits, globalR
       const mergedOptions = {
         ...options,
         globalRateLimits,
-        globalRetry
+        globalRetry,
+        profileReasoning: config?.reasoning
       };
       return executeComplete(prompt, mergedOptions, env);
     }, env)