reasonix 0.3.1 → 0.3.2

package/README.md

@@ -6,20 +6,25 @@
 [![downloads](https://img.shields.io/npm/dm/reasonix.svg)](https://www.npmjs.com/package/reasonix)
 [![node](https://img.shields.io/node/v/reasonix.svg)](./package.json)
 
-**The DeepSeek-native agent framework.** TypeScript. Ink TUI. No LangChain.
-
-Reasonix is not another generic agent wrapper. Every abstraction is justified
-by a DeepSeek-specific property — dirt-cheap tokens, R1 reasoning traces,
-automatic prefix caching, JSON mode. Generic frameworks treat DeepSeek as
-"OpenAI with a different base URL" and leave these advantages on the table.
-Reasonix leans into them.
+**A DeepSeek-native AI coding assistant in your terminal.** Ink TUI. MCP
+first-class. No LangChain.
 
 ```bash
-npx reasonix chat          # first run prompts for your DeepSeek key
-                           # inside the TUI, type /help for everything else
+npx reasonix
 ```
 
-No flag soup. All feature toggles live behind slash commands in the TUI.
+One command. First run walks you through a 30-second wizard (API key →
+preset → pick MCP servers from a checklist); every run after that drops
+straight into chat with your tools wired up. Inside the chat, type `/help`.
+
+Why bother with yet another agent framework? Because every abstraction
+here earns its weight against a DeepSeek-specific property — dirt-cheap
+tokens, R1 reasoning traces, automatic prefix caching, JSON mode.
+Generic wrappers treat DeepSeek as "OpenAI with a different base URL"
+and leave these advantages on the table. Reasonix leans into them:
+on the same τ-bench-lite workload,
+[**94.4% cache hit, ~40% cheaper tokens, 100% pass rate**](#validated-numbers)
+vs. a cache-hostile baseline.
 
 ---
 
@@ -27,12 +32,15 @@ No flag soup. All feature toggles live behind slash commands in the TUI.
 
 | Feature | How it works | Opt in |
 |---|---|---|
+| **Setup wizard** | First run of `npx reasonix`: pick preset, multi-select MCP servers from a curated catalog, saved to config so the next run just launches chat | always on (first run) |
+| **MCP (stdio + SSE)** | Multi-server bridge — every MCP tool inherits Cache-First + repair + context-safety automatically. `reasonix mcp list` shows the catalog | always on |
 | **Cache-First Loop** | Immutable prefix + append-only log = prefix byte-stable across turns → DeepSeek's automatic prefix cache hits at 70–95% | always on |
-| **R1 Thought Harvesting** | Parses `reasoning_content` into typed `{ subgoals, hypotheses, uncertainties, rejectedPaths }` via a cheap V3 call | `--harvest` |
-| **Self-Consistency Branching** | Runs N parallel samples at spread temperatures; picks the one with the fewest flagged uncertainties | `--branch <N>` |
+| **Context safety net** | Tool results capped at 32k chars · oversized sessions auto-heal on load · `/compact` to shrink further · ctx gauge in the status bar · Esc to abort exploration and get a forced summary | always on |
+| **R1 Thought Harvesting** | Parses `reasoning_content` into typed `{ subgoals, hypotheses, uncertainties, rejectedPaths }` via a cheap V3 call | `/preset smart` |
+| **Self-Consistency Branching** | Runs N parallel samples at spread temperatures; picks the one with the fewest flagged uncertainties | `/preset max` / `/branch N` |
 | **Tool-Call Repair** | Auto-flattens deep/wide schemas, scavenges tool calls leaked into `<think>`, repairs truncated JSON, breaks call-storms | always on |
 | **Retry layer** | Exponential backoff + jitter on 408/429/500/502/503/504 and network errors. 4xx auth errors don't retry | always on |
-| **Ink TUI** | Live cache-hit / cost panel. Streams R1 thinking to a compact preview. Renders Markdown (bold / lists / code / stripped LaTeX) | always on |
+| **Ink TUI** | Live cache-hit / cost / context panel. Streams R1 thinking to a compact preview. Renders Markdown (bold / lists / code / stripped LaTeX) | always on |
 
 ---
 
@@ -91,10 +99,12 @@ with your own API key: `npx tsx benchmarks/tau-bench/runner.ts --repeats 3`.
 
 [r]: ./benchmarks/tau-bench/report.md
 
-### Extends to MCP (v0.3-alpha)
+### MCP — works out of the box
 
 Any [MCP](https://spec.modelcontextprotocol.io/) server's tools inherit
-the same Cache-First benefits. Two live runs, two data points:
+Cache-First + repair + context-safety automatically. The wizard (`npx
+reasonix`) lets you multi-select from a curated catalog — no flags, no
+JSON-by-hand. Three live reference runs:
 
 | server | turns | tool calls | cache hit | cost | vs Claude |
 |---|---:|---:|---:|---:|---:|
@@ -103,40 +113,21 @@ the same Cache-First benefits. Two live runs, two data points:
 | **both concurrently** (`demo_add` + `fs_write_file`) | 5 | 4 | **81.1%** | $0.001852 | −95.9% |
 
 The third row is the ecosystem proof: two MCP servers running as
-separate subprocesses, tools from both exercised in one conversation
-(compute `17+25` with the demo server, write the result to a real file
-via the filesystem server). **One single prefix hash across all 5
-turns** — byte-stability survives concurrent MCP subprocesses.
+separate subprocesses, tools from both exercised in one conversation.
+**One single prefix hash across all 5 turns** — byte-stability survives
+concurrent MCP subprocesses.
 
-**Reproduce without an API key** (replay the committed transcripts):
+Reproduce without an API key (replay the committed transcripts):
 
 ```bash
 npx reasonix replay benchmarks/tau-bench/transcripts/mcp-demo.add.jsonl
 npx reasonix replay benchmarks/tau-bench/transcripts/mcp-filesystem.jsonl
 ```
 
-**Reproduce with your own key** (live, ~$0.002):
-
-```bash
-# Don't know what MCP servers exist? Start here:
-reasonix mcp list
-# Prints a curated catalog (filesystem, fetch, github, sqlite, …) with
-# ready-to-paste --mcp commands.
-
-# One server:
-reasonix chat --mcp "filesystem=npx -y @modelcontextprotocol/server-filesystem /tmp/safe"
-
-# Multiple servers at once — each gets its own namespace prefix:
-reasonix chat \
-  --mcp "fs=npx -y @modelcontextprotocol/server-filesystem /tmp/safe" \
-  --mcp "mem=npx -y @modelcontextprotocol/server-memory"
-# Tools land in a shared registry as fs_read_file, mem_set, etc.
-
-# Remote / hosted MCP server — pass an http(s) URL instead of a command.
-# Reasonix opens an SSE stream and POSTs JSON-RPC to the endpoint the
-# server advertises (MCP 2024-11-05 HTTP+SSE transport).
-reasonix chat --mcp "kb=https://mcp.example.com/sse"
-```
+Supported transports: **stdio** (local `npx` or binary) and **HTTP+SSE**
+(remote / hosted servers, MCP 2024-11-05 spec). Pass an `http(s)://`
+URL to `--mcp` and Reasonix opens the SSE stream and POSTs JSON-RPC
+to the endpoint the server advertises.
 
 [mcp]: ./benchmarks/tau-bench/transcripts/mcp-demo.add.jsonl
 
@@ -144,55 +135,66 @@ reasonix chat --mcp "kb=https://mcp.example.com/sse"
 
 ## Usage
 
-### CLI
+### One command
 
 ```bash
-npx reasonix chat                # auto-saves to session 'default'; resumes next time
-npx reasonix chat --session work # use a different named session
-npx reasonix chat --no-session   # ephemeral — nothing persisted
-npx reasonix run "ask anything"  # one-shot, streams to stdout
-npx reasonix stats session.jsonl # quick summary of a transcript
-npx reasonix replay chat.jsonl   # pretty-print a transcript + rebuild cost/cache offline
-npx reasonix diff a.jsonl b.jsonl --md diff.md   # compare two transcripts: cache/cost delta + first divergence
+npx reasonix
 ```
 
-Sessions live as JSONL under `~/.reasonix/sessions/<name>.jsonl` — every
-turn's message log is appended atomically, so killing the CLI never loses
-context. Inside the TUI: `/sessions` to list, `/forget` to delete the
-current one.
+First run: a wizard asks for your API key, lets you pick a preset
+(fast / smart / max), then offers a multi-select checklist of MCP
+servers — filesystem, memory, github, puppeteer, everything. Everything
+is saved to `~/.reasonix/config.json`. Subsequent runs drop straight
+into chat.
 
-### Inside the chat — slash commands
+### Inside the chat
 
-A command strip runs under the input box so you don't have to memorize
-anything. Type `/help` for the full list. The biggest shortcut:
+A status bar at the top shows cache hit %, cost, Claude-equivalent, and
+the **context gauge** (`ctx 42k/131k (32%)` — yellow at 50%, red + a
+`/compact` nudge at 80%). A command strip under the input lists the
+slash commands:
 
 ```
-/preset fast     deepseek-chat, no harvest, no branch        (default)
-/preset smart    reasoner + harvest                           (~10x cost)
-/preset max      reasoner + harvest + branch 3                (~30x cost, slowest)
+/help                   full list + hints
+/preset <fast|smart|max> one-tap bundles (model + harvest + branch)
+/mcp                    list attached MCP servers and tools
+/compact [cap]          shrink oversized tool results in history
+/sessions · /forget     list / delete saved sessions
+/setup                  reconfigure (exits and tells you to run `reasonix setup`)
+/clear · /exit
 ```
 
-One-tap switch between fast daily driver, careful thinker, and max-quality
-self-consistency. Individual knobs are available too:
+**Esc while thinking** — abort the current exploration and force the
+model to summarize what it already found. No more "model ran 24 tool
+calls and gave up" — you get an answer every time.
 
-```
-/status          show current model / harvest / branch / stream
-/model <id>      deepseek-chat or deepseek-reasoner
-/harvest [on|off] Pillar 2 — parse R1 reasoning into typed plan state
-/branch <N|off>  run N parallel samples per turn, pick most confident
-/clear           clear displayed history (log is kept)
-/exit            quit
-```
+Sessions live as JSONL under `~/.reasonix/sessions/<name>.jsonl` —
+every message appended atomically, so killing the CLI never loses
+context. Oversized tool results auto-heal on load, so poisoning a
+session with one giant `read_file` doesn't brick your history.
 
-The top panel shows active flags live: `· harvest · branch3` appear next to
-the model once enabled.
+### Advanced — CLI subcommands and flags
 
-### Flags (for automation / CI)
+```bash
+npx reasonix setup                       # reconfigure any time
+npx reasonix chat --session work         # a different named session
+npx reasonix chat --no-session           # ephemeral — nothing persisted
+npx reasonix run "ask anything"          # one-shot, streams to stdout
+npx reasonix stats session.jsonl         # summarize a transcript
+npx reasonix replay chat.jsonl           # scrub a transcript + rebuild cost/cache
+npx reasonix diff a.jsonl b.jsonl --md   # compare two transcripts
+npx reasonix mcp list                    # curated MCP server catalog
+```
 
-The same knobs are also available as CLI flags if you're scripting:
+Power users can still bypass config and drive Reasonix with flags:
 
 ```bash
-npx reasonix chat -m deepseek-reasoner --harvest --branch 3 --transcript session.jsonl
+npx reasonix chat \
+  --preset max \
+  --mcp "filesystem=npx -y @modelcontextprotocol/server-filesystem /tmp/safe" \
+  --mcp "kb=https://mcp.example.com/sse" \
+  --transcript session.jsonl \
+  --no-config   # ignore ~/.reasonix/config.json (for CI / reproducing issues)
 ```
 
 ### Library
@@ -238,16 +240,19 @@ console.log(loop.stats.summary());
 
 ### Configuration
 
-On first run the CLI prompts for your DeepSeek API key and saves it to
-`~/.reasonix/config.json`. Alternatives:
+The wizard handles everything on first run. If you'd rather use env vars
+(CI, shared boxes, etc.):
 
 ```bash
-export DEEPSEEK_API_KEY=sk-...        # env var (wins over config file)
+export DEEPSEEK_API_KEY=sk-...        # wins over ~/.reasonix/config.json
 export DEEPSEEK_BASE_URL=https://...  # optional alternate endpoint
 ```
 
 Get a key (free credit on signup): <https://platform.deepseek.com/api_keys>
 
+Re-run `npx reasonix setup` any time to add/remove MCP servers or switch
+preset — your existing selections are pre-checked.
+
 ---
 
 ## Non-goals
@@ -269,7 +274,7 @@ cd reasonix
 npm install
 npm run dev chat        # run CLI from source via tsx
 npm run build           # tsup to dist/
-npm test                # vitest (89 tests)
+npm test                # vitest (279 tests)
 npm run lint            # biome
 npm run typecheck       # tsc --noEmit
 ```

package/dist/cli/index.js

@@ -1155,6 +1155,12 @@ var CacheFirstLoop = class {
   resumedMessageCount;
   _turn = 0;
   _streamPreference;
+  /**
+   * Set by {@link abort} to short-circuit the tool-call loop after the
+   * current iteration. Reset at the start of each `step()` so an Esc
+   * during one turn doesn't poison the next.
+   */
+  _aborted = false;
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
@@ -1266,12 +1272,42 @@ var CacheFirstLoop = class {
     if (pendingUser !== null) msgs.push({ role: "user", content: pendingUser });
     return msgs;
   }
+  /**
+   * Signal the currently-running {@link step} that the user wants to
+   * stop exploring. Takes effect at the next iteration boundary — if a
+   * tool call is mid-flight it will be allowed to finish, then the
+   * loop diverts to the forced-summary path so the user gets an
+   * answer instead of a cliff. Called by the TUI on Esc.
+   */
+  abort() {
+    this._aborted = true;
+  }
   async *step(userInput) {
     this._turn++;
     this.scratch.reset();
+    this._aborted = false;
     let pendingUser = userInput;
     const toolSpecs = this.prefix.tools();
+    const warnAt = Math.max(1, Math.floor(this.maxToolIters * 0.7));
+    let warnedForIterBudget = false;
     for (let iter = 0; iter < this.maxToolIters; iter++) {
+      if (this._aborted) {
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 forcing summary from what was gathered`
+        };
+        yield* this.forceSummaryAfterIterLimit({ reason: "aborted" });
+        return;
+      }
+      if (!warnedForIterBudget && iter >= warnAt) {
+        warnedForIterBudget = true;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `${iter}/${this.maxToolIters} tool calls used \u2014 approaching budget. Press Esc to force a summary now.`
+        };
+      }
       const messages = this.buildMessages(pendingUser);
       let assistantContent = "";
       let reasoningContent = "";
@@ -1459,9 +1495,9 @@ var CacheFirstLoop = class {
         };
       }
     }
-    yield* this.forceSummaryAfterIterLimit();
+    yield* this.forceSummaryAfterIterLimit({ reason: "budget" });
   }
-  async *forceSummaryAfterIterLimit() {
+  async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
     try {
       const messages = this.buildMessages(null);
       const resp = await this.client.chat({
@@ -1470,7 +1506,8 @@ var CacheFirstLoop = class {
         // no tools → model is forced to answer in text
       });
       const summary = resp.content?.trim() || "(model returned no text; try a narrower question or raise --max-tool-iters)";
-      const annotated = `[tool-call budget (${this.maxToolIters}) reached \u2014 forcing summary from what I found]
+      const reasonPrefix = opts.reason === "aborted" ? "[aborted by user (Esc) \u2014 summarizing what I found so far]" : `[tool-call budget (${this.maxToolIters}) reached \u2014 forcing summary from what I found]`;
+      const annotated = `${reasonPrefix}
 
 ${summary}`;
       const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
@@ -1483,11 +1520,12 @@ ${summary}`;
       };
       yield { turn: this._turn, role: "done", content: summary };
     } catch (err) {
+      const label = opts.reason === "aborted" ? "aborted by user" : `tool-call budget (${this.maxToolIters}) reached`;
       yield {
         turn: this._turn,
         role: "error",
         content: "",
-        error: `tool-call budget (${this.maxToolIters}) reached and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or pass --max-tool-iters higher.`
+        error: `${label} and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`
       };
       yield { turn: this._turn, role: "done", content: "" };
     }
@@ -2533,14 +2571,14 @@ function parseMcpSpec(input) {
 }
 
 // src/index.ts
-var VERSION = "0.3.1";
+var VERSION = "0.3.2";
 
 // src/cli/commands/chat.tsx
 import { render } from "ink";
 import React8, { useState as useState4 } from "react";
 
 // src/cli/ui/App.tsx
-import { Box as Box6, Static, Text as Text6, useApp } from "ink";
+import { Box as Box6, Static, Text as Text6, useApp, useInput } from "ink";
 import React6, { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
 
 // src/cli/ui/EventLog.tsx
@@ -2771,6 +2809,9 @@ var EventRow = React3.memo(function EventRow2({ event }) {
   if (event.role === "info") {
     return /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, event.text));
   }
+  if (event.role === "warning") {
+    return /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, "\u25B8 "), /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, event.text));
+  }
   return /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, null, event.text));
 });
 function BranchBlock({ branch }) {
@@ -3059,6 +3100,7 @@ function App({
   const [streaming, setStreaming] = useState2(null);
   const [input, setInput] = useState2("");
   const [busy, setBusy] = useState2(false);
+  const abortedThisTurn = useRef(false);
   const [summary, setSummary] = useState2({
     turns: 0,
     totalCostUsd: 0,
@@ -3126,6 +3168,13 @@ function App({
       ]);
     }
   }, [session, loop]);
+  useInput((_input, key) => {
+    if (!key.escape) return;
+    if (!busy) return;
+    if (abortedThisTurn.current) return;
+    abortedThisTurn.current = true;
+    loop.abort();
+  });
   const prefixHash = loop.prefix.fingerprint;
   const writeTranscript = useCallback(
     (ev) => {
@@ -3171,6 +3220,7 @@ function App({
       const reasoningBuf = { current: "" };
       setStreaming({ id: assistantId, role: "assistant", text: "", streaming: true });
       setBusy(true);
+      abortedThisTurn.current = false;
       const flush = () => {
         if (!contentBuf.current && !reasoningBuf.current) return;
         streamRef.text += contentBuf.current;
@@ -3243,6 +3293,11 @@ function App({
               ...prev,
               { id: `e-${Date.now()}`, role: "error", text: ev.error ?? ev.content }
             ]);
+          } else if (ev.role === "warning") {
+            setHistorical((prev) => [
+              ...prev,
+              { id: `w-${Date.now()}-${Math.random()}`, role: "warning", text: ev.content }
+            ]);
           }
         }
         flush();
@@ -3267,7 +3322,7 @@ function App({
   ), /* @__PURE__ */ React6.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React6.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React6.createElement(Box6, { marginY: 1 }, /* @__PURE__ */ React6.createElement(EventRow, { event: streaming })) : null, /* @__PURE__ */ React6.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }), /* @__PURE__ */ React6.createElement(CommandStrip, null));
 }
 function CommandStrip() {
-  return /* @__PURE__ */ React6.createElement(Box6, { paddingX: 2 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "/help \xB7 /preset ", "<fast|smart|max>", " \xB7 /mcp \xB7 /compact \xB7 /sessions \xB7 /setup \xB7 /clear \xB7 /exit"));
+  return /* @__PURE__ */ React6.createElement(Box6, { paddingX: 2, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "/help \xB7 /preset ", "<fast|smart|max>", " \xB7 /mcp \xB7 /compact \xB7 /sessions \xB7 /setup \xB7 /clear \xB7 /exit"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "Esc (while thinking) \u2014 abort & summarize what was found so far"));
 }
 function describeRepair(repair) {
   const parts = [];
@@ -3404,7 +3459,7 @@ import { render as render2 } from "ink";
 import React11 from "react";
 
 // src/cli/ui/DiffApp.tsx
-import { Box as Box9, Static as Static2, Text as Text9, useApp as useApp3, useInput } from "ink";
+import { Box as Box9, Static as Static2, Text as Text9, useApp as useApp3, useInput as useInput2 } from "ink";
 import React10, { useState as useState5 } from "react";
 
 // src/cli/ui/RecordView.tsx
@@ -3449,7 +3504,7 @@ function DiffApp({ report }) {
   const maxIdx = Math.max(0, report.pairs.length - 1);
   const initialIdx = report.firstDivergenceTurn ? report.pairs.findIndex((p) => p.turn === report.firstDivergenceTurn) : 0;
   const [idx, setIdx] = useState5(Math.max(0, initialIdx));
-  useInput((input, key) => {
+  useInput2((input, key) => {
     if (input === "q" || key.ctrl && input === "c") {
       exit();
       return;
@@ -3629,13 +3684,13 @@ import { render as render3 } from "ink";
 import React13 from "react";
 
 // src/cli/ui/ReplayApp.tsx
-import { Box as Box10, Static as Static3, Text as Text10, useApp as useApp4, useInput as useInput2 } from "ink";
+import { Box as Box10, Static as Static3, Text as Text10, useApp as useApp4, useInput as useInput3 } from "ink";
 import React12, { useMemo as useMemo2, useState as useState6 } from "react";
 function ReplayApp({ meta, pages }) {
   const { exit } = useApp4();
   const maxIdx = Math.max(0, pages.length - 1);
   const [idx, setIdx] = useState6(maxIdx);
-  useInput2((input, key) => {
+  useInput3((input, key) => {
     if (input === "q" || key.ctrl && input === "c") {
       exit();
       return;
@@ -3990,12 +4045,12 @@ import { render as render4 } from "ink";
 import React16 from "react";
 
 // src/cli/ui/Wizard.tsx
-import { Box as Box12, Text as Text12, useApp as useApp5, useInput as useInput4 } from "ink";
+import { Box as Box12, Text as Text12, useApp as useApp5, useInput as useInput5 } from "ink";
 import TextInput3 from "ink-text-input";
 import React15, { useState as useState8 } from "react";
 
 // src/cli/ui/Select.tsx
-import { Box as Box11, Text as Text11, useInput as useInput3 } from "ink";
+import { Box as Box11, Text as Text11, useInput as useInput4 } from "ink";
 import React14, { useState as useState7 } from "react";
 function SingleSelect({
   items,
@@ -4008,7 +4063,7 @@ function SingleSelect({
     items.findIndex((i) => i.value === initialValue && !i.disabled)
   );
   const [index, setIndex] = useState7(initialIndex === -1 ? 0 : initialIndex);
-  useInput3((_input, key) => {
+  useInput4((_input, key) => {
     if (key.upArrow) {
       setIndex((i) => findNextEnabled(items, i, -1));
     } else if (key.downArrow) {
@@ -4042,7 +4097,7 @@ function MultiSelect({
     return first === -1 ? 0 : first;
   });
   const [selected, setSelected] = useState7(new Set(initialSelected));
-  useInput3((input, key) => {
+  useInput4((input, key) => {
     if (key.upArrow) {
       setIndex((i) => findNextEnabled(items, i, -1));
     } else if (key.downArrow) {
@@ -4128,7 +4183,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
     catalogArgs: {}
   });
   const [error, setError] = useState8(null);
-  useInput4((_input, key) => {
+  useInput5((_input, key) => {
     if (key.escape && step !== "saved" && onCancel) onCancel();
   });
   if (step === "apiKey") {
@@ -4290,13 +4345,13 @@ function McpArgsStep({
   )), error ? /* @__PURE__ */ React15.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React15.createElement(Text12, { color: "red" }, error)) : null));
 }
 function ReviewConfirm({ onConfirm }) {
-  useInput4((_i, key) => {
+  useInput5((_i, key) => {
     if (key.return) onConfirm();
   });
   return null;
 }
 function ExitOnEnter({ onExit }) {
-  useInput4((_i, key) => {
+  useInput5((_i, key) => {
     if (key.return) onExit();
   });
   return null;