reasonix 0.4.1 → 0.4.5

package/dist/index.d.ts

@@ -366,7 +366,7 @@ declare class ToolCallRepair {
     private readonly storm;
     private readonly opts;
     constructor(opts: ToolCallRepairOptions);
-    process(declaredCalls: ToolCall[], reasoningContent: string | null): {
+    process(declaredCalls: ToolCall[], reasoningContent: string | null, content?: string | null): {
         calls: ToolCall[];
         report: RepairReport;
     };
@@ -585,11 +585,34 @@ declare class CacheFirstLoop {
      * answer instead of a cliff. Called by the TUI on Esc.
      */
     abort(): void;
+    /**
+     * Drop everything in the log after (and including) the most recent
+     * user message. Used by `/retry` so the caller can re-send that
+     * message with a fresh turn instead of layering another response on
+     * top of the prior exchange. Returns the content of the dropped user
+     * message, or `null` if there isn't one yet.
+     *
+     * Persists by rewriting the session file — otherwise the next
+     * launch would rehydrate the old exchange and `/retry` would seem
+     * to have done nothing.
+     */
+    retryLastUser(): string | null;
     step(userInput: string): AsyncGenerator<LoopEvent>;
     private forceSummaryAfterIterLimit;
     run(userInput: string, onEvent?: (ev: LoopEvent) => void): Promise<string>;
     private assistantMessage;
 }
+/**
+ * R1 occasionally hallucinates tool-call markup as plain text when the
+ * real tool channel has been closed — typically our forced-summary
+ * path, where `tools: undefined` is supposed to force prose but isn't
+ * always respected. The markup isn't parsed by our tool-call path
+ * (the API response's structured `tool_calls` field is empty), so
+ * it's just noise in the user's view. Strip known envelope shapes.
+ *
+ * Exported so tests can exercise it against concrete R1 outputs.
+ */
+declare function stripHallucinatedToolMarkup(s: string): string;
 /**
  * Truncate any tool-role message whose content exceeds the cap. User
  * and assistant messages are left alone because (a) they're almost
@@ -878,8 +901,9 @@ declare function renderMarkdown(report: DiffReport): string;
  *     insulated as long as we keep up with the spec itself.
  *
  * Spec reference: https://spec.modelcontextprotocol.io/ (2024-11-05 draft
- * at time of writing). Only the subset Reasonix consumes is modeled here —
- * tools list/call + init handshake. Resources and prompts are deferred.
+ * at time of writing). Reasonix models the subset it consumes: tools
+ * list/call, resources list/read, prompts list/get, plus the init
+ * handshake. Sampling and progress notifications remain deferred.
  *
  * Transport note: the wire format for stdio MCP is **newline-delimited
  * JSON** (NDJSON), not the LSP-style Content-Length header framing that
@@ -966,6 +990,78 @@ interface CallToolResult {
     /** True = tool raised an error; the content describes it. */
     isError?: boolean;
 }
+/**
+ * A resource the server can expose — think "file the model can read."
+ * The URI is opaque to the client: servers may use `file://`, custom
+ * schemes, or bare strings. Reasonix doesn't interpret them.
+ */
+interface McpResource {
+    uri: string;
+    name: string;
+    description?: string;
+    /** Hint for the content type (e.g. "text/markdown"). Purely informational. */
+    mimeType?: string;
+}
+interface ListResourcesResult {
+    resources: McpResource[];
+    nextCursor?: string;
+}
+/**
+ * One resource can return multiple content blobs (e.g. the file + a
+ * side-car). `text` is the common case for UTF-8 content; `blob` is
+ * base64-encoded bytes for binary content. Servers populate exactly
+ * one of the two for each entry.
+ */
+interface McpResourceContentsText {
+    uri: string;
+    mimeType?: string;
+    text: string;
+}
+interface McpResourceContentsBlob {
+    uri: string;
+    mimeType?: string;
+    blob: string;
+}
+type McpResourceContents = McpResourceContentsText | McpResourceContentsBlob;
+interface ReadResourceResult {
+    contents: McpResourceContents[];
+}
+/**
+ * A parameterizable prompt template the server exposes. Clients fetch
+ * it with `prompts/get` and pass the result to the model as-is.
+ */
+interface McpPromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+interface McpPrompt {
+    name: string;
+    description?: string;
+    arguments?: McpPromptArgument[];
+}
+interface ListPromptsResult {
+    prompts: McpPrompt[];
+    nextCursor?: string;
+}
+/**
+ * MCP prompt messages are modeled after chat completions: role + content.
+ * Content can be a text block OR (per the spec) a resource/image block;
+ * Reasonix cares about text in v1, but surfaces the raw array so callers
+ * can render other kinds if they need to.
+ */
+interface McpPromptMessage {
+    role: "user" | "assistant";
+    content: McpContentBlock | McpPromptResourceBlock;
+}
+interface McpPromptResourceBlock {
+    type: "resource";
+    resource: McpResourceContents;
+}
+interface GetPromptResult {
+    description?: string;
+    messages: McpPromptMessage[];
+}
 /** Current MCP protocol version Reasonix is coded against. */
 declare const MCP_PROTOCOL_VERSION = "2024-11-05";
 /** Type guard — success vs error response. */
@@ -1068,6 +1164,24 @@ declare class McpClient {
     listTools(): Promise<ListToolsResult>;
     /** Invoke a tool by name. Returns the raw MCP result (caller unwraps content). */
     callTool(name: string, args?: Record<string, unknown>): Promise<CallToolResult>;
+    /**
+     * 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.
+     */
+    listResources(cursor?: string): Promise<ListResourcesResult>;
+    /** Read the contents of a resource by URI. */
+    readResource(uri: string): Promise<ReadResourceResult>;
+    /** List prompt templates the server exposes. */
+    listPrompts(cursor?: string): Promise<ListPromptsResult>;
+    /**
+     * 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.
+     */
+    getPrompt(name: string, args?: Record<string, string>): Promise<GetPromptResult>;
     /** Close the transport and reject any outstanding requests. */
     close(): Promise<void>;
     private assertInitialized;
@@ -1416,6 +1530,6 @@ declare function redactKey(key: string): string;
 
 /** Reasonix — DeepSeek-native agent framework. Library entry point. */
 
-declare const VERSION = "0.4.1";
+declare const VERSION = "0.4.3";
 
-export { AppendOnlyLog, type ApplyResult, type ApplyStatus, type BranchOptions, type BranchProgress, type BranchResult, type BranchSample, type BranchSelector, type BranchSummary, type BridgeOptions, type BridgeResult, CODE_SYSTEM_PROMPT, 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 EditBlock, type EditSnapshot, 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, applyEditBlock, applyEditBlocks, bridgeMcpTools, claudeEquivalentCost, codeSystemPrompt, computeReplayStats, costUsd, defaultConfigPath, defaultSelector, deleteSession, diffTranscripts, emptyPlanState, fetchWithRetry, flattenMcpResult, flattenSchema, formatLoopError, harvest, healLoadedMessages, isJsonRpcError, isPlanStateEmpty, isPlausibleKey, listSessions, loadApiKey, loadDotenv, loadSessionMessages, nestArguments, openTranscriptFile, parseEditBlocks, parseMcpSpec, parseTranscript, readConfig, readTranscript, recordFromLoopEvent, redactKey, renderMarkdown as renderDiffMarkdown, renderSummaryTable as renderDiffSummary, repairTruncatedJson, replayFromFile, restoreSnapshots, runBranches, sanitizeName as sanitizeSessionName, saveApiKey, scavengeToolCalls, sessionPath, sessionsDir, similarity, snapshotBeforeEdits, truncateForModel, writeConfig, writeMeta, writeRecord };
+export { AppendOnlyLog, type ApplyResult, type ApplyStatus, type BranchOptions, type BranchProgress, type BranchResult, type BranchSample, type BranchSelector, type BranchSummary, type BridgeOptions, type BridgeResult, CODE_SYSTEM_PROMPT, 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 EditBlock, type EditSnapshot, type EventRole, type FlattenDecision, type FlattenOptions, type GetPromptResult, type HarvestOptions, ImmutablePrefix, type ImmutablePrefixOptions, type InitializeResult, type JSONSchema, type JsonRpcMessage, type JsonRpcRequest, type JsonRpcResponse, type ListPromptsResult, type ListResourcesResult, type ListToolsResult, type LoopEvent, MCP_PROTOCOL_VERSION, McpClient, type McpClientOptions, type McpContentBlock, type McpPrompt, type McpPromptArgument, type McpPromptMessage, type McpPromptResourceBlock, type McpResource, type McpResourceContents, type McpResourceContentsBlob, type McpResourceContentsText, type McpSpec, type McpTool, type McpToolSchema, type McpTransport, type ReadResourceResult, 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, applyEditBlock, applyEditBlocks, bridgeMcpTools, claudeEquivalentCost, codeSystemPrompt, computeReplayStats, costUsd, defaultConfigPath, defaultSelector, deleteSession, diffTranscripts, emptyPlanState, fetchWithRetry, flattenMcpResult, flattenSchema, formatLoopError, harvest, healLoadedMessages, isJsonRpcError, isPlanStateEmpty, isPlausibleKey, listSessions, loadApiKey, loadDotenv, loadSessionMessages, nestArguments, openTranscriptFile, parseEditBlocks, parseMcpSpec, parseTranscript, readConfig, readTranscript, recordFromLoopEvent, redactKey, renderMarkdown as renderDiffMarkdown, renderSummaryTable as renderDiffSummary, repairTruncatedJson, replayFromFile, restoreSnapshots, runBranches, sanitizeName as sanitizeSessionName, saveApiKey, scavengeToolCalls, sessionPath, sessionsDir, similarity, snapshotBeforeEdits, stripHallucinatedToolMarkup, truncateForModel, writeConfig, writeMeta, writeRecord };

package/dist/index.js

@@ -673,7 +673,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) {
@@ -683,6 +695,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;
@@ -868,14 +914,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
     });
@@ -1234,6 +1281,39 @@ var CacheFirstLoop = class {
   abort() {
     this._aborted = true;
   }
+  /**
+   * Drop everything in the log after (and including) the most recent
+   * user message. Used by `/retry` so the caller can re-send that
+   * message with a fresh turn instead of layering another response on
+   * top of the prior exchange. Returns the content of the dropped user
+   * message, or `null` if there isn't one yet.
+   *
+   * Persists by rewriting the session file — otherwise the next
+   * launch would rehydrate the old exchange and `/retry` would seem
+   * to have done nothing.
+   */
+  retryLastUser() {
+    const entries = this.log.entries;
+    let lastUserIdx = -1;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      if (entries[i].role === "user") {
+        lastUserIdx = i;
+        break;
+      }
+    }
+    if (lastUserIdx < 0) return null;
+    const raw = entries[lastUserIdx].content;
+    const userText = typeof raw === "string" ? raw : "";
+    const preserved = entries.slice(0, lastUserIdx).map((m) => ({ ...m }));
+    this.log.compactInPlace(preserved);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, preserved);
+      } catch {
+      }
+    }
+    return userText;
+  }
   async *step(userInput) {
     this._turn++;
     this.scratch.reset();
@@ -1247,9 +1327,17 @@ var CacheFirstLoop = class {
         yield {
           turn: this._turn,
           role: "warning",
-          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 forcing summary from what was gathered`
+          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)`
+        };
+        const stoppedMsg = "[aborted by user (Esc) \u2014 no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
+        this.appendAndPersist({ role: "assistant", content: stoppedMsg });
+        yield {
+          turn: this._turn,
+          role: "assistant_final",
+          content: stoppedMsg,
+          forcedSummary: true
         };
-        yield* this.forceSummaryAfterIterLimit({ reason: "aborted" });
+        yield { turn: this._turn, role: "done", content: stoppedMsg };
         return;
       }
       if (!warnedForIterBudget && iter >= warnAt) {
@@ -1412,7 +1500,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 {
@@ -1471,12 +1560,18 @@ var CacheFirstLoop = class {
   async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
     try {
       const messages = this.buildMessages(null);
+      messages.push({
+        role: "user",
+        content: "I'm out of tool-call budget for this turn. Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
+      });
       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 rawContent = resp.content?.trim() ?? "";
+      const cleaned = stripHallucinatedToolMarkup(rawContent);
+      const summary = cleaned || "(model emitted fake tool-call markup instead of a prose summary \u2014 try /retry with a narrower question, or /think to inspect R1's reasoning)";
       const reasonPrefix = reasonPrefixFor(opts.reason, this.maxToolIters);
       const annotated = `${reasonPrefix}
 
@@ -1517,6 +1612,14 @@ ${summary}`;
     return msg;
   }
 };
+function stripHallucinatedToolMarkup(s) {
+  let out = s;
+  out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
+  out = out.replace(/<\|DSML\|function_calls>[\s\S]*?<\/?\|DSML\|function_calls>/g, "");
+  out = out.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "");
+  out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
+  return out.trim();
+}
 function reasonPrefixFor(reason, iterCap) {
   if (reason === "aborted") return "[aborted by user (Esc) \u2014 summarizing what I found so far]";
   if (reason === "context-guard") {
@@ -2111,7 +2214,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 ?? {};
@@ -2135,6 +2243,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) {
@@ -2766,7 +2913,7 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.4.1";
+var VERSION = "0.4.3";
 export {
   AppendOnlyLog,
   CODE_SYSTEM_PROMPT,
@@ -2835,6 +2982,7 @@ export {
   sessionsDir,
   similarity,
   snapshotBeforeEdits,
+  stripHallucinatedToolMarkup,
   truncateForModel,
   writeConfig,
   writeMeta,