replicas-engine 0.1.325 → 0.1.326

package/dist/src/index.js

@@ -287,7 +287,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-16-v4";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-17-v1";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -2034,6 +2034,75 @@ function parseReplicasConfigString(content, filename) {
   return parseReplicasConfig(parsed, filename);
 }
 
+// ../shared/src/errors.ts
+var TRANSIENT_NETWORK_ERROR_PATTERNS = [
+  /socket connection was closed unexpectedly/,
+  /fetch failed/,
+  /network error/,
+  /network request failed/,
+  /econnreset/,
+  /econnrefused/,
+  /etimedout/,
+  /enotfound/,
+  /eai_again/,
+  /und_err_socket/,
+  /und_err_connect_timeout/,
+  /headers timeout/,
+  /body timeout/,
+  /connection reset/,
+  /connection closed/,
+  /closed unexpectedly/
+];
+var HTTP_CONTEXT_PATTERN = /(api error|request|response|status|http)/;
+var HTTP_STATUS_PATTERN = /(^|[^0-9])([1-5][0-9]{2})(?=$|[^0-9])/g;
+function extractErrorText(error) {
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  const collect = (value) => {
+    if (value === null || value === void 0 || seen.has(value)) return;
+    seen.add(value);
+    if (typeof value === "string") {
+      parts.push(value);
+      return;
+    }
+    if (value instanceof Error) {
+      parts.push(value.name, value.message);
+      collect(value.cause);
+      return;
+    }
+    if (typeof value === "object") {
+      const record = value;
+      for (const key of ["name", "message", "code", "error", "cause"]) {
+        collect(record[key]);
+      }
+      const errors = record.errors;
+      if (Array.isArray(errors)) {
+        for (const err of errors) collect(err);
+      }
+      return;
+    }
+    parts.push(String(value));
+  };
+  collect(error);
+  return parts.filter(Boolean).join("\n");
+}
+function isTransientErrorText(text, options = {}) {
+  const normalized = text.toLowerCase();
+  if (!normalized) return false;
+  if (TRANSIENT_NETWORK_ERROR_PATTERNS.some((pattern) => pattern.test(normalized))) return true;
+  if (options.includeRateLimit && /rate limit/.test(normalized)) return true;
+  if (options.extraPatterns?.some((pattern) => pattern.test(normalized))) return true;
+  const httpStatuses = new Set(options.httpStatuses ?? []);
+  const httpStatusClasses = new Set(options.httpStatusClasses ?? []);
+  if (httpStatuses.size === 0 && httpStatusClasses.size === 0) return false;
+  if (options.requireHttpContext !== false && !HTTP_CONTEXT_PATTERN.test(normalized)) return false;
+  for (const match of normalized.matchAll(HTTP_STATUS_PATTERN)) {
+    const status = Number(match[2]);
+    if (httpStatuses.has(status) || httpStatusClasses.has(Math.floor(status / 100))) return true;
+  }
+  return false;
+}
+
 // ../shared/src/claude-auth.ts
 function isClaudeAuthErrorText(text) {
   const lower = text.toLowerCase();
@@ -6220,6 +6289,16 @@ var ClaudeAuthError = class extends Error {
     this.name = "ClaudeAuthError";
   }
 };
+var ClaudeTransientTurnError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ClaudeTransientTurnError";
+  }
+};
+var MAX_AUTH_RETRIES = 2;
+var MAX_TRANSIENT_RETRIES = 2;
+var TRANSIENT_RETRY_DELAYS_MS = [1e3, 2500];
+var CLAUDE_TRANSIENT_HTTP_STATUSES = [408, 500, 502, 503, 504, 529];
 var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   historyFile;
   sessionId = null;
@@ -6384,35 +6463,52 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     };
   }
   async processMessageInternal(request) {
-    const MAX_AUTH_RETRIES = 2;
     let lastError;
     let authRetryExhausted = false;
+    let attempt = 0;
+    let authRetries = 0;
+    let transientRetries = 0;
     try {
-      for (let attempt = 0; attempt <= MAX_AUTH_RETRIES; attempt++) {
+      while (true) {
         try {
           await this.executeQuery(request, { skipUserMessageRecord: attempt > 0 });
           return;
         } catch (error) {
           lastError = error;
-          if (!_ClaudeManager.isAuthError(error)) {
-            throw error;
-          }
-          if (attempt === MAX_AUTH_RETRIES) {
-            authRetryExhausted = true;
-            throw error;
+          if (_ClaudeManager.isAuthError(error)) {
+            if (authRetries >= MAX_AUTH_RETRIES) {
+              authRetryExhausted = true;
+              throw error;
+            }
+            authRetries++;
+            console.error(
+              `[ClaudeManager] Auth failure detected (attempt ${authRetries}/${MAX_AUTH_RETRIES}), refreshing credentials and retrying...`,
+              error
+            );
+            this.setAuthRetrying(true);
+            const refreshed = await claudeTokenManager.fetchFreshCredentials(
+              error instanceof Error ? error.message : String(error)
+            );
+            if (!refreshed) {
+              authRetryExhausted = true;
+              throw error;
+            }
+            attempt++;
+            continue;
           }
-          console.error(
-            `[ClaudeManager] Auth failure detected (attempt ${attempt + 1}/${MAX_AUTH_RETRIES + 1}), refreshing credentials and retrying...`,
-            error
-          );
-          this.setAuthRetrying(true);
-          const refreshed = await claudeTokenManager.fetchFreshCredentials(
-            error instanceof Error ? error.message : String(error)
-          );
-          if (!refreshed) {
-            authRetryExhausted = true;
-            throw error;
+          if (_ClaudeManager.isTransientTurnError(error) && transientRetries < MAX_TRANSIENT_RETRIES) {
+            transientRetries++;
+            const delayMs = TRANSIENT_RETRY_DELAYS_MS[transientRetries - 1] ?? TRANSIENT_RETRY_DELAYS_MS[TRANSIENT_RETRY_DELAYS_MS.length - 1];
+            console.warn(
+              `[ClaudeManager] Transient turn failure detected (attempt ${transientRetries}/${MAX_TRANSIENT_RETRIES}), retrying in ${delayMs}ms...`,
+              error
+            );
+            await this.tearDownSession();
+            await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+            attempt++;
+            continue;
           }
+          throw error;
         }
       }
     } finally {
@@ -6526,7 +6622,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       return;
     }
     await new Promise((resolve4, reject) => {
-      this.pendingTurn = { resolve: resolve4, reject };
+      this.pendingTurn = { resolve: resolve4, reject, sawActivity: false };
       promptStream.push(userMessage);
     });
   }
@@ -6659,11 +6755,13 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   async runSessionLoop(response) {
     const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     const iterator = response[Symbol.asyncIterator]();
+    let loopError = null;
     try {
       while (true) {
         const next = await iterator.next();
         if (next.done) break;
         const msg = next.value;
+        if (!msg) break;
         const authErrorMessage = _ClaudeManager.detectAuthErrorInMessage(msg);
         if (authErrorMessage) {
           this.failPendingTurn(new ClaudeAuthError(authErrorMessage));
@@ -6674,7 +6772,23 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
           }
           return;
         }
+        const transientErrorMessage = _ClaudeManager.detectTransientTurnErrorInMessage(
+          msg,
+          this.pendingTurn?.sawActivity ?? false
+        );
+        if (transientErrorMessage) {
+          this.failPendingTurn(new ClaudeTransientTurnError(transientErrorMessage));
+          try {
+            response.close();
+          } catch (err) {
+            console.warn("[ClaudeManager] query.close() during transient failure failed:", err);
+          }
+          return;
+        }
         this.setAuthRetrying(false);
+        if (this.pendingTurn && _ClaudeManager.isTurnActivity(msg)) {
+          this.pendingTurn.sawActivity = true;
+        }
         await this.handleMessage(msg);
         _ClaudeManager.updateBackgroundTaskState(msg, this.activeBackgroundTasks);
         if (linearSessionId && this.sessionLinearForwarder) {
@@ -6687,9 +6801,16 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
           this.resolvePendingTurn();
         }
       }
+    } catch (error) {
+      loopError = error;
+      if (!_ClaudeManager.isTransientTurnError(error)) {
+        console.error("[ClaudeManager] Session loop crashed:", error);
+      }
     } finally {
       this.sessionLinearForwarder?.flushThoughtAsResponse();
-      this.failPendingTurn(new Error("Claude session ended unexpectedly"));
+      const pending = this.pendingTurn;
+      const pendingError = loopError ? pending?.sawActivity && _ClaudeManager.isTransientTurnError(loopError) ? new Error("Claude session ended unexpectedly") : loopError : pending && !pending.sawActivity ? new ClaudeTransientTurnError("Claude session ended unexpectedly before producing a response") : new Error("Claude session ended unexpectedly");
+      this.failPendingTurn(pendingError);
       if (this.activeQuery === response) {
         this.clearSessionState();
       }
@@ -6803,6 +6924,27 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     if (error instanceof ClaudeAuthError) return true;
     return isClaudeAuthErrorText(error instanceof Error ? error.message : String(error));
   }
+  static isTransientTurnError(error) {
+    if (error instanceof ClaudeTransientTurnError) return true;
+    return _ClaudeManager.isTransientTurnErrorText(extractErrorText(error));
+  }
+  static isTransientTurnErrorText(text) {
+    return isTransientErrorText(text, { httpStatuses: CLAUDE_TRANSIENT_HTTP_STATUSES });
+  }
+  static detectTransientTurnErrorInMessage(message, sawActivity) {
+    if (sawActivity) return null;
+    if (message.type === "assistant" && "error" in message && typeof message.error === "string") {
+      return _ClaudeManager.isTransientTurnErrorText(message.error) ? message.error : null;
+    }
+    if (message.type === "result" && message.is_error) {
+      const text = message.subtype === "success" ? message.result : message.errors.join("\n");
+      return _ClaudeManager.isTransientTurnErrorText(text) ? text : null;
+    }
+    return null;
+  }
+  static isTurnActivity(message) {
+    return message.type === "assistant" || message.type === "stream_event";
+  }
   // Done at the message-stream layer (rather than letting the failure flow
   // downstream as a normal result) so we can suppress emission before the
   // dashboard renders the raw 401 to the user.
@@ -7149,7 +7291,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.325";
+var ENGINE_PACKAGE_VERSION = "0.1.326";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.325",
+  "version": "0.1.326",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",