openfox 2.0.115 → 2.0.117

package/dist/{chunk-I7FY2LTR.js → chunk-4GHLULHB.js}

@@ -4,7 +4,7 @@ import {
 import {
   createServerMessage,
   isClientMessage
-} from "./chunk-X25Q6RAV.js";
+} from "./chunk-ZKLE2Q3I.js";
 
 // src/server/session/client-session.ts
 function toClientSession(session) {
@@ -140,6 +140,12 @@ function createChatDoneMessage(messageId, reason, stats, agentType) {
 function createChatErrorMessage(error, recoverable) {
   return createServerMessage("chat.error", { error, recoverable });
 }
+function createChatMessageRemovedMessage(messageIds) {
+  return createServerMessage("chat.message_removed", { messageIds });
+}
+function createChatStepRetryMessage(stepName, attempt, retryInMs) {
+  return createServerMessage("chat.step_retry", { stepName, attempt, retryInMs });
+}
 function createChatPathConfirmationMessage(callId, tool, paths, workdir, reason) {
   return createServerMessage("chat.path_confirmation", { callId, tool, paths, workdir, reason });
 }
@@ -316,6 +322,14 @@ function storedEventToServerMessage(event) {
       const data = event.data;
       return createChatFormatRetryMessage(data.attempt, data.maxAttempts, data.pattern, data.field, data.matchedContent);
     }
+    case "message.removed": {
+      const data = event.data;
+      return createChatMessageRemovedMessage(data.messageIds);
+    }
+    case "workflow.step_retry": {
+      const data = event.data;
+      return createChatStepRetryMessage(data.stepName, data.attempt, data.retryInMs);
+    }
     case "path.confirmation_pending":
     case "path.confirmation_responded":
       return null;
@@ -351,6 +365,8 @@ export {
   createChatMessageUpdatedMessage,
   createChatDoneMessage,
   createChatErrorMessage,
+  createChatMessageRemovedMessage,
+  createChatStepRetryMessage,
   createChatPathConfirmationMessage,
   createChatAskUserMessage,
   createModeChangedMessage,
@@ -366,4 +382,4 @@ export {
   createQueueStateMessage,
   storedEventToServerMessage
 };
-//# sourceMappingURL=chunk-I7FY2LTR.js.map
+//# sourceMappingURL=chunk-4GHLULHB.js.map

package/dist/{chunk-TGLVWAFC.js → chunk-6XHDNSA3.js}

@@ -1,14 +1,14 @@
 import {
   combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-ERNWAKUB.js";
+} from "./chunk-TGVDUK4N.js";
 import {
   updateSessionMetadata
-} from "./chunk-VWEATA7R.js";
+} from "./chunk-KLQEL2DZ.js";
 import {
   createContextStateMessage,
   createSessionStateMessage
-} from "./chunk-I7FY2LTR.js";
+} from "./chunk-4GHLULHB.js";
 import {
   getPendingQuestionsForSession
 } from "./chunk-JURM3RPZ.js";
@@ -153,7 +153,7 @@ async function generateSessionNameForSession(sessionId, userMessage, deps, signa
       client = deps.getLLMClient();
       client.setModel(providerConfig.model);
     } else if (providerConfig) {
-      const { createLLMClient } = await import("./client-KE7EDI2D.js");
+      const { createLLMClient } = await import("./client-KCNTDTIR.js");
       client = createLLMClient({
         llm: {
           baseUrl: providerConfig.baseUrl,
@@ -204,4 +204,4 @@ export {
   needsNameGeneration,
   generateSessionNameForSession
 };
-//# sourceMappingURL=chunk-TGLVWAFC.js.map
+//# sourceMappingURL=chunk-6XHDNSA3.js.map

package/dist/{chunk-3QQAIUZI.js → chunk-7SDJXHJH.js}

@@ -1,14 +1,14 @@
 import {
   runAgentTurn
-} from "./chunk-3NPLERPQ.js";
+} from "./chunk-I6MY65LO.js";
 import {
   executeSubAgent,
   getToolRegistryForAgent
-} from "./chunk-JFK4GKQD.js";
+} from "./chunk-2PQA3DHY.js";
 import {
   TurnMetrics,
   createMessageStartEvent
-} from "./chunk-YX3OQBNX.js";
+} from "./chunk-EQ7DK2TG.js";
 import {
   checkAborted,
   decodeUtf8,
@@ -27,21 +27,24 @@ import {
   loadProjectWorkflows,
   loadUserWorkflows,
   normalizeWorkflowScope
-} from "./chunk-6RGACY4E.js";
+} from "./chunk-HZSKKJHQ.js";
 import {
   getCurrentContextWindowId,
   getEventStore
-} from "./chunk-ERNWAKUB.js";
+} from "./chunk-TGVDUK4N.js";
 import {
   createChatMessageMessage,
   createSessionRunningMessage
-} from "./chunk-I7FY2LTR.js";
+} from "./chunk-4GHLULHB.js";
 import {
   findAgentById,
   getRuntimeConfig,
   loadAllAgentsDefault,
   resolveDefaultAgentId
 } from "./chunk-LNNBLB6G.js";
+import {
+  LLMError
+} from "./chunk-LTYL6ZGH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -50,11 +53,19 @@ import {
 } from "./chunk-VUQCQXXJ.js";
 import {
   createServerMessage
-} from "./chunk-X25Q6RAV.js";
+} from "./chunk-ZKLE2Q3I.js";
 import {
   getGlobalConfigDir
 } from "./chunk-CQGTEGKL.js";
 
+// src/server/runner/types.ts
+var DEFAULT_LLM_RETRY_POLICY = {
+  backoffMs: [1e3, 5e3, 3e4],
+  minIntervalMs: 6e4,
+  maxDurationMs: 30 * 6e4,
+  maxAttempts: 40
+};
+
 // src/server/workflows/types.ts
 var TERMINAL_DONE = "$done";
 var TERMINAL_BLOCKED = "$blocked";
@@ -336,6 +347,64 @@ function getCurrentWindowMessageOptions(sessionId) {
   const contextWindowId = getCurrentContextWindowId(sessionId);
   return contextWindowId ? { contextWindowId } : void 0;
 }
+function sleepWithSignal(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Aborted"));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new Error("Aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function evaluateLLMRetry(failures, firstFailureAt, now, policy) {
+  if (now - firstFailureAt >= policy.maxDurationMs) return { retry: false };
+  if (failures >= policy.maxAttempts) return { retry: false };
+  const delayMs = failures <= policy.backoffMs.length ? policy.backoffMs[failures - 1] : policy.minIntervalMs;
+  return { retry: true, delayMs, attempt: failures + 1 };
+}
+function rollbackFailedAttempt(sessionId, turnStartSeq) {
+  const eventStore = getEventStore();
+  const fromSeq = Math.max(1, turnStartSeq);
+  const events = eventStore.getEvents(sessionId, fromSeq + 1);
+  const assistantIds = new Set(
+    events.filter((e) => e.type === "message.start" && e.data.role === "assistant").map((e) => e.data.messageId)
+  );
+  const tombstoneSeqs = events.filter((e) => {
+    switch (e.type) {
+      case "message.start":
+        return e.data.role === "assistant";
+      case "message.delta":
+      case "message.thinking":
+      case "message.done":
+      case "chat.done":
+        return assistantIds.has(e.data.messageId);
+      case "chat.error":
+      case "pattern.retry":
+      case "tool.preparing":
+      case "tool.call":
+      case "tool.output":
+      case "tool.result":
+        return true;
+      default:
+        return false;
+    }
+  }).map((e) => e.seq);
+  if (tombstoneSeqs.length > 0) {
+    eventStore.tombstoneEvents(sessionId, tombstoneSeqs);
+  }
+  if (assistantIds.size > 0) {
+    eventStore.append(sessionId, { type: "message.removed", data: { messageIds: [...assistantIds] } });
+  }
+}
 function buildReason(metadataEntries) {
   const entries = metadataEntries?.["criteria"] ?? [];
   const remaining = entries.filter((e) => e.status !== "passed");
@@ -353,6 +422,8 @@ async function executeWorkflow(workflow, options, subGroup) {
   let currentStepId = isResume ? resumeFromStep : subGroup ? activeSteps[0]?.id ?? workflow.entryStep : workflow.entryStep;
   let lastStepOutput = options.initialStepOutput ?? {};
   const firstEntryForStep = /* @__PURE__ */ new Set();
+  const stepLLMFailures = /* @__PURE__ */ new Map();
+  const stepLLMDeadlines = /* @__PURE__ */ new Map();
   const messagesBeforeWorkflow = sessionManager.requireSession(sessionId).messages.length;
   const activeStepIds = new Set(activeSteps.map((s) => s.id));
   const activeSubGroups = /* @__PURE__ */ new Set();
@@ -497,9 +568,10 @@ async function executeWorkflow(workflow, options, subGroup) {
         const agentStep = step;
         const STEP_DONE_PROMPT = "\n\nOnce you're done, call step_done()";
         const STEP_DONE_NUDGE = "You haven't called step_done(). If you haven't finished the task, continue and when you're finished call step_done()";
+        const isResumingCurrentStep = isResume && step.id === resumeFromStep && !resumeConsumed;
+        const isLLMFailedRetry = firstEntryForStep.has(step.id) && (stepLLMFailures.get(step.id) ?? 0) > 0;
         let promptContent;
         let nudgeContent;
-        const isResumingCurrentStep = isResume && step.id === resumeFromStep && !resumeConsumed;
         if (!firstEntryForStep.has(step.id) && agentStep.prompt && !isResumingCurrentStep) {
           const resolvedPrompt = resolveTemplate(agentStep.prompt, templateCtx);
           promptContent = resolvedPrompt + STEP_DONE_PROMPT;
@@ -528,7 +600,7 @@ async function executeWorkflow(workflow, options, subGroup) {
               })
             );
           }
-        } else if (firstEntryForStep.has(step.id) && !isResumingCurrentStep) {
+        } else if (firstEntryForStep.has(step.id) && !isResumingCurrentStep && !isLLMFailedRetry) {
           const parts = [];
           if (agentStep.nudgePrompt) {
             const resolvedNudge = resolveTemplate(agentStep.nudgePrompt, templateCtx);
@@ -538,32 +610,105 @@ async function executeWorkflow(workflow, options, subGroup) {
           nudgeContent = parts.join("\n\n");
           emitWorkflowMessage(eventStore, sessionId, nudgeContent, currentWindowMessageOptions, onMessage);
         }
+        const turnStartSeq = eventStore.getLatestSeq(sessionId) ?? 0;
+        let retryBlocked = null;
+        let blockedReason = "";
+        const retryPolicy = { ...DEFAULT_LLM_RETRY_POLICY, ...options.llmRetryPolicy };
+        const handleLLMFailure = async (errorMessage) => {
+          const failures = (stepLLMFailures.get(step.id) ?? 0) + 1;
+          stepLLMFailures.set(step.id, failures);
+          const firstFailureAt = stepLLMDeadlines.get(step.id) ?? Date.now();
+          stepLLMDeadlines.set(step.id, firstFailureAt);
+          const decision = evaluateLLMRetry(failures, firstFailureAt, Date.now(), retryPolicy);
+          if (decision.retry) {
+            rollbackFailedAttempt(sessionId, turnStartSeq);
+            firstEntryForStep.add(step.id);
+            resumeConsumed = true;
+            eventStore.append(sessionId, {
+              type: "workflow.step_retry",
+              data: { stepName: step.name, attempt: decision.attempt, retryInMs: decision.delayMs }
+            });
+            retryBlocked = "retry";
+            await sleepWithSignal(decision.delayMs, signal);
+            return;
+          }
+          rollbackFailedAttempt(sessionId, turnStartSeq);
+          sessionManager.setPhase(sessionId, "blocked");
+          if (executionId) {
+            sessionManager.blockWorkflow(
+              sessionId,
+              executionId,
+              workflow.metadata.id,
+              workflow.metadata.name,
+              workflow.metadata.color
+            );
+          }
+          blockedReason = `Step "${step.name}" failed after ${failures} attempts: ${errorMessage}`;
+          eventStore.append(sessionId, { type: "chat.error", data: { error: blockedReason, recoverable: false } });
+          retryBlocked = "blocked";
+        };
         const turnMetrics = new TurnMetrics();
         const es = getEventStore();
         const append = (event) => es.append(sessionId, event);
         let stepDoneCalled = false;
-        const agentResult = await runAgentTurn(
-          {
-            sessionManager,
-            sessionId,
-            llmClient,
-            ...options.statsIdentity ? { statsIdentity: options.statsIdentity } : {},
-            ...signal ? { signal } : {},
-            ...onMessage ? { onMessage } : {}
-          },
-          turnMetrics,
-          agentStep.agentId ?? resolveDefaultAgentId(),
-          append,
-          {
-            ...!firstEntryForStep.has(step.id) && !agentStep.prompt && !isResumingCurrentStep ? { injectKickoff: () => injectGenericKickoff(sessionId) } : {},
-            onToolExecuted: (toolCall, toolResult) => {
-              if (toolCall.name === "step_done" && toolResult.success) {
-                stepDoneCalled = true;
+        let agentResult;
+        try {
+          agentResult = await runAgentTurn(
+            {
+              sessionManager,
+              sessionId,
+              llmClient,
+              ...options.statsIdentity ? { statsIdentity: options.statsIdentity } : {},
+              ...signal ? { signal } : {},
+              ...onMessage ? { onMessage } : {},
+              suppressRecoverableErrors: true,
+              ...isLLMFailedRetry || isResumingCurrentStep ? { skipAgentReminder: true } : {}
+            },
+            turnMetrics,
+            agentStep.agentId ?? resolveDefaultAgentId(),
+            append,
+            {
+              ...!firstEntryForStep.has(step.id) && !agentStep.prompt && !isResumingCurrentStep ? { injectKickoff: () => injectGenericKickoff(sessionId) } : {},
+              onToolExecuted: (toolCall, toolResult) => {
+                if (toolCall.name === "step_done" && toolResult.success) {
+                  stepDoneCalled = true;
+                }
               }
             }
+          );
+        } catch (error) {
+          if (error instanceof Error && error.message === "Aborted") {
+            throw error;
           }
-        );
+          if (!(error instanceof LLMError)) {
+            throw error;
+          }
+          await handleLLMFailure(error.message);
+          if (retryBlocked === "retry") {
+            iterations -= 1;
+            continue;
+          }
+          return {
+            finalAction: { type: "BLOCKED", reason: blockedReason, blockedCriteria: [] },
+            iterations,
+            totalTime: (performance.now() - startTime) / 1e3
+          };
+        }
+        if (agentResult.failed) {
+          await handleLLMFailure(agentResult.failed.error);
+          if (retryBlocked === "retry") {
+            iterations -= 1;
+            continue;
+          }
+          return {
+            finalAction: { type: "BLOCKED", reason: blockedReason, blockedCriteria: [] },
+            iterations,
+            totalTime: (performance.now() - startTime) / 1e3
+          };
+        }
         firstEntryForStep.add(step.id);
+        stepLLMFailures.delete(step.id);
+        stepLLMDeadlines.delete(step.id);
         resumeConsumed = true;
         const agentReturnValue = agentResult.returnValueResult ?? "completed";
         lastStepOutput = {
@@ -894,9 +1039,9 @@ function launchWorkflowRun(deps, payload) {
     ...payload.stepOutput ? { initialStepOutput: payload.stepOutput } : {},
     ...payload.userChoice ? { userChoice: payload.userChoice } : {},
     ...payload.resumeFrom ? (() => {
-      const exec = sessionManager.getActiveWorkflowExecution(sessionId);
+      const exec = sessionManager.getLatestWorkflowExecution(sessionId);
       if (!exec) return {};
-      if (exec.status === "waiting") {
+      if (exec.status === "waiting" || exec.status === "blocked") {
         const resumed = sessionManager.resumeWorkflow(
           sessionId,
           exec.id,
@@ -954,4 +1099,4 @@ export {
   abortRunnerRun,
   launchWorkflowRun
 };
-//# sourceMappingURL=chunk-3QQAIUZI.js.map
+//# sourceMappingURL=chunk-7SDJXHJH.js.map

package/dist/{chunk-4H427UBV.js → chunk-AGXJ5O63.js}

@@ -1,7 +1,7 @@
 import {
   __commonJS,
   __toESM
-} from "./chunk-5WRI5ZAA.js";
+} from "./chunk-YLJ4XMA6.js";
 
 // node_modules/sisteransi/src/index.js
 var require_src = __commonJS({
@@ -1295,4 +1295,4 @@ export {
   select,
   text
 };
-//# sourceMappingURL=chunk-4H427UBV.js.map
+//# sourceMappingURL=chunk-AGXJ5O63.js.map