reasonix 0.4.3 → 0.4.5

package/dist/cli/index.js

@@ -722,7 +722,19 @@ function scavengeToolCalls(reasoningContent, opts) {
   const max = opts.maxCalls ?? 4;
   const notes = [];
   const out = [];
-  for (const candidate of iterateJsonObjects(reasoningContent)) {
+  for (const invoke of iterateDsmlInvokes(reasoningContent)) {
+    if (out.length >= max) break;
+    if (!opts.allowedNames.has(invoke.name)) continue;
+    out.push({
+      function: {
+        name: invoke.name,
+        arguments: JSON.stringify(invoke.args)
+      }
+    });
+    notes.push(`scavenged DSML call: ${invoke.name}`);
+  }
+  const nonDsml = stripDsmlBlocks(reasoningContent);
+  for (const candidate of iterateJsonObjects(nonDsml)) {
     if (out.length >= max) break;
     const call = coerceToToolCall(candidate, opts.allowedNames);
     if (call) {
@@ -732,6 +744,40 @@ function scavengeToolCalls(reasoningContent, opts) {
   }
   return { calls: out, notes };
 }
+function stripDsmlBlocks(text) {
+  let out = text;
+  out = out.replace(/<[｜|]DSML[｜|]function_calls>[\s\S]*?<\/?[｜|]DSML[｜|]function_calls>/g, "");
+  out = out.replace(/<[｜|]DSML[｜|]invoke\s+[^>]*>[\s\S]*?<\/[｜|]DSML[｜|]invoke>/g, "");
+  return out;
+}
+function* iterateDsmlInvokes(text) {
+  const INVOKE_RE = /<[｜|]DSML[｜|]invoke\s+name="([^"]+)">([\s\S]*?)<\/[｜|]DSML[｜|]invoke>/g;
+  for (const match of text.matchAll(INVOKE_RE)) {
+    const name = match[1];
+    const body = match[2];
+    if (!name || body === void 0) continue;
+    yield { name, args: parseDsmlParameters(body) };
+  }
+}
+function parseDsmlParameters(body) {
+  const PARAM_RE = /<[｜|]DSML[｜|]parameter\s+name="([^"]+)"(?:\s+string="(true|false)")?\s*>([\s\S]*?)<\/[｜|]DSML[｜|]parameter>/g;
+  const args = {};
+  for (const m of body.matchAll(PARAM_RE)) {
+    const key = m[1];
+    const stringFlag = m[2];
+    const raw = (m[3] ?? "").trim();
+    if (!key) continue;
+    if (stringFlag === "false") {
+      try {
+        args[key] = JSON.parse(raw);
+        continue;
+      } catch {
+      }
+    }
+    args[key] = raw;
+  }
+  return args;
+}
 function* iterateJsonObjects(text) {
   for (let i = 0; i < text.length; i++) {
     if (text[i] !== "{") continue;
@@ -917,14 +963,15 @@ var ToolCallRepair = class {
     this.opts = opts;
     this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3);
   }
-  process(declaredCalls, reasoningContent) {
+  process(declaredCalls, reasoningContent, content = null) {
     const report = {
       scavenged: 0,
       truncationsFixed: 0,
       stormsBroken: 0,
       notes: []
     };
-    const scavenged = scavengeToolCalls(reasoningContent, {
+    const combined = [reasoningContent ?? "", content ?? ""].filter(Boolean).join("\n");
+    const scavenged = scavengeToolCalls(combined || null, {
       allowedNames: this.opts.allowedToolNames,
       maxCalls: this.opts.maxScavenge ?? 4
     });
@@ -1502,7 +1549,8 @@ var CacheFirstLoop = class {
       const planState = preHarvestedPlanState ? preHarvestedPlanState : this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions) : emptyPlanState();
       const { calls: repairedCalls, report } = this.repair.process(
         toolCalls,
-        reasoningContent || null
+        reasoningContent || null,
+        assistantContent || null
       );
       this.appendAndPersist(this.assistantMessage(assistantContent, repairedCalls));
       yield {
@@ -2246,7 +2294,12 @@ var McpClient = class {
     this.startReaderIfNeeded();
     const result = await this.request("initialize", {
       protocolVersion: MCP_PROTOCOL_VERSION,
-      capabilities: { tools: {} },
+      // Advertise every method the client can consume so servers know
+      // they can send listChanged notifications etc. Sub-feature flags
+      // (e.g. `resources.subscribe`) are omitted — we don't implement
+      // those yet and the empty object means "method-level support, no
+      // sub-features."
+      capabilities: { tools: {}, resources: {}, prompts: {} },
       clientInfo: this.clientInfo
     });
     this._serverCapabilities = result.capabilities ?? {};
@@ -2270,6 +2323,45 @@ var McpClient = class {
       arguments: args ?? {}
     });
   }
+  /**
+   * List resources the server exposes. Supports a pagination cursor;
+   * callers interested in the full set should loop on `nextCursor`.
+   * Servers that don't support resources respond with method-not-found
+   * (−32601) — we surface that as a thrown Error so callers can gate
+   * on the `serverCapabilities.resources` field first.
+   */
+  async listResources(cursor) {
+    this.assertInitialized();
+    return this.request("resources/list", {
+      ...cursor ? { cursor } : {}
+    });
+  }
+  /** Read the contents of a resource by URI. */
+  async readResource(uri) {
+    this.assertInitialized();
+    return this.request("resources/read", {
+      uri
+    });
+  }
+  /** List prompt templates the server exposes. */
+  async listPrompts(cursor) {
+    this.assertInitialized();
+    return this.request("prompts/list", {
+      ...cursor ? { cursor } : {}
+    });
+  }
+  /**
+   * Fetch a rendered prompt by name. `args` supplies values for any
+   * required template arguments; the server validates. Returns messages
+   * ready to prepend to the model's input.
+   */
+  async getPrompt(name, args) {
+    this.assertInitialized();
+    return this.request("prompts/get", {
+      name,
+      ...args ? { arguments: args } : {}
+    });
+  }
   /** Close the transport and reject any outstanding requests. */
   async close() {
     for (const [, pending] of this.pending) {
@@ -3209,6 +3301,7 @@ function handleSlash(cmd, args, loop, ctx = {}) {
           "  /setup                   (exit + reconfigure) \u2192 run `reasonix setup`",
           "  /compact [cap]           shrink large tool results in history (default 4k/result)",
           "  /think                   dump the most recent turn's full R1 reasoning (reasoner only)",
+          "  /tool [N]                list tool calls (or dump full output of #N, 1=most recent)",
           "  /retry                   truncate & resend your last message (fresh sample from the model)",
           "  /apply                   (code mode) commit the pending edit blocks to disk",
           "  /discard                 (code mode) drop pending edits without writing",
@@ -3280,6 +3373,38 @@ function handleSlash(cmd, args, loop, ctx = {}) {
 
 ${raw.trim()}` };
     }
+    case "tool": {
+      const history = ctx.toolHistory?.() ?? [];
+      if (history.length === 0) {
+        return {
+          info: "no tool calls yet in this session. `/tool` lists them once the model has actually used a tool; `/tool N` dumps the full (untruncated) output of the Nth-most-recent."
+        };
+      }
+      const raw = (args[0] ?? "").toLowerCase();
+      if (raw === "" || raw === "list" || raw === "ls") {
+        return { info: formatToolList(history) };
+      }
+      const n = Number.parseInt(raw, 10);
+      if (!Number.isFinite(n) || n < 1) {
+        return {
+          info: "usage: /tool [N]   (no arg \u2192 list; N=1 \u2192 most recent result in full, N=2 \u2192 previous, \u2026)"
+        };
+      }
+      if (n > history.length) {
+        return {
+          info: `only ${history.length} tool call(s) in history \u2014 asked for #${n}. Try /tool with no arg to see the list.`
+        };
+      }
+      const entry = history[history.length - n];
+      if (!entry) {
+        return { info: `could not read tool call #${n}` };
+      }
+      return {
+        info: `\u21B3 tool<${entry.toolName}> #${n} (${entry.text.length} chars):
+
+${entry.text}`
+      };
+    }
     case "undo": {
       if (!ctx.codeUndo) {
         return {
@@ -3434,6 +3559,29 @@ ${raw.trim()}` };
       return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
   }
 }
+function formatToolList(history) {
+  const total = history.length;
+  const header = `Tool calls in this session (${total}, most recent first):`;
+  const shown = Math.min(total, 10);
+  const lines = [header];
+  for (let i = 0; i < shown; i++) {
+    const entry = history[total - 1 - i];
+    if (!entry) continue;
+    const idx = i + 1;
+    const flat = entry.text.replace(/\s+/g, " ").trim();
+    const preview = flat.length > 80 ? `${flat.slice(0, 80)}\u2026` : flat;
+    const name = entry.toolName.length > 24 ? `${entry.toolName.slice(0, 23)}\u2026` : entry.toolName;
+    lines.push(
+      `  #${String(idx).padStart(2)}  ${name.padEnd(24)}  ${String(entry.text.length).padStart(6)} chars  ${preview}`
+    );
+  }
+  if (total > shown) {
+    lines.push(`  \u2026 (${total - shown} earlier, reach with /tool N)`);
+  }
+  lines.push("");
+  lines.push("View full output: /tool N   (N=1 \u2192 most recent)");
+  return lines.join("\n");
+}
 function compactNum(n) {
   if (n < 1e3) return String(n);
   const k = n / 1e3;
@@ -3496,6 +3644,7 @@ function App({
   const pendingEdits = useRef([]);
   const promptHistory = useRef([]);
   const historyCursor = useRef(-1);
+  const toolHistoryRef = useRef([]);
   const [summary, setSummary] = useState2({
     turns: 0,
     totalCostUsd: 0,
@@ -3645,7 +3794,8 @@ function App({
           codeApply: codeMode ? codeApply : void 0,
           codeDiscard: codeMode ? codeDiscard : void 0,
           codeRoot: codeMode?.rootDir,
-          pendingEditCount: codeMode ? pendingEdits.current.length : void 0
+          pendingEditCount: codeMode ? pendingEdits.current.length : void 0,
+          toolHistory: () => toolHistoryRef.current
         });
         if (result.exit) {
           transcriptRef.current?.end();
@@ -3758,6 +3908,10 @@ function App({
           } else if (ev.role === "tool") {
             flush();
             setOngoingTool(null);
+            toolHistoryRef.current.push({
+              toolName: ev.toolName ?? "?",
+              text: ev.content
+            });
             setHistorical((prev) => [
               ...prev,
               {
@@ -3858,7 +4012,7 @@ function summarizeToolArgs(name, args) {
   return args.length > 80 ? `${args.slice(0, 80)}\u2026` : args;
 }
 function CommandStrip({ codeMode }) {
-  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"), codeMode ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, 'code mode: /apply (y) \xB7 /discard (n) \xB7 /undo \xB7 /commit "msg" \u2014 edits NEVER write without /apply') : null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "\u2191/\u2193 recall prompts \xB7 /retry re-send last \xB7 /think see R1 full reasoning"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "Esc (while thinking) \u2014 abort & summarize what was found so far"));
+  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"), codeMode ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, 'code mode: /apply (y) \xB7 /discard (n) \xB7 /undo \xB7 /commit "msg" \u2014 edits NEVER write without /apply') : null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "\u2191/\u2193 recall prompts \xB7 /retry re-send last \xB7 /think see R1 reasoning \xB7 /tool N full tool output"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "Esc (while thinking) \u2014 abort & summarize what was found so far"));
 }
 function formatEditResults(results) {
   const lines = results.map((r) => {