@odla-ai/harness 0.11.0 → 0.11.1

package/dist/code-runtime-cli.cjs

@@ -422,40 +422,40 @@ async function readBoundedResponse(body, maximum) {
   return result;
 }
 
-// src/code-runtime.ts
-var CODE_RUNTIME_PROTOCOL_VERSION = 3;
-async function runCodeRuntimeHeartbeatLoop(options) {
-  const heartbeatMs = options.heartbeatMs ?? 15e3;
-  if (!Number.isSafeInteger(heartbeatMs) || heartbeatMs < 1e3 || heartbeatMs > 3e5) {
-    throw new TypeError("heartbeatMs must be an integer from 1000 to 300000");
-  }
-  let retryMs = 1e3;
-  do {
-    if (options.signal?.aborted) return;
+// src/code-runtime-overload.ts
+var OVERLOAD_RETRY_DELAYS_MS = [2e3, 4e3, 8e3, 16e3];
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["control_plane_overloaded", "registry_overloaded", "transport_unavailable"]);
+function overloadedControlFailure(cause) {
+  if (!cause || typeof cause !== "object") return false;
+  const failure = cause;
+  return failure.status === 503 && typeof failure.code === "string" && RETRYABLE_CODES.has(failure.code);
+}
+async function withOverloadRetry(call, wait2, onRetry = () => void 0) {
+  for (let attempt = 0; ; attempt += 1) {
     try {
-      const snapshot = await options.control.heartbeat(options.runtimeVersion, options.capabilities);
-      await options.onSnapshot?.(snapshot);
-      retryMs = 1e3;
-      if (options.once) return;
-      await wait(heartbeatMs, options.signal);
-    } catch (error) {
-      if (options.signal?.aborted) return;
-      if (options.once || !retryableControlFailure(error)) throw error;
-      await options.onRetry?.(error, retryMs);
-      await wait(retryMs, options.signal);
-      retryMs = Math.min(retryMs * 2, 3e4);
+      return await call();
+    } catch (cause) {
+      const delayMs = OVERLOAD_RETRY_DELAYS_MS[attempt];
+      if (delayMs === void 0 || !overloadedControlFailure(cause)) throw cause;
+      await onRetry(cause, delayMs);
+      await wait2(delayMs);
     }
-  } while (!options.signal?.aborted);
+  }
 }
+
+// src/code-runtime-reconciler.ts
+var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 var CodeRuntimeReconciler = class {
-  constructor(control, engine, onDiagnostic) {
+  constructor(control, engine, onDiagnostic, options = {}) {
     this.control = control;
     this.engine = engine;
     this.onDiagnostic = onDiagnostic;
+    this.options = options;
   }
   control;
   engine;
   onDiagnostic;
+  options;
   results = /* @__PURE__ */ new Map();
   async reconcile(snapshot) {
     for (const command of snapshot.commands) {
@@ -474,7 +474,15 @@ var CodeRuntimeReconciler = class {
       await this.control.acknowledge(command.commandId, completed.result);
       if (!completed.notified) {
         try {
-          await this.engine.acknowledged?.(command, completed.result);
+          await withOverloadRetry(
+            async () => {
+              await this.engine.acknowledged?.(command, completed.result);
+            },
+            (ms) => (this.options.wait ?? sleep)(ms),
+            (cause, delayMs) => this.onDiagnostic?.(
+              `command ${command.commandId} acknowledged handling waits ${delayMs}ms for an overloaded control plane \xB7 ${cause instanceof Error ? cause.message : String(cause)}`
+            )
+          );
         } catch (error) {
           this.onDiagnostic?.(
             `command ${command.commandId} acknowledged handling failed \xB7 ${error instanceof Error ? error.message : String(error)}`
@@ -485,6 +493,32 @@ var CodeRuntimeReconciler = class {
     }
   }
 };
+
+// src/code-runtime.ts
+var CODE_RUNTIME_PROTOCOL_VERSION = 3;
+async function runCodeRuntimeHeartbeatLoop(options) {
+  const heartbeatMs = options.heartbeatMs ?? 15e3;
+  if (!Number.isSafeInteger(heartbeatMs) || heartbeatMs < 1e3 || heartbeatMs > 3e5) {
+    throw new TypeError("heartbeatMs must be an integer from 1000 to 300000");
+  }
+  let retryMs = 1e3;
+  do {
+    if (options.signal?.aborted) return;
+    try {
+      const snapshot = await options.control.heartbeat(options.runtimeVersion, options.capabilities);
+      await options.onSnapshot?.(snapshot);
+      retryMs = 1e3;
+      if (options.once) return;
+      await wait(heartbeatMs, options.signal);
+    } catch (error) {
+      if (options.signal?.aborted) return;
+      if (options.once || !retryableControlFailure(error)) throw error;
+      await options.onRetry?.(error, retryMs);
+      await wait(retryMs, options.signal);
+      retryMs = Math.min(retryMs * 2, 3e4);
+    }
+  } while (!options.signal?.aborted);
+}
 function retryableControlFailure(value) {
   if (!value || typeof value !== "object") return false;
   const failure = value;
@@ -2384,23 +2418,7 @@ async function sessionSkillsFor(options, command) {
 }
 
 // src/code-runtime-inference.ts
-var OVERLOAD_RETRY_DELAYS_MS = [2e3, 4e3, 8e3, 16e3];
-var RETRYABLE_CODES = /* @__PURE__ */ new Set(["control_plane_overloaded", "registry_overloaded", "transport_unavailable"]);
-function overloadedControlFailure(cause) {
-  return cause instanceof CodeRuntimeControlError && cause.status === 503 && RETRYABLE_CODES.has(cause.code);
-}
-async function inferWithBackoff(infer, wait2, onRetry) {
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      return await infer();
-    } catch (cause) {
-      const delayMs = OVERLOAD_RETRY_DELAYS_MS[attempt];
-      if (delayMs === void 0 || !overloadedControlFailure(cause)) throw cause;
-      await onRetry(cause, delayMs);
-      await wait2(delayMs);
-    }
-  }
-}
+var inferWithBackoff = (infer, wait2, onRetry) => withOverloadRetry(infer, wait2, (cause, delayMs) => onRetry(cause, delayMs));
 async function handleCodeRuntimeInference(input) {
   const { command, request, state } = input;
   const startedAt = Date.now();