@debugg-ai/debugg-ai-mcp 6.1.1 → 6.1.3

package/dist/handlers/testPageChangesHandler.js

@@ -608,7 +608,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
             // the response) must not POST a cancel for finished work. EXCEPTION: on a
             // poll-deadline timeout the execution may still be running backend-side,
             // so keep it cancellable.
-            if (!finalExecution.timedOut)
+            if (!finalExecution.timedOut && !finalExecution.stalled)
                 currentExecutionUuid = '';
             // Decide retry vs exit: only retry on documented transient signatures
             // AND while we still have budget. Otherwise break and surface whatever
@@ -617,7 +617,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                 break;
             // A poll-deadline timeout (bead 56kd.3) is never retried — surface the
             // partial result instead of burning another 10 minutes.
-            if (finalExecution.timedOut)
+            if (finalExecution.timedOut || finalExecution.stalled)
                 break;
             if (!isTransientWorkflowError(finalExecution))
                 break;
@@ -641,6 +641,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
             // real numbers from the deadline path, so the reason is a record of what
             // we observed rather than a fixed sentence
             pollTimeout: timedOut ? finalExecution.pollTimeout : undefined,
+            stalled: finalExecution.stalled ? finalExecution.stall : undefined,
         });
         const relayActionTrace = verdict.actionTrace;
         // Evaluation: the backend derives it from the SAME verdict as the headline

package/dist/services/verdictAdapter.js

@@ -150,6 +150,13 @@ export function credentialSubstitutions(logins, namedIdentities) {
         && typeof l.username === 'string' && l.username.trim() !== ''
         && !named.has(norm(l.username)));
 }
+/** Backend agent loop was never started: an internal init bug, not a verdict on the user's page. */
+const BRAIN_UNINITIALISED = /BrowserUseBrain\.initialize\(\)|must be called before decide_next_action/i;
+export function stalledReason(facts) {
+    const where = facts.executionUuid ? ` (execution ${facts.executionUuid})` : '';
+    const secs = typeof facts.elapsedMs === 'number' ? ` after ${Math.round(facts.elapsedMs / 1000)}s` : '';
+    return `The run never started its agent loop${secs} (0 steps taken)${where}. This is a backend/browser-session start-up failure, not a result about your page; retry, and if it repeats report this execution id.`;
+}
 /**
  * Map a workflow execution onto the MCP relay verdict. Never throws.
  */
@@ -166,8 +173,9 @@ export function adaptVerdict(execution, opts = {}) {
     const rawOutcome = opts.outcomeOverride ?? verdict?.outcome;
     const raw = typeof rawOutcome === 'string' ? rawOutcome.trim() : '';
     const isOurPollTimeout = opts.outcomeOverride === 'timeout';
+    const isStalled = !!opts.stalled;
     const backendReason = typeof verdict?.reason === 'string' && verdict.reason.trim() !== '' ? verdict.reason : null;
-    if (!isOurPollTimeout && !raw) {
+    if (!isOurPollTimeout && !isStalled && !raw) {
         // A run that never attempted a test (platform-98fv.16): no verdict, and the
         // backend's recorded reason, verbatim.
         if (verdict?.skipped === true) {
@@ -189,7 +197,7 @@ export function adaptVerdict(execution, opts = {}) {
     // error covers: the backend's own 'error'/'timeout', every retired non-answer
     // (inconclusive/unverified/unknown/abandoned), anything a newer backend
     // invents, and a verdict that never arrived.
-    const outcome = toUserFacingOutcome(raw);
+    const outcome = isStalled ? 'error' : toUserFacingOutcome(raw);
     const relay = { outcome };
     if (budget && typeof budget === 'object')
         relay.budget = budget;
@@ -202,13 +210,19 @@ export function adaptVerdict(execution, opts = {}) {
     // any reason we are holding came from a mid-flight poll — it describes a run
     // still in progress, not its result. Relaying it next to outcome='error'
     // would pair someone else's "looks good" with our failure.
-    if (isOurPollTimeout) {
+    if (isStalled) {
+        relay.reason = stalledReason({ executionUuid: execution?.uuid, ...opts.stalled });
+    }
+    else if (isOurPollTimeout) {
         relay.reason = pollTimeoutReason({
             executionUuid: execution?.uuid,
             lastStatus: execution?.status,
             ...(opts.pollTimeout ?? {}),
         });
     }
+    else if (backendReason && BRAIN_UNINITIALISED.test(backendReason)) {
+        relay.reason = `${stalledReason({ executionUuid: execution?.uuid, elapsedMs: execution?.durationMs ?? undefined })} Backend said: ${backendReason}`;
+    }
     else if (backendReason) {
         relay.reason = backendReason;
     }

package/dist/services/workflows.js

@@ -13,6 +13,15 @@ const POLL_INTERVAL_INITIAL_MS = 1000;
 const POLL_INTERVAL_MAX_MS = 5000;
 const POLL_BACKOFF_MULTIPLIER = 1.5;
 const EXECUTION_TIMEOUT_MS = 10 * 60 * 1000; // 10 min
+// A run that is still non-terminal with ZERO agent steps this long after we
+// started polling is not "slow", it is wedged (e.g. the backend brain never
+// initialised, so the agent loop never starts). Stop waiting and say so rather
+// than burning the full run budget. Override with DEBUGGAI_NO_PROGRESS_TIMEOUT_MS.
+const DEFAULT_NO_PROGRESS_TIMEOUT_MS = 4 * 60 * 1000;
+const noProgressTimeoutMs = () => {
+    const n = Number(process.env.DEBUGGAI_NO_PROGRESS_TIMEOUT_MS);
+    return Number.isFinite(n) && n > 0 ? n : DEFAULT_NO_PROGRESS_TIMEOUT_MS;
+};
 /**
  * Stable dispatch slugs for the three MCP browser workflows (bug clka /
  * bead 56kd.8). All three handlers pin to a STABLE slug so a backend
@@ -145,6 +154,24 @@ export const createWorkflowsService = (tx) => {
                 if (signal?.aborted) {
                     throw new Error(`Polling cancelled for execution ${executionUuid}`);
                 }
+                const hasSteps = (execution.state?.stepsTaken ?? 0) > 0 ||
+                    (execution.nodeExecutions ?? []).some(n => n.nodeType === 'brain.step');
+                if (!hasSteps && Date.now() - pollStart >= noProgressTimeoutMs()) {
+                    Telemetry.capture(TelemetryEvents.WORKFLOW_EXECUTED, {
+                        status: execution.status,
+                        success: false,
+                        outcome: 'stalled',
+                        stepsTaken: 0,
+                        durationMs: Date.now() - pollStart,
+                        pollCount,
+                        finalIntervalMs: intervalMs,
+                    });
+                    return {
+                        ...execution,
+                        stalled: true,
+                        stall: { elapsedMs: Date.now() - pollStart, pollCount },
+                    };
+                }
                 const sleepMs = intervalMs;
                 await new Promise((resolve, reject) => {
                     const timer = setTimeout(resolve, sleepMs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "6.1.1",
+  "version": "6.1.3",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "caddy": "2.11.3",