@joshuaswarren/openclaw-engram 9.1.12 → 9.1.14

package/dist/access-cli.js

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

package/dist/{chunk-BEELVTEN.js → chunk-WUKDMJRD.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
    */
@@ -3489,17 +3545,17 @@ var LocalLlmClient = class _LocalLlmClient {
       });
       clearTimeout(timeout);
       if (!response.ok) {
-        return { ok: false, data: null };
+        return { ok: false, data: null, status: response.status };
       }
       const contentType = response.headers.get("content-type");
       if (contentType?.includes("application/json")) {
-        return { ok: true, data: await response.json() };
+        return { ok: true, data: await response.json(), status: response.status };
       } else {
-        return { ok: true, data: await response.text() };
+        return { ok: true, data: await response.text(), status: response.status };
       }
     } catch (err) {
       clearTimeout(timeout);
-      return { ok: false, data: null };
+      return { ok: false, data: null, status: null };
     }
   }
   /**
@@ -3508,10 +3564,20 @@ 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;
     }
     const baseUrl = this.config.localLlmUrl.replace("localhost", "127.0.0.1").replace(/\/+$/, "");
+    let sawUnauthorizedProbe = false;
     for (const serverConfig of LOCAL_SERVERS) {
       const healthUrl = `${baseUrl}${serverConfig.healthEndpoint}`;
       log.debug(`checking ${serverConfig.type} at ${healthUrl}`);
@@ -3523,6 +3589,9 @@ var LocalLlmClient = class _LocalLlmClient {
         log.info(`detected ${serverConfig.type} at ${baseUrl}`);
         return true;
       }
+      if (result.status === 401 || result.status === 403) {
+        sawUnauthorizedProbe = true;
+      }
     }
     try {
       const modelsUrl = `${baseUrl}/v1/models`;
@@ -3534,11 +3603,19 @@ var LocalLlmClient = class _LocalLlmClient {
         log.info(`detected generic OpenAI-compatible server at ${baseUrl}`);
         return true;
       }
+      if (result.status === 401 || result.status === 403) {
+        sawUnauthorizedProbe = true;
+      }
     } catch {
     }
     this.isAvailable = false;
     this.detectedType = null;
     this.lastHealthCheck = now;
+    if (sawUnauthorizedProbe) {
+      log.warn(
+        `local LLM availability probe was unauthorized at ${baseUrl}; verify localLlmApiKey and localLlmAuthHeader settings`
+      );
+    }
     log.debug("local LLM not available at", baseUrl);
     return false;
   }
@@ -3908,6 +3985,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 +4025,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 +4040,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 +4100,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) {
@@ -4019,6 +4129,11 @@ var LocalLlmClient = class _LocalLlmClient {
     try {
       const result = await this.fetchWithTimeout(modelsUrl, 3e3);
       if (!result.ok) {
+        if (result.status === 401 || result.status === 403) {
+          log.warn(
+            `Local LLM: unauthorized while fetching models from ${modelsUrl}; verify localLlmApiKey and localLlmAuthHeader settings`
+          );
+        }
         log.warn(`Local LLM: Failed to fetch models from ${modelsUrl} - server returned error`);
         return null;
       }
@@ -31330,4 +31445,4 @@ export {
   EngramAccessInputError,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-BEELVTEN.js.map
+//# sourceMappingURL=chunk-WUKDMJRD.js.map