reasonix 0.11.2 → 0.12.6

package/dist/index.js

@@ -1358,25 +1358,32 @@ function coerceToToolCall(candidateJson, allowedNames) {
 var StormBreaker = class {
   windowSize;
   threshold;
+  isMutating;
   recent = [];
-  constructor(windowSize = 6, threshold = 3) {
+  constructor(windowSize = 6, threshold = 3, isMutating) {
     this.windowSize = windowSize;
     this.threshold = threshold;
+    this.isMutating = isMutating;
   }
   inspect(call) {
-    const sig = signature(call);
-    if (!sig) return { suppress: false };
-    const count = this.recent.reduce(
-      (n, [name, args]) => name === sig[0] && args === sig[1] ? n + 1 : n,
-      0
-    );
+    const name = call.function?.name;
+    if (!name) return { suppress: false };
+    const args = call.function?.arguments ?? "";
+    const mutating = this.isMutating ? this.isMutating(call) : false;
+    const readOnly = !mutating;
+    if (mutating) {
+      for (let i = this.recent.length - 1; i >= 0; i--) {
+        if (this.recent[i].readOnly) this.recent.splice(i, 1);
+      }
+    }
+    const count = this.recent.reduce((n, e) => e.name === name && e.args === args ? n + 1 : n, 0);
     if (count >= this.threshold - 1) {
       return {
         suppress: true,
-        reason: `call-storm suppressed: ${sig[0]} called with identical args ${count + 1} times within window=${this.windowSize}`
+        reason: `call-storm suppressed: ${name} called with identical args ${count + 1} times within window=${this.windowSize}`
       };
     }
-    this.recent.push(sig);
+    this.recent.push({ name, args, readOnly });
     while (this.recent.length > this.windowSize) this.recent.shift();
     return { suppress: false };
   }
@@ -1384,11 +1391,6 @@ var StormBreaker = class {
     this.recent.length = 0;
   }
 };
-function signature(call) {
-  const name = call.function?.name;
-  if (!name) return null;
-  return [name, call.function?.arguments ?? ""];
-}
 
 // src/repair/truncation.ts
 function repairTruncatedJson(input) {
@@ -1466,7 +1468,7 @@ var ToolCallRepair = class {
   opts;
   constructor(opts) {
     this.opts = opts;
-    this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3);
+    this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3, opts.isMutating);
   }
   /**
    * Drop the StormBreaker's sliding window of recent (name, args)
@@ -1490,13 +1492,13 @@ var ToolCallRepair = class {
       allowedNames: this.opts.allowedToolNames,
       maxCalls: this.opts.maxScavenge ?? 4
     });
-    const seenSignatures = new Set(declaredCalls.map(signature2));
+    const seenSignatures = new Set(declaredCalls.map(signature));
     const merged = [...declaredCalls];
     for (const sc of scavenged.calls) {
-      if (!seenSignatures.has(signature2(sc))) {
+      if (!seenSignatures.has(signature(sc))) {
         merged.push(sc);
         report.scavenged++;
-        seenSignatures.add(signature2(sc));
+        seenSignatures.add(signature(sc));
       }
     }
     report.notes.push(...scavenged.notes);
@@ -1522,7 +1524,7 @@ var ToolCallRepair = class {
     return { calls: filtered, report };
   }
 };
-function signature2(call) {
+function signature(call) {
   return `${call.function?.name ?? ""}::${call.function?.arguments ?? ""}`;
 }
 
@@ -1661,6 +1663,12 @@ function outputCostUsd(model, usage) {
   if (!p) return 0;
   return usage.completionTokens * p.output / 1e6;
 }
+function cacheSavingsUsd(model, hitTokens) {
+  if (hitTokens <= 0) return 0;
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return hitTokens * (p.inputCacheMiss - p.inputCacheHit) / 1e6;
+}
 function claudeEquivalentCost(usage) {
   return (usage.promptTokens * CLAUDE_SONNET_PRICING.input + usage.completionTokens * CLAUDE_SONNET_PRICING.output) / 1e6;
 }
@@ -1751,6 +1759,13 @@ var CacheFirstLoop = class {
   branchOptions;
   /** See ReconfigurableOptions — mutable so `/effort` can flip mid-session. */
   reasoningEffort;
+  /**
+   * Auto-escalation toggle. `true` lets the loop self-promote to pro
+   * mid-turn (NEEDS_PRO marker / failure threshold); `false` keeps it
+   * pinned to `model`. Mutable so the dashboard's preset switcher can
+   * flip it live alongside `model`.
+   */
+  autoEscalate = true;
   sessionName;
   /**
    * Hook list, mutable so `/hooks reload` can swap it without
@@ -1815,6 +1830,7 @@ var CacheFirstLoop = class {
     this.tools = opts.tools ?? new ToolRegistry();
     this.model = opts.model ?? "deepseek-v4-flash";
     this.reasoningEffort = opts.reasoningEffort ?? "max";
+    if (opts.autoEscalate !== void 0) this.autoEscalate = opts.autoEscalate;
     this.maxToolIters = opts.maxToolIters ?? 64;
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
@@ -1832,7 +1848,26 @@ var CacheFirstLoop = class {
     this._streamPreference = opts.stream ?? true;
     this.stream = this.branchEnabled ? false : this._streamPreference;
     const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
-    this.repair = new ToolCallRepair({ allowedToolNames: allowedNames });
+    const registry = this.tools;
+    const isMutating = (call) => {
+      const name = call.function?.name;
+      if (!name) return false;
+      const def = registry.get(name);
+      if (!def) return false;
+      if (def.readOnlyCheck) {
+        let args = {};
+        try {
+          args = JSON.parse(call.function?.arguments ?? "{}") ?? {};
+        } catch {
+        }
+        try {
+          if (def.readOnlyCheck(args)) return false;
+        } catch {
+        }
+      }
+      return def.readOnly !== true;
+    };
+    this.repair = new ToolCallRepair({ allowedToolNames: allowedNames, isMutating });
     this.sessionName = opts.session ?? null;
     if (this.sessionName) {
       const prior = loadSessionMessages(this.sessionName);
@@ -2013,6 +2048,7 @@ var CacheFirstLoop = class {
     if (opts.model !== void 0) this.model = opts.model;
     if (opts.stream !== void 0) this._streamPreference = opts.stream;
     if (opts.reasoningEffort !== void 0) this.reasoningEffort = opts.reasoningEffort;
+    if (opts.autoEscalate !== void 0) this.autoEscalate = opts.autoEscalate;
     if (opts.branch !== void 0) {
       if (typeof opts.branch === "number") {
         this.branchOptions = { budget: opts.branch };
@@ -2128,7 +2164,7 @@ var CacheFirstLoop = class {
       if (repair.truncationsFixed > 0) bump("truncated", repair.truncationsFixed);
       if (repair.stormsBroken > 0) bump("storm-broken", repair.stormsBroken);
     }
-    if (bumped && !this._escalateThisTurn && this._turnFailureCount >= FAILURE_ESCALATION_THRESHOLD) {
+    if (bumped && !this._escalateThisTurn && this.autoEscalate && this._turnFailureCount >= FAILURE_ESCALATION_THRESHOLD) {
       this._escalateThisTurn = true;
       return true;
     }
@@ -2373,7 +2409,7 @@ var CacheFirstLoop = class {
           const callBuf = /* @__PURE__ */ new Map();
           const readyIndices = /* @__PURE__ */ new Set();
           const callModel = this.modelForCurrentCall();
-          const bufferForEscalation = callModel !== ESCALATION_MODEL;
+          const bufferForEscalation = this.autoEscalate && callModel !== ESCALATION_MODEL;
           let escalationBuf = "";
           let escalationBufFlushed = false;
           for await (const chunk of this.client.stream({
@@ -2485,7 +2521,7 @@ var CacheFirstLoop = class {
         };
         return;
       }
-      if (this.modelForCurrentCall() !== ESCALATION_MODEL && this.isEscalationRequest(assistantContent)) {
+      if (this.autoEscalate && this.modelForCurrentCall() !== ESCALATION_MODEL && this.isEscalationRequest(assistantContent)) {
         const { reason } = this.parseEscalationMarker(assistantContent);
         this._escalateThisTurn = true;
         const reasonSuffix = reason ? ` \u2014 ${reason}` : "";
@@ -7325,6 +7361,159 @@ var SseTransport = class {
   }
 };
 
+// src/mcp/streamable-http.ts
+import { createParser as createParser3 } from "eventsource-parser";
+var SESSION_HEADER = "mcp-session-id";
+var StreamableHttpTransport = class {
+  url;
+  extraHeaders;
+  queue = [];
+  waiters = [];
+  controller = new AbortController();
+  /** Session id minted by server on (typically) the initialize response. */
+  sessionId = null;
+  closed = false;
+  /** Background SSE read-loops kicked off by send(); awaited on close(). */
+  streams = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.url = opts.url;
+    this.extraHeaders = opts.headers ?? {};
+  }
+  async send(message) {
+    if (this.closed) throw new Error("MCP Streamable HTTP transport is closed");
+    const headers = {
+      "content-type": "application/json",
+      // Both accepted — server picks. application/json first signals a
+      // mild preference for the simpler shape when the response is a
+      // single message.
+      accept: "application/json, text/event-stream",
+      ...this.extraHeaders
+    };
+    if (this.sessionId !== null) headers["mcp-session-id"] = this.sessionId;
+    let res;
+    try {
+      res = await fetch(this.url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: this.controller.signal
+      });
+    } catch (err) {
+      throw new Error(`MCP Streamable HTTP POST ${this.url} failed: ${err.message}`);
+    }
+    const serverSessionId = res.headers.get(SESSION_HEADER);
+    if (serverSessionId && this.sessionId === null) {
+      this.sessionId = serverSessionId;
+    }
+    if (res.status === 404 && this.sessionId !== null) {
+      await res.body?.cancel().catch(() => void 0);
+      throw new Error(
+        `MCP Streamable HTTP session expired (server returned 404 with Mcp-Session-Id "${this.sessionId}"). Reinitialize the client.`
+      );
+    }
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(
+        `MCP Streamable HTTP POST ${this.url} \u2192 ${res.status} ${res.statusText}${body ? `: ${body}` : ""}`
+      );
+    }
+    if (res.status === 202) {
+      await res.body?.cancel().catch(() => void 0);
+      return;
+    }
+    const ct = (res.headers.get("content-type") ?? "").toLowerCase();
+    if (ct.includes("application/json")) {
+      let parsed;
+      try {
+        parsed = await res.json();
+      } catch (err) {
+        throw new Error(`MCP Streamable HTTP body wasn't valid JSON: ${err.message}`);
+      }
+      if (Array.isArray(parsed)) {
+        for (const item of parsed) this.pushMessage(item);
+      } else {
+        this.pushMessage(parsed);
+      }
+      return;
+    }
+    if (ct.includes("text/event-stream")) {
+      if (!res.body) {
+        throw new Error("MCP Streamable HTTP SSE response had no body");
+      }
+      const stream = this.consumeStream(res.body);
+      this.streams.add(stream);
+      stream.finally(() => this.streams.delete(stream));
+      return;
+    }
+    await res.body?.cancel().catch(() => void 0);
+  }
+  async *messages() {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift();
+        continue;
+      }
+      if (this.closed) return;
+      const next = await new Promise((resolve9) => {
+        this.waiters.push(resolve9);
+      });
+      if (next === null) return;
+      yield next;
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()(null);
+    try {
+      this.controller.abort();
+    } catch {
+    }
+    await Promise.allSettled(Array.from(this.streams));
+  }
+  /** Visible for tests — confirm session header round-trip. */
+  getSessionId() {
+    return this.sessionId;
+  }
+  // ---------- internals ----------
+  async consumeStream(body) {
+    const parser = createParser3({
+      onEvent: (ev) => {
+        const type = ev.event ?? "message";
+        if (type !== "message") return;
+        try {
+          const parsed = JSON.parse(ev.data);
+          this.pushMessage(parsed);
+        } catch {
+        }
+      }
+    });
+    const decoder = new TextDecoder();
+    try {
+      for await (const chunk of body) {
+        if (this.closed) break;
+        parser.feed(decoder.decode(chunk, { stream: true }));
+      }
+    } catch (err) {
+      if (!this.closed) {
+        this.pushMessage({
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32e3,
+            message: `Streamable HTTP stream error: ${err.message}`
+          }
+        });
+      }
+    }
+  }
+  pushMessage(msg) {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(msg);
+    else this.queue.push(msg);
+  }
+};
+
 // src/mcp/shell-split.ts
 function shellSplit(input) {
   const tokens = [];
@@ -7377,6 +7566,7 @@ function shellSplit(input) {
 // src/mcp/spec.ts
 var NAME_PREFIX = /^([a-zA-Z_][a-zA-Z0-9_]*)=(.*)$/;
 var HTTP_URL = /^https?:\/\//i;
+var STREAMABLE_PREFIX = /^streamable\+(https?:\/\/.+)$/i;
 function parseMcpSpec(input) {
   const trimmed = input.trim();
   if (!trimmed) {
@@ -7388,6 +7578,10 @@ function parseMcpSpec(input) {
   if (!body) {
     throw new Error(`MCP spec has name but no command: ${input}`);
   }
+  const streamMatch = STREAMABLE_PREFIX.exec(body);
+  if (streamMatch) {
+    return { transport: "streamable-http", name, url: streamMatch[1] };
+  }
   if (HTTP_URL.test(body)) {
     return { transport: "sse", name, url: body };
   }
@@ -8000,7 +8194,8 @@ function emptyBucket(label, since) {
     cacheHitTokens: 0,
     cacheMissTokens: 0,
     costUsd: 0,
-    claudeEquivUsd: 0
+    claudeEquivUsd: 0,
+    cacheSavingsUsd: 0
   };
 }
 function addToBucket(b, r) {
@@ -8011,6 +8206,7 @@ function addToBucket(b, r) {
   b.cacheMissTokens += r.cacheMissTokens;
   b.costUsd += r.costUsd;
   b.claudeEquivUsd += r.claudeEquivUsd;
+  b.cacheSavingsUsd += cacheSavingsUsd(r.model, r.cacheHitTokens);
 }
 function aggregateUsage(records, opts = {}) {
   const now = opts.now ?? Date.now();
@@ -8112,6 +8308,7 @@ export {
   SseTransport,
   StdioTransport,
   StormBreaker,
+  StreamableHttpTransport,
   ToolCallRepair,
   ToolRegistry,
   USER_MEMORY_DIR,