@probelabs/probe 0.6.0-rc167 → 0.6.0-rc169

package/build/agent/index.js

@@ -8296,8 +8296,8 @@ var init_vercel = __esm({
               const { writeFileSync: writeFileSync2, unlinkSync } = await import("fs");
               const { join: join3 } = await import("path");
               const { tmpdir } = await import("os");
-              const { randomUUID: randomUUID7 } = await import("crypto");
-              tempFilePath = join3(tmpdir(), `probe-extract-${randomUUID7()}.txt`);
+              const { randomUUID: randomUUID8 } = await import("crypto");
+              tempFilePath = join3(tmpdir(), `probe-extract-${randomUUID8()}.txt`);
               writeFileSync2(tempFilePath, input_content);
               if (debug) {
                 console.error(`Created temporary file for input content: ${tempFilePath}`);
@@ -17550,17 +17550,30 @@ var init_xmlParsingUtils = __esm({
 // src/agent/tools.js
 import { randomUUID as randomUUID3 } from "crypto";
 function createTools(configOptions) {
-  const tools2 = {
-    searchTool: searchTool(configOptions),
-    queryTool: queryTool(configOptions),
-    extractTool: extractTool(configOptions),
-    delegateTool: delegateTool(configOptions)
-  };
-  if (configOptions.enableBash) {
+  const tools2 = {};
+  const isToolAllowed = configOptions.isToolAllowed || ((toolName) => {
+    if (!configOptions.allowedTools) return true;
+    return configOptions.allowedTools.isEnabled(toolName);
+  });
+  if (isToolAllowed("search")) {
+    tools2.searchTool = searchTool(configOptions);
+  }
+  if (isToolAllowed("query")) {
+    tools2.queryTool = queryTool(configOptions);
+  }
+  if (isToolAllowed("extract")) {
+    tools2.extractTool = extractTool(configOptions);
+  }
+  if (configOptions.enableDelegate && isToolAllowed("delegate")) {
+    tools2.delegateTool = delegateTool(configOptions);
+  }
+  if (configOptions.enableBash && isToolAllowed("bash")) {
     tools2.bashTool = bashTool(configOptions);
   }
-  if (configOptions.allowEdit) {
+  if (configOptions.allowEdit && isToolAllowed("edit")) {
     tools2.editTool = editTool(configOptions);
+  }
+  if (configOptions.allowEdit && isToolAllowed("create")) {
     tools2.createTool = createTool(configOptions);
   }
   return tools2;
@@ -55844,6 +55857,126 @@ Provide only the corrected Mermaid diagram within a mermaid code block. Do not a
   }
 });
 
+// src/agent/shared/prompts.js
+var predefinedPrompts;
+var init_prompts = __esm({
+  "src/agent/shared/prompts.js"() {
+    "use strict";
+    predefinedPrompts = {
+      "code-explorer": `You are ProbeChat Code Explorer - an AI assistant focused on reading and explaining code using Probe's semantic search capabilities.
+
+Your primary role is to explore codebases, understand code structure, and provide clear explanations. You should:
+
+1. Use the 'search' tool to find relevant code snippets across the codebase
+2. Use the 'query' tool to locate specific symbols, functions, or classes
+3. Use the 'extract' tool to get full context for files or specific code blocks
+4. Explain code behavior, architecture patterns, and relationships between components
+5. Provide concise summaries with key insights highlighted
+
+When exploring code:
+- Start with targeted searches to find relevant areas
+- Extract full context when you need to understand implementation details
+- Trace function calls and data flow to understand how components interact
+- Focus on "why" and "how" rather than just describing what the code does
+
+You should NOT:
+- Make changes to the codebase (read-only access)
+- Execute or run code
+- Make assumptions without verifying through search/query/extract`,
+      "architect": `You are ProbeChat Architect - a senior software architect specialized in analyzing and designing software systems.
+
+Your role is to:
+
+1. Analyze existing codebases to understand architecture patterns and design decisions
+2. Identify architectural issues, technical debt, and improvement opportunities
+3. Propose refactoring strategies and architectural changes
+4. Design new features that fit well with existing architecture
+5. Create high-level architecture diagrams and documentation
+
+When analyzing architecture:
+- Use search/query/extract to understand component boundaries and dependencies
+- Identify layers, modules, and their responsibilities
+- Look for patterns like MVC, microservices, event-driven, etc.
+- Assess coupling, cohesion, and separation of concerns
+- Consider scalability, maintainability, and testability
+
+When proposing changes:
+- Provide clear rationale backed by architectural principles
+- Consider migration paths and backwards compatibility
+- Identify risks and tradeoffs
+- Suggest incremental implementation steps`,
+      "code-review": `You are ProbeChat Code Reviewer - a meticulous code reviewer focused on quality, best practices, and maintainability.
+
+Your role is to:
+
+1. Review code changes for correctness, clarity, and best practices
+2. Identify bugs, security issues, and performance problems
+3. Suggest improvements for readability and maintainability
+4. Ensure consistency with project conventions and patterns
+5. Verify test coverage and edge case handling
+
+When reviewing code:
+- Use search to find similar patterns in the codebase for consistency
+- Look for common issues: null checks, error handling, resource leaks
+- Check for security vulnerabilities: injection, XSS, etc.
+- Assess complexity and suggest simplifications
+- Verify naming conventions and code organization
+
+Provide constructive feedback:
+- Start with what's good about the code
+- Be specific about issues with examples
+- Suggest concrete improvements with code snippets
+- Prioritize critical issues over style preferences
+- Explain the "why" behind your suggestions`,
+      "engineer": `You are a senior engineer who helps implement features and fix bugs.
+
+Your role is to:
+
+1. Implement new features following project conventions
+2. Fix bugs by understanding root causes
+3. Refactor code to improve quality
+4. Write clear, maintainable code
+5. Add appropriate tests and documentation
+
+When implementing:
+- Use search/query to understand existing patterns
+- Follow the project's coding style and conventions
+- Consider edge cases and error handling
+- Write self-documenting code with clear names
+- Add comments for complex logic
+
+You have access to:
+- search: Find relevant code patterns
+- query: Locate specific symbols/functions
+- extract: Get full file context
+- implement: Create or modify files (use carefully)
+- delegate: Break down complex tasks`,
+      "support": `You are ProbeChat Support - a helpful assistant focused on answering questions about codebases.
+
+Your role is to:
+
+1. Answer questions about how code works
+2. Help users locate specific functionality
+3. Explain error messages and debugging approaches
+4. Guide users to relevant documentation
+5. Provide examples and usage patterns
+
+When helping users:
+- Ask clarifying questions if the request is ambiguous
+- Use search/query to find relevant code quickly
+- Provide clear, step-by-step explanations
+- Include code examples when helpful
+- Point to relevant files and line numbers
+
+You should be:
+- Patient and encouraging
+- Clear and concise
+- Thorough but not overwhelming
+- Honest about limitations (say "I don't know" when appropriate)`
+    };
+  }
+});
+
 // src/agent/mcp/config.js
 import { readFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync } from "fs";
 import { join as join2, dirname as dirname3 } from "path";
@@ -57383,15 +57516,60 @@ var init_contextCompactor = __esm({
 // src/agent/mcp/built-in-server.js
 import { createServer } from "http";
 import { EventEmitter as EventEmitter3 } from "events";
+import { randomUUID as randomUUID4 } from "crypto";
 import { Server as MCPServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import {
   CallToolRequestSchema,
-  ListToolsRequestSchema
+  ListToolsRequestSchema,
+  isInitializeRequest
 } from "@modelcontextprotocol/sdk/types.js";
-var BuiltInMCPServer;
+var InMemoryEventStore, BuiltInMCPServer;
 var init_built_in_server = __esm({
   "src/agent/mcp/built-in-server.js"() {
     "use strict";
+    InMemoryEventStore = class {
+      constructor() {
+        this.events = /* @__PURE__ */ new Map();
+      }
+      generateEventId(streamId) {
+        return `${streamId}_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`;
+      }
+      getStreamIdFromEventId(eventId) {
+        const parts = eventId.split("_");
+        return parts.length > 0 ? parts[0] : "";
+      }
+      async storeEvent(streamId, message) {
+        const eventId = this.generateEventId(streamId);
+        this.events.set(eventId, { streamId, message });
+        return eventId;
+      }
+      async replayEventsAfter(lastEventId, { send }) {
+        if (!lastEventId || !this.events.has(lastEventId)) {
+          return "";
+        }
+        const streamId = this.getStreamIdFromEventId(lastEventId);
+        if (!streamId) {
+          return "";
+        }
+        let foundLastEvent = false;
+        const sortedEvents = [...this.events.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+        for (const [eventId, { streamId: eventStreamId, message }] of sortedEvents) {
+          if (eventStreamId !== streamId) {
+            continue;
+          }
+          if (eventId === lastEventId) {
+            foundLastEvent = true;
+            continue;
+          }
+          if (foundLastEvent) {
+            await send(eventId, message);
+          }
+        }
+        return streamId;
+      }
+    };
     BuiltInMCPServer = class extends EventEmitter3 {
       constructor(agent, options = {}) {
         super();
@@ -57400,6 +57578,8 @@ var init_built_in_server = __esm({
         this.host = options.host || "127.0.0.1";
         this.httpServer = null;
         this.mcpServer = null;
+        this.sseTransports = /* @__PURE__ */ new Map();
+        this.streamableTransports = /* @__PURE__ */ new Map();
         this.connections = /* @__PURE__ */ new Set();
         this.debug = options.debug || false;
       }
@@ -57421,11 +57601,13 @@ var init_built_in_server = __esm({
         });
         this.registerHandlers();
         return new Promise((resolve6, reject2) => {
-          this.httpServer.listen(this.port, this.host, () => {
+          this.httpServer.listen(this.port, this.host, async () => {
             const address = this.httpServer.address();
             this.port = address.port;
             if (this.debug) {
               console.log(`[MCP] Built-in server started at http://${this.host}:${this.port}`);
+              console.log(`[MCP] SSE endpoint: http://${this.host}:${this.port}/sse`);
+              console.log(`[MCP] Messages endpoint: http://${this.host}:${this.port}/messages`);
             }
             this.emit("ready", { host: this.host, port: this.port });
             resolve6({ host: this.host, port: this.port });
@@ -57438,6 +57620,9 @@ var init_built_in_server = __esm({
        */
       handleRequest(req, res) {
         const { method, url } = req;
+        if (this.debug) {
+          console.log(`[MCP] Request: ${method} ${url}`);
+        }
         res.setHeader("Access-Control-Allow-Origin", "*");
         res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
         res.setHeader("Access-Control-Allow-Headers", "Content-Type");
@@ -57447,15 +57632,22 @@ var init_built_in_server = __esm({
           return;
         }
         if (url === "/sse" && method === "GET") {
-          this.handleSSE(req, res);
+          if (this.debug) {
+            console.log("[MCP] Routing to handleSSEConnection");
+          }
+          this.handleSSEConnection(req, res);
+          return;
+        }
+        if (url.startsWith("/messages") && method === "POST") {
+          this.handleSSEMessage(req, res);
           return;
         }
         if (url === "/rpc" && method === "POST") {
           this.handleJSONRPC(req, res);
           return;
         }
-        if (url === "/mcp" && method === "POST") {
-          this.handleMCPProtocol(req, res);
+        if (url === "/mcp") {
+          this.handleStreamableHTTP(req, res);
           return;
         }
         if (url === "/health") {
@@ -57471,7 +57663,190 @@ var init_built_in_server = __esm({
         res.end("Not Found");
       }
       /**
-       * Handle Server-Sent Events connection
+       * Handle SSE connection (GET /sse) - creates new transport
+       */
+      async handleSSEConnection(req, res) {
+        if (this.debug) {
+          console.log("[MCP] New SSE connection request");
+        }
+        const transport = new SSEServerTransport("/messages", res);
+        this.sseTransports.set(transport.sessionId, transport);
+        res.on("close", () => {
+          if (this.debug) {
+            console.log("[MCP] SSE connection closed, sessionId:", transport.sessionId);
+          }
+          this.sseTransports.delete(transport.sessionId);
+        });
+        try {
+          await this.mcpServer.connect(transport);
+          if (this.debug) {
+            console.log("[MCP] MCP server connected to SSE transport, sessionId:", transport.sessionId);
+          }
+        } catch (error) {
+          if (this.debug) {
+            console.error("[MCP] Error connecting MCP server to transport:", error);
+          }
+          this.sseTransports.delete(transport.sessionId);
+        }
+      }
+      /**
+       * Handle SSE message (POST /messages?sessionId=...) - routes to existing transport
+       */
+      async handleSSEMessage(req, res) {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const sessionId = url.searchParams.get("sessionId");
+        if (!sessionId) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Bad Request: sessionId query parameter is required"
+            },
+            id: null
+          }));
+          return;
+        }
+        const transport = this.sseTransports.get(sessionId);
+        if (!transport) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: `Bad Request: No transport found for sessionId: ${sessionId}`
+            },
+            id: null
+          }));
+          return;
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", async () => {
+          try {
+            const message = JSON.parse(body);
+            await transport.handlePostMessage(req, res, message);
+          } catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32603,
+                message: "Internal error",
+                data: error.message
+              },
+              id: null
+            }));
+          }
+        });
+      }
+      /**
+       * Handle Streamable HTTP protocol (GET/POST/DELETE on /mcp)
+       */
+      async handleStreamableHTTP(req, res) {
+        const { method } = req;
+        if (this.debug) {
+          console.log(`[MCP] Streamable HTTP ${method} request`);
+        }
+        try {
+          let body = null;
+          if (method === "POST") {
+            body = await this.parseRequestBody(req);
+          }
+          const sessionId = req.headers["mcp-session-id"];
+          let transport;
+          if (sessionId && this.streamableTransports.has(sessionId)) {
+            transport = this.streamableTransports.get(sessionId);
+            if (this.debug) {
+              console.log(`[MCP] Reusing existing transport for session: ${sessionId}`);
+            }
+          } else if (!sessionId && method === "POST" && body && isInitializeRequest(body)) {
+            if (this.debug) {
+              console.log("[MCP] Creating new Streamable HTTP transport for initialization");
+            }
+            const eventStore = new InMemoryEventStore();
+            transport = new StreamableHTTPServerTransport({
+              sessionIdGenerator: () => randomUUID4(),
+              eventStore,
+              // Enable resumability
+              onsessioninitialized: (newSessionId) => {
+                if (this.debug) {
+                  console.log(`[MCP] Streamable HTTP session initialized: ${newSessionId}`);
+                }
+                this.streamableTransports.set(newSessionId, transport);
+              },
+              onsessionclosed: (closedSessionId) => {
+                if (this.debug) {
+                  console.log(`[MCP] Streamable HTTP session closed: ${closedSessionId}`);
+                }
+                this.streamableTransports.delete(closedSessionId);
+              }
+            });
+            transport.onclose = () => {
+              const sid = transport.sessionId;
+              if (sid && this.streamableTransports.has(sid)) {
+                if (this.debug) {
+                  console.log(`[MCP] Transport closed for session ${sid}`);
+                }
+                this.streamableTransports.delete(sid);
+              }
+            };
+            await this.mcpServer.connect(transport);
+          } else {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32e3,
+                message: "Bad Request: No valid session ID provided or not an initialization request"
+              },
+              id: null
+            }));
+            return;
+          }
+          await transport.handleRequest(req, res, body);
+        } catch (error) {
+          if (this.debug) {
+            console.error("[MCP] Error handling Streamable HTTP request:", error);
+          }
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32603,
+                message: "Internal server error",
+                data: error.message
+              },
+              id: null
+            }));
+          }
+        }
+      }
+      /**
+       * Parse request body as JSON
+       */
+      async parseRequestBody(req) {
+        return new Promise((resolve6, reject2) => {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const parsed = body ? JSON.parse(body) : null;
+              resolve6(parsed);
+            } catch (error) {
+              reject2(error);
+            }
+          });
+          req.on("error", reject2);
+        });
+      }
+      /**
+       * Handle Server-Sent Events connection (DEPRECATED - use handleSSEConnection instead)
        */
       handleSSE(req, res) {
         res.writeHead(200, {
@@ -57738,6 +58113,32 @@ data: ${JSON.stringify(data)}
        * Stop the server
        */
       async stop() {
+        for (const [sessionId, transport] of this.streamableTransports.entries()) {
+          try {
+            await transport.close();
+            if (this.debug) {
+              console.log(`[MCP] Closed Streamable HTTP transport for session: ${sessionId}`);
+            }
+          } catch (error) {
+            if (this.debug) {
+              console.error(`[MCP] Error closing Streamable HTTP transport ${sessionId}:`, error);
+            }
+          }
+        }
+        this.streamableTransports.clear();
+        for (const [sessionId, transport] of this.sseTransports.entries()) {
+          try {
+            await transport.close();
+            if (this.debug) {
+              console.log(`[MCP] Closed SSE transport for session: ${sessionId}`);
+            }
+          } catch (error) {
+            if (this.debug) {
+              console.error(`[MCP] Error closing SSE transport ${sessionId}:`, error);
+            }
+          }
+        }
+        this.sseTransports.clear();
         for (const connection of this.connections) {
           connection.end();
         }
@@ -57769,6 +58170,59 @@ data: ${JSON.stringify(data)}
   }
 });
 
+// src/agent/shared/Session.js
+var Session;
+var init_Session = __esm({
+  "src/agent/shared/Session.js"() {
+    "use strict";
+    Session = class {
+      constructor(id, debug = false) {
+        this.id = id;
+        this.conversationId = null;
+        this.messageCount = 0;
+        this.debug = debug;
+      }
+      /**
+       * Set the conversation ID for session resumption
+       * @param {string} conversationId - Provider's conversation/thread ID
+       */
+      setConversationId(conversationId) {
+        this.conversationId = conversationId;
+        if (this.debug) {
+          console.log(`[Session ${this.id}] Conversation ID: ${conversationId}`);
+        }
+      }
+      /**
+       * Increment the message count
+       */
+      incrementMessageCount() {
+        this.messageCount++;
+      }
+      /**
+       * Get session info as plain object
+       * @returns {Object} Session information
+       */
+      getInfo() {
+        return {
+          id: this.id,
+          conversationId: this.conversationId,
+          messageCount: this.messageCount
+        };
+      }
+      /**
+       * Get resume arguments for CLI commands (used by Claude Code)
+       * @returns {Array<string>} CLI arguments for resuming conversation
+       */
+      getResumeArgs() {
+        if (this.conversationId && this.messageCount > 0) {
+          return ["--resume", this.conversationId];
+        }
+        return [];
+      }
+    };
+  }
+});
+
 // src/agent/engines/enhanced-claude-code.js
 var enhanced_claude_code_exports = {};
 __export(enhanced_claude_code_exports, {
@@ -57782,7 +58236,7 @@ import os3 from "os";
 import { EventEmitter as EventEmitter4 } from "events";
 async function createEnhancedClaudeCLIEngine(options = {}) {
   const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools } = options;
-  const session = new ClaudeSession(
+  const session = new Session(
     sessionId || randomBytes(8).toString("hex"),
     debug
   );
@@ -57993,11 +58447,7 @@ ${opts.schema}`;
      * Get session info
      */
     getSession() {
-      return {
-        id: session.id,
-        conversationId: session.conversationId,
-        messageCount: session.messageCount
-      };
+      return session.getInfo();
     },
     /**
      * Clean up - MUST be called to stop MCP server and clean resources
@@ -58178,40 +58628,285 @@ function combinePrompts(systemPrompt, customPrompt, agent) {
   }
   return systemPrompt || "";
 }
-var ClaudeSession;
 var init_enhanced_claude_code = __esm({
   "src/agent/engines/enhanced-claude-code.js"() {
     "use strict";
     init_built_in_server();
-    ClaudeSession = class {
-      constructor(id, debug = false) {
-        this.id = id;
-        this.conversationId = null;
-        this.messageCount = 0;
-        this.debug = debug;
+    init_Session();
+  }
+});
+
+// src/agent/engines/codex.js
+var codex_exports = {};
+__export(codex_exports, {
+  createCodexEngine: () => createCodexEngine
+});
+import { spawn as spawn4 } from "child_process";
+import { randomBytes as randomBytes2 } from "crypto";
+import { createInterface } from "readline";
+async function createCodexEngine(options = {}) {
+  const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools, model } = options;
+  const session = new Session(
+    sessionId || randomBytes2(8).toString("hex"),
+    debug
+  );
+  let mcpServer = null;
+  let mcpServerUrl = null;
+  let mcpServerName = null;
+  if (agent) {
+    mcpServer = new BuiltInMCPServer(agent, {
+      port: 0,
+      host: "127.0.0.1",
+      debug
+    });
+    const { host, port } = await mcpServer.start();
+    mcpServerUrl = `http://${host}:${port}/mcp`;
+    mcpServerName = `probe_${session.id}`;
+    if (debug) {
+      console.log("[DEBUG] Built-in Probe MCP server started");
+      console.log("[DEBUG] Probe MCP URL:", mcpServerUrl);
+    }
+  }
+  if (debug) {
+    console.log("[DEBUG] Starting Codex MCP server...");
+  }
+  const codexProcess = spawn4("codex", ["mcp-server"], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let requestId = 0;
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const stdoutReader = createInterface({
+    input: codexProcess.stdout,
+    crlfDelay: Infinity
+  });
+  stdoutReader.on("line", (line) => {
+    try {
+      const message = JSON.parse(line);
+      if (debug) {
+        if (message.method === "codex/event") {
+          console.log(`[DEBUG] Codex event: ${message.params?.msg?.type}`);
+        }
       }
-      /**
-       * Update session with Claude's conversation ID
-       */
-      setConversationId(convId) {
-        this.conversationId = convId;
-        if (this.debug) {
-          console.log(`[Session ${this.id}] Conversation ID: ${convId}`);
+      if (message.id !== void 0 && pendingRequests.has(message.id)) {
+        const { resolve: resolve6, reject: reject2 } = pendingRequests.get(message.id);
+        pendingRequests.delete(message.id);
+        if (message.error) {
+          reject2(new Error(message.error.message || JSON.stringify(message.error)));
+        } else {
+          resolve6(message.result);
         }
       }
-      /**
-       * Get resume arguments for continuing conversation
-       */
-      getResumeArgs() {
-        if (this.conversationId && this.messageCount > 0) {
-          return ["--resume", this.conversationId];
+      if (message.method === "codex/event" && message.params) {
+        const requestId2 = message.params._meta?.requestId;
+        if (requestId2 !== void 0 && eventHandlers.has(requestId2)) {
+          eventHandlers.get(requestId2)(message.params);
         }
-        return [];
       }
-      incrementMessageCount() {
-        this.messageCount++;
+    } catch (e) {
+      if (debug) {
+        console.error("[DEBUG] Failed to parse message:", line);
       }
-    };
+    }
+  });
+  if (debug) {
+    codexProcess.stderr.on("data", (data) => {
+      console.error("[CODEX STDERR]", data.toString());
+    });
+  }
+  function sendRequest(method, params = {}) {
+    return new Promise((resolve6, reject2) => {
+      const id = ++requestId;
+      const request = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      };
+      pendingRequests.set(id, { resolve: resolve6, reject: reject2 });
+      setTimeout(() => {
+        if (pendingRequests.has(id)) {
+          pendingRequests.delete(id);
+          reject2(new Error(`Request ${method} timed out after 10 minutes`));
+        }
+      }, 6e5);
+      codexProcess.stdin.write(JSON.stringify(request) + "\n");
+    });
+  }
+  await sendRequest("initialize", {
+    protocolVersion: "2024-11-05",
+    capabilities: { tools: {} },
+    clientInfo: {
+      name: "probe-codex-client",
+      version: "1.0.0"
+    }
+  });
+  if (debug) {
+    console.log("[DEBUG] Connected to Codex MCP server");
+    console.log("[DEBUG] Session:", session.id);
+  }
+  const fullPrompt = combinePrompts2(systemPrompt, customPrompt, agent);
+  return {
+    sessionId: session.id,
+    session,
+    /**
+     * Query Codex via MCP protocol with event streaming
+     */
+    async *query(prompt, opts = {}) {
+      let finalPrompt = prompt;
+      if (!session.conversationId && fullPrompt) {
+        finalPrompt = `${fullPrompt}
+
+${prompt}`;
+      }
+      const isFollowUp = session.conversationId !== null;
+      const toolName = isFollowUp ? "codex-reply" : "codex";
+      const toolArgs = { prompt: finalPrompt };
+      if (isFollowUp) {
+        toolArgs.conversationId = session.conversationId;
+        if (debug) {
+          console.log(`[DEBUG] Follow-up with conversationId: ${session.conversationId}`);
+        }
+      } else {
+        if (model) {
+          toolArgs.model = model;
+        }
+        if (mcpServerUrl && mcpServerName) {
+          toolArgs.config = {
+            mcp_servers: {
+              [mcpServerName]: { url: mcpServerUrl }
+            }
+          };
+        }
+        if (debug) {
+          console.log(`[DEBUG] Initial query with tool: ${toolName}`);
+        }
+      }
+      try {
+        const reqId = requestId + 1;
+        let fullResponse = "";
+        let gotSessionId = false;
+        const eventPromise = new Promise((resolve6) => {
+          eventHandlers.set(reqId, (eventParams) => {
+            const msg = eventParams.msg;
+            if (msg.type === "session_configured" && msg.session_id && !gotSessionId) {
+              session.setConversationId(msg.session_id);
+              gotSessionId = true;
+            }
+            if (msg.type === "raw_response_item" && msg.item?.role === "assistant") {
+              const content = msg.item.content;
+              if (Array.isArray(content)) {
+                for (const part of content) {
+                  if (part.type === "text" && part.text) {
+                    fullResponse += part.text;
+                  }
+                }
+              }
+            }
+          });
+          setTimeout(() => {
+            eventHandlers.delete(reqId);
+            resolve6();
+          }, 6e5);
+        });
+        const resultPromise = sendRequest("tools/call", {
+          name: toolName,
+          arguments: toolArgs
+        });
+        const result = await resultPromise;
+        eventHandlers.delete(reqId);
+        if (result && result.content && Array.isArray(result.content)) {
+          for (const item of result.content) {
+            if (item.type === "text" && item.text) {
+              yield {
+                type: "text",
+                content: item.text
+              };
+              fullResponse = item.text;
+            }
+          }
+        }
+        if (fullResponse && (!result.content || result.content.length === 0)) {
+          yield {
+            type: "text",
+            content: fullResponse
+          };
+        }
+        session.incrementMessageCount();
+        yield {
+          type: "metadata",
+          data: {
+            sessionId: session.id,
+            conversationId: session.conversationId,
+            messageCount: session.messageCount
+          }
+        };
+      } catch (error) {
+        if (debug) {
+          console.error("[DEBUG] Codex query error:", error);
+        }
+        yield {
+          type: "error",
+          error
+        };
+      }
+    },
+    /**
+     * Get session info
+     */
+    getSession() {
+      return session.getInfo();
+    },
+    /**
+     * Clean up resources
+     */
+    async close() {
+      try {
+        if (stdoutReader) {
+          stdoutReader.close();
+          if (debug) {
+            console.log("[DEBUG] Closed stdout reader");
+          }
+        }
+        pendingRequests.clear();
+        eventHandlers.clear();
+        if (codexProcess && !codexProcess.killed) {
+          codexProcess.kill();
+          if (debug) {
+            console.log("[DEBUG] Killed Codex MCP server process");
+          }
+        }
+        if (mcpServer) {
+          await mcpServer.stop();
+          if (debug) {
+            console.log("[DEBUG] Stopped Probe MCP server");
+          }
+        }
+        if (debug) {
+          console.log("[DEBUG] Engine closed, session:", session.id);
+        }
+      } catch (error) {
+        if (debug) {
+          console.error("[DEBUG] Error during cleanup:", error.message);
+        }
+      }
+    }
+  };
+}
+function combinePrompts2(systemPrompt, customPrompt, agent) {
+  if (!systemPrompt && customPrompt) {
+    return customPrompt;
+  }
+  if (systemPrompt && customPrompt) {
+    return systemPrompt + "\n\n## Additional Instructions\n" + customPrompt;
+  }
+  return systemPrompt || "";
+}
+var init_codex = __esm({
+  "src/agent/engines/codex.js"() {
+    "use strict";
+    init_built_in_server();
+    init_Session();
   }
 });
 
@@ -58294,7 +58989,7 @@ import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
 import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
 import { createAmazonBedrock as createAmazonBedrock2 } from "@ai-sdk/amazon-bedrock";
 import { streamText as streamText2 } from "ai";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { EventEmitter as EventEmitter5 } from "events";
 import { existsSync as existsSync5 } from "fs";
 import { readFile, stat } from "fs/promises";
@@ -58314,6 +59009,7 @@ var init_ProbeAgent = __esm({
     init_index();
     init_schemaUtils();
     init_xmlParsingUtils();
+    init_prompts();
     init_mcp();
     init_RetryManager();
     init_FallbackManager();
@@ -58335,6 +59031,7 @@ var init_ProbeAgent = __esm({
        * @param {Object} options - Configuration options
        * @param {string} [options.sessionId] - Optional session ID
        * @param {string} [options.customPrompt] - Custom prompt to replace the default system message
+       * @param {string} [options.systemPrompt] - Alias for customPrompt; takes precedence when both are provided
        * @param {string} [options.promptType] - Predefined prompt type (architect, code-review, support)
        * @param {boolean} [options.allowEdit=false] - Allow the use of the 'implement' tool
        * @param {boolean} [options.enableDelegate=false] - Enable the delegate tool for task distribution to subagents
@@ -58369,8 +59066,8 @@ var init_ProbeAgent = __esm({
        * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
        */
       constructor(options = {}) {
-        this.sessionId = options.sessionId || randomUUID4();
-        this.customPrompt = options.customPrompt || null;
+        this.sessionId = options.sessionId || randomUUID5();
+        this.customPrompt = options.systemPrompt || options.customPrompt || null;
         this.promptType = options.promptType || "code-explorer";
         this.allowEdit = !!options.allowEdit;
         this.enableDelegate = !!options.enableDelegate;
@@ -58494,9 +59191,10 @@ var init_ProbeAgent = __esm({
        * This method initializes MCP and merges MCP tools into the tool list, and loads history from storage
        */
       async initialize() {
-        if (!this.provider && !this.clientApiProvider && this.apiType !== "claude-code") {
+        if (!this.provider && !this.clientApiProvider && this.apiType !== "claude-code" && this.apiType !== "codex") {
           if (this.apiType === "uninitialized") {
             const claudeAvailable = await this.isClaudeCommandAvailable();
+            const codexAvailable = await this.isCodexCommandAvailable();
             if (claudeAvailable) {
               if (this.debug) {
                 console.log("[DEBUG] No API keys found, but claude command detected");
@@ -58506,8 +59204,17 @@ var init_ProbeAgent = __esm({
               this.provider = null;
               this.model = this.clientApiModel || "claude-3-5-sonnet-20241022";
               this.apiType = "claude-code";
+            } else if (codexAvailable) {
+              if (this.debug) {
+                console.log("[DEBUG] No API keys found, but codex command detected");
+                console.log("[DEBUG] Auto-switching to codex provider");
+              }
+              this.clientApiProvider = "codex";
+              this.provider = null;
+              this.model = this.clientApiModel || "gpt-4o";
+              this.apiType = "codex";
             } else {
-              throw new Error("No API key provided and claude command not found. Please either:\n1. Set an API key: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, or AWS credentials\n2. Install claude command from https://docs.claude.com/en/docs/claude-code");
+              throw new Error("No API key provided and neither claude nor codex command found. Please either:\n1. Set an API key: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, or AWS credentials\n2. Install claude command from https://docs.claude.com/en/docs/claude-code\n3. Install codex command from https://openai.com/codex");
             }
           }
         }
@@ -58570,25 +59277,43 @@ var init_ProbeAgent = __esm({
        * Initialize tools with configuration
        */
       initializeTools() {
+        const isToolAllowed = (toolName) => this.allowedTools.isEnabled(toolName);
         const configOptions = {
           sessionId: this.sessionId,
           debug: this.debug,
           defaultPath: this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd(),
           allowedFolders: this.allowedFolders,
           outline: this.outline,
+          allowEdit: this.allowEdit,
+          enableDelegate: this.enableDelegate,
           enableBash: this.enableBash,
-          bashConfig: this.bashConfig
+          bashConfig: this.bashConfig,
+          allowedTools: this.allowedTools,
+          isToolAllowed
         };
         const baseTools = createTools(configOptions);
         const wrappedTools = createWrappedTools(baseTools);
-        this.toolImplementations = {
-          search: wrappedTools.searchToolInstance,
-          query: wrappedTools.queryToolInstance,
-          extract: wrappedTools.extractToolInstance,
-          delegate: wrappedTools.delegateToolInstance,
-          listFiles: listFilesToolInstance,
-          searchFiles: searchFilesToolInstance,
-          readImage: {
+        this.toolImplementations = {};
+        if (wrappedTools.searchToolInstance && isToolAllowed("search")) {
+          this.toolImplementations.search = wrappedTools.searchToolInstance;
+        }
+        if (wrappedTools.queryToolInstance && isToolAllowed("query")) {
+          this.toolImplementations.query = wrappedTools.queryToolInstance;
+        }
+        if (wrappedTools.extractToolInstance && isToolAllowed("extract")) {
+          this.toolImplementations.extract = wrappedTools.extractToolInstance;
+        }
+        if (this.enableDelegate && wrappedTools.delegateToolInstance && isToolAllowed("delegate")) {
+          this.toolImplementations.delegate = wrappedTools.delegateToolInstance;
+        }
+        if (isToolAllowed("listFiles")) {
+          this.toolImplementations.listFiles = listFilesToolInstance;
+        }
+        if (isToolAllowed("searchFiles")) {
+          this.toolImplementations.searchFiles = searchFilesToolInstance;
+        }
+        if (isToolAllowed("readImage")) {
+          this.toolImplementations.readImage = {
             execute: async (params) => {
               const imagePath = params.path;
               if (!imagePath) {
@@ -58600,16 +59325,16 @@ var init_ProbeAgent = __esm({
               }
               return `Image loaded successfully: ${imagePath}. The image is now available for analysis in the conversation.`;
             }
-          }
-        };
-        if (this.enableBash && wrappedTools.bashToolInstance) {
+          };
+        }
+        if (this.enableBash && wrappedTools.bashToolInstance && isToolAllowed("bash")) {
           this.toolImplementations.bash = wrappedTools.bashToolInstance;
         }
         if (this.allowEdit) {
-          if (wrappedTools.editToolInstance) {
+          if (wrappedTools.editToolInstance && isToolAllowed("edit")) {
             this.toolImplementations.edit = wrappedTools.editToolInstance;
           }
-          if (wrappedTools.createToolInstance) {
+          if (wrappedTools.createToolInstance && isToolAllowed("create")) {
             this.toolImplementations.create = wrappedTools.createToolInstance;
           }
         }
@@ -58629,13 +59354,33 @@ var init_ProbeAgent = __esm({
       }
       /**
        * Check if claude command is available on the system
+       * Uses execFile instead of exec to avoid shell injection risks
        * @returns {Promise<boolean>} True if claude command is available
        * @private
        */
       async isClaudeCommandAvailable() {
         try {
-          const { execSync } = await import("child_process");
-          execSync("claude --version", { stdio: "ignore" });
+          const { execFile: execFile3 } = await import("child_process");
+          const { promisify: promisify8 } = await import("util");
+          const execFileAsync3 = promisify8(execFile3);
+          await execFileAsync3("claude", ["--version"], { timeout: 5e3 });
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+      /**
+       * Check if codex command is available on the system
+       * Uses execFile instead of exec to avoid shell injection risks
+       * @returns {Promise<boolean>} True if codex command is available
+       * @private
+       */
+      async isCodexCommandAvailable() {
+        try {
+          const { execFile: execFile3 } = await import("child_process");
+          const { promisify: promisify8 } = await import("util");
+          const execFileAsync3 = promisify8(execFile3);
+          await execFileAsync3("codex", ["--version"], { timeout: 5e3 });
           return true;
         } catch (error) {
           return false;
@@ -58659,6 +59404,20 @@ var init_ProbeAgent = __esm({
           }
           return;
         }
+        if (this.clientApiProvider === "codex" || process.env.USE_CODEX === "true") {
+          this.provider = null;
+          this.model = modelName || null;
+          this.apiType = "codex";
+          if (this.debug) {
+            console.log("[DEBUG] Codex CLI engine selected - will use built-in access if available");
+            if (this.model) {
+              console.log(`[DEBUG] Using model: ${this.model}`);
+            } else {
+              console.log("[DEBUG] Using Codex account default model");
+            }
+          }
+          return;
+        }
         const anthropicApiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN;
         const openaiApiKey = process.env.OPENAI_API_KEY;
         const googleApiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY;
@@ -58820,6 +59579,44 @@ var init_ProbeAgent = __esm({
             }
           }
         }
+        if (this.clientApiProvider === "codex" || process.env.USE_CODEX === "true") {
+          try {
+            const engine = await this.getEngine();
+            if (engine && engine.query) {
+              const userMessages = options.messages.filter(
+                (m) => m.role === "user" && !m.content.includes("WARNING: You have reached the maximum tool iterations limit")
+              );
+              const lastUserMessage = userMessages[userMessages.length - 1];
+              const prompt = lastUserMessage ? lastUserMessage.content : "";
+              const engineOptions = {
+                maxTokens: options.maxTokens,
+                temperature: options.temperature,
+                messages: options.messages,
+                systemPrompt: options.messages.find((m) => m.role === "system")?.content
+              };
+              const engineStream = engine.query(prompt, engineOptions);
+              async function* createTextStream() {
+                for await (const message of engineStream) {
+                  if (message.type === "text" && message.content) {
+                    yield message.content;
+                  } else if (typeof message === "string") {
+                    yield message;
+                  }
+                }
+              }
+              return {
+                textStream: createTextStream(),
+                usage: Promise.resolve({})
+                // Engine should handle its own usage tracking
+                // Add other streamText-compatible properties as needed
+              };
+            }
+          } catch (error) {
+            if (this.debug) {
+              console.log(`[DEBUG] Failed to use Codex engine, falling back to Vercel:`, error.message);
+            }
+          }
+        }
         if (!this.retryManager) {
           this.retryManager = new RetryManager({
             maxRetries: this.retryConfig.maxRetries ?? 3,
@@ -58972,6 +59769,35 @@ var init_ProbeAgent = __esm({
             this.clientApiProvider = null;
           }
         }
+        if (this.clientApiProvider === "codex" || process.env.USE_CODEX === "true") {
+          try {
+            const { createCodexEngine: createCodexEngine2 } = await Promise.resolve().then(() => (init_codex(), codex_exports));
+            const systemPrompt = this.customPrompt || this.getCodexNativeSystemPrompt();
+            this.engine = await createCodexEngine2({
+              agent: this,
+              // Pass reference to ProbeAgent for tool access
+              systemPrompt,
+              customPrompt: this.customPrompt,
+              sessionId: this.options?.sessionId,
+              debug: this.debug,
+              allowedTools: this.allowedTools,
+              // Pass tool filtering configuration
+              model: this.model
+              // Pass model name (e.g., gpt-4o, o3, etc.)
+            });
+            if (this.debug) {
+              console.log("[DEBUG] Using Codex CLI engine with Probe tools");
+              if (this.customPrompt) {
+                console.log("[DEBUG] Using custom prompt/persona");
+              }
+            }
+            return this.engine;
+          } catch (error) {
+            console.warn("[WARNING] Failed to load Codex CLI engine:", error.message);
+            console.warn("[WARNING] Falling back to Vercel AI SDK");
+            this.clientApiProvider = null;
+          }
+        }
         const { createEnhancedVercelEngine: createEnhancedVercelEngine2 } = await Promise.resolve().then(() => (init_enhanced_vercel(), enhanced_vercel_exports));
         this.engine = createEnhancedVercelEngine2(this);
         if (this.debug) {
@@ -58979,6 +59805,32 @@ var init_ProbeAgent = __esm({
         }
         return this.engine;
       }
+      /**
+       * Get session information including thread ID for resumability
+       * @returns {Object} Session info with sessionId, threadId, messageCount
+       */
+      getSessionInfo() {
+        if (this.engine && this.engine.getSession) {
+          return this.engine.getSession();
+        }
+        return {
+          id: this.sessionId,
+          threadId: null,
+          messageCount: 0
+        };
+      }
+      /**
+       * Close the agent and clean up resources (e.g., MCP servers)
+       * @returns {Promise<void>}
+       */
+      async close() {
+        if (this.engine && this.engine.close) {
+          await this.engine.close();
+        }
+        if (this.mcpBridge) {
+          this.mcpBridge = null;
+        }
+      }
       /**
        * Process assistant response content and detect/load image references
        * @param {string} content - The assistant's response content
@@ -59271,11 +60123,61 @@ var init_ProbeAgent = __esm({
        */
       getClaudeNativeSystemPrompt() {
         let systemPrompt = "";
-        if (this.predefinedPrompt) {
-          const personaPrompt = getPromptByType(this.predefinedPrompt);
-          if (personaPrompt?.system) {
-            systemPrompt += personaPrompt.system + "\n\n";
-          }
+        if (this.customPrompt) {
+          systemPrompt += this.customPrompt + "\n\n";
+        } else if (this.promptType && predefinedPrompts[this.promptType]) {
+          systemPrompt += predefinedPrompts[this.promptType] + "\n\n";
+        } else {
+          systemPrompt += predefinedPrompts["code-explorer"] + "\n\n";
+        }
+        systemPrompt += `You have access to powerful code search and analysis tools through MCP:
+- search: Find code patterns using semantic search
+- extract: Extract specific code sections with context
+- query: Use AST patterns for structural code matching
+- listFiles: Browse directory contents
+- searchFiles: Find files by name patterns`;
+        if (this.enableBash) {
+          systemPrompt += `
+- bash: Execute bash commands for system operations`;
+        }
+        systemPrompt += `
+
+When exploring code:
+1. Start with search to find relevant code patterns
+2. Use extract to get detailed context when needed
+3. Prefer focused, specific searches over broad queries
+4. Combine multiple tools to build complete understanding`;
+        if (this.allowedFolders && this.allowedFolders.length > 0) {
+          systemPrompt += `
+
+Workspace: ${this.allowedFolders.join(", ")}`;
+        }
+        if (this.fileList) {
+          systemPrompt += `
+
+# Repository Structure
+`;
+          systemPrompt += `You are working with a repository located at: ${this.allowedFolders[0]}
+
+`;
+          systemPrompt += `Here's an overview of the repository structure (showing up to 100 most relevant files):
+
+`;
+          systemPrompt += "```\n" + this.fileList + "\n```\n";
+        }
+        return systemPrompt;
+      }
+      /**
+       * Get system prompt for Codex CLI (similar to Claude but optimized for Codex)
+       */
+      getCodexNativeSystemPrompt() {
+        let systemPrompt = "";
+        if (this.customPrompt) {
+          systemPrompt += this.customPrompt + "\n\n";
+        } else if (this.promptType && predefinedPrompts[this.promptType]) {
+          systemPrompt += predefinedPrompts[this.promptType] + "\n\n";
+        } else {
+          systemPrompt += predefinedPrompts["code-explorer"] + "\n\n";
         }
         systemPrompt += `You have access to powerful code search and analysis tools through MCP:
 - search: Find code patterns using semantic search
@@ -59471,7 +60373,7 @@ Follow these instructions carefully:
     - Use 'create' for new files or complete file rewrites` : ""}
 </instructions>
 `;
-        const predefinedPrompts = {
+        const predefinedPrompts2 = {
           "code-explorer": `You are ProbeChat Code Explorer, a specialized AI assistant focused on helping developers, product managers, and QAs understand and navigate codebases. Your primary function is to answer questions based on code, explain how systems work, and provide insights into code functionality using the provided code analysis tools.
 
 When exploring code:
@@ -59527,14 +60429,14 @@ When troubleshooting:
           if (this.debug) {
             console.log(`[DEBUG] Using custom prompt`);
           }
-        } else if (this.promptType && predefinedPrompts[this.promptType]) {
-          systemMessage = "<role>" + predefinedPrompts[this.promptType] + "</role>";
+        } else if (this.promptType && predefinedPrompts2[this.promptType]) {
+          systemMessage = "<role>" + predefinedPrompts2[this.promptType] + "</role>";
           if (this.debug) {
             console.log(`[DEBUG] Using predefined prompt: ${this.promptType}`);
           }
           systemMessage += commonInstructions;
         } else {
-          systemMessage = "<role>" + predefinedPrompts["code-explorer"] + "</role>";
+          systemMessage = "<role>" + predefinedPrompts2["code-explorer"] + "</role>";
           if (this.debug) {
             console.log(`[DEBUG] Using default prompt: code explorer`);
           }
@@ -59675,6 +60577,7 @@ You are working with a repository located at: ${searchDirectory}
           const baseMaxIterations = this.maxIterations || MAX_TOOL_ITERATIONS;
           const maxIterations = options.schema ? baseMaxIterations + 4 : baseMaxIterations;
           const isClaudeCode = this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true";
+          const isCodex = this.clientApiProvider === "codex" || process.env.USE_CODEX === "true";
           if (isClaudeCode) {
             if (this.debug) {
               console.log(`[DEBUG] Using Claude Code engine - bypassing tool loop (black box mode)`);
@@ -59727,6 +60630,58 @@ You are working with a repository located at: ${searchDirectory}
               throw error;
             }
           }
+          if (isCodex) {
+            if (this.debug) {
+              console.log(`[DEBUG] Using Codex engine - bypassing tool loop (black box mode)`);
+              console.log(`[DEBUG] Sending question directly to Codex: ${message.substring(0, 100)}...`);
+            }
+            try {
+              const engine = await this.getEngine();
+              if (engine && engine.query) {
+                let assistantResponseContent = "";
+                let toolBatch = null;
+                for await (const chunk of engine.query(message, options)) {
+                  if (chunk.type === "text" && chunk.content) {
+                    assistantResponseContent += chunk.content;
+                    if (options.onStream) {
+                      options.onStream(chunk.content);
+                    }
+                  } else if (chunk.type === "toolBatch" && chunk.tools) {
+                    toolBatch = chunk.tools;
+                    if (this.debug) {
+                      console.log(`[DEBUG] Received batch of ${chunk.tools.length} tool events from Codex`);
+                    }
+                  } else if (chunk.type === "error") {
+                    throw chunk.error;
+                  }
+                }
+                if (toolBatch && toolBatch.length > 0 && this.events) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] Emitting ${toolBatch.length} tool events from Codex batch`);
+                  }
+                  for (const toolEvent of toolBatch) {
+                    this.events.emit("toolCall", toolEvent);
+                  }
+                }
+                this.history.push(userMessage);
+                this.history.push({
+                  role: "assistant",
+                  content: assistantResponseContent
+                });
+                await this.hooks.emit(HOOK_TYPES.COMPLETION, {
+                  sessionId: this.sessionId,
+                  prompt: message,
+                  response: assistantResponseContent
+                });
+                return assistantResponseContent;
+              }
+            } catch (error) {
+              if (this.debug) {
+                console.error("[DEBUG] Codex error:", error);
+              }
+              throw error;
+            }
+          }
           if (this.debug) {
             console.log(`[DEBUG] Starting agentic flow for question: ${message.substring(0, 100)}...`);
             if (options.schema) {
@@ -60607,7 +61562,7 @@ Convert your previous response content into actual JSON data that follows this s
        */
       clone(options = {}) {
         const {
-          sessionId = randomUUID4(),
+          sessionId = randomUUID5(),
           stripInternalMessages = true,
           keepSystemMessage = true,
           deepCopy = true,
@@ -60826,7 +61781,7 @@ import { readFileSync as readFileSync2, existsSync as existsSync6 } from "fs";
 import { resolve as resolve5 } from "path";
 
 // src/agent/acp/server.js
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/agent/acp/connection.js
 import { EventEmitter as EventEmitter6 } from "events";
@@ -61318,7 +62273,7 @@ var ACPServer = class {
    * Handle new session request
    */
   async handleNewSession(params) {
-    const sessionId = params?.sessionId || randomUUID5();
+    const sessionId = params?.sessionId || randomUUID6();
     const mode = params?.mode || SessionMode.NORMAL;
     const session = new ACPSession(sessionId, mode);
     this.sessions.set(sessionId, session);
@@ -61490,7 +62445,7 @@ var ACPServer = class {
 };
 
 // src/agent/acp/tools.js
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/agent/index.js
 dotenv3.config();