@probelabs/probe 0.6.0-rc116 → 0.6.0-rc117

package/build/agent/index.js

@@ -30026,6 +30026,268 @@ var init_simpleTelemetry = __esm({
   }
 });
 
+// src/agent/probeTool.js
+import { exec as exec6 } from "child_process";
+import { promisify as promisify6 } from "util";
+import { randomUUID as randomUUID2 } from "crypto";
+import { EventEmitter } from "events";
+import fs5 from "fs";
+import { promises as fsPromises } from "fs";
+import path5 from "path";
+import { glob } from "glob";
+function isSessionCancelled(sessionId) {
+  return activeToolExecutions.get(sessionId)?.cancelled || false;
+}
+function registerToolExecution(sessionId) {
+  if (!sessionId) return;
+  if (!activeToolExecutions.has(sessionId)) {
+    activeToolExecutions.set(sessionId, { cancelled: false });
+  } else {
+    activeToolExecutions.get(sessionId).cancelled = false;
+  }
+}
+function clearToolExecutionData(sessionId) {
+  if (!sessionId) return;
+  if (activeToolExecutions.has(sessionId)) {
+    activeToolExecutions.delete(sessionId);
+    if (process.env.DEBUG === "1") {
+      console.log(`Cleared tool execution data for session: ${sessionId}`);
+    }
+  }
+}
+function createWrappedTools(baseTools) {
+  const wrappedTools = {};
+  if (baseTools.searchTool) {
+    wrappedTools.searchToolInstance = wrapToolWithEmitter(
+      baseTools.searchTool,
+      "search",
+      baseTools.searchTool.execute
+    );
+  }
+  if (baseTools.queryTool) {
+    wrappedTools.queryToolInstance = wrapToolWithEmitter(
+      baseTools.queryTool,
+      "query",
+      baseTools.queryTool.execute
+    );
+  }
+  if (baseTools.extractTool) {
+    wrappedTools.extractToolInstance = wrapToolWithEmitter(
+      baseTools.extractTool,
+      "extract",
+      baseTools.extractTool.execute
+    );
+  }
+  if (baseTools.delegateTool) {
+    wrappedTools.delegateToolInstance = wrapToolWithEmitter(
+      baseTools.delegateTool,
+      "delegate",
+      baseTools.delegateTool.execute
+    );
+  }
+  if (baseTools.bashTool) {
+    wrappedTools.bashToolInstance = wrapToolWithEmitter(
+      baseTools.bashTool,
+      "bash",
+      baseTools.bashTool.execute
+    );
+  }
+  return wrappedTools;
+}
+var toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var init_probeTool = __esm({
+  "src/agent/probeTool.js"() {
+    "use strict";
+    init_index();
+    toolCallEmitter = new EventEmitter();
+    activeToolExecutions = /* @__PURE__ */ new Map();
+    wrapToolWithEmitter = (tool3, toolName, baseExecute) => {
+      return {
+        ...tool3,
+        // Spread schema, description etc.
+        execute: async (params) => {
+          const debug = process.env.DEBUG === "1";
+          const toolSessionId = params.sessionId || randomUUID2();
+          if (debug) {
+            console.log(`[DEBUG] probeTool: Executing ${toolName} for session ${toolSessionId}`);
+          }
+          registerToolExecution(toolSessionId);
+          let executionError = null;
+          let result = null;
+          try {
+            const toolCallStartData = {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              name: toolName,
+              args: params,
+              status: "started"
+            };
+            if (debug) {
+              console.log(`[DEBUG] probeTool: Emitting toolCallStart:${toolSessionId}`);
+            }
+            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallStartData);
+            if (isSessionCancelled(toolSessionId)) {
+              if (debug) {
+                console.log(`Tool execution cancelled before start for ${toolSessionId}`);
+              }
+              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+            }
+            result = await baseExecute(params);
+            if (isSessionCancelled(toolSessionId)) {
+              if (debug) {
+                console.log(`Tool execution cancelled after completion for ${toolSessionId}`);
+              }
+              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+            }
+          } catch (error2) {
+            executionError = error2;
+            if (debug) {
+              console.error(`[DEBUG] probeTool: Error in ${toolName}:`, error2);
+            }
+          }
+          if (executionError) {
+            const toolCallErrorData = {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              name: toolName,
+              args: params,
+              error: executionError.message || "Unknown error",
+              status: "error"
+            };
+            if (debug) {
+              console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (error)`);
+            }
+            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallErrorData);
+            throw executionError;
+          } else {
+            if (isSessionCancelled(toolSessionId)) {
+              if (process.env.DEBUG === "1") {
+                console.log(`Tool execution finished but session was cancelled for ${toolSessionId}`);
+              }
+              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+            }
+            const toolCallData = {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              name: toolName,
+              args: params,
+              // Safely preview result
+              resultPreview: typeof result === "string" ? result.length > 200 ? result.substring(0, 200) + "..." : result : result ? JSON.stringify(result).substring(0, 200) + "..." : "No Result",
+              status: "completed"
+            };
+            if (debug) {
+              console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (completed)`);
+            }
+            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallData);
+            return result;
+          }
+        }
+      };
+    };
+    listFilesTool = {
+      execute: async (params) => {
+        const { directory = ".", workingDirectory } = params;
+        const baseCwd = workingDirectory || process.cwd();
+        const secureBaseDir = path5.resolve(baseCwd);
+        const targetDir = path5.resolve(secureBaseDir, directory);
+        if (!targetDir.startsWith(secureBaseDir + path5.sep) && targetDir !== secureBaseDir) {
+          throw new Error("Path traversal attempt detected. Access denied.");
+        }
+        const debug = process.env.DEBUG === "1";
+        if (debug) {
+          console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
+        }
+        try {
+          const files = await fsPromises.readdir(targetDir, { withFileTypes: true });
+          const formatSize = (size) => {
+            if (size < 1024) return `${size}B`;
+            if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
+            if (size < 1024 * 1024 * 1024) return `${(size / (1024 * 1024)).toFixed(1)}M`;
+            return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
+          };
+          const entries = await Promise.all(files.map(async (file) => {
+            const isDirectory = file.isDirectory();
+            const fullPath = path5.join(targetDir, file.name);
+            let size = 0;
+            try {
+              const stats = await fsPromises.stat(fullPath);
+              size = stats.size;
+            } catch (statError) {
+              if (debug) {
+                console.log(`[DEBUG] Could not stat file ${file.name}:`, statError.message);
+              }
+            }
+            return {
+              name: file.name,
+              isDirectory,
+              size
+            };
+          }));
+          entries.sort((a3, b3) => {
+            if (a3.isDirectory && !b3.isDirectory) return -1;
+            if (!a3.isDirectory && b3.isDirectory) return 1;
+            return a3.name.localeCompare(b3.name);
+          });
+          const formatted = entries.map((entry) => {
+            const type = entry.isDirectory ? "dir " : "file";
+            const sizeStr = formatSize(entry.size).padStart(8);
+            return `${type} ${sizeStr}  ${entry.name}`;
+          });
+          if (debug) {
+            console.log(`[DEBUG] Found ${entries.length} files/directories in ${targetDir}`);
+          }
+          const header = `${targetDir}:
+`;
+          const output = header + formatted.join("\n");
+          return output;
+        } catch (error2) {
+          throw new Error(`Failed to list files: ${error2.message}`);
+        }
+      }
+    };
+    searchFilesTool = {
+      execute: async (params) => {
+        const { pattern, directory = ".", recursive = true, workingDirectory } = params;
+        if (!pattern) {
+          throw new Error("Pattern is required for file search");
+        }
+        const baseCwd = workingDirectory || process.cwd();
+        const secureBaseDir = path5.resolve(baseCwd);
+        const targetDir = path5.resolve(secureBaseDir, directory);
+        if (!targetDir.startsWith(secureBaseDir + path5.sep) && targetDir !== secureBaseDir) {
+          throw new Error("Path traversal attempt detected. Access denied.");
+        }
+        if (pattern.includes("**/**") || pattern.split("*").length > 10) {
+          throw new Error("Pattern too complex. Please use a simpler glob pattern.");
+        }
+        try {
+          const options = {
+            cwd: targetDir,
+            ignore: ["node_modules/**", ".git/**"],
+            absolute: false
+          };
+          if (!recursive) {
+            options.deep = 1;
+          }
+          const timeoutPromise = new Promise((_2, reject2) => {
+            setTimeout(() => reject2(new Error("Search operation timed out after 10 seconds")), 1e4);
+          });
+          const files = await Promise.race([
+            glob(pattern, options),
+            timeoutPromise
+          ]);
+          const maxResults = 1e3;
+          if (files.length > maxResults) {
+            return files.slice(0, maxResults);
+          }
+          return files;
+        } catch (error2) {
+          throw new Error(`Failed to search files: ${error2.message}`);
+        }
+      }
+    };
+    listFilesToolInstance = wrapToolWithEmitter(listFilesTool, "listFiles", listFilesTool.execute);
+    searchFilesToolInstance = wrapToolWithEmitter(searchFilesTool, "searchFiles", searchFilesTool.execute);
+  }
+});
+
 // src/index.js
 var init_index = __esm({
   "src/index.js"() {
@@ -30043,6 +30305,7 @@ var init_index = __esm({
     init_bash();
     init_ProbeAgent();
     init_simpleTelemetry();
+    init_probeTool();
   }
 });
 
@@ -30146,7 +30409,7 @@ var init_xmlParsingUtils = __esm({
 });
 
 // src/agent/tools.js
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 function createTools(configOptions) {
   const tools2 = {
     searchTool: searchTool(configOptions),
@@ -30249,216 +30512,6 @@ User: Find all markdown files in the docs directory, but only at the top level.
   }
 });
 
-// src/agent/probeTool.js
-import { exec as exec6 } from "child_process";
-import { promisify as promisify6 } from "util";
-import { randomUUID as randomUUID3 } from "crypto";
-import { EventEmitter } from "events";
-import fs5 from "fs";
-import { promises as fsPromises } from "fs";
-import path5 from "path";
-import { glob } from "glob";
-function isSessionCancelled(sessionId) {
-  return activeToolExecutions.get(sessionId)?.cancelled || false;
-}
-function registerToolExecution(sessionId) {
-  if (!sessionId) return;
-  if (!activeToolExecutions.has(sessionId)) {
-    activeToolExecutions.set(sessionId, { cancelled: false });
-  } else {
-    activeToolExecutions.get(sessionId).cancelled = false;
-  }
-}
-function clearToolExecutionData(sessionId) {
-  if (!sessionId) return;
-  if (activeToolExecutions.has(sessionId)) {
-    activeToolExecutions.delete(sessionId);
-    if (process.env.DEBUG === "1") {
-      console.log(`Cleared tool execution data for session: ${sessionId}`);
-    }
-  }
-}
-function createWrappedTools(baseTools) {
-  const wrappedTools = {};
-  if (baseTools.searchTool) {
-    wrappedTools.searchToolInstance = wrapToolWithEmitter(
-      baseTools.searchTool,
-      "search",
-      baseTools.searchTool.execute
-    );
-  }
-  if (baseTools.queryTool) {
-    wrappedTools.queryToolInstance = wrapToolWithEmitter(
-      baseTools.queryTool,
-      "query",
-      baseTools.queryTool.execute
-    );
-  }
-  if (baseTools.extractTool) {
-    wrappedTools.extractToolInstance = wrapToolWithEmitter(
-      baseTools.extractTool,
-      "extract",
-      baseTools.extractTool.execute
-    );
-  }
-  if (baseTools.delegateTool) {
-    wrappedTools.delegateToolInstance = wrapToolWithEmitter(
-      baseTools.delegateTool,
-      "delegate",
-      baseTools.delegateTool.execute
-    );
-  }
-  if (baseTools.bashTool) {
-    wrappedTools.bashToolInstance = wrapToolWithEmitter(
-      baseTools.bashTool,
-      "bash",
-      baseTools.bashTool.execute
-    );
-  }
-  return wrappedTools;
-}
-var toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
-var init_probeTool = __esm({
-  "src/agent/probeTool.js"() {
-    "use strict";
-    init_index();
-    toolCallEmitter = new EventEmitter();
-    activeToolExecutions = /* @__PURE__ */ new Map();
-    wrapToolWithEmitter = (tool3, toolName, baseExecute) => {
-      return {
-        ...tool3,
-        // Spread schema, description etc.
-        execute: async (params) => {
-          const debug = process.env.DEBUG === "1";
-          const toolSessionId = params.sessionId || randomUUID3();
-          if (debug) {
-            console.log(`[DEBUG] probeTool: Executing ${toolName} for session ${toolSessionId}`);
-          }
-          registerToolExecution(toolSessionId);
-          let executionError = null;
-          let result = null;
-          try {
-            const toolCallStartData = {
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              name: toolName,
-              args: params,
-              status: "started"
-            };
-            if (debug) {
-              console.log(`[DEBUG] probeTool: Emitting toolCallStart:${toolSessionId}`);
-            }
-            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallStartData);
-            if (isSessionCancelled(toolSessionId)) {
-              if (debug) {
-                console.log(`Tool execution cancelled before start for ${toolSessionId}`);
-              }
-              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
-            }
-            result = await baseExecute(params);
-            if (isSessionCancelled(toolSessionId)) {
-              if (debug) {
-                console.log(`Tool execution cancelled after completion for ${toolSessionId}`);
-              }
-              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
-            }
-          } catch (error2) {
-            executionError = error2;
-            if (debug) {
-              console.error(`[DEBUG] probeTool: Error in ${toolName}:`, error2);
-            }
-          }
-          if (executionError) {
-            const toolCallErrorData = {
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              name: toolName,
-              args: params,
-              error: executionError.message || "Unknown error",
-              status: "error"
-            };
-            if (debug) {
-              console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (error)`);
-            }
-            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallErrorData);
-            throw executionError;
-          } else {
-            if (isSessionCancelled(toolSessionId)) {
-              if (process.env.DEBUG === "1") {
-                console.log(`Tool execution finished but session was cancelled for ${toolSessionId}`);
-              }
-              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
-            }
-            const toolCallData = {
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              name: toolName,
-              args: params,
-              // Safely preview result
-              resultPreview: typeof result === "string" ? result.length > 200 ? result.substring(0, 200) + "..." : result : result ? JSON.stringify(result).substring(0, 200) + "..." : "No Result",
-              status: "completed"
-            };
-            if (debug) {
-              console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (completed)`);
-            }
-            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallData);
-            return result;
-          }
-        }
-      };
-    };
-    listFilesTool = {
-      execute: async (params) => {
-        const { directory = ".", workingDirectory } = params;
-        const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = path5.resolve(baseCwd);
-        const targetDir = path5.resolve(secureBaseDir, directory);
-        if (!targetDir.startsWith(secureBaseDir + path5.sep) && targetDir !== secureBaseDir) {
-          throw new Error("Path traversal attempt detected. Access denied.");
-        }
-        try {
-          const files = await listFilesByLevel({
-            directory: targetDir,
-            maxFiles: 100,
-            respectGitignore: !process.env.PROBE_NO_GITIGNORE || process.env.PROBE_NO_GITIGNORE === "",
-            cwd: secureBaseDir
-          });
-          return files;
-        } catch (error2) {
-          throw new Error(`Failed to list files: ${error2.message}`);
-        }
-      }
-    };
-    searchFilesTool = {
-      execute: async (params) => {
-        const { pattern, directory = ".", recursive = true, workingDirectory } = params;
-        if (!pattern) {
-          throw new Error("Pattern is required for file search");
-        }
-        const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = path5.resolve(baseCwd);
-        const targetDir = path5.resolve(secureBaseDir, directory);
-        if (!targetDir.startsWith(secureBaseDir + path5.sep) && targetDir !== secureBaseDir) {
-          throw new Error("Path traversal attempt detected. Access denied.");
-        }
-        try {
-          const options = {
-            cwd: targetDir,
-            ignore: ["node_modules/**", ".git/**"],
-            absolute: false
-          };
-          if (!recursive) {
-            options.deep = 1;
-          }
-          const files = await glob(pattern, options);
-          return files;
-        } catch (error2) {
-          throw new Error(`Failed to search files: ${error2.message}`);
-        }
-      }
-    };
-    listFilesToolInstance = wrapToolWithEmitter(listFilesTool, "listFiles", listFilesTool.execute);
-    searchFilesToolInstance = wrapToolWithEmitter(searchFilesTool, "searchFiles", searchFilesTool.execute);
-  }
-});
-
 // src/agent/mockProvider.js
 function createMockProvider() {
   return {
@@ -57910,8 +57963,8 @@ When presented with a broken Mermaid diagram, analyze it thoroughly and provide
             debug: this.options.debug,
             tracer: this.options.tracer,
             allowEdit: this.options.allowEdit,
-            maxIterations: 2,
-            // Limit mermaid fixing to 2 iterations to prevent long loops
+            maxIterations: 10,
+            // Allow more iterations for mermaid fixing to handle complex diagrams
             disableMermaidValidation: true
             // CRITICAL: Disable mermaid validation in nested agent to prevent infinite recursion
           });
@@ -58811,6 +58864,18 @@ var init_ProbeAgent = __esm({
           this.toolImplementations.bash = wrappedTools.bashToolInstance;
         }
         this.wrappedTools = wrappedTools;
+        if (this.debug) {
+          console.error("\n[DEBUG] ========================================");
+          console.error("[DEBUG] ProbeAgent Tools Initialized");
+          console.error("[DEBUG] Session ID:", this.sessionId);
+          console.error("[DEBUG] Available tools:");
+          for (const toolName of Object.keys(this.toolImplementations)) {
+            console.error(`[DEBUG]   - ${toolName}`);
+          }
+          console.error("[DEBUG] Allowed folders:", this.allowedFolders);
+          console.error("[DEBUG] Outline mode:", this.outline);
+          console.error("[DEBUG] ========================================\n");
+        }
       }
       /**
        * Initialize the AI model based on available API keys and forced provider setting
@@ -59581,12 +59646,28 @@ You are working with a repository located at: ${searchDirectory}
                 const { type } = parsedTool;
                 if (type === "mcp" && this.mcpBridge && this.mcpBridge.isMcpTool(toolName)) {
                   try {
-                    if (this.debug) console.log(`[DEBUG] Executing MCP tool '${toolName}' with params:`, params);
+                    if (this.debug) {
+                      console.error(`
+[DEBUG] ========================================`);
+                      console.error(`[DEBUG] Executing MCP tool: ${toolName}`);
+                      console.error(`[DEBUG] Arguments:`);
+                      for (const [key, value] of Object.entries(params)) {
+                        const displayValue = typeof value === "string" && value.length > 100 ? value.substring(0, 100) + "..." : value;
+                        console.error(`[DEBUG]   ${key}: ${JSON.stringify(displayValue)}`);
+                      }
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     const executionResult = await this.mcpBridge.mcpTools[toolName].execute(params);
                     const toolResultContent = typeof executionResult === "string" ? executionResult : JSON.stringify(executionResult, null, 2);
-                    const preview = createMessagePreview(toolResultContent);
                     if (this.debug) {
-                      console.log(`[DEBUG] MCP tool '${toolName}' executed successfully. Result preview: ${preview}`);
+                      const preview = toolResultContent.length > 500 ? toolResultContent.substring(0, 500) + "..." : toolResultContent;
+                      console.error(`[DEBUG] ========================================`);
+                      console.error(`[DEBUG] MCP tool '${toolName}' completed successfully`);
+                      console.error(`[DEBUG] Result preview:`);
+                      console.error(preview);
+                      console.error(`[DEBUG] ========================================
+`);
                     }
                     currentMessages.push({ role: "user", content: `<tool_result>
 ${toolResultContent}
@@ -59594,7 +59675,13 @@ ${toolResultContent}
                   } catch (error2) {
                     console.error(`Error executing MCP tool ${toolName}:`, error2);
                     const toolResultContent = `Error executing MCP tool ${toolName}: ${error2.message}`;
-                    if (this.debug) console.log(`[DEBUG] MCP tool '${toolName}' execution FAILED.`);
+                    if (this.debug) {
+                      console.error(`[DEBUG] ========================================`);
+                      console.error(`[DEBUG] MCP tool '${toolName}' failed with error:`);
+                      console.error(`[DEBUG] ${error2.message}`);
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     currentMessages.push({ role: "user", content: `<tool_result>
 ${toolResultContent}
 </tool_result>` });
@@ -59606,6 +59693,18 @@ ${toolResultContent}
                       sessionId: this.sessionId,
                       workingDirectory: this.allowedFolders && this.allowedFolders[0] || process.cwd()
                     };
+                    if (this.debug) {
+                      console.error(`
+[DEBUG] ========================================`);
+                      console.error(`[DEBUG] Executing tool: ${toolName}`);
+                      console.error(`[DEBUG] Arguments:`);
+                      for (const [key, value] of Object.entries(params)) {
+                        const displayValue = typeof value === "string" && value.length > 100 ? value.substring(0, 100) + "..." : value;
+                        console.error(`[DEBUG]   ${key}: ${JSON.stringify(displayValue)}`);
+                      }
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     this.events.emit("toolCall", {
                       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                       name: toolName,
@@ -59647,6 +59746,15 @@ ${toolResultContent}
                       } else {
                         toolResult = await executeToolCall();
                       }
+                      if (this.debug) {
+                        const resultPreview = typeof toolResult === "string" ? toolResult.length > 500 ? toolResult.substring(0, 500) + "..." : toolResult : toolResult ? JSON.stringify(toolResult, null, 2).substring(0, 500) + "..." : "No Result";
+                        console.error(`[DEBUG] ========================================`);
+                        console.error(`[DEBUG] Tool '${toolName}' completed successfully`);
+                        console.error(`[DEBUG] Result preview:`);
+                        console.error(resultPreview);
+                        console.error(`[DEBUG] ========================================
+`);
+                      }
                       this.events.emit("toolCall", {
                         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                         name: toolName,
@@ -59655,6 +59763,13 @@ ${toolResultContent}
                         status: "completed"
                       });
                     } catch (toolError) {
+                      if (this.debug) {
+                        console.error(`[DEBUG] ========================================`);
+                        console.error(`[DEBUG] Tool '${toolName}' failed with error:`);
+                        console.error(`[DEBUG] ${toolError.message}`);
+                        console.error(`[DEBUG] ========================================
+`);
+                      }
                       this.events.emit("toolCall", {
                         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                         name: toolName,
@@ -59704,6 +59819,16 @@ Error: Unknown tool '${toolName}'. Available tools: ${allAvailableTools.join(",
                 }
               }
             } else {
+              const hasMermaidCodeBlock = /```mermaid\s*\n[\s\S]*?\n```/.test(assistantResponseContent);
+              const hasNoSchemaOrTools = !options.schema && validTools.length === 0;
+              if (hasMermaidCodeBlock && hasNoSchemaOrTools) {
+                finalResult = assistantResponseContent;
+                completionAttempted = true;
+                if (this.debug) {
+                  console.error(`[DEBUG] Accepting mermaid code block as valid completion (no schema, no tools)`);
+                }
+                break;
+              }
               currentMessages.push({ role: "assistant", content: assistantResponseContent });
               let reminderContent;
               if (options.schema) {