@gakim-digital/dexter-bridge 0.5.7 → 0.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gakim-digital/dexter-bridge",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "Local Companion bridge for the Dexter Framer plugin — runs Codex or Claude Code on your machine.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -108,45 +108,81 @@ function nowIso() {
   return new Date().toISOString();
 }
 
+const TERMINAL_EVENT_TYPES = new Set(['done', 'error']);
+const TERMINAL_EVENT_MAX_ATTEMPTS = 5;
+
+function waitForRetry(delayMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
+function terminalEventRetryDelay(error, attempt) {
+  const status = Number(error?.status);
+  const retryable =
+    !Number.isFinite(status)
+    || status === 408
+    || status === 429
+    || status >= 500;
+  if (!retryable) return null;
+  if (Number.isFinite(error?.retryAfterMs) && error.retryAfterMs > 0) {
+    return Math.min(65_000, Math.max(250, error.retryAfterMs));
+  }
+  return Math.min(8_000, 500 * (2 ** (attempt - 1)));
+}
+
 function createEventPoster({ apiBaseUrl, deviceToken, run, fetchImpl, trace }) {
   return async function send(type, payload = {}) {
     const eventId = `${type}_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     const started = Date.now();
-    trace?.info('event_post_start', {
-      type,
-      eventId,
-      payload: summarizePayload(payload),
-    });
-    try {
-      const response = await postRunEvent(apiBaseUrl, {
-        deviceToken,
-        runId: run.runId,
-        fetchImpl,
-        event: {
-          type,
-          eventId,
-          payload,
-        },
-      });
-      trace?.info('event_post_done', {
-        type,
-        eventId,
-        durationMs: Date.now() - started,
-        accepted: response?.accepted,
-        status: response?.status,
-        hasToolResult: Boolean(response?.toolResult),
-        toolResult: summarizeToolResult(response?.toolResult),
-      });
-      return response;
-    } catch (error) {
-      trace?.error('event_post_failed', {
+    const maxAttempts = TERMINAL_EVENT_TYPES.has(type)
+      ? TERMINAL_EVENT_MAX_ATTEMPTS
+      : 1;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      trace?.info('event_post_start', {
         type,
         eventId,
-        durationMs: Date.now() - started,
-        error: errorMeta(error),
+        attempt,
+        payload: summarizePayload(payload),
       });
-      throw error;
+      try {
+        const response = await postRunEvent(apiBaseUrl, {
+          deviceToken,
+          runId: run.runId,
+          fetchImpl,
+          event: {
+            type,
+            eventId,
+            payload,
+          },
+        });
+        trace?.info('event_post_done', {
+          type,
+          eventId,
+          attempt,
+          durationMs: Date.now() - started,
+          accepted: response?.accepted,
+          status: response?.status,
+          hasToolResult: Boolean(response?.toolResult),
+          toolResult: summarizeToolResult(response?.toolResult),
+        });
+        return response;
+      } catch (error) {
+        const retryDelayMs =
+          attempt < maxAttempts
+            ? terminalEventRetryDelay(error, attempt)
+            : null;
+        trace?.error('event_post_failed', {
+          type,
+          eventId,
+          attempt,
+          durationMs: Date.now() - started,
+          retryDelayMs,
+          error: errorMeta(error),
+        });
+        if (retryDelayMs === null) throw error;
+        await waitForRetry(retryDelayMs);
+      }
     }
+    throw new Error(`Unable to deliver ${type} event.`);
   };
 }
 
@@ -887,7 +923,7 @@ class CompanionRunCancelledError extends Error {
 async function callProviderAdapter(adapter, input, {
   send,
   trace,
-  controlPollMs = 250,
+  controlPollMs = 5_000,
 } = {}) {
   if (!adapter || typeof adapter.runModelTurn !== 'function') {
     throw new Error('The selected provider adapter cannot execute model turns.');
@@ -1209,9 +1245,9 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
       trace: options.trace,
       controlPollMs: boundedDurationMs(
         options.controlPollMs ?? options.env?.DEXTER_BRIDGE_CONTROL_POLL_MS,
-        250,
-        50,
-        1000,
+        5_000,
+        1_000,
+        30_000,
       ),
     };
     let result;
@@ -1253,9 +1289,9 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
     const monitorAbort = new AbortController();
     const controlPollMs = boundedDurationMs(
       options.controlPollMs ?? options.env?.DEXTER_BRIDGE_CONTROL_POLL_MS,
-      250,
-      50,
-      1000,
+      5_000,
+      1_000,
+      30_000,
     );
     let cliFinished = false;
     let cliCancelled = false;

package/src/api.js

@@ -7,11 +7,12 @@ import {
 } from './config.js';
 
 export class DexterBridgeApiError extends Error {
-  constructor(message, status, body) {
+  constructor(message, status, body, retryAfterMs) {
     super(message);
     this.name = 'DexterBridgeApiError';
     this.status = status;
     this.body = body;
+    this.retryAfterMs = retryAfterMs;
   }
 }
 
@@ -50,10 +51,18 @@ export async function requestJson(apiBaseUrl, path, {
   });
   const parsed = await response.json().catch(() => null);
   if (!response.ok || parsed?.success === false) {
+    const retryAfterHeader = Number(response.headers?.get?.('retry-after'));
+    const retryAfterSeconds = Number(parsed?.retryAfterSeconds);
+    const retryAfterMs = Number.isFinite(retryAfterHeader) && retryAfterHeader > 0
+      ? retryAfterHeader * 1000
+      : Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0
+        ? retryAfterSeconds * 1000
+        : undefined;
     throw new DexterBridgeApiError(
       parsed?.error || parsed?.message || `Dexter API request failed with status ${response.status}`,
       response.status,
       parsed,
+      retryAfterMs,
     );
   }
   return parsed;