reasonix 0.3.0-alpha.6 → 0.3.1

package/dist/index.d.ts

@@ -244,6 +244,14 @@ declare class AppendOnlyLog {
     private _entries;
     append(message: ChatMessage): void;
     extend(messages: ChatMessage[]): void;
+    /**
+     * 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: ChatMessage[]): void;
     get entries(): readonly ChatMessage[];
     toMessages(): ChatMessage[];
     get length(): number;
@@ -379,6 +387,13 @@ interface SessionSummary {
     claudeEquivalentUsd: number;
     savingsVsClaudePct: number;
     cacheHitRatio: number;
+    /**
+     * Most recent turn's prompt-token count. Used by the TUI's context
+     * gauge: we can't know the next call's cost without making it, but
+     * the last turn's prompt tokens is the floor (next call is last
+     * prompt + user delta + any new tool outputs).
+     */
+    lastPromptTokens: number;
 }
 declare class SessionStats {
     readonly turns: TurnStats[];
@@ -514,6 +529,21 @@ declare class CacheFirstLoop {
     private _turn;
     private _streamPreference;
     constructor(opts: CacheFirstLoopOptions);
+    /**
+     * 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?: number): {
+        healedCount: number;
+        charsSaved: number;
+    };
     private appendAndPersist;
     /**
      * Reconfigure model/harvest/branch/stream mid-session. The loop's log,
@@ -524,6 +554,7 @@ declare class CacheFirstLoop {
     configure(opts: ReconfigurableOptions): void;
     private buildMessages;
     step(userInput: string): AsyncGenerator<LoopEvent>;
+    private forceSummaryAfterIterLimit;
     run(userInput: string, onEvent?: (ev: LoopEvent) => void): Promise<string>;
     private assistantMessage;
 }
@@ -1246,6 +1277,6 @@ declare function redactKey(key: string): string;
 
 /** Reasonix — DeepSeek-native agent framework. Library entry point. */
 
-declare const VERSION = "0.3.0-alpha.6";
+declare const VERSION = "0.3.1";
 
 export { AppendOnlyLog, type BranchOptions, type BranchProgress, type BranchResult, type BranchSample, type BranchSelector, type BranchSummary, type BridgeOptions, type BridgeResult, CacheFirstLoop, type CacheFirstLoopOptions, type CallToolResult, type ChatMessage, type ChatResponse, DEFAULT_MAX_RESULT_CHARS, DeepSeekClient, type DeepSeekClientOptions, type RenderOptions as DiffRenderOptions, type DiffReport, type DiffSide, type EventRole, type FlattenDecision, type FlattenOptions, type HarvestOptions, ImmutablePrefix, type ImmutablePrefixOptions, type InitializeResult, type JSONSchema, type JsonRpcMessage, type JsonRpcRequest, type JsonRpcResponse, type ListToolsResult, type LoopEvent, MCP_PROTOCOL_VERSION, McpClient, type McpClientOptions, type McpContentBlock, type McpSpec, type McpTool, type McpToolSchema, type McpTransport, type ReadTranscriptResult, type ReasonixConfig, type ReconfigurableOptions, type RepairReport, type ReplayStats, type RetryInfo, type RetryOptions, type Role, type ScavengeOptions, type ScavengeResult, type SessionInfo, SessionStats, type SessionSummary, type SseMcpSpec, SseTransport, type SseTransportOptions, type StdioMcpSpec, StdioTransport, type StdioTransportOptions, StormBreaker, type StreamChunk, type ToolCall, ToolCallRepair, type ToolCallRepairOptions, type ToolDefinition, type ToolFunctionSpec, ToolRegistry, type ToolSpec, type TranscriptMeta, type TranscriptRecord, type TruncationRepairResult, type TurnPair, type TurnStats, type TypedPlanState, Usage, VERSION, VolatileScratch, aggregateBranchUsage, analyzeSchema, appendSessionMessage, bridgeMcpTools, claudeEquivalentCost, computeReplayStats, costUsd, defaultConfigPath, defaultSelector, deleteSession, diffTranscripts, emptyPlanState, fetchWithRetry, flattenMcpResult, flattenSchema, formatLoopError, harvest, healLoadedMessages, isJsonRpcError, isPlanStateEmpty, isPlausibleKey, listSessions, loadApiKey, loadDotenv, loadSessionMessages, nestArguments, openTranscriptFile, parseMcpSpec, parseTranscript, readConfig, readTranscript, recordFromLoopEvent, redactKey, renderMarkdown as renderDiffMarkdown, renderSummaryTable as renderDiffSummary, repairTruncatedJson, replayFromFile, runBranches, sanitizeName as sanitizeSessionName, saveApiKey, scavengeToolCalls, sessionPath, sessionsDir, similarity, truncateForModel, writeConfig, writeMeta, writeRecord };

package/dist/index.js

@@ -636,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;
   }
@@ -914,7 +924,8 @@ import {
   readFileSync,
   readdirSync,
   statSync,
-  unlinkSync
+  unlinkSync,
+  writeFileSync
 } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
@@ -983,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");
@@ -1041,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
     };
   }
 };
@@ -1083,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") {
@@ -1118,6 +1142,33 @@ var CacheFirstLoop = class {
       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) {
@@ -1355,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 = "";
@@ -1578,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) {
@@ -2365,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() {
@@ -2382,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 {
@@ -2408,7 +2492,7 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0-alpha.6";
+var VERSION = "0.3.1";
 export {
   AppendOnlyLog,
   CacheFirstLoop,