reasonix 0.3.0-alpha.4 → 0.3.1

package/dist/index.js

@@ -404,6 +404,201 @@ function resolveTemperatures(budget, custom) {
   return out;
 }
 
+// src/repair/flatten.ts
+function analyzeSchema(schema) {
+  if (!schema) return { shouldFlatten: false, leafCount: 0, maxDepth: 0 };
+  let leafCount = 0;
+  let maxDepth = 0;
+  walk(schema, 0, (depth, isLeaf) => {
+    if (isLeaf) leafCount++;
+    if (depth > maxDepth) maxDepth = depth;
+  });
+  return {
+    shouldFlatten: leafCount > 10 || maxDepth > 2,
+    leafCount,
+    maxDepth
+  };
+}
+function flattenSchema(schema) {
+  const flatProps = {};
+  const required = [];
+  collect("", schema, flatProps, required, true);
+  return {
+    type: "object",
+    properties: flatProps,
+    required
+  };
+}
+function nestArguments(flatArgs) {
+  const out = {};
+  for (const [key, value] of Object.entries(flatArgs)) {
+    setByPath(out, key.split("."), value);
+  }
+  return out;
+}
+function walk(schema, depth, visit) {
+  if (schema.type === "object" && schema.properties) {
+    for (const child of Object.values(schema.properties)) {
+      walk(child, depth + 1, visit);
+    }
+    return;
+  }
+  if (schema.type === "array" && schema.items) {
+    walk(schema.items, depth + 1, visit);
+    return;
+  }
+  visit(depth, true);
+}
+function collect(prefix, schema, out, required, isRootRequired) {
+  if (schema.type === "object" && schema.properties) {
+    const requiredSet = new Set(schema.required ?? []);
+    for (const [key, child] of Object.entries(schema.properties)) {
+      const nextPrefix = prefix ? `${prefix}.${key}` : key;
+      const childRequired = isRootRequired && requiredSet.has(key);
+      collect(nextPrefix, child, out, required, childRequired);
+    }
+    return;
+  }
+  out[prefix] = schema;
+  if (isRootRequired) required.push(prefix);
+}
+function setByPath(target, path, value) {
+  let cur = target;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (typeof cur[key] !== "object" || cur[key] === null) cur[key] = {};
+    cur = cur[key];
+  }
+  cur[path[path.length - 1]] = value;
+}
+
+// src/tools.ts
+var ToolRegistry = class {
+  _tools = /* @__PURE__ */ new Map();
+  _autoFlatten;
+  constructor(opts = {}) {
+    this._autoFlatten = opts.autoFlatten !== false;
+  }
+  register(def) {
+    if (!def.name) throw new Error("tool requires a name");
+    const internal = { ...def };
+    if (this._autoFlatten && def.parameters) {
+      const decision = analyzeSchema(def.parameters);
+      if (decision.shouldFlatten) {
+        internal.flatSchema = flattenSchema(def.parameters);
+      }
+    }
+    this._tools.set(def.name, internal);
+    return this;
+  }
+  has(name) {
+    return this._tools.has(name);
+  }
+  get(name) {
+    return this._tools.get(name);
+  }
+  get size() {
+    return this._tools.size;
+  }
+  /** True if a registered tool's schema was flattened for the model. */
+  wasFlattened(name) {
+    return Boolean(this._tools.get(name)?.flatSchema);
+  }
+  specs() {
+    return [...this._tools.values()].map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description ?? "",
+        parameters: t.flatSchema ?? t.parameters ?? { type: "object", properties: {} }
+      }
+    }));
+  }
+  async dispatch(name, argumentsRaw) {
+    const tool = this._tools.get(name);
+    if (!tool) {
+      return JSON.stringify({ error: `unknown tool: ${name}` });
+    }
+    let args;
+    try {
+      args = typeof argumentsRaw === "string" ? argumentsRaw.trim() ? JSON.parse(argumentsRaw) ?? {} : {} : argumentsRaw ?? {};
+    } catch (err) {
+      return JSON.stringify({
+        error: `invalid tool arguments JSON: ${err.message}`
+      });
+    }
+    if (tool.flatSchema && args && typeof args === "object" && hasDotKey(args)) {
+      args = nestArguments(args);
+    }
+    try {
+      const result = await tool.fn(args);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    } catch (err) {
+      return JSON.stringify({
+        error: `${err.name}: ${err.message}`
+      });
+    }
+  }
+};
+function hasDotKey(obj) {
+  for (const k of Object.keys(obj)) {
+    if (k.includes(".")) return true;
+  }
+  return false;
+}
+
+// src/mcp/registry.ts
+var DEFAULT_MAX_RESULT_CHARS = 32e3;
+async function bridgeMcpTools(client, opts = {}) {
+  const registry = opts.registry ?? new ToolRegistry({ autoFlatten: opts.autoFlatten });
+  const prefix = opts.namePrefix ?? "";
+  const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS;
+  const result = { registry, registeredNames: [], skipped: [] };
+  const listed = await client.listTools();
+  for (const mcpTool of listed.tools) {
+    if (!mcpTool.name) {
+      result.skipped.push({ name: "?", reason: "empty tool name" });
+      continue;
+    }
+    const registeredName = `${prefix}${mcpTool.name}`;
+    registry.register({
+      name: registeredName,
+      description: mcpTool.description ?? "",
+      parameters: mcpTool.inputSchema,
+      fn: async (args) => {
+        const toolResult = await client.callTool(mcpTool.name, args);
+        return flattenMcpResult(toolResult, { maxChars: maxResultChars });
+      }
+    });
+    result.registeredNames.push(registeredName);
+  }
+  return result;
+}
+function flattenMcpResult(result, opts = {}) {
+  const parts = result.content.map(blockToString);
+  const joined = parts.join("\n").trim();
+  const prefixed = result.isError ? `ERROR: ${joined || "(no error message from server)"}` : joined;
+  return opts.maxChars ? truncateForModel(prefixed, opts.maxChars) : prefixed;
+}
+function truncateForModel(s, maxChars) {
+  if (s.length <= maxChars) return s;
+  const tailBudget = Math.min(1024, Math.floor(maxChars * 0.1));
+  const headBudget = Math.max(0, maxChars - tailBudget);
+  const head = s.slice(0, headBudget);
+  const tail = s.slice(-tailBudget);
+  const dropped = s.length - head.length - tail.length;
+  return `${head}
+
+[\u2026truncated ${dropped} chars \u2014 raise BridgeOptions.maxResultChars, or call the tool with a narrower scope (filter, head, pagination)\u2026]
+
+${tail}`;
+}
+function blockToString(block) {
+  if (block.type === "text") return block.text;
+  if (block.type === "image") return `[image ${block.mimeType}, ${block.data.length} chars base64]`;
+  return `[unknown block: ${JSON.stringify(block)}]`;
+}
+
 // src/memory.ts
 import { createHash } from "crypto";
 var ImmutablePrefix = class {
@@ -441,6 +636,16 @@ var AppendOnlyLog = class {
   extend(messages) {
     for (const m of messages) this.append(m);
   }
+  /**
+   * Bulk-replace entries. Intentionally named to be hard to reach for —
+   * this is the one mutation path that breaks the log's append-only
+   * spirit, reserved for compaction flows (`/compact`) and recovery
+   * where the caller has consciously decided to drop old history. Any
+   * other use is almost certainly wrong; append() is what you want.
+   */
+  compactInPlace(replacement) {
+    this._entries = [...replacement];
+  }
   get entries() {
     return this._entries;
   }
@@ -655,74 +860,6 @@ function repairTruncatedJson(input) {
   }
 }
 
-// src/repair/flatten.ts
-function analyzeSchema(schema) {
-  if (!schema) return { shouldFlatten: false, leafCount: 0, maxDepth: 0 };
-  let leafCount = 0;
-  let maxDepth = 0;
-  walk(schema, 0, (depth, isLeaf) => {
-    if (isLeaf) leafCount++;
-    if (depth > maxDepth) maxDepth = depth;
-  });
-  return {
-    shouldFlatten: leafCount > 10 || maxDepth > 2,
-    leafCount,
-    maxDepth
-  };
-}
-function flattenSchema(schema) {
-  const flatProps = {};
-  const required = [];
-  collect("", schema, flatProps, required, true);
-  return {
-    type: "object",
-    properties: flatProps,
-    required
-  };
-}
-function nestArguments(flatArgs) {
-  const out = {};
-  for (const [key, value] of Object.entries(flatArgs)) {
-    setByPath(out, key.split("."), value);
-  }
-  return out;
-}
-function walk(schema, depth, visit) {
-  if (schema.type === "object" && schema.properties) {
-    for (const child of Object.values(schema.properties)) {
-      walk(child, depth + 1, visit);
-    }
-    return;
-  }
-  if (schema.type === "array" && schema.items) {
-    walk(schema.items, depth + 1, visit);
-    return;
-  }
-  visit(depth, true);
-}
-function collect(prefix, schema, out, required, isRootRequired) {
-  if (schema.type === "object" && schema.properties) {
-    const requiredSet = new Set(schema.required ?? []);
-    for (const [key, child] of Object.entries(schema.properties)) {
-      const nextPrefix = prefix ? `${prefix}.${key}` : key;
-      const childRequired = isRootRequired && requiredSet.has(key);
-      collect(nextPrefix, child, out, required, childRequired);
-    }
-    return;
-  }
-  out[prefix] = schema;
-  if (isRootRequired) required.push(prefix);
-}
-function setByPath(target, path, value) {
-  let cur = target;
-  for (let i = 0; i < path.length - 1; i++) {
-    const key = path[i];
-    if (typeof cur[key] !== "object" || cur[key] === null) cur[key] = {};
-    cur = cur[key];
-  }
-  cur[path[path.length - 1]] = value;
-}
-
 // src/repair/index.ts
 var ToolCallRepair = class {
   storm;
@@ -787,7 +924,8 @@ import {
   readFileSync,
   readdirSync,
   statSync,
-  unlinkSync
+  unlinkSync,
+  writeFileSync
 } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
@@ -856,6 +994,17 @@ function deleteSession(name) {
     return false;
   }
 }
+function rewriteSession(name, messages) {
+  const path = sessionPath(name);
+  mkdirSync(dirname(path), { recursive: true });
+  const body = messages.map((m) => JSON.stringify(m)).join("\n");
+  writeFileSync(path, body ? `${body}
+` : "", "utf8");
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
 function countLines(path) {
   try {
     const raw = readFileSync(path, "utf8");
@@ -914,12 +1063,14 @@ var SessionStats = class {
     return denom > 0 ? hit / denom : 0;
   }
   summary() {
+    const last = this.turns[this.turns.length - 1];
     return {
       turns: this.turns.length,
       totalCostUsd: round(this.totalCost, 6),
       claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
       savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
-      cacheHitRatio: round(this.aggregateCacheHitRatio, 4)
+      cacheHitRatio: round(this.aggregateCacheHitRatio, 4),
+      lastPromptTokens: last?.usage.promptTokens ?? 0
     };
   }
 };
@@ -928,81 +1079,6 @@ function round(n, digits) {
   return Math.round(n * f) / f;
 }
 
-// src/tools.ts
-var ToolRegistry = class {
-  _tools = /* @__PURE__ */ new Map();
-  _autoFlatten;
-  constructor(opts = {}) {
-    this._autoFlatten = opts.autoFlatten !== false;
-  }
-  register(def) {
-    if (!def.name) throw new Error("tool requires a name");
-    const internal = { ...def };
-    if (this._autoFlatten && def.parameters) {
-      const decision = analyzeSchema(def.parameters);
-      if (decision.shouldFlatten) {
-        internal.flatSchema = flattenSchema(def.parameters);
-      }
-    }
-    this._tools.set(def.name, internal);
-    return this;
-  }
-  has(name) {
-    return this._tools.has(name);
-  }
-  get(name) {
-    return this._tools.get(name);
-  }
-  get size() {
-    return this._tools.size;
-  }
-  /** True if a registered tool's schema was flattened for the model. */
-  wasFlattened(name) {
-    return Boolean(this._tools.get(name)?.flatSchema);
-  }
-  specs() {
-    return [...this._tools.values()].map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description ?? "",
-        parameters: t.flatSchema ?? t.parameters ?? { type: "object", properties: {} }
-      }
-    }));
-  }
-  async dispatch(name, argumentsRaw) {
-    const tool = this._tools.get(name);
-    if (!tool) {
-      return JSON.stringify({ error: `unknown tool: ${name}` });
-    }
-    let args;
-    try {
-      args = typeof argumentsRaw === "string" ? argumentsRaw.trim() ? JSON.parse(argumentsRaw) ?? {} : {} : argumentsRaw ?? {};
-    } catch (err) {
-      return JSON.stringify({
-        error: `invalid tool arguments JSON: ${err.message}`
-      });
-    }
-    if (tool.flatSchema && args && typeof args === "object" && hasDotKey(args)) {
-      args = nestArguments(args);
-    }
-    try {
-      const result = await tool.fn(args);
-      return typeof result === "string" ? result : JSON.stringify(result);
-    } catch (err) {
-      return JSON.stringify({
-        error: `${err.name}: ${err.message}`
-      });
-    }
-  }
-};
-function hasDotKey(obj) {
-  for (const k of Object.keys(obj)) {
-    if (k.includes(".")) return true;
-  }
-  return false;
-}
-
 // src/loop.ts
 var CacheFirstLoop = class {
   client;
@@ -1031,7 +1107,7 @@ var CacheFirstLoop = class {
     this.prefix = opts.prefix;
     this.tools = opts.tools ?? new ToolRegistry();
     this.model = opts.model ?? "deepseek-chat";
-    this.maxToolIters = opts.maxToolIters ?? 8;
+    this.maxToolIters = opts.maxToolIters ?? 24;
     if (typeof opts.branch === "number") {
       this.branchOptions = { budget: opts.branch };
     } else if (opts.branch && typeof opts.branch === "object") {
@@ -1050,12 +1126,49 @@ var CacheFirstLoop = class {
     this.sessionName = opts.session ?? null;
     if (this.sessionName) {
       const prior = loadSessionMessages(this.sessionName);
-      for (const msg of prior) this.log.append(msg);
-      this.resumedMessageCount = prior.length;
+      const { messages, healedCount, healedFrom } = healLoadedMessages(
+        prior,
+        DEFAULT_MAX_RESULT_CHARS
+      );
+      for (const msg of messages) this.log.append(msg);
+      this.resumedMessageCount = messages.length;
+      if (healedCount > 0) {
+        process.stderr.write(
+          `\u25B8 session "${this.sessionName}": healed ${healedCount} oversized tool result(s) (was ${healedFrom.toLocaleString()} chars total). Old payloads were truncated to fit DeepSeek's context window; the conversation is preserved.
+`
+        );
+      }
     } else {
       this.resumedMessageCount = 0;
     }
   }
+  /**
+   * Shrink the log by re-truncating oversized tool results to a tighter
+   * cap, and persist the result back to disk so the next launch doesn't
+   * re-inherit a fat session file. Returns a summary the TUI can
+   * display.
+   *
+   * Only tool-role messages are touched (same rationale as
+   * {@link healLoadedMessages}). User and assistant messages carry
+   * authored intent we can't mechanically shrink without losing
+   * meaning.
+   */
+  compact(tightCapChars = 4e3) {
+    const before = this.log.toMessages();
+    const { messages, healedCount, healedFrom } = healLoadedMessages(before, tightCapChars);
+    const afterBytes = messages.filter((m) => m.role === "tool").reduce((s, m) => s + (typeof m.content === "string" ? m.content.length : 0), 0);
+    const charsSaved = healedFrom - afterBytes;
+    if (healedCount > 0) {
+      this.log.compactInPlace(messages);
+      if (this.sessionName) {
+        try {
+          rewriteSession(this.sessionName, messages);
+        } catch {
+        }
+      }
+    }
+    return { healedCount, charsSaved };
+  }
   appendAndPersist(message) {
     this.log.append(message);
     if (this.sessionName) {
@@ -1245,7 +1358,7 @@ var CacheFirstLoop = class {
           turn: this._turn,
           role: "error",
           content: "",
-          error: err.message
+          error: formatLoopError(err)
         };
         return;
       }
@@ -1293,7 +1406,38 @@ var CacheFirstLoop = class {
         };
       }
     }
-    yield { turn: this._turn, role: "done", content: "[max_tool_iters reached]" };
+    yield* this.forceSummaryAfterIterLimit();
+  }
+  async *forceSummaryAfterIterLimit() {
+    try {
+      const messages = this.buildMessages(null);
+      const resp = await this.client.chat({
+        model: this.model,
+        messages
+        // 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]
+
+${summary}`;
+      const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
+      this.appendAndPersist({ role: "assistant", content: summary });
+      yield {
+        turn: this._turn,
+        role: "assistant_final",
+        content: annotated,
+        stats: summaryStats
+      };
+      yield { turn: this._turn, role: "done", content: summary };
+    } catch (err) {
+      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.`
+      };
+      yield { turn: this._turn, role: "done", content: "" };
+    }
   }
   async run(userInput, onEvent) {
     let final = "";
@@ -1318,6 +1462,28 @@ function summarizeBranch(chosen, samples) {
     temperatures: samples.map((s) => s.temperature)
   };
 }
+function healLoadedMessages(messages, maxChars) {
+  let healedCount = 0;
+  let healedFrom = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "tool") return msg;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (content.length <= maxChars) return msg;
+    healedCount += 1;
+    healedFrom += content.length;
+    return { ...msg, content: truncateForModel(content, maxChars) };
+  });
+  return { messages: out, healedCount, healedFrom };
+}
+function formatLoopError(err) {
+  const msg = err.message ?? "";
+  if (msg.includes("maximum context length")) {
+    const reqMatch = msg.match(/requested\s+(\d+)\s+tokens/);
+    const requested = reqMatch ? `${Number(reqMatch[1]).toLocaleString()} tokens` : "too many tokens";
+    return `Context overflow (DeepSeek 400): session history is ${requested}, past the 131,072-token limit. Usually this means a single tool call returned a huge payload. v0.3.0-alpha.6+ caps new tool results at 32k chars, AND auto-heals oversized history on session load \u2014 restart Reasonix and this session should come back trimmed. If it still overflows, run /forget (delete the session) or /clear (drop the displayed history) to start fresh.`;
+  }
+  return msg;
+}
 
 // src/env.ts
 import { readFileSync as readFileSync2 } from "fs";
@@ -1494,12 +1660,14 @@ function summarizeTurns(turns) {
   }
   const cacheHitRatio = hit + miss > 0 ? hit / (hit + miss) : 0;
   const savingsVsClaude = totalClaude > 0 ? 1 - totalCost / totalClaude : 0;
+  const lastTurn = turns[turns.length - 1];
   return {
     turns: turns.length,
     totalCostUsd: round2(totalCost, 6),
     claudeEquivalentUsd: round2(totalClaude, 6),
     savingsVsClaudePct: round2(savingsVsClaude * 100, 2),
-    cacheHitRatio: round2(cacheHitRatio, 4)
+    cacheHitRatio: round2(cacheHitRatio, 4),
+    lastPromptTokens: lastTurn?.usage.promptTokens ?? 0
   };
 }
 function round2(n, digits) {
@@ -2206,45 +2374,6 @@ var SseTransport = class {
   }
 };
 
-// src/mcp/registry.ts
-async function bridgeMcpTools(client, opts = {}) {
-  const registry = opts.registry ?? new ToolRegistry({ autoFlatten: opts.autoFlatten });
-  const prefix = opts.namePrefix ?? "";
-  const result = { registry, registeredNames: [], skipped: [] };
-  const listed = await client.listTools();
-  for (const mcpTool of listed.tools) {
-    if (!mcpTool.name) {
-      result.skipped.push({ name: "?", reason: "empty tool name" });
-      continue;
-    }
-    const registeredName = `${prefix}${mcpTool.name}`;
-    registry.register({
-      name: registeredName,
-      description: mcpTool.description ?? "",
-      parameters: mcpTool.inputSchema,
-      fn: async (args) => {
-        const toolResult = await client.callTool(mcpTool.name, args);
-        return flattenMcpResult(toolResult);
-      }
-    });
-    result.registeredNames.push(registeredName);
-  }
-  return result;
-}
-function flattenMcpResult(result) {
-  const parts = result.content.map(blockToString);
-  const joined = parts.join("\n").trim();
-  if (result.isError) {
-    return `ERROR: ${joined || "(no error message from server)"}`;
-  }
-  return joined;
-}
-function blockToString(block) {
-  if (block.type === "text") return block.text;
-  if (block.type === "image") return `[image ${block.mimeType}, ${block.data.length} chars base64]`;
-  return `[unknown block: ${JSON.stringify(block)}]`;
-}
-
 // src/mcp/shell-split.ts
 function shellSplit(input) {
   const tokens = [];
@@ -2320,7 +2449,7 @@ function parseMcpSpec(input) {
 }
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 function defaultConfigPath() {
@@ -2337,7 +2466,7 @@ function readConfig(path = defaultConfigPath()) {
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
   mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(cfg, null, 2), "utf8");
+  writeFileSync2(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
     chmodSync2(path, 384);
   } catch {
@@ -2363,10 +2492,11 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0-alpha.4";
+var VERSION = "0.3.1";
 export {
   AppendOnlyLog,
   CacheFirstLoop,
+  DEFAULT_MAX_RESULT_CHARS,
   DeepSeekClient,
   ImmutablePrefix,
   MCP_PROTOCOL_VERSION,
@@ -2395,7 +2525,9 @@ export {
   fetchWithRetry,
   flattenMcpResult,
   flattenSchema,
+  formatLoopError,
   harvest,
+  healLoadedMessages,
   isJsonRpcError,
   isPlanStateEmpty,
   isPlausibleKey,
@@ -2422,6 +2554,7 @@ export {
   sessionPath,
   sessionsDir,
   similarity,
+  truncateForModel,
   writeConfig,
   writeMeta,
   writeRecord