openfox 2.0.117 → 2.0.119

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

@@ -1,14 +1,14 @@
 import {
   runAgentTurn
-} from "./chunk-I6MY65LO.js";
+} from "./chunk-6DDB67FN.js";
 import {
   executeSubAgent,
   getToolRegistryForAgent
-} from "./chunk-2PQA3DHY.js";
+} from "./chunk-V5XWUVF5.js";
 import {
   TurnMetrics,
   createMessageStartEvent
-} from "./chunk-EQ7DK2TG.js";
+} from "./chunk-SE62ZBNX.js";
 import {
   checkAborted,
   decodeUtf8,
@@ -27,15 +27,15 @@ import {
   loadProjectWorkflows,
   loadUserWorkflows,
   normalizeWorkflowScope
-} from "./chunk-HZSKKJHQ.js";
+} from "./chunk-5FAPM2GM.js";
 import {
   getCurrentContextWindowId,
   getEventStore
-} from "./chunk-TGVDUK4N.js";
+} from "./chunk-JOCR4CF4.js";
 import {
   createChatMessageMessage,
   createSessionRunningMessage
-} from "./chunk-4GHLULHB.js";
+} from "./chunk-XAAEP5XM.js";
 import {
   findAgentById,
   getRuntimeConfig,
@@ -53,19 +53,11 @@ import {
 } from "./chunk-VUQCQXXJ.js";
 import {
   createServerMessage
-} from "./chunk-ZKLE2Q3I.js";
+} from "./chunk-KSDWQ6IZ.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";
@@ -75,13 +67,13 @@ import { spawn } from "child_process";
 function getGitDiffFiles(cwd) {
   return new Promise((resolve) => {
     const env = gitSpawnEnv();
-    const diffProc = spawn("git", ["diff", "--name-status", "HEAD"], {
+    const diffProc = spawn("git", ["diff", "--ignore-submodules=none", "--name-status", "HEAD"], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
-    const statusProc = spawn("git", ["status", "--porcelain"], {
+    const statusProc = spawn("git", ["status", "--porcelain", "--ignore-submodules=none"], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -347,64 +339,6 @@ 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");
@@ -422,8 +356,6 @@ 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();
@@ -569,7 +501,6 @@ async function executeWorkflow(workflow, options, subGroup) {
         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;
         if (!firstEntryForStep.has(step.id) && agentStep.prompt && !isResumingCurrentStep) {
@@ -600,7 +531,7 @@ async function executeWorkflow(workflow, options, subGroup) {
               })
             );
           }
-        } else if (firstEntryForStep.has(step.id) && !isResumingCurrentStep && !isLLMFailedRetry) {
+        } else if (firstEntryForStep.has(step.id) && !isResumingCurrentStep) {
           const parts = [];
           if (agentStep.nudgePrompt) {
             const resolvedNudge = resolveTemplate(agentStep.nudgePrompt, templateCtx);
@@ -610,29 +541,7 @@ 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);
+        const blockOnLLMFailure = (errorMessage) => {
           sessionManager.setPhase(sessionId, "blocked");
           if (executionId) {
             sessionManager.blockWorkflow(
@@ -643,9 +552,12 @@ async function executeWorkflow(workflow, options, subGroup) {
               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 reason = `Step "${step.name}" failed: ${errorMessage}`;
+          return {
+            finalAction: { type: "BLOCKED", reason, blockedCriteria: [] },
+            iterations,
+            totalTime: (performance.now() - startTime) / 1e3
+          };
         };
         const turnMetrics = new TurnMetrics();
         const es = getEventStore();
@@ -658,11 +570,12 @@ async function executeWorkflow(workflow, options, subGroup) {
               sessionManager,
               sessionId,
               llmClient,
+              ...options.getSessionLLMClient ? { getSessionLLMClient: options.getSessionLLMClient } : {},
               ...options.statsIdentity ? { statsIdentity: options.statsIdentity } : {},
               ...signal ? { signal } : {},
               ...onMessage ? { onMessage } : {},
-              suppressRecoverableErrors: true,
-              ...isLLMFailedRetry || isResumingCurrentStep ? { skipAgentReminder: true } : {}
+              ...options.llmRetryPolicy ? { llmRetryPolicy: options.llmRetryPolicy } : {},
+              ...isResumingCurrentStep ? { skipAgentReminder: true } : {}
             },
             turnMetrics,
             agentStep.agentId ?? resolveDefaultAgentId(),
@@ -683,32 +596,12 @@ async function executeWorkflow(workflow, options, subGroup) {
           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
-          };
+          return blockOnLLMFailure(error.message);
         }
         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
-          };
+          return blockOnLLMFailure(agentResult.failed.error);
         }
         firstEntryForStep.add(step.id);
-        stepLLMFailures.delete(step.id);
-        stepLLMDeadlines.delete(step.id);
         resumeConsumed = true;
         const agentReturnValue = agentResult.returnValueResult ?? "completed";
         lastStepOutput = {
@@ -1018,7 +911,16 @@ function abortRunnerRun(sessionId) {
   return true;
 }
 function launchWorkflowRun(deps, payload) {
-  const { sessionManager, sessionId, controller, llmClient, statsIdentity, broadcastForSession, onFinished } = deps;
+  const {
+    sessionManager,
+    sessionId,
+    controller,
+    llmClient,
+    getSessionLLMClient,
+    statsIdentity,
+    broadcastForSession,
+    onFinished
+  } = deps;
   const signal = controller.signal;
   activeRuns.set(sessionId, controller);
   sessionManager.setRunning(sessionId, true);
@@ -1030,6 +932,7 @@ function launchWorkflowRun(deps, payload) {
     sessionManager,
     sessionId,
     llmClient,
+    ...getSessionLLMClient ? { getSessionLLMClient } : {},
     statsIdentity,
     scope: normalizeWorkflowScope(payload.scope),
     ...payload.workflowId ? { workflowId: payload.workflowId } : {},
@@ -1099,4 +1002,4 @@ export {
   abortRunnerRun,
   launchWorkflowRun
 };
-//# sourceMappingURL=chunk-7SDJXHJH.js.map
+//# sourceMappingURL=chunk-AVQCOSOF.js.map

package/dist/chunk-EW25UQG3.js

@@ -0,0 +1,7 @@
+// src/constants.ts
+var VERSION = "2.0.119";
+
+export {
+  VERSION
+};
+//# sourceMappingURL=chunk-EW25UQG3.js.map

package/dist/{chunk-MKWS7TQH.js → chunk-J6KFWVZ3.js}

@@ -13,7 +13,7 @@ import {
   getThinking,
   mapFinishReason,
   parseToolArguments
-} from "./chunk-TOKQ2UVG.js";
+} from "./chunk-MIPQOHWS.js";
 import {
   LLMError,
   OpenAIHttpClient
@@ -169,15 +169,6 @@ function createLLMClient(config, initialBackend = "unknown") {
           ...buildExtraParams(resolvedEffort)
         });
         const { params: streamingParams } = createParams;
-        const stream = httpClient.createChatCompletionStream(streamingParams, {
-          signal: request.signal
-        });
-        let fullContent = "";
-        let fullThinking = "";
-        const toolCalls = /* @__PURE__ */ new Map();
-        let finishReason = "stop";
-        let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
-        let responseId = "";
         let lastChunkTime = Date.now();
         const idleTimeoutController = new AbortController();
         const idleTimer = setInterval(() => {
@@ -187,6 +178,16 @@ function createLLMClient(config, initialBackend = "unknown") {
             idleTimeoutController.abort();
           }
         }, 100);
+        const streamSignal = request.signal ? AbortSignal.any([request.signal, idleTimeoutController.signal]) : idleTimeoutController.signal;
+        const stream = httpClient.createChatCompletionStream(streamingParams, {
+          signal: streamSignal
+        });
+        let fullContent = "";
+        let fullThinking = "";
+        const toolCalls = /* @__PURE__ */ new Map();
+        let finishReason = "stop";
+        let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        let responseId = "";
         const onAbort = () => clearInterval(idleTimer);
         request.signal?.addEventListener("abort", onAbort, { once: true });
         try {
@@ -203,9 +204,9 @@ function createLLMClient(config, initialBackend = "unknown") {
             responseId = chunk.id;
             if (chunk.usage) {
               usage = {
-                promptTokens: chunk.usage.prompt_tokens,
-                completionTokens: chunk.usage.completion_tokens,
-                totalTokens: chunk.usage.total_tokens
+                promptTokens: chunk.usage.prompt_tokens ?? usage.promptTokens,
+                completionTokens: chunk.usage.completion_tokens ?? usage.completionTokens,
+                totalTokens: chunk.usage.total_tokens ?? usage.totalTokens
               };
             }
             const choice = chunk.choices[0];
@@ -259,6 +260,11 @@ function createLLMClient(config, initialBackend = "unknown") {
               }
             }
           }
+        } catch (error) {
+          if (idleTimeoutController.signal.aborted && !request.signal?.aborted) {
+            throw new Error(`LLM stream idle timeout: no chunks received for ${idleTimeout}ms`);
+          }
+          throw error;
         } finally {
           clearInterval(idleTimer);
           request.signal?.removeEventListener("abort", onAbort);
@@ -297,7 +303,7 @@ function createLLMClient(config, initialBackend = "unknown") {
           }
         };
       } catch (error) {
-        logger.error("LLM stream error", { error });
+        logger.error("LLM stream error", { error: String(error) });
         yield {
           type: "error",
           error: error instanceof Error ? error.message : "Unknown LLM error"
@@ -310,4 +316,4 @@ function createLLMClient(config, initialBackend = "unknown") {
 export {
   createLLMClient
 };
-//# sourceMappingURL=chunk-MKWS7TQH.js.map
+//# sourceMappingURL=chunk-J6KFWVZ3.js.map

package/dist/{chunk-TGVDUK4N.js → chunk-JOCR4CF4.js}

@@ -1465,4 +1465,4 @@ export {
   truncateSessionMessages,
   getRecentUserPromptsForSession
 };
-//# sourceMappingURL=chunk-TGVDUK4N.js.map
+//# sourceMappingURL=chunk-JOCR4CF4.js.map

package/dist/chunk-K2QKX4ZJ.js

@@ -0,0 +1,31 @@
+// src/server/providers/lmstudio.ts
+function unwrap(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (raw && typeof raw === "object") {
+    const record = raw;
+    if (Array.isArray(record.models)) return record.models;
+    if (Array.isArray(record.data)) return record.data;
+  }
+  return [];
+}
+function parseLmStudioModels(raw) {
+  return unwrap(raw).map((model) => {
+    const id = model.key ?? model.id ?? "";
+    const loaded = model.loaded_instances?.[0]?.config?.context_length;
+    const contextWindow = loaded ?? model.max_context_length;
+    return {
+      id,
+      ...contextWindow ? { contextWindow } : {},
+      supportsVision: model.capabilities?.vision ?? false
+    };
+  }).filter((model) => model.id !== "");
+}
+function findLmStudioModel(raw, modelId) {
+  return parseLmStudioModels(raw).find((model) => model.id === modelId);
+}
+
+export {
+  parseLmStudioModels,
+  findLmStudioModel
+};
+//# sourceMappingURL=chunk-K2QKX4ZJ.js.map

package/dist/{chunk-ZKLE2Q3I.js → chunk-KSDWQ6IZ.js}

@@ -26,4 +26,4 @@ export {
   isClientMessage,
   isServerMessage
 };
-//# sourceMappingURL=chunk-ZKLE2Q3I.js.map
+//# sourceMappingURL=chunk-KSDWQ6IZ.js.map

package/dist/{chunk-TOKQ2UVG.js → chunk-MIPQOHWS.js}

@@ -463,11 +463,12 @@ function parseToolArguments(raw, _meta) {
   }
 }
 function buildModelParams(params) {
+  const isOmitted = (key) => params.omitParams?.includes(key) ?? false;
   return {
-    ...params.temperature !== void 0 && { temperature: params.temperature },
-    ...params.topP !== void 0 && { topP: params.topP },
-    ...params.topK !== void 0 && { topK: params.topK },
-    ...params.maxTokens !== void 0 && { maxTokens: params.maxTokens }
+    ...!isOmitted("temperature") && params.temperature !== void 0 && { temperature: params.temperature },
+    ...!isOmitted("top_p") && params.topP !== void 0 && { topP: params.topP },
+    ...!isOmitted("top_k") && params.topK !== void 0 && { topK: params.topK },
+    ...!isOmitted("max_tokens") && params.maxTokens !== void 0 && { maxTokens: params.maxTokens }
   };
 }
 async function buildAttachmentContent(msgContent, attachments, modelSupportsVision) {
@@ -644,7 +645,20 @@ async function buildChatCompletionCreateParams(model, request, profile, capabili
       };
     }
   }
-  const modelParams = buildModelParams({ temperature, topP, topK, maxTokens });
+  const omitParams = request.modelSettings?.omitParams;
+  if (omitParams && omitParams.length > 0) {
+    const paramRecord = params;
+    for (const key of omitParams) {
+      delete paramRecord[key];
+    }
+  }
+  const modelParams = buildModelParams({
+    temperature,
+    topP,
+    topK,
+    maxTokens,
+    ...omitParams !== void 0 && { omitParams }
+  });
   return { params, modelParams };
 }
 async function buildCreateParamsFromInput(input, isStreaming) {
@@ -697,4 +711,4 @@ export {
   buildStreamingCreateParams,
   mapFinishReason
 };
-//# sourceMappingURL=chunk-TOKQ2UVG.js.map
+//# sourceMappingURL=chunk-MIPQOHWS.js.map

package/dist/{chunk-EQ7DK2TG.js → chunk-SE62ZBNX.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-AZHWLLPP.js";
 import {
   buildModelParams
-} from "./chunk-TOKQ2UVG.js";
+} from "./chunk-MIPQOHWS.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -111,7 +111,13 @@ async function* streamLLMPure(options) {
   const maxTokens = userMaxTokens ?? profile.defaultMaxTokens;
   const topP = userTopP ?? profile.topP;
   const topK = userTopK ?? (backend.supportsTopK ? profile.topK : void 0);
-  const modelParams = buildModelParams({ temperature, topP, topK, maxTokens });
+  const modelParams = buildModelParams({
+    temperature,
+    topP,
+    topK,
+    maxTokens,
+    ...options.modelSettings?.omitParams !== void 0 && { omitParams: options.modelSettings.omitParams }
+  });
   logger.debug("LLM request settings", {
     model: llmClient.getModel(),
     profile: profile.name,
@@ -244,11 +250,6 @@ async function* streamLLMPure(options) {
         case "error":
           if (signal?.aborted) break;
           streamError = value.error;
-          if (options.suppressChatError) break;
-          yield {
-            type: "chat.error",
-            data: { error: value.error, recoverable: true }
-          };
           break;
       }
       if (activePatterns.length > 0 && (accumulatedContent || accumulatedThinking)) {
@@ -291,6 +292,73 @@ async function* streamLLMPure(options) {
   }
   return baseResult;
 }
+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 };
+}
+var retryWaiters = /* @__PURE__ */ new Map();
+var llmFailures = /* @__PURE__ */ new Map();
+function hasRecentLLMFailure(sessionId, withinMs) {
+  const at = llmFailures.get(sessionId);
+  if (at === void 0) return false;
+  if (Date.now() - at <= withinMs) return true;
+  llmFailures.delete(sessionId);
+  return false;
+}
+function interruptLLMRetryWait(sessionId) {
+  const controller = retryWaiters.get(sessionId);
+  if (!controller) return false;
+  controller.abort();
+  return true;
+}
+function sleepWithRetryInterrupt(ms, signal, retryNowSignal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve("aborted");
+      return;
+    }
+    if (retryNowSignal?.aborted) {
+      resolve("retry-now");
+      return;
+    }
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      retryNowSignal?.removeEventListener("abort", onRetryNow);
+    };
+    const onAbort = () => {
+      cleanup();
+      resolve("aborted");
+    };
+    const onRetryNow = () => {
+      cleanup();
+      resolve("retry-now");
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve("waited");
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    retryNowSignal?.addEventListener("abort", onRetryNow, { once: true });
+  });
+}
+async function sleepThroughRetryBackoff(ms, sessionId, signal) {
+  const retryNowController = new AbortController();
+  retryWaiters.set(sessionId, retryNowController);
+  try {
+    return await sleepWithRetryInterrupt(ms, signal, retryNowController.signal);
+  } finally {
+    retryWaiters.delete(sessionId);
+  }
+}
+function recordLLMFailure(sessionId) {
+  llmFailures.set(sessionId, Date.now());
+}
+function clearLLMFailure(sessionId) {
+  llmFailures.delete(sessionId);
+}
 var TurnMetrics = class {
   startTime;
   totalPrefillTokens = 0;
@@ -434,6 +502,12 @@ async function consumeStreamGenerator(gen, onEvent) {
 
 export {
   streamLLMPure,
+  evaluateLLMRetry,
+  hasRecentLLMFailure,
+  interruptLLMRetryWait,
+  sleepThroughRetryBackoff,
+  recordLLMFailure,
+  clearLLMFailure,
   TurnMetrics,
   createMessageStartEvent,
   createMessageDoneEvent,
@@ -442,4 +516,4 @@ export {
   createChatDoneEvent,
   consumeStreamGenerator
 };
-//# sourceMappingURL=chunk-EQ7DK2TG.js.map
+//# sourceMappingURL=chunk-SE62ZBNX.js.map