@remnic/plugin-openclaw 9.54.5 → 9.54.7

package/dist/index.js

@@ -1,3 +1,6 @@
+import {
+  createOpenClawSupportPassportModelRoute
+} from "./chunk-HDTN2ZKK.js";
 import {
   __export,
   __reExport
@@ -3103,8 +3106,8 @@ import { registerLcmTools } from "@remnic/core/lcm/index";
 import { estimateTokens as estimateLcmTokens } from "@remnic/core/lcm/archive";
 import { registerCli } from "@remnic/core/cli";
 import {
-  FallbackLlmClient,
-  fallbackLlmRuntimeContextFromConfig
+  FallbackLlmClient as FallbackLlmClient2,
+  fallbackLlmRuntimeContextFromConfig as fallbackLlmRuntimeContextFromConfig2
 } from "@remnic/core/fallback-llm";
 
 // ../../src/objective-state.ts
@@ -3133,8 +3136,36 @@ async function probeQmdAvailability(host) {
 
 // ../../src/access-service.ts
 var access_service_exports = {};
+__export(access_service_exports, {
+  EngramAccessService: () => EngramAccessService,
+  createConfiguredSupportPassportGatewayRoute: () => createConfiguredSupportPassportGatewayRoute
+});
 __reExport(access_service_exports, access_service_star);
 import * as access_service_star from "@remnic/core/access-service";
+import { EngramAccessService as CoreEngramAccessService } from "@remnic/core/access-service";
+import { FallbackLlmClient, fallbackLlmRuntimeContextFromConfig } from "@remnic/core/fallback-llm";
+import { createOpenClawSupportPassportModelRoute as createOpenClawSupportPassportModelRoute2 } from "@remnic/plugin-openclaw/support-passport-model-route";
+function createConfiguredSupportPassportGatewayRoute(config, preferredClient) {
+  const gatewayClient = preferredClient ?? (config.gatewayConfig ? new FallbackLlmClient(
+    config.gatewayConfig,
+    fallbackLlmRuntimeContextFromConfig(config)
+  ) : null);
+  return gatewayClient ? createOpenClawSupportPassportModelRoute2(config, gatewayClient) : null;
+}
+var EngramAccessService = class extends CoreEngramAccessService {
+  supportPassportGatewayRoute;
+  constructor(orchestrator, options = {}) {
+    super(orchestrator, options);
+    const injectedRoute = super.supportPassportGatewayRouteRef;
+    this.supportPassportGatewayRoute = injectedRoute ?? createConfiguredSupportPassportGatewayRoute(
+      orchestrator.config,
+      orchestrator.fastGatewayLlm
+    );
+  }
+  get supportPassportGatewayRouteRef() {
+    return this.supportPassportGatewayRoute;
+  }
+};
 
 // ../../src/access-http.ts
 var access_http_exports = {};
@@ -5364,7 +5395,7 @@ import path8 from "path";
 import {
   renderMemoryContextPrompt
 } from "@remnic/core";
-import { log as log6 } from "@remnic/core/logger";
+import { log as log7 } from "@remnic/core/logger";
 
 // src/delegate-authorization.ts
 import { log as log2 } from "@remnic/core/logger";
@@ -7680,8 +7711,301 @@ function registerDelegateMemoryCapability(api, options) {
   return built;
 }
 
+// src/delegate-support-passport-model.ts
+import {
+  SUPPORT_PASSPORT_MODEL_ACK_PATH,
+  SUPPORT_PASSPORT_MODEL_JOB_PATH,
+  SUPPORT_PASSPORT_MODEL_RESULT_PATH,
+  acceptsSupportPassportModelResponse,
+  parseSupportPassportModelJob
+} from "@remnic/core";
+import { log as log6 } from "@remnic/core/logger";
+var MODEL_WORKER_COUNT = 4;
+var DEFAULT_REQUEST_TIMEOUT_MS = 25e3;
+var RESULT_REQUEST_TIMEOUT_MS = 5e3;
+var RESULT_RETRY_DELAY_MS = 1e3;
+var POLL_RETRY_MAX_DELAY_MS = 3e4;
+var SHUTDOWN_RESULT_REQUEST_TIMEOUT_MS = 250;
+function supportPassportModelPollRetryDelayMs(consecutiveFailures) {
+  const exponent = Math.max(0, Math.min(30, Math.floor(consecutiveFailures) - 1));
+  return Math.min(POLL_RETRY_MAX_DELAY_MS, RESULT_RETRY_DELAY_MS * 2 ** exponent);
+}
+async function post(target, serviceId, pathname, body, signal, timeoutMs) {
+  const auth = target.resolveAuthToken();
+  const requestSignal = AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]);
+  const response = await fetch(daemonUrl(target, pathname), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...auth.token ? { Authorization: `Bearer ${auth.token}` } : {}
+    },
+    body: JSON.stringify(body),
+    signal: requestSignal
+  });
+  if (response.status === 401 || response.status === 403) {
+    reportDaemonAuthorizationFailure(serviceId, pathname, response.status, auth.source);
+  }
+  return response;
+}
+function abortableRetryDelay(signal, delayMs = RESULT_RETRY_DELAY_MS) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    const timeout = setTimeout(done, delayMs);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+function createDelegateSupportPassportModelService(options) {
+  let controller;
+  let worker;
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  if (!Number.isInteger(requestTimeoutMs) || requestTimeoutMs < 1) {
+    throw new Error("requestTimeoutMs must be a positive integer");
+  }
+  const invoke = async (job, signal) => {
+    const timeoutSignal = AbortSignal.timeout(job.timeoutMs);
+    const modelSignal = AbortSignal.any([signal, timeoutSignal]);
+    if (modelSignal.aborted) return null;
+    let removeAbort = () => {
+    };
+    const aborted = new Promise((resolve) => {
+      const onAbort = () => resolve(null);
+      modelSignal.addEventListener("abort", onAbort, { once: true });
+      removeAbort = () => modelSignal.removeEventListener("abort", onAbort);
+    });
+    try {
+      return await Promise.race([
+        options.route.invoke(job.messages, {
+          temperature: job.temperature,
+          maxTokens: job.maxTokens,
+          timeoutMs: job.timeoutMs,
+          signal: modelSignal,
+          operation: job.operation,
+          jsonSchema: job.jsonSchema,
+          acceptResponse: (candidate) => acceptsSupportPassportModelResponse(job.operation, job.messages, candidate.content)
+        }),
+        aborted
+      ]);
+    } catch (error) {
+      if (!modelSignal.aborted) {
+        log6.warn(`delegate support passport model call failed: ${String(error)}`);
+      }
+      return null;
+    } finally {
+      removeAbort();
+    }
+  };
+  const completeDuringShutdown = async (job, deadline) => {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) return;
+    const shutdownTimeoutMs = Math.min(SHUTDOWN_RESULT_REQUEST_TIMEOUT_MS, remainingMs);
+    const completion = await post(
+      options.target,
+      options.serviceId,
+      SUPPORT_PASSPORT_MODEL_RESULT_PATH,
+      { id: job.id, claimId: job.claimId, result: null },
+      AbortSignal.timeout(shutdownTimeoutMs),
+      shutdownTimeoutMs
+    );
+    await completion.body?.cancel();
+    if (!completion.ok && completion.status !== 404) {
+      throw new Error(`delegate support passport model completion was rejected with HTTP ${completion.status}`);
+    }
+  };
+  const complete = async (job, result, signal, deadline, serviceSignal, onAccepted) => {
+    if (signal.aborted) {
+      if (serviceSignal.aborted) await completeDuringShutdown(job, deadline);
+      return;
+    }
+    let lastFailure = "the job deadline elapsed";
+    while (!signal.aborted && Date.now() < deadline) {
+      const remainingMs = deadline - Date.now();
+      let completion;
+      try {
+        completion = await post(
+          options.target,
+          options.serviceId,
+          SUPPORT_PASSPORT_MODEL_RESULT_PATH,
+          { id: job.id, claimId: job.claimId, result },
+          signal,
+          Math.min(RESULT_REQUEST_TIMEOUT_MS, remainingMs)
+        );
+      } catch (error) {
+        if (signal.aborted) {
+          if (serviceSignal.aborted) await completeDuringShutdown(job, deadline);
+          return;
+        }
+        lastFailure = String(error);
+        const retryDelayMs2 = Math.min(RESULT_RETRY_DELAY_MS, deadline - Date.now());
+        if (retryDelayMs2 > 0) await abortableRetryDelay(signal, retryDelayMs2);
+        continue;
+      }
+      const status = completion.status;
+      if (completion.ok) {
+        onAccepted();
+        await completion.body?.cancel().catch(() => void 0);
+        return;
+      }
+      await completion.body?.cancel();
+      if (status !== 408 && status !== 425 && status !== 429 && status < 500) {
+        throw new Error(`delegate support passport model completion was rejected with HTTP ${status}`);
+      }
+      if (signal.aborted) {
+        if (serviceSignal.aborted) await completeDuringShutdown(job, deadline);
+        return;
+      }
+      lastFailure = `HTTP ${status}`;
+      const retryDelayMs = Math.min(RESULT_RETRY_DELAY_MS, deadline - Date.now());
+      if (retryDelayMs > 0) await abortableRetryDelay(signal, retryDelayMs);
+    }
+    if (signal.aborted) {
+      if (serviceSignal.aborted) await completeDuringShutdown(job, deadline);
+      return;
+    }
+    throw new Error(`delegate support passport model completion missed its deadline after ${lastFailure}`);
+  };
+  const acknowledge = async (job, signal, timeoutMs, settleOnShutdown = false) => {
+    if (!job.claimId) return true;
+    const deadline = Date.now() + Math.min(job.timeoutMs, timeoutMs);
+    while (!signal.aborted && Date.now() < deadline) {
+      const remainingMs = deadline - Date.now();
+      try {
+        const response = await post(
+          options.target,
+          options.serviceId,
+          SUPPORT_PASSPORT_MODEL_ACK_PATH,
+          { id: job.id, claimId: job.claimId },
+          signal,
+          Math.min(RESULT_REQUEST_TIMEOUT_MS, remainingMs)
+        );
+        const status = response.status;
+        await response.body?.cancel();
+        if (response.ok) return true;
+        if (status !== 408 && status !== 425 && status !== 429 && status < 500) return false;
+      } catch {
+        if (signal.aborted) {
+          if (settleOnShutdown) await completeDuringShutdown(job, deadline);
+          return false;
+        }
+      }
+      const retryDelayMs = Math.min(RESULT_RETRY_DELAY_MS, deadline - Date.now());
+      if (retryDelayMs > 0) await abortableRetryDelay(signal, retryDelayMs);
+    }
+    if (signal.aborted && settleOnShutdown) await completeDuringShutdown(job, deadline);
+    return false;
+  };
+  const maintainClaim = async (job, signal, deadline) => {
+    if (!job.claimId || !job.executionLeaseTimeoutMs) return;
+    const renewalDelayMs = Math.max(1, Math.floor(job.executionLeaseTimeoutMs / 3));
+    const renewalTimeoutMs = Math.max(1, job.executionLeaseTimeoutMs - renewalDelayMs);
+    while (!signal.aborted && Date.now() < deadline) {
+      await abortableRetryDelay(signal, Math.min(renewalDelayMs, deadline - Date.now()));
+      if (signal.aborted || Date.now() >= deadline) return;
+      if (!await acknowledge(job, signal, Math.min(renewalTimeoutMs, deadline - Date.now()))) {
+        throw new Error("delegate support passport model claim lease renewal failed");
+      }
+    }
+  };
+  const runPoller = async (signal) => {
+    let consecutiveFailures = 0;
+    const delayAfterFailure = async () => {
+      consecutiveFailures += 1;
+      await abortableRetryDelay(signal, supportPassportModelPollRetryDelayMs(consecutiveFailures));
+    };
+    while (!signal.aborted) {
+      try {
+        const response = await post(
+          options.target,
+          options.serviceId,
+          SUPPORT_PASSPORT_MODEL_JOB_PATH,
+          { timeoutMs: 2e4, claimLease: true },
+          signal,
+          requestTimeoutMs
+        );
+        if (response.status === 204) {
+          consecutiveFailures = 0;
+          continue;
+        }
+        if (!response.ok) {
+          await response.body?.cancel();
+          await delayAfterFailure();
+          continue;
+        }
+        const job = parseSupportPassportModelJob(await response.json());
+        if (!job) {
+          log6.warn("delegate support passport model bridge received an invalid job");
+          await delayAfterFailure();
+          continue;
+        }
+        consecutiveFailures = 0;
+        const deadline = Date.now() + job.timeoutMs;
+        if (!await acknowledge(job, signal, job.claimAckTimeoutMs ?? job.timeoutMs, true)) {
+          log6.warn("delegate support passport model bridge could not acknowledge a claimed job");
+          await delayAfterFailure();
+          continue;
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) continue;
+        const claimedJob = { ...job, timeoutMs: remainingMs };
+        const heartbeatController = new AbortController();
+        const workController = new AbortController();
+        const heartbeatSignal = AbortSignal.any([signal, heartbeatController.signal]);
+        const workSignal = AbortSignal.any([signal, workController.signal]);
+        let heartbeatError;
+        let completionAccepted = false;
+        const heartbeat = maintainClaim(claimedJob, heartbeatSignal, deadline).catch((error) => {
+          if (heartbeatSignal.aborted || completionAccepted) return;
+          heartbeatError = error;
+          workController.abort();
+        });
+        try {
+          const result = await invoke(claimedJob, workSignal);
+          if (heartbeatError) throw heartbeatError;
+          await complete(claimedJob, result, workSignal, deadline, signal, () => {
+            completionAccepted = true;
+          });
+          if (heartbeatError && !completionAccepted) throw heartbeatError;
+        } catch (error) {
+          log6.warn(`delegate support passport model completion failed: ${String(error)}`);
+        } finally {
+          heartbeatController.abort();
+          workController.abort();
+          await heartbeat;
+        }
+      } catch (error) {
+        if (signal.aborted) break;
+        log6.warn(`delegate support passport model bridge failed: ${String(error)}`);
+        await delayAfterFailure();
+      }
+    }
+  };
+  const run = async (signal) => {
+    await Promise.all(Array.from({ length: MODEL_WORKER_COUNT }, () => runPoller(signal)));
+  };
+  return {
+    id: `${options.serviceId}:support-passport-model`,
+    async start() {
+      if (worker) return;
+      controller = new AbortController();
+      worker = run(controller.signal).finally(() => {
+        worker = void 0;
+        controller = void 0;
+      });
+    },
+    async stop() {
+      controller?.abort();
+      await worker;
+    }
+  };
+}
+
 // src/delegate-runtime.ts
 var DELEGATE_BATCH_FLUSH_CACHE_TTL_MS = 3e4;
+var delegatePassportServiceApiServices = /* @__PURE__ */ new WeakMap();
 function sessionKeyFrom(event, ctx) {
   const fromCtx = ctx?.sessionKey;
   if (typeof fromCtx === "string" && fromCtx.length > 0) return fromCtx;
@@ -7732,9 +8056,34 @@ function readContextComposition(response, fallbackContext) {
 function registerDelegateRuntime(api, options) {
   const { target, namespace, namespaceBindings } = options;
   const now = options.now ?? Date.now;
+  if (options.supportPassportModelRoute) {
+    const registeredServices = delegatePassportServiceApiServices.get(api);
+    if (registeredServices?.has(options.serviceId)) {
+      log7.debug(
+        `delegate register: ${options.serviceId} already has its support passport model service on this api`
+      );
+    } else if (typeof api.registerService !== "function") {
+      log7.error(
+        `[${options.serviceId}] delegate support passport gateway routing is unavailable: host exposes no service registration surface`
+      );
+    } else {
+      api.registerService(
+        createDelegateSupportPassportModelService({
+          serviceId: options.serviceId,
+          target,
+          route: options.supportPassportModelRoute
+        })
+      );
+      const services = registeredServices ?? /* @__PURE__ */ new Set();
+      services.add(options.serviceId);
+      if (registeredServices === void 0) {
+        delegatePassportServiceApiServices.set(api, services);
+      }
+    }
+  }
   if (options.passive) {
-    log6.info(
-      `[${options.serviceId}] bridge mode delegate: memory slot not owned \u2014 passive, no hooks registered`
+    log7.info(
+      `[${options.serviceId}] bridge mode delegate: memory slot not owned \u2014 passive, no memory hooks registered`
     );
     return;
   }
@@ -7802,13 +8151,13 @@ function registerDelegateRuntime(api, options) {
       const promptRemaining = () => promptDeadline - Date.now();
       try {
         if (options.shouldSkipRecall(sessionKey)) {
-          log6.debug(`delegate recall skipped: cron policy excludes ${sessionKey}`);
+          log7.debug(`delegate recall skipped: cron policy excludes ${sessionKey}`);
           return void 0;
         }
         const runtimeAgent = ctx?.runtime?.agent;
         const agentId = (typeof ctx?.agentId === "string" ? ctx.agentId : void 0) ?? (typeof runtimeAgent?.id === "string" ? runtimeAgent.id : void 0) ?? "main";
         if (await options.resolveSessionDisabled(sessionKey, agentId)) {
-          log6.debug(`delegate recall skipped: session toggle disables memory for ${sessionKey}`);
+          log7.debug(`delegate recall skipped: session toggle disables memory for ${sessionKey}`);
           return void 0;
         }
         const cwd = cwdFrom(event, ctx, options.cwd);
@@ -7855,7 +8204,7 @@ function registerDelegateRuntime(api, options) {
         }
         return { prependSystemContext: prompt };
       } catch (err) {
-        log6.warn(`delegate recall failed: ${String(err)}`);
+        log7.warn(`delegate recall failed: ${String(err)}`);
         return void 0;
       }
     };
@@ -7877,7 +8226,7 @@ function registerDelegateRuntime(api, options) {
       api.registerMemoryPromptSection(memoryBuildFn);
     }
   } else {
-    log6.info(
+    log7.info(
       `[${options.serviceId}] bridge mode delegate: prompt injection disabled by hooks policy`
     );
   }
@@ -7923,7 +8272,7 @@ function registerDelegateRuntime(api, options) {
         Math.max(1, observeRemaining())
       );
     } catch (err) {
-      log6.warn(`delegate observe failed: ${String(err)}`);
+      log7.warn(`delegate observe failed: ${String(err)}`);
     }
   });
   let cachedBatchFlushSupport;
@@ -7977,7 +8326,7 @@ function registerDelegateRuntime(api, options) {
       const remainingBudget = () => deadline - Date.now();
       const sessionKey = lifecycleSessionKeyFrom(event, ctx);
       if (sessionKey === void 0) {
-        log6.warn("delegate flush skipped: lifecycle event has malformed session key");
+        log7.warn("delegate flush skipped: lifecycle event has malformed session key");
         return false;
       }
       const namespaces = await lifecycleSessionNamespacesFrom(
@@ -8002,7 +8351,7 @@ function registerDelegateRuntime(api, options) {
           remainingTimeoutMs: remainingBudget
         });
       } catch (err) {
-        log6.warn(`delegate flush-plan ingestion failed: ${String(err)}`);
+        log7.warn(`delegate flush-plan ingestion failed: ${String(err)}`);
       }
       const flushNamespace = async (sessionNamespace) => postJson(
         target,
@@ -8072,7 +8421,7 @@ function registerDelegateRuntime(api, options) {
       }
       return flushIndividually();
     } catch (err) {
-      log6.warn(`delegate flush failed: ${String(err)}`);
+      log7.warn(`delegate flush failed: ${String(err)}`);
       return false;
     }
   };
@@ -8082,7 +8431,7 @@ function registerDelegateRuntime(api, options) {
     api.on("before_reset", flushEndedSession);
     api.on("session_end", flushEndedSession);
   }
-  log6.info(
+  log7.info(
     `[${options.serviceId}] bridge mode delegate: memory loop backed by daemon at ${target.host}:${target.port} (embedded orchestrator skipped; tools/CLI stay daemon-side)`
   );
 }
@@ -8139,7 +8488,7 @@ function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapt
       return previous;
     } catch (err) {
       if (current.length > 0) {
-        log6.warn(
+        log7.warn(
           `[${serviceId}] delegate legacy namespace read failed; using canonical bindings: ${String(err)}`
         );
         return [];
@@ -8170,7 +8519,7 @@ function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapt
       try {
         await legacy.replace?.(sessionKey, []);
       } catch (err) {
-        log6.warn(`[${serviceId}] delegate legacy namespace cleanup failed: ${String(err)}`);
+        log7.warn(`[${serviceId}] delegate legacy namespace cleanup failed: ${String(err)}`);
       }
     }
     rememberMigratedLegacySession(sessionKey);
@@ -8191,7 +8540,7 @@ function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapt
           await persistNamespaceHistory(primary, sessionKey, merged);
           await completeLegacyMigration(sessionKey);
         } catch (err) {
-          log6.warn(`[${serviceId}] delegate namespace migration failed: ${String(err)}`);
+          log7.warn(`[${serviceId}] delegate namespace migration failed: ${String(err)}`);
         }
         return merged;
       });
@@ -8219,13 +8568,13 @@ var delegateAuthorizationPreflightServices = /* @__PURE__ */ new WeakMap();
 function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkDaemonHealthSync }) {
   const boundServices = delegateHookApiServices.get(api);
   if (boundServices?.has(options.serviceId)) {
-    log6.debug(
+    log7.debug(
       `delegate register: ${options.serviceId} already has hooks bound on this api \u2014 skipping duplicate registration`
     );
     return true;
   }
   if (delegateEmbeddedFallbackApis.has(api)) {
-    log6.debug(
+    log7.debug(
       `delegate register: ${options.serviceId} previously fell back to embedded on this api \u2014 staying embedded to avoid stacking memory paths`
     );
     return false;
@@ -8239,11 +8588,11 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     bridge = resolveBridgeMode(options.configBridgeMode, {
       memoryDir: options.memoryDir,
       timeoutMs: bridgeHealthTimeoutMs,
-      onSkip: (reason) => log6.info(`[${options.serviceId}] bridge mode auto: staying embedded \u2014 ${reason}`)
+      onSkip: (reason) => log7.info(`[${options.serviceId}] bridge mode auto: staying embedded \u2014 ${reason}`)
     });
   } catch (err) {
     const wantedDelegate = requestedDelegate(options.configBridgeMode);
-    log6.error(
+    log7.error(
       wantedDelegate ? `${String(err)} \u2014 falling back to the embedded runtime` : `${String(err)} \u2014 the deployment is embedded, so this only affects delegate mode`
     );
     if (!options.passive) delegateEmbeddedFallbackApis.add(api);
@@ -8251,7 +8600,7 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
   }
   if (bridge.mode !== "delegate") {
     if (delegateBoundApis.has(api)) {
-      log6.warn(
+      log7.warn(
         `[${options.serviceId}] bridge mode resolved embedded, but a sibling service already bound delegate hooks on this api \u2014 reusing them instead of stacking an embedded runtime`
       );
       return true;
@@ -8259,7 +8608,7 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     if (!options.passive) {
       delegateEmbeddedFallbackApis.add(api);
       if (resolveRequestedBridgeMode(options.configBridgeMode) === "auto") {
-        log6.info(
+        log7.info(
           `[${options.serviceId}] bridge mode auto: embedded hooks are bound on this api \u2014 a daemon that starts later is picked up on the next gateway restart`
         );
       }
@@ -8268,13 +8617,13 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
   }
   if (!bridge.healthVerified && !deps.checkHealth(bridge.daemonHost, bridge.daemonPort, bridgeHealthTimeoutMs)) {
     if (delegateBoundApis.has(api)) {
-      log6.warn(
+      log7.warn(
         `[${options.serviceId}] no healthy daemon at ${bridge.daemonHost}:${bridge.daemonPort}, but a sibling service already bound delegate hooks on this api \u2014 reusing them instead of stacking an embedded runtime`
       );
       return true;
     }
     delegateEmbeddedFallbackApis.add(api);
-    log6.error(
+    log7.error(
       `bridge mode delegate requested but no healthy daemon at ${bridge.daemonHost}:${bridge.daemonPort} \u2014 falling back to the embedded runtime`
     );
     return false;
@@ -8316,7 +8665,8 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     capability: options.capability,
     recallTimeoutMs: 25e3,
     observeTimeoutMs: 12e4,
-    flushTimeoutMs: 55e3
+    flushTimeoutMs: 55e3,
+    supportPassportModelRoute: options.supportPassportModelRoute
   });
   let preflightServices = delegateAuthorizationPreflightServices.get(api);
   if (!options.passive && !preflightServices?.has(options.serviceId)) {
@@ -8331,16 +8681,16 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     void probe(target, "", operations).then((result) => {
       if (result.state === "authorized") return;
       if (result.state === "unauthorized") {
-        log6.warn(
+        log7.warn(
           `delegate authorization preflight rejected ${operationLabel} (${result.status}; token source: ${result.tokenSource}) \u2014 runtime remains active`
         );
         return;
       }
-      log6.warn(
+      log7.warn(
         `delegate authorization preflight could not verify ${operationLabel} (token source: ${result.tokenSource}) \u2014 runtime remains active`
       );
     }).catch(() => {
-      log6.warn("delegate authorization preflight could not complete \u2014 runtime remains active");
+      log7.warn("delegate authorization preflight could not complete \u2014 runtime remains active");
     });
   }
   return true;
@@ -9349,6 +9699,7 @@ var pluginDefinition = {
       }
     );
     const delegateApi = api;
+    const delegateSupportPassportGatewayRoute = createConfiguredSupportPassportGatewayRoute(cfg);
     const delegateHandled = maybeRegisterDelegateRuntime(delegateApi, {
       serviceId,
       configBridgeMode: cfg.bridgeMode,
@@ -9367,6 +9718,7 @@ var pluginDefinition = {
       shouldSkipRecall: (sk) => shouldSkipRecallForSession(sk, cfg),
       cwd: getOpenClawRuntimeWorkspaceDir(api),
       flushOnResetEnabled: cfg.flushOnResetEnabled,
+      supportPassportModelRoute: delegateSupportPassportGatewayRoute ?? void 0,
       // Memory-slot capability inputs. Mirrors the embedded derivation: the
       // registration-time runtime agent owns this memory, and QMD is the
       // backend only when it is both selected and enabled.
@@ -9434,7 +9786,7 @@ var pluginDefinition = {
       globalThis.__openclawEngramTrace = void 0;
     }
     const existingAccessService = globalThis[keys.ACCESS_SERVICE];
-    const accessService = existingAccessService && existingAccessService ? existingAccessService : new access_service_exports.EngramAccessService(orchestrator, {
+    const accessService = existingAccessService && existingAccessService ? existingAccessService : new EngramAccessService(orchestrator, {
       resolveSecretRef: (ref, context) => loadOpenClawSecretRefResolver().then((resolver) => resolver ? resolver(ref, context) : void 0)
     });
     globalThis[keys.ACCESS_SERVICE] = accessService;
@@ -9680,9 +10032,9 @@ Keep the reflection grounded in the evidence below.
       let rawNarrative = "";
       try {
         if (route.kind === "gateway") {
-          const llm = new FallbackLlmClient(
+          const llm = new FallbackLlmClient2(
             cfg.gatewayConfig,
-            fallbackLlmRuntimeContextFromConfig(cfg)
+            fallbackLlmRuntimeContextFromConfig2(cfg)
           );
           if (!route.hasExplicitModel && !llm.isAvailable(route.options)) {
             logger_exports.log.debug(
@@ -12145,6 +12497,7 @@ var export_loadDaySummaryPrompt = day_summary_exports.loadDaySummaryPrompt;
 export {
   buildHourlySummaryCronJob,
   checkDaemonHealth,
+  createOpenClawSupportPassportModelRoute,
   src_default as default,
   detectBridgeMode,
   detectDaemonBridgeMode,

package/dist/support-passport-model-route.d.ts

@@ -0,0 +1,7 @@
+import { PluginConfig, SupportPassportModelRoute } from '@remnic/core';
+import { FallbackLlmClient } from '@remnic/core/fallback-llm';
+
+type SupportPassportGatewayConfig = Pick<PluginConfig, "modelSource" | "taskModelChain" | "gatewayAgentId" | "gatewayConfig">;
+declare function createOpenClawSupportPassportModelRoute(config: SupportPassportGatewayConfig, client: Pick<FallbackLlmClient, "chatCompletion">): SupportPassportModelRoute;
+
+export { createOpenClawSupportPassportModelRoute };

package/dist/support-passport-model-route.js

@@ -0,0 +1,7 @@
+import {
+  createOpenClawSupportPassportModelRoute
+} from "./chunk-HDTN2ZKK.js";
+import "./chunk-I2KLQ2HA.js";
+export {
+  createOpenClawSupportPassportModelRoute
+};