@joshuaswarren/openclaw-engram 9.1.12 → 9.1.13

package/dist/access-cli.js

@@ -3,7 +3,7 @@ import {
   EngramAccessService,
   Orchestrator,
   parseConfig
-} from "./chunk-BEELVTEN.js";
+} from "./chunk-7L2Q2HQB.js";
 import "./chunk-4PXEFPHR.js";
 import "./chunk-IMMYYNXG.js";
 import "./chunk-4XBRUH6C.js";

package/dist/{chunk-BEELVTEN.js → chunk-7L2Q2HQB.js}

@@ -3412,6 +3412,7 @@ var LOCAL_SERVERS = [
     detectFn: (resp) => resp === "" || typeof resp === "object" && resp !== null
   }
 ];
+var LOCAL_LLM_GLOBAL_BACKEND_STATE = "__openclawEngramLocalLlmBackendState";
 var LocalLlmClient = class _LocalLlmClient {
   config;
   isAvailable = null;
@@ -3476,6 +3477,61 @@ var LocalLlmClient = class _LocalLlmClient {
   getDetectedType() {
     return this.detectedType;
   }
+  getBackendKey() {
+    return this.config.localLlmUrl.replace("localhost", "127.0.0.1").replace(/\/+$/, "").replace(/\/v1$/, "");
+  }
+  getGlobalBackendState() {
+    const globalAny = globalThis;
+    if (!globalAny[LOCAL_LLM_GLOBAL_BACKEND_STATE]) {
+      globalAny[LOCAL_LLM_GLOBAL_BACKEND_STATE] = /* @__PURE__ */ new Map();
+    }
+    return globalAny[LOCAL_LLM_GLOBAL_BACKEND_STATE];
+  }
+  getTrippedBackendState(now) {
+    const state = this.getGlobalBackendState().get(this.getBackendKey()) ?? null;
+    if (!state) return null;
+    if (state.untilMs <= now) {
+      this.getGlobalBackendState().delete(this.getBackendKey());
+      this.lastHealthCheck = 0;
+      return null;
+    }
+    return state;
+  }
+  markBackendUnavailable(reason, durationMs) {
+    const normalizedReason = this.normalizeBackendTripReason(reason);
+    if (durationMs > 0) {
+      const untilMs = Date.now() + durationMs;
+      this.getGlobalBackendState().set(this.getBackendKey(), { untilMs, reason: normalizedReason });
+    } else {
+      this.getGlobalBackendState().delete(this.getBackendKey());
+    }
+    this.isAvailable = false;
+    this.lastHealthCheck = 0;
+    log.warn(
+      `local LLM backend unavailable for ${durationMs}ms: model=${this.config.localLlmModel} reason=${normalizedReason}`
+    );
+  }
+  extractNonRecoverableBackendReason(reason) {
+    const match = reason.match(
+      /Failed to load model|Library not loaded|different Team IDs|code signature|llm_engine_mlx_amphibian/i
+    );
+    return match?.[0] ?? null;
+  }
+  extractNonRecoverableBackendReasonFromErrorText(errorText) {
+    const directReason = this.extractNonRecoverableBackendReason(errorText);
+    if (directReason) return directReason;
+    try {
+      const parsed = JSON.parse(errorText);
+      return this.extractNonRecoverableBackendReason(parsed?.error?.message ?? "");
+    } catch {
+      return null;
+    }
+  }
+  normalizeBackendTripReason(reason) {
+    const cleaned = reason.replace(/\s+/g, " ").replace(/^[-:–—\s]+/, "").trim();
+    if (!cleaned) return "unknown local backend failure";
+    return cleaned.length > 160 ? `${cleaned.slice(0, 157)}...` : cleaned;
+  }
   /**
    * Fetch with timeout for health checks
    */
@@ -3508,6 +3564,15 @@ var LocalLlmClient = class _LocalLlmClient {
    */
   async checkAvailability() {
     const now = Date.now();
+    const trippedState = this.getTrippedBackendState(now);
+    if (trippedState) {
+      this.isAvailable = false;
+      this.lastHealthCheck = 0;
+      log.info(
+        `local LLM availability: backend circuit open for ${Math.max(0, trippedState.untilMs - now)}ms (${trippedState.reason})`
+      );
+      return false;
+    }
     if (this.isAvailable !== null && now - this.lastHealthCheck < _LocalLlmClient.HEALTH_CHECK_INTERVAL_MS) {
       return this.isAvailable;
     }
@@ -3908,6 +3973,22 @@ var LocalLlmClient = class _LocalLlmClient {
           clearTimeout(attemptTimeout);
         }
         if (response.ok) break;
+        if (response.status >= 500 && attempt < maxAttempts) {
+          try {
+            const errorText = await response.clone().text();
+            const nonRecoverableReason = this.extractNonRecoverableBackendReasonFromErrorText(errorText);
+            if (nonRecoverableReason) {
+              this.markBackendUnavailable(
+                nonRecoverableReason,
+                this.config.localLlm400CooldownMs
+              );
+              this.consecutive400s = 0;
+              return null;
+            }
+          } catch (e) {
+            log.debug(`local LLM failed to inspect retryable error body: ${e}`);
+          }
+        }
         if (response.status < 500 || attempt >= maxAttempts) break;
         const backoffMs = this.config.localLlmRetryBackoffMs * attempt;
         log.warn(
@@ -3932,8 +4013,9 @@ var LocalLlmClient = class _LocalLlmClient {
       }
       if (!response.ok) {
         let reason = "";
+        let errorText = "";
         try {
-          const errorText = await response.text();
+          errorText = await response.text();
           try {
             const parsed = JSON.parse(errorText);
             reason = parsed?.error?.message ? ` \u2014 ${parsed.error.message}` : "";
@@ -3946,6 +4028,15 @@ var LocalLlmClient = class _LocalLlmClient {
         log.warn(
           `local LLM request failed: ${response.status} ${response.statusText}${reason} (op=${operation}, model=${this.config.localLlmModel}, url=${chatUrl}, promptChars=${promptChars}, maxTokens=${requestBody.max_tokens})`
         );
+        const nonRecoverableReason = this.extractNonRecoverableBackendReason(reason) ?? this.extractNonRecoverableBackendReasonFromErrorText(errorText);
+        if (nonRecoverableReason) {
+          this.markBackendUnavailable(
+            nonRecoverableReason,
+            this.config.localLlm400CooldownMs
+          );
+          this.consecutive400s = 0;
+          return null;
+        }
         if (response.status === 400) {
           this.consecutive400s += 1;
           if (this.consecutive400s >= this.config.localLlm400TripThreshold) {
@@ -3997,6 +4088,13 @@ var LocalLlmClient = class _LocalLlmClient {
       }
       log.warn(`local LLM request error: op=${operation} error=${errMsg}`);
       this.isAvailable = false;
+      const nonRecoverableReason = this.extractNonRecoverableBackendReason(errMsg);
+      if (nonRecoverableReason) {
+        this.markBackendUnavailable(
+          nonRecoverableReason,
+          this.config.localLlm400CooldownMs
+        );
+      }
       return null;
     } finally {
       if (queueMeta) {
@@ -31330,4 +31428,4 @@ export {
   EngramAccessInputError,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-BEELVTEN.js.map
+//# sourceMappingURL=chunk-7L2Q2HQB.js.map