@probelabs/probe 0.6.0-rc226 → 0.6.0-rc228

package/build/agent/index.js

@@ -68681,8 +68681,6 @@ async function truncateIfNeeded(content, tokenCounter, sessionId, maxTokens) {
   if (tokenCount <= limit) {
     return { truncated: false, content };
   }
-  const maxChars = limit * CHARS_PER_TOKEN2;
-  const truncatedContent = content.substring(0, maxChars);
   let tempFilePath = null;
   let fileError = null;
   try {
@@ -68694,22 +68692,38 @@ async function truncateIfNeeded(content, tokenCounter, sessionId, maxTokens) {
     fileError = err.message || "Unknown file system error";
     tempFilePath = null;
   }
+  let truncatedBody;
+  const useTail = limit >= MIN_LIMIT_FOR_TAIL;
+  if (useTail) {
+    const headTokens = limit - TAIL_TOKENS;
+    const headChars = headTokens * CHARS_PER_TOKEN2;
+    const tailChars = TAIL_TOKENS * CHARS_PER_TOKEN2;
+    const headContent = content.substring(0, headChars);
+    const tailContent = content.substring(content.length - tailChars);
+    const omittedTokens = tokenCount - headTokens - TAIL_TOKENS;
+    truncatedBody = `${headContent}
+
+... ${omittedTokens} tokens omitted ...
+
+${tailContent}`;
+  } else {
+    const maxChars = limit * CHARS_PER_TOKEN2;
+    truncatedBody = content.substring(0, maxChars);
+  }
   let message;
   if (tempFilePath) {
     message = `Output exceeded maximum size (${tokenCount} tokens, limit: ${limit}).
 Full output saved to: ${tempFilePath}
 
---- Truncated Output (first ${limit} tokens approx) ---
-${truncatedContent}
-...
+--- Truncated Output ---
+${truncatedBody}
 --- End of Truncated Output ---`;
   } else {
     message = `Output exceeded maximum size (${tokenCount} tokens, limit: ${limit}).
 Warning: Could not save full output to file (${fileError}).
 
---- Truncated Output (first ${limit} tokens approx) ---
-${truncatedContent}
-...
+--- Truncated Output ---
+${truncatedBody}
 --- End of Truncated Output ---`;
   }
   return {
@@ -68720,12 +68734,14 @@ ${truncatedContent}
     error: fileError || void 0
   };
 }
-var DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN2;
+var DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN2, TAIL_TOKENS, MIN_LIMIT_FOR_TAIL;
 var init_outputTruncator = __esm({
   "src/agent/outputTruncator.js"() {
     "use strict";
     DEFAULT_MAX_OUTPUT_TOKENS = 2e4;
     CHARS_PER_TOKEN2 = 4;
+    TAIL_TOKENS = 1e3;
+    MIN_LIMIT_FOR_TAIL = 2e3;
   }
 });
 
@@ -69451,7 +69467,7 @@ import path8 from "path";
 import os3 from "os";
 import { EventEmitter as EventEmitter4 } from "events";
 async function createEnhancedClaudeCLIEngine(options = {}) {
-  const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools } = options;
+  const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools, timeout = 12e4 } = options;
   const session = new Session(
     sessionId || randomBytes(8).toString("hex"),
     debug
@@ -69550,6 +69566,30 @@ ${opts.schema}`;
         stdio: ["ignore", "pipe", "pipe"]
         // Ignore stdin since echo handles it
       });
+      let killed = false;
+      let timeoutHandle;
+      let sigkillHandle;
+      if (timeout > 0) {
+        timeoutHandle = setTimeout(() => {
+          if (!killed) {
+            killed = true;
+            processEnded = true;
+            proc2.kill("SIGTERM");
+            if (debug) {
+              console.log(`[DEBUG] Process timed out after ${timeout}ms, sending SIGTERM`);
+            }
+            sigkillHandle = setTimeout(() => {
+              if (proc2.exitCode === null) {
+                proc2.kill("SIGKILL");
+                if (debug) {
+                  console.log("[DEBUG] Process did not exit, sending SIGKILL");
+                }
+              }
+            }, 5e3);
+            emitter.emit("error", new Error(`Claude CLI process timed out after ${timeout}ms`));
+          }
+        }, timeout);
+      }
       proc2.stdout.on("data", (data) => {
         buffer += data.toString();
         processJsonBuffer(buffer, emitter, session, debug, toolCollector);
@@ -69566,10 +69606,20 @@ ${opts.schema}`;
         }
       });
       proc2.on("close", (code) => {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        if (sigkillHandle) {
+          clearTimeout(sigkillHandle);
+        }
         processEnded = true;
         if (code !== 0 && debug) {
           console.log(`[DEBUG] Process exited with code ${code}`);
         }
+        if (killed) {
+          emitter.emit("end");
+          return;
+        }
         if (buffer.trim()) {
           processJsonBuffer(buffer, emitter, session, debug, toolCollector);
         }
@@ -69585,6 +69635,13 @@ ${opts.schema}`;
         emitter.emit("end");
       });
       proc2.on("error", (error) => {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        if (sigkillHandle) {
+          clearTimeout(sigkillHandle);
+        }
+        processEnded = true;
         emitter.emit("error", error);
       });
       const messageQueue = [];
@@ -69630,7 +69687,22 @@ ${opts.schema}`;
 \u{1F527} Using ${msg.name}: ${JSON.stringify(msg.input)}
 `
             };
-            const result = await executeProbleTool(agent, msg.name, msg.input);
+            const toolTimeout = 3e4;
+            let toolTimeoutId;
+            const timeoutPromise = new Promise((_, reject2) => {
+              toolTimeoutId = setTimeout(() => reject2(new Error(`Tool ${msg.name} timed out after ${toolTimeout}ms`)), toolTimeout);
+            });
+            let result;
+            try {
+              result = await Promise.race([
+                executeProbleTool(agent, msg.name, msg.input),
+                timeoutPromise
+              ]);
+            } catch (error) {
+              result = `Tool error: ${error.message}`;
+            } finally {
+              clearTimeout(toolTimeoutId);
+            }
             yield { type: "text", content: `${result}
 ` };
           } else if (msg.type === "toolBatch") {
@@ -70197,6 +70269,9 @@ var init_enhanced_vercel = __esm({
 // src/agent/ProbeAgent.js
 var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
+  ENGINE_ACTIVITY_TIMEOUT_DEFAULT: () => ENGINE_ACTIVITY_TIMEOUT_DEFAULT,
+  ENGINE_ACTIVITY_TIMEOUT_MAX: () => ENGINE_ACTIVITY_TIMEOUT_MAX,
+  ENGINE_ACTIVITY_TIMEOUT_MIN: () => ENGINE_ACTIVITY_TIMEOUT_MIN,
   ProbeAgent: () => ProbeAgent
 });
 import dotenv2 from "dotenv";
@@ -70231,7 +70306,7 @@ Your content here
 
 Do NOT wrap in other tags like <api_call>, <tool_name>, <function>, etc.`;
 }
-var MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     "use strict";
@@ -70260,6 +70335,9 @@ var init_ProbeAgent = __esm({
     init_delegate();
     init_tasks();
     dotenv2.config();
+    ENGINE_ACTIVITY_TIMEOUT_DEFAULT = 18e4;
+    ENGINE_ACTIVITY_TIMEOUT_MIN = 5e3;
+    ENGINE_ACTIVITY_TIMEOUT_MAX = 6e5;
     MAX_TOOL_ITERATIONS = (() => {
       const val = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
       if (isNaN(val) || val < 1 || val > 200) {
@@ -70318,6 +70396,8 @@ var init_ProbeAgent = __esm({
        * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
        * @param {string} [options.completionPrompt] - Custom prompt to run after attempt_completion for validation/review (runs before mermaid/JSON validation)
        * @param {number} [options.maxOutputTokens] - Maximum tokens for tool output before truncation (default: 20000, can also be set via PROBE_MAX_OUTPUT_TOKENS env var)
+       * @param {number} [options.requestTimeout] - Timeout in ms for AI requests (default: 120000 or REQUEST_TIMEOUT env var). Used to abort hung requests.
+       * @param {number} [options.maxOperationTimeout] - Maximum timeout in ms for the entire operation including all retries and fallbacks (default: 300000 or MAX_OPERATION_TIMEOUT env var). This is the absolute maximum time for streamTextWithRetryAndFallback.
        */
       constructor(options = {}) {
         this.sessionId = options.sessionId || randomUUID6();
@@ -70403,6 +70483,32 @@ var init_ProbeAgent = __esm({
         this.enableTasks = !!options.enableTasks;
         this.taskManager = null;
         this.delegationManager = new DelegationManager();
+        this.requestTimeout = options.requestTimeout ?? (() => {
+          if (process.env.REQUEST_TIMEOUT) {
+            const parsed = parseInt(process.env.REQUEST_TIMEOUT, 10);
+            if (isNaN(parsed) || parsed < 1e3 || parsed > 36e5) {
+              return 12e4;
+            }
+            return parsed;
+          }
+          return 12e4;
+        })();
+        if (this.debug) {
+          console.log(`[DEBUG] Request timeout: ${this.requestTimeout}ms`);
+        }
+        this.maxOperationTimeout = options.maxOperationTimeout ?? (() => {
+          if (process.env.MAX_OPERATION_TIMEOUT) {
+            const parsed = parseInt(process.env.MAX_OPERATION_TIMEOUT, 10);
+            if (isNaN(parsed) || parsed < 1e3 || parsed > 72e5) {
+              return 3e5;
+            }
+            return parsed;
+          }
+          return 3e5;
+        })();
+        if (this.debug) {
+          console.log(`[DEBUG] Max operation timeout: ${this.maxOperationTimeout}ms`);
+        }
         this.retryConfig = options.retry || {};
         this.retryManager = null;
         this.fallbackConfig = options.fallback || null;
@@ -71022,88 +71128,98 @@ var init_ProbeAgent = __esm({
         }
       }
       /**
-       * Execute streamText with retry and fallback support
-       * @param {Object} options - streamText options
-       * @returns {Promise<Object>} - streamText result
+       * Create a streamText-compatible result from an engine stream with timeout handling
+       * @param {AsyncGenerator} engineStream - The engine's query result
+       * @param {AbortSignal} abortSignal - Signal for aborting the operation
+       * @param {number} requestTimeout - Per-request timeout in ms
+       * @param {Object} timeoutState - Object with timeoutId property (mutable for cleanup)
+       * @returns {Object} - streamText-compatible result with textStream
        * @private
        */
-      async streamTextWithRetryAndFallback(options) {
-        if (this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true") {
+      _createEngineTextStreamResult(engineStream, abortSignal, requestTimeout, timeoutState) {
+        const activityTimeout = (() => {
+          const parsed = parseInt(process.env.ENGINE_ACTIVITY_TIMEOUT, 10);
+          return isNaN(parsed) || parsed < ENGINE_ACTIVITY_TIMEOUT_MIN || parsed > ENGINE_ACTIVITY_TIMEOUT_MAX ? ENGINE_ACTIVITY_TIMEOUT_DEFAULT : parsed;
+        })();
+        const startTime = Date.now();
+        async function* createTextStream() {
+          let lastActivity = Date.now();
           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;
-                  }
-                }
+            for await (const message of engineStream) {
+              if (abortSignal.aborted) {
+                const abortError = new Error("Operation aborted");
+                abortError.name = "AbortError";
+                throw abortError;
               }
-              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 Claude Code engine, falling back to Vercel:`, error.message);
-            }
-          }
-        }
-        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;
-                  }
-                }
+              const now = Date.now();
+              if (now - lastActivity > activityTimeout) {
+                throw new Error(`Engine stream timeout - no activity for ${activityTimeout}ms`);
+              }
+              if (requestTimeout > 0 && now - startTime > requestTimeout) {
+                throw new Error(`Engine stream timeout - request exceeded ${requestTimeout}ms`);
+              }
+              lastActivity = now;
+              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);
+          } finally {
+            if (timeoutState.timeoutId) {
+              clearTimeout(timeoutState.timeoutId);
+              timeoutState.timeoutId = null;
             }
           }
         }
+        return {
+          textStream: createTextStream(),
+          usage: Promise.resolve({})
+          // Engine should handle its own usage tracking
+          // Add other streamText-compatible properties as needed
+        };
+      }
+      /**
+       * Try to use an engine (claude-code or codex) for streaming
+       * @param {Object} options - streamText options
+       * @param {AbortController} controller - Abort controller for the operation
+       * @param {Object} timeoutState - Mutable timeout state for cleanup
+       * @returns {Promise<Object|null>} - Stream result or null if engine unavailable
+       * @private
+       */
+      async _tryEngineStreamPath(options, controller, timeoutState) {
+        const engine = await this.getEngine();
+        if (!engine || !engine.query) {
+          return null;
+        }
+        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,
+          abortSignal: controller.signal
+        };
+        const engineStream = engine.query(prompt, engineOptions);
+        return this._createEngineTextStreamResult(
+          engineStream,
+          controller.signal,
+          this.requestTimeout,
+          timeoutState
+        );
+      }
+      /**
+       * Execute streamText with Vercel AI SDK using retry/fallback logic
+       * @param {Object} options - streamText options
+       * @param {AbortController} controller - Abort controller for the operation
+       * @returns {Promise<Object>} - Stream result
+       * @private
+       */
+      async _executeWithVercelProvider(options, controller) {
         if (!this.retryManager) {
           this.retryManager = new RetryManager({
             maxRetries: this.retryConfig.maxRetries ?? 3,
@@ -71116,10 +71232,11 @@ var init_ProbeAgent = __esm({
         }
         if (!this.fallbackManager) {
           return await this.retryManager.executeWithRetry(
-            () => streamText2(options),
+            () => streamText2({ ...options, abortSignal: controller.signal }),
             {
               provider: this.apiType,
-              model: this.model
+              model: this.model,
+              signal: controller.signal
             }
           );
         }
@@ -71127,7 +71244,8 @@ var init_ProbeAgent = __esm({
           async (provider, model, config) => {
             const fallbackOptions = {
               ...options,
-              model: provider(model)
+              model: provider(model),
+              abortSignal: controller.signal
             };
             const providerRetryManager = new RetryManager({
               maxRetries: config.maxRetries ?? this.retryConfig.maxRetries ?? 3,
@@ -71141,12 +71259,54 @@ var init_ProbeAgent = __esm({
               () => streamText2(fallbackOptions),
               {
                 provider: config.provider,
-                model
+                model,
+                signal: controller.signal
               }
             );
           }
         );
       }
+      /**
+       * Execute streamText with retry and fallback support
+       * @param {Object} options - streamText options
+       * @returns {Promise<Object>} - streamText result
+       * @private
+       */
+      async streamTextWithRetryAndFallback(options) {
+        const controller = new AbortController();
+        const timeoutState = { timeoutId: null };
+        if (this.maxOperationTimeout && this.maxOperationTimeout > 0) {
+          timeoutState.timeoutId = setTimeout(() => {
+            controller.abort();
+            if (this.debug) {
+              console.log(`[DEBUG] Operation timed out after ${this.maxOperationTimeout}ms (max operation timeout)`);
+            }
+          }, this.maxOperationTimeout);
+        }
+        try {
+          const useClaudeCode = this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true";
+          const useCodex = this.clientApiProvider === "codex" || process.env.USE_CODEX === "true";
+          if (useClaudeCode || useCodex) {
+            try {
+              const result = await this._tryEngineStreamPath(options, controller, timeoutState);
+              if (result) {
+                return result;
+              }
+            } catch (error) {
+              if (this.debug) {
+                const engineType = useClaudeCode ? "Claude Code" : "Codex";
+                console.log(`[DEBUG] Failed to use ${engineType} engine, falling back to Vercel:`, error.message);
+              }
+            }
+          }
+          return await this._executeWithVercelProvider(options, controller);
+        } finally {
+          if (timeoutState.timeoutId) {
+            clearTimeout(timeoutState.timeoutId);
+            timeoutState.timeoutId = null;
+          }
+        }
+      }
       /**
        * Initialize Anthropic model
        */

package/build/agent/outputTruncator.js

@@ -5,6 +5,8 @@ import { randomUUID } from 'crypto';
 
 const DEFAULT_MAX_OUTPUT_TOKENS = 20000;
 const CHARS_PER_TOKEN = 4; // Conservative approximation
+const TAIL_TOKENS = 1000; // Number of tokens to show from the end of truncated output
+const MIN_LIMIT_FOR_TAIL = 2000; // Minimum token limit to use head+tail split
 
 /**
  * Validate and normalize a token limit value.
@@ -61,10 +63,6 @@ export async function truncateIfNeeded(content, tokenCounter, sessionId, maxToke
     return { truncated: false, content };
   }
 
-  // Truncate to approximately maxTokens worth of characters
-  const maxChars = limit * CHARS_PER_TOKEN;
-  const truncatedContent = content.substring(0, maxChars);
-
   // Try to write full output to temp file
   let tempFilePath = null;
   let fileError = null;
@@ -79,22 +77,37 @@ export async function truncateIfNeeded(content, tokenCounter, sessionId, maxToke
     tempFilePath = null;
   }
 
+  // Build truncated content with head + tail for better context
+  let truncatedBody;
+  const useTail = limit >= MIN_LIMIT_FOR_TAIL;
+
+  if (useTail) {
+    const headTokens = limit - TAIL_TOKENS;
+    const headChars = headTokens * CHARS_PER_TOKEN;
+    const tailChars = TAIL_TOKENS * CHARS_PER_TOKEN;
+    const headContent = content.substring(0, headChars);
+    const tailContent = content.substring(content.length - tailChars);
+    const omittedTokens = tokenCount - headTokens - TAIL_TOKENS;
+    truncatedBody = `${headContent}\n\n... ${omittedTokens} tokens omitted ...\n\n${tailContent}`;
+  } else {
+    const maxChars = limit * CHARS_PER_TOKEN;
+    truncatedBody = content.substring(0, maxChars);
+  }
+
   let message;
   if (tempFilePath) {
     message = `Output exceeded maximum size (${tokenCount} tokens, limit: ${limit}).
 Full output saved to: ${tempFilePath}
 
---- Truncated Output (first ${limit} tokens approx) ---
-${truncatedContent}
-...
+--- Truncated Output ---
+${truncatedBody}
 --- End of Truncated Output ---`;
   } else {
     message = `Output exceeded maximum size (${tokenCount} tokens, limit: ${limit}).
 Warning: Could not save full output to file (${fileError}).
 
---- Truncated Output (first ${limit} tokens approx) ---
-${truncatedContent}
-...
+--- Truncated Output ---
+${truncatedBody}
 --- End of Truncated Output ---`;
   }