reasonix 0.3.0-alpha.3 → 0.3.0-alpha.6

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 {
@@ -655,74 +850,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;
@@ -928,81 +1055,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;
@@ -1050,8 +1102,18 @@ 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;
     }
@@ -1245,7 +1307,7 @@ var CacheFirstLoop = class {
           turn: this._turn,
           role: "error",
           content: "",
-          error: err.message
+          error: formatLoopError(err)
         };
         return;
       }
@@ -1318,6 +1380,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";
@@ -2067,43 +2151,217 @@ function quoteArg(s, windows) {
   return `"${s.replace(/"/g, '""')}"`;
 }
 
-// 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;
+// src/mcp/sse.ts
+import { createParser as createParser2 } from "eventsource-parser";
+var SseTransport = class {
+  url;
+  headers;
+  queue = [];
+  waiters = [];
+  controller = new AbortController();
+  closed = false;
+  postUrl = null;
+  endpointReady;
+  resolveEndpoint;
+  rejectEndpoint;
+  constructor(opts) {
+    this.url = opts.url;
+    this.headers = opts.headers ?? {};
+    this.endpointReady = new Promise((resolve2, reject) => {
+      this.resolveEndpoint = resolve2;
+      this.rejectEndpoint = reject;
+    });
+    this.endpointReady.catch(() => void 0);
+    void this.runStream();
+  }
+  async send(message) {
+    if (this.closed) throw new Error("MCP SSE transport is closed");
+    const postUrl = await this.endpointReady;
+    const res = await fetch(postUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...this.headers },
+      body: JSON.stringify(message),
+      signal: this.controller.signal
+    });
+    await res.arrayBuffer().catch(() => void 0);
+    if (!res.ok) {
+      throw new Error(`MCP SSE POST ${postUrl} failed: ${res.status} ${res.statusText}`);
     }
-    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);
+  }
+  async *messages() {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift();
+        continue;
+      }
+      if (this.closed) return;
+      const next = await new Promise((resolve2) => {
+        this.waiters.push(resolve2);
+      });
+      if (next === null) return;
+      yield next;
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()(null);
+    this.rejectEndpoint(new Error("MCP SSE transport closed before endpoint was ready"));
+    try {
+      this.controller.abort();
+    } catch {
+    }
+  }
+  // ---------- internals ----------
+  async runStream() {
+    let res;
+    try {
+      res = await fetch(this.url, {
+        method: "GET",
+        headers: { accept: "text/event-stream", ...this.headers },
+        signal: this.controller.signal
+      });
+    } catch (err) {
+      this.failHandshake(`SSE connect to ${this.url} failed: ${err.message}`);
+      return;
+    }
+    if (!res.ok || !res.body) {
+      await res.body?.cancel().catch(() => void 0);
+      this.failHandshake(`SSE handshake ${this.url} \u2192 ${res.status} ${res.statusText}`);
+      return;
+    }
+    const parser = createParser2({
+      onEvent: (ev) => this.handleEvent(ev.event ?? "message", ev.data)
+    });
+    const decoder = new TextDecoder();
+    try {
+      for await (const chunk of res.body) {
+        parser.feed(decoder.decode(chunk, { stream: true }));
+      }
+    } catch (err) {
+      if (!this.closed) {
+        this.pushError(`SSE stream error: ${err.message}`);
       }
+    } finally {
+      this.markClosed();
+    }
+  }
+  handleEvent(type, data) {
+    if (type === "endpoint") {
+      if (this.postUrl) return;
+      try {
+        this.postUrl = new URL(data, this.url).toString();
+        this.resolveEndpoint(this.postUrl);
+      } catch (err) {
+        this.failHandshake(`SSE endpoint event had bad URL "${data}": ${err.message}`);
+      }
+      return;
+    }
+    if (type === "message") {
+      try {
+        const parsed = JSON.parse(data);
+        this.pushMessage(parsed);
+      } catch {
+      }
+      return;
+    }
+  }
+  failHandshake(reason) {
+    this.rejectEndpoint(new Error(reason));
+    this.pushError(reason);
+    this.markClosed();
+  }
+  pushMessage(msg) {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(msg);
+    else this.queue.push(msg);
+  }
+  pushError(message) {
+    this.pushMessage({
+      jsonrpc: "2.0",
+      id: null,
+      error: { code: -32e3, message }
     });
-    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)"}`;
+  markClosed() {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()(null);
   }
-  return joined;
+};
+
+// src/mcp/shell-split.ts
+function shellSplit(input) {
+  const tokens = [];
+  let cur = "";
+  let quote = null;
+  let i = 0;
+  const s = input;
+  while (i < s.length) {
+    const ch = s[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+        i++;
+        continue;
+      }
+      if (ch === "\\" && quote === '"' && i + 1 < s.length) {
+        cur += s[i + 1];
+        i += 2;
+        continue;
+      }
+      cur += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      i++;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      if (cur.length > 0) {
+        tokens.push(cur);
+        cur = "";
+      }
+      i++;
+      continue;
+    }
+    cur += ch;
+    i++;
+  }
+  if (quote) {
+    throw new Error(
+      `shellSplit: unterminated ${quote === '"' ? "double" : "single"} quote in input`
+    );
+  }
+  if (cur.length > 0) tokens.push(cur);
+  return tokens;
 }
-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/spec.ts
+var NAME_PREFIX = /^([a-zA-Z_][a-zA-Z0-9_]*)=(.*)$/;
+var HTTP_URL = /^https?:\/\//i;
+function parseMcpSpec(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("empty MCP spec");
+  }
+  const nameMatch = NAME_PREFIX.exec(trimmed);
+  const name = nameMatch ? nameMatch[1] : null;
+  const body = (nameMatch ? nameMatch[2] : trimmed).trim();
+  if (!body) {
+    throw new Error(`MCP spec has name but no command: ${input}`);
+  }
+  if (HTTP_URL.test(body)) {
+    return { transport: "sse", name, url: body };
+  }
+  const argv = shellSplit(body);
+  if (argv.length === 0) {
+    throw new Error(`MCP spec has name but no command: ${input}`);
+  }
+  const [command, ...args] = argv;
+  return { transport: "stdio", name, command, args };
 }
 
 // src/config.ts
@@ -2150,15 +2408,17 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0-alpha.3";
+var VERSION = "0.3.0-alpha.6";
 export {
   AppendOnlyLog,
   CacheFirstLoop,
+  DEFAULT_MAX_RESULT_CHARS,
   DeepSeekClient,
   ImmutablePrefix,
   MCP_PROTOCOL_VERSION,
   McpClient,
   SessionStats,
+  SseTransport,
   StdioTransport,
   StormBreaker,
   ToolCallRepair,
@@ -2181,7 +2441,9 @@ export {
   fetchWithRetry,
   flattenMcpResult,
   flattenSchema,
+  formatLoopError,
   harvest,
+  healLoadedMessages,
   isJsonRpcError,
   isPlanStateEmpty,
   isPlausibleKey,
@@ -2191,6 +2453,7 @@ export {
   loadSessionMessages,
   nestArguments,
   openTranscriptFile,
+  parseMcpSpec,
   parseTranscript,
   readConfig,
   readTranscript,
@@ -2207,6 +2470,7 @@ export {
   sessionPath,
   sessionsDir,
   similarity,
+  truncateForModel,
   writeConfig,
   writeMeta,
   writeRecord