@t0ken.ai/memoryx-openclaw-plugin 2.2.68 → 2.2.70

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const PLUGIN_VERSION = "2.2.68";
+export declare const PLUGIN_VERSION = "2.2.70";
 export declare const DEFAULT_API_BASE = "https://t0ken.ai/api";
 export declare const PLUGIN_DIR: string;
 /** 真实上游 baseUrl 缓存文件：重启后若配置已被改成 localhost，从此文件恢复各厂商真实地址。 */

package/dist/constants.js

@@ -4,7 +4,7 @@
 import * as path from "path";
 import * as os from "os";
 // Plugin version - synced from package.json by prebuild script
-export const PLUGIN_VERSION = "2.2.68";
+export const PLUGIN_VERSION = "2.2.70";
 export const DEFAULT_API_BASE = "https://t0ken.ai/api";
 export const PLUGIN_DIR = path.join(os.homedir(), ".openclaw", "extensions", "memoryx-openclaw-plugin");
 /** 真实上游 baseUrl 缓存文件：重启后若配置已被改成 localhost，从此文件恢复各厂商真实地址。 */

package/dist/hooks.d.ts

@@ -1,5 +1,6 @@
 /**
- * OpenClaw hooks: message_received, llm_input, llm_output, before_agent_start, session_end.
+ * OpenClaw hooks: message_received, llm_input, llm_output,
+ * before_model_resolve, before_agent_start, session_end.
  */
 import type { MemoryXPlugin } from "./plugin-core.js";
 export declare function registerHooks(api: any, plugin: MemoryXPlugin, wrapProvidersWithProxy: () => void, applySidecarRedirect: (opts?: {

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,wBAAgB,aAAa,CACzB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,aAAa,EACrB,sBAAsB,EAAE,MAAM,IAAI,EAClC,oBAAoB,EAAE,CAAC,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,IAAI,EAC1D,gBAAgB,EAAE,MAAM,OAAO,GAChC,IAAI,CAoCN"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,wBAAgB,aAAa,CACzB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,aAAa,EACrB,sBAAsB,EAAE,MAAM,IAAI,EAClC,oBAAoB,EAAE,CAAC,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,IAAI,EAC1D,gBAAgB,EAAE,MAAM,OAAO,GAChC,IAAI,CAoCN"}

package/dist/hooks.js

@@ -1,13 +1,10 @@
+import { log } from "./logger.js";
 export function registerHooks(api, plugin, wrapProvidersWithProxy, applySidecarRedirect, shouldApplyProxy) {
-    let useVirtualProviderInLastRun = false;
     api.on("message_received", async (event) => {
         const { content } = event;
         if (content && plugin)
             await plugin.onMessage("user", content);
     });
-    api.on("llm_input", (_event) => {
-        useVirtualProviderInLastRun = _event?.provider === "memoryx-gateway";
-    });
     api.on("llm_output", async (event) => {
         const { assistantTexts } = event;
         if (assistantTexts && Array.isArray(assistantTexts) && plugin) {
@@ -16,11 +13,18 @@ export function registerHooks(api, plugin, wrapProvidersWithProxy, applySidecarR
                 await plugin.onMessage("assistant", fullContent);
         }
     });
+    // Override model to "auto" (which doesn't exist in models.json) so
+    // resolveModel() falls through to the config fallback path. The fallback
+    // reads baseUrl from cfg.models.providers[provider] — which we patch to
+    // the sidecar URL in runtimeConfigSnapshot. This preserves the original
+    // provider (correct API key + protocol) while routing through the sidecar.
+    api.on("before_model_resolve", async () => {
+        if (!shouldApplyProxy())
+            return undefined;
+        log(`[Proxy] before_model_resolve → modelOverride=auto (provider preserved)`);
+        return { modelOverride: "auto" };
+    });
     api.on("before_agent_start", async (_event) => {
-        if (shouldApplyProxy()) {
-            wrapProvidersWithProxy();
-            applySidecarRedirect({ quiet: true });
-        }
         try {
             await plugin.startTimersIfNeeded();
         }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,aAAa,EAAU,MAAM,kBAAkB,CAAC;;;;;;kBAsBvC,GAAG,iBAAiB,YAAY,GAAG,IAAI;;AARzD,wBAmGE;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,aAAa,EAAU,MAAM,kBAAkB,CAAC;;;;;;kBAwBvC,GAAG,iBAAiB,YAAY,GAAG,IAAI;;AARzD,wBAwIE;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/index.js

@@ -18,7 +18,7 @@
 import { PLUGIN_VERSION, DEFAULT_API_BASE, SIDECAR_PORT } from "./constants.js";
 import { log, LOG_FILE } from "./logger.js";
 import { MemoryXPlugin, getSDK } from "./plugin-core.js";
-import { extractProviderCredentials, getDefaultModelAndProvider, realUpstreamCredentialsForSidecar, syncRealUpstreamBaseUrlCacheFromConfig, } from "./proxy-credentials.js";
+import { extractProviderCredentials, getDefaultModelAndProvider, buildRealUpstreamBaseUrlMap, realUpstreamCredentialsForSidecar, saveRealUpstreamBaseUrlCache, loadRealUpstreamBaseUrlCache, } from "./proxy-credentials.js";
 import { createProxyRedirect } from "./proxy-redirect.js";
 import { SidecarServer } from "./sidecar.js";
 import { registerHooks } from "./hooks.js";
@@ -39,7 +39,6 @@ export default {
         }
         plugin = new MemoryXPlugin(pluginConfig);
         registerTools(api, plugin);
-        // Pure memory: read provider list from api.config (no file I/O, same as slimclaw)
         const configCredentials = extractProviderCredentials(api.config);
         log(`[Proxy] Found ${configCredentials.size} providers in config`);
         const defaultConfig = getDefaultModelAndProvider(configCredentials, api.config);
@@ -50,21 +49,58 @@ export default {
         let sidecar = null;
         const getSidecarBase = () => sidecar ? `http://localhost:${sidecar.getPort()}` : sidecarBaseUrl;
         const { applySidecarRedirect, wrapProvidersWithProxy } = createProxyRedirect(api, getSidecarBase, realProviderHeader);
-        const shouldApplyProxy = () => {
-            const creds = extractProviderCredentials(api.config);
-            return getDefaultModelAndProvider(creds, api.config).provider === "memoryx-gateway";
-        };
+        // Capture real upstream URLs (sync, no I/O).
+        // Do NOT call applySidecarRedirect() here — it mutates runtimeConfigSnapshot
+        // and makes writeConfigFile's merge-patch compute an empty diff.
+        const savedRealUpstreamUrls = buildRealUpstreamBaseUrlMap(configCredentials, sidecarBaseUrl);
+        const shouldApplyProxy = () => true;
         registerHooks(api, plugin, wrapProvidersWithProxy, applySidecarRedirect, shouldApplyProxy);
         api.registerService({
             id: "memoryx-sidecar",
             start: async () => {
                 try {
-                    // Re-read credentials from api.config (pure memory, may have updated since register)
+                    // 1. Save real upstream URLs to disk cache (for sidecar forwarding)
+                    let cached;
+                    try {
+                        cached = await loadRealUpstreamBaseUrlCache();
+                    }
+                    catch {
+                        cached = new Map();
+                    }
+                    for (const [id, url] of savedRealUpstreamUrls) {
+                        if (id !== "memoryx-gateway" && url && !url.includes("localhost")) {
+                            cached.set(id, url);
+                        }
+                    }
+                    await saveRealUpstreamBaseUrlCache(cached);
+                    // 2. Patch runtimeConfigSnapshot so resolveModel()'s config
+                    //    fallback path uses sidecar baseUrl. api.config and
+                    //    runtimeConfigSnapshot are separate clones — we must
+                    //    patch the one loadConfig() returns.
+                    const runtimeSnapshot = api.runtime?.config?.loadConfig?.();
+                    if (runtimeSnapshot?.models?.providers) {
+                        const providers = runtimeSnapshot.models.providers;
+                        let n = 0;
+                        for (const [id, p] of Object.entries(providers)) {
+                            if (id === "memoryx-gateway" || !p || typeof p !== "object")
+                                continue;
+                            const cur = (p.baseUrl || "").trim();
+                            if (cur && !cur.includes("localhost")) {
+                                p.baseUrl = `${sidecarBaseUrl}/_p/${id}`;
+                                n++;
+                            }
+                        }
+                        if (n > 0)
+                            log(`[Proxy] Patched runtimeConfigSnapshot: ${n} provider(s) → Sidecar`);
+                    }
+                    // 3. Start sidecar with real upstream credentials.
+                    //    API keys are in OpenClaw's AuthStorage (auth.json),
+                    //    NOT in config — credentials will have empty apiKey.
+                    //    The sidecar uses the incoming request's Authorization
+                    //    header instead, passed as incoming_api_key to the gateway.
                     const credentials = extractProviderCredentials(api.config);
                     const defaults = getDefaultModelAndProvider(credentials, api.config);
-                    // Sync baseUrl cache: config → compare with cache → update non-localhost
-                    await syncRealUpstreamBaseUrlCacheFromConfig(api.config, getSidecarBase());
-                    const realUpstreamCredentials = realUpstreamCredentialsForSidecar(credentials, new Map());
+                    const realUpstreamCredentials = realUpstreamCredentialsForSidecar(credentials, savedRealUpstreamUrls);
                     sidecar = new SidecarServer(realUpstreamCredentials, { model: defaults.model, provider: defaults.provider }, defaults.availableProviders, {
                         proxyUrl,
                         getSDK,
@@ -73,16 +109,25 @@ export default {
                     });
                     await sidecar.start();
                     api.logger.info(`[MemoryX] Sidecar started on port ${sidecar.getPort()}`);
-                    if (defaults.provider === "memoryx-gateway") {
-                        wrapProvidersWithProxy();
-                        applySidecarRedirect();
-                    }
                 }
                 catch (e) {
                     api.logger.error(`[MemoryX] Sidecar failed to start: ${e.message}`);
                 }
             },
             stop: async () => {
+                // Restore runtimeConfigSnapshot baseUrls
+                try {
+                    const realUrls = await loadRealUpstreamBaseUrlCache();
+                    const snapshot = api.runtime?.config?.loadConfig?.();
+                    if (snapshot?.models?.providers && realUrls.size > 0) {
+                        for (const [id, url] of realUrls) {
+                            const p = snapshot.models.providers[id];
+                            if (p && typeof p === "object" && url)
+                                p.baseUrl = url;
+                        }
+                    }
+                }
+                catch { /* best-effort */ }
                 if (sidecar)
                     await sidecar.stop();
                 api.logger.info("[MemoryX] Sidecar stopped");

package/dist/proxy-redirect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxy-redirect.d.ts","sourceRoot":"","sources":["../src/proxy-redirect.ts"],"names":[],"mappings":"AAyBA,wBAAgB,mBAAmB,CAC/B,GAAG,EAAE,GAAG,EACR,cAAc,EAAE,MAAM,MAAM,EAC5B,kBAAkB,EAAE,MAAM,GAC3B;IACC,oBAAoB,EAAE,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3D,sBAAsB,EAAE,MAAM,IAAI,CAAC;CACtC,CAyDA"}
+{"version":3,"file":"proxy-redirect.d.ts","sourceRoot":"","sources":["../src/proxy-redirect.ts"],"names":[],"mappings":"AAmBA,wBAAgB,mBAAmB,CAC/B,GAAG,EAAE,GAAG,EACR,cAAc,EAAE,MAAM,MAAM,EAC5B,kBAAkB,EAAE,MAAM,GAC3B;IACC,oBAAoB,EAAE,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3D,sBAAsB,EAAE,MAAM,IAAI,CAAC;CACtC,CAmEA"}

package/dist/proxy-redirect.js

@@ -2,31 +2,26 @@
  * Redirect provider baseUrl to Sidecar and wrap config so reads always resolve to Sidecar.
  *
  * Neither function performs file I/O. They only mutate api.config in memory.
+ *
+ * IMPORTANT (OpenClaw config lifecycle):
+ * api.config is a direct reference to the config object at startup time.
+ * At startup, api.config === runtimeConfigSnapshot (same object), so mutations
+ * here are visible to loadConfig() and LLM requests.
+ * After a config hot-reload, loadConfig() returns a NEW cloned object, so the
+ * Proxy on api.config no longer affects LLM requests. This is an accepted
+ * limitation — only "plugins" config changes trigger a full gateway restart
+ * (re-running register()), while "models" changes are kind:"none" and rarely
+ * happen mid-session.
  */
 import { log } from "./logger.js";
-/**
- * Get all non-memoryx-gateway provider IDs from api.config.models.providers.
- * Pure memory read, no file I/O.
- */
-function getProviderIds(config) {
-    const providers = config?.models?.providers;
-    if (!providers || typeof providers !== "object")
-        return [];
-    const ids = [];
-    for (const id of Object.keys(providers)) {
-        if (id === "memoryx-gateway")
-            continue;
-        const p = providers[id];
-        if (p && typeof p === "object" && "baseUrl" in p) {
-            ids.push(id);
-        }
-    }
-    return ids;
-}
+const WRAPPED_MARKER = Symbol.for("memoryx-proxy-wrapped");
 export function createProxyRedirect(api, getSidecarBase, realProviderHeader) {
+    let redirectApplied = false;
     const applySidecarRedirect = (opts) => {
+        if (redirectApplied && opts?.quiet)
+            return;
         const sidecarBase = getSidecarBase();
-        const providerIds = getProviderIds(api.config);
+        const providerIds = getProviderIdsFromRaw(api.config);
         if (providerIds.length === 0) {
             if (!opts?.quiet)
                 log(`[Proxy] No providers to redirect`, { console: true });
@@ -43,23 +38,32 @@ export function createProxyRedirect(api, getSidecarBase, realProviderHeader) {
                 p.headers = {};
             p.headers[realProviderHeader] = providerId;
             n++;
-            log(`[Proxy] Redirected provider "${providerId}" baseUrl → Sidecar, header ${realProviderHeader}=${providerId}`);
         }
-        if (n > 0 && !opts?.quiet) {
-            api.logger.info(`[MemoryX] ✅ Sidecar redirect applied for ${n} provider(s).`);
+        if (n > 0) {
+            if (!opts?.quiet) {
+                api.logger.info(`[MemoryX] ✅ Sidecar redirect applied for ${n} provider(s).`);
+            }
+            if (!redirectApplied) {
+                log(`[Proxy] Redirected ${n} provider(s) baseUrl → Sidecar`);
+            }
+            redirectApplied = true;
         }
     };
     const wrapProvidersWithProxy = () => {
         if (!api.config?.models?.providers || typeof api.config.models.providers !== "object")
             return;
-        const providerIds = new Set(getProviderIds(api.config));
+        const current = api.config.models.providers;
+        if (current[WRAPPED_MARKER])
+            return;
+        const providerIds = new Set(getProviderIdsFromRaw(api.config));
         if (providerIds.size === 0)
             return;
-        const raw = api.config.models.providers;
         const handler = {
             get(target, prop) {
+                if (prop === WRAPPED_MARKER)
+                    return true;
                 const val = target[prop];
-                if (val && typeof val === "object" && providerIds.has(prop)) {
+                if (val && typeof val === "object" && typeof prop === "string" && providerIds.has(prop)) {
                     return new Proxy(val, {
                         get(t, k) {
                             if (k === "baseUrl")
@@ -76,8 +80,23 @@ export function createProxyRedirect(api, getSidecarBase, realProviderHeader) {
                 return val;
             },
         };
-        api.config.models.providers = new Proxy(raw, handler);
+        api.config.models.providers = new Proxy(current, handler);
         log(`[Proxy] Wrapped models.providers in Proxy so baseUrl/headers always resolve to Sidecar`);
     };
     return { applySidecarRedirect, wrapProvidersWithProxy };
 }
+function getProviderIdsFromRaw(config) {
+    const providers = config?.models?.providers;
+    if (!providers || typeof providers !== "object")
+        return [];
+    const ids = [];
+    for (const id of Object.keys(providers)) {
+        if (id === "memoryx-gateway")
+            continue;
+        const p = providers[id];
+        if (p && typeof p === "object" && "baseUrl" in p) {
+            ids.push(id);
+        }
+    }
+    return ids;
+}

package/dist/sidecar.d.ts

@@ -1,7 +1,8 @@
 /**
  * Local HTTP Sidecar: lightweight forwarder.
- * Reads base_url_map from local cache file, credentials from constructor (api.config).
+ * Reads base_url_map from local cache file, credentials from constructor.
  * Packages payload and POSTs to MemoryX API server.
+ * On gateway failure, falls back to real upstream directly.
  */
 import type { ProviderCredentials } from "./types.js";
 import type { PluginConfig } from "./types.js";
@@ -18,6 +19,10 @@ export declare class SidecarServer {
     private defaultProvider;
     private availableProviders;
     private options;
+    private cachedBaseUrlMap;
+    private cachedMemoryxApiKey;
+    private cachedAgentId;
+    private accountInfoResolved;
     constructor(credentials: Map<string, ProviderCredentials>, defaultProvider: {
         model: string;
         provider: string;
@@ -28,6 +33,14 @@ export declare class SidecarServer {
     start(): Promise<void>;
     stop(): Promise<void>;
     getPort(): number;
+    private warmCaches;
+    private getBaseUrlMap;
+    /**
+     * Fallback: forward request directly to the real upstream provider,
+     * bypassing the gateway. Used when gateway is unavailable.
+     * Uses the default provider's real base URL + the incoming API key.
+     */
+    private fallbackToUpstream;
     private handleRequest;
     private readBody;
 }

package/dist/sidecar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidecar.d.ts","sourceRoot":"","sources":["../src/sidecar.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAE7D,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,eAAe,CAAsC;IAC7D,OAAO,CAAC,kBAAkB,CAA6C;IACvE,OAAO,CAAC,OAAO,CAAiB;gBAG5B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAC7C,eAAe,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EACpD,kBAAkB,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,EAC9D,OAAO,EAAE,cAAc;IAQrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAa3B,OAAO,IAAI,MAAM;YAMH,aAAa;IAiM3B,OAAO,CAAC,QAAQ;CAQnB"}
+{"version":3,"file":"sidecar.d.ts","sourceRoot":"","sources":["../src/sidecar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAE7D,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,eAAe,CAAsC;IAC7D,OAAO,CAAC,kBAAkB,CAA6C;IACvE,OAAO,CAAC,OAAO,CAAiB;IAEhC,OAAO,CAAC,gBAAgB,CAAuC;IAC/D,OAAO,CAAC,mBAAmB,CAAc;IACzC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,mBAAmB,CAAS;gBAGhC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAC7C,eAAe,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EACpD,kBAAkB,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,EAC9D,OAAO,EAAE,cAAc;IAQrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAa3B,OAAO,IAAI,MAAM;YAMH,UAAU;IAuBxB,OAAO,CAAC,aAAa;IAIrB;;;;OAIG;YACW,kBAAkB;YA6GlB,aAAa;IA8M3B,OAAO,CAAC,QAAQ;CAQnB"}

package/dist/sidecar.js

@@ -1,7 +1,8 @@
 /**
  * Local HTTP Sidecar: lightweight forwarder.
- * Reads base_url_map from local cache file, credentials from constructor (api.config).
+ * Reads base_url_map from local cache file, credentials from constructor.
  * Packages payload and POSTs to MemoryX API server.
+ * On gateway failure, falls back to real upstream directly.
  */
 import * as http from "http";
 import { SIDECAR_PORT } from "./constants.js";
@@ -13,6 +14,10 @@ export class SidecarServer {
     defaultProvider;
     availableProviders;
     options;
+    cachedBaseUrlMap = null;
+    cachedMemoryxApiKey = "";
+    cachedAgentId = "";
+    accountInfoResolved = false;
     constructor(credentials, defaultProvider, availableProviders, options) {
         this.credentials = credentials;
         this.defaultProvider = defaultProvider;
@@ -20,6 +25,7 @@ export class SidecarServer {
         this.options = options;
     }
     async start() {
+        await this.warmCaches();
         return new Promise((resolve, reject) => {
             const server = http.createServer(async (req, res) => {
                 await this.handleRequest(req, res);
@@ -63,17 +69,162 @@ export class SidecarServer {
             ? this.server.address().port
             : SIDECAR_PORT;
     }
+    async warmCaches() {
+        try {
+            const map = await loadRealUpstreamBaseUrlCache();
+            const obj = {};
+            for (const [id, u] of map) {
+                if (id && u?.trim())
+                    obj[id] = u.trim();
+            }
+            this.cachedBaseUrlMap = obj;
+        }
+        catch {
+            this.cachedBaseUrlMap = {};
+        }
+        try {
+            const sdk = await this.options.getSDK(this.options.pluginConfig);
+            const accountInfo = await sdk.getAccountInfo();
+            this.cachedMemoryxApiKey = accountInfo.apiKey || "";
+            this.cachedAgentId = accountInfo.agentId || "";
+            this.accountInfoResolved = true;
+        }
+        catch {
+            this.accountInfoResolved = true;
+        }
+    }
+    getBaseUrlMap() {
+        return this.cachedBaseUrlMap ?? {};
+    }
+    /**
+     * Fallback: forward request directly to the real upstream provider,
+     * bypassing the gateway. Used when gateway is unavailable.
+     * Uses the default provider's real base URL + the incoming API key.
+     */
+    async fallbackToUpstream(reqUrl, res, reqId, parsedBody, requestFormat, incomingApiKey, anthropicVersion, provider) {
+        const baseUrlMap = this.getBaseUrlMap();
+        const realBaseUrl = baseUrlMap[provider] || "";
+        if (!realBaseUrl || !incomingApiKey) {
+            log(`[Sidecar] ${reqId} fallback: no upstream URL or key for ${provider}`, { console: true });
+            return false;
+        }
+        const fallbackBody = { ...parsedBody };
+        if (fallbackBody.model === "auto") {
+            const match = this.availableProviders.find(p => p.provider === provider);
+            if (match?.model)
+                fallbackBody.model = match.model;
+        }
+        const upstreamUrl = realBaseUrl.replace(/\/+$/, "") + reqUrl;
+        const headers = { "Content-Type": "application/json" };
+        if (requestFormat === "anthropic") {
+            headers["x-api-key"] = incomingApiKey;
+            headers["anthropic-version"] = anthropicVersion || "2023-06-01";
+        }
+        else {
+            headers["Authorization"] = `Bearer ${incomingApiKey}`;
+        }
+        log(`[Sidecar] ${reqId} fallback → ${provider} ${upstreamUrl} model=${fallbackBody.model} fmt=${requestFormat}`, { console: true });
+        const stream = !!fallbackBody.stream;
+        const timeout = stream ? 20_000 : 90_000;
+        const abort = new AbortController();
+        const timer = setTimeout(() => abort.abort(), timeout);
+        let resp;
+        try {
+            resp = await fetch(upstreamUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(fallbackBody),
+                signal: abort.signal,
+            });
+        }
+        catch (e) {
+            clearTimeout(timer);
+            log(`[Sidecar] ${reqId} fallback fetch error: ${e?.message}`, { console: true });
+            return false;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (resp.status >= 400) {
+            let detail = "";
+            try {
+                detail = await resp.text();
+            }
+            catch { }
+            log(`[Sidecar] ${reqId} fallback upstream ${resp.status}: ${detail.slice(0, 200)}`, { console: true });
+            return false;
+        }
+        if (stream && resp.body) {
+            const reader = resp.body.getReader();
+            res.writeHead(resp.status, {
+                "Content-Type": resp.headers.get("content-type") || "text/event-stream",
+            });
+            const FIRST_CHUNK_TIMEOUT = 120_000;
+            const CHUNK_TIMEOUT = 30_000;
+            let isFirst = true;
+            try {
+                while (true) {
+                    const chunkTimeout = isFirst ? FIRST_CHUNK_TIMEOUT : CHUNK_TIMEOUT;
+                    const { done, value } = await Promise.race([
+                        reader.read(),
+                        new Promise((_, rej) => setTimeout(() => rej(new Error("chunk timeout")), chunkTimeout)),
+                    ]);
+                    if (done || !value)
+                        break;
+                    if (res.destroyed)
+                        break;
+                    res.write(Buffer.from(value));
+                    isFirst = false;
+                }
+            }
+            catch (e) {
+                log(`[Sidecar] ${reqId} fallback stream error: ${e?.message}`, { console: true });
+            }
+            finally {
+                try {
+                    reader.cancel();
+                }
+                catch { }
+                try {
+                    reader.releaseLock();
+                }
+                catch { }
+            }
+            res.end();
+            log(`[Sidecar] ${reqId} ← ${resp.status} fallback stream (${provider})`, { console: true });
+        }
+        else if (resp.body) {
+            const text = await resp.text();
+            res.writeHead(resp.status, {
+                "Content-Type": resp.headers.get("content-type") || "application/json",
+            });
+            res.end(text);
+            log(`[Sidecar] ${reqId} ← ${resp.status} fallback body=${text.length} (${provider})`, { console: true });
+        }
+        else {
+            res.writeHead(resp.status);
+            res.end();
+        }
+        return true;
+    }
     async handleRequest(req, res) {
-        const url = req.url || "/";
+        let url = req.url || "/";
         const method = req.method?.toUpperCase();
-        const { proxyUrl, getSDK, pluginConfig } = this.options;
+        const { proxyUrl } = this.options;
         if (url === "/health" && method === "GET") {
             res.writeHead(200, { "Content-Type": "text/plain" });
             res.end("OK");
             return;
         }
+        // Extract provider from URL path prefix: /_p/<provider>/chat/completions
+        let urlProvider = "";
+        const prefixMatch = url.match(/^\/_p\/([^/]+)(\/.*)/);
+        if (prefixMatch) {
+            urlProvider = prefixMatch[1];
+            url = prefixMatch[2]; // strip prefix, keep the real path
+        }
         const reqId = `req-${Date.now()}`;
-        log(`[Sidecar] ${reqId} in ${method} ${url}`, { console: true });
+        log(`[Sidecar] ${reqId} in ${method} ${req.url}`, { console: true });
         let body;
         try {
             body = await this.readBody(req);
@@ -84,76 +235,60 @@ export class SidecarServer {
             res.end(JSON.stringify({ error: e?.message || "Read body failed" }));
             return;
         }
-        let openaiRequest;
+        let parsedBody;
         try {
-            openaiRequest = JSON.parse(body || "{}");
+            parsedBody = JSON.parse(body || "{}");
         }
         catch {
-            openaiRequest = {};
+            parsedBody = {};
         }
-        const stream = !!openaiRequest.stream;
-        // Read base_url_map from cache file (async)
-        let baseUrlMap;
-        try {
-            baseUrlMap = await loadRealUpstreamBaseUrlCache();
-        }
-        catch {
-            baseUrlMap = new Map();
-        }
-        const baseUrlMapObj = {};
-        for (const [id, u] of baseUrlMap) {
-            if (id && u?.trim())
-                baseUrlMapObj[id] = u.trim();
-        }
-        const rawProvider = req.headers["x-memoryx-real-provider"]?.trim() || "";
+        const stream = !!parsedBody.stream;
+        const isAnthropic = (url.includes("/messages") && !url.includes("/chat/completions"))
+            || !!req.headers["anthropic-version"];
+        const requestFormat = isAnthropic ? "anthropic" : "openai";
+        const baseUrlMapObj = this.getBaseUrlMap();
         const authHeader = req.headers["authorization"]?.trim() || "";
         const incomingApiKey = authHeader.startsWith("Bearer ")
             ? authHeader.slice(7).trim()
-            : authHeader;
-        // Build credentials: use incoming Authorization header as apiKey for the target provider
+            : req.headers["x-api-key"]?.trim() || authHeader;
+        const realProvider = urlProvider || this.defaultProvider.provider || "";
         const credentialsObj = {};
         for (const [id, creds] of this.credentials) {
             const realBaseUrl = baseUrlMapObj[id] || creds.baseUrl || "";
-            const apiKey = (id === rawProvider && incomingApiKey)
-                ? incomingApiKey
-                : (creds.apiKey || "");
-            credentialsObj[id] = { baseUrl: realBaseUrl, apiKey };
+            credentialsObj[id] = { baseUrl: realBaseUrl, apiKey: creds.apiKey || "" };
         }
-        const messages = openaiRequest.messages || [];
+        const messages = parsedBody.messages || [];
         const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
         const searchQuery = typeof lastUserMsg?.content === "string" ? lastUserMsg.content : "";
-        let memoryxApiKey = "";
-        let agentId = "";
-        try {
-            const sdk = await getSDK(pluginConfig);
-            const accountInfo = await sdk.getAccountInfo();
-            memoryxApiKey = accountInfo.apiKey || "";
-            agentId = accountInfo.agentId || "";
-        }
-        catch (_e) {
-            /* do not block */
-        }
         const proxyRequestBody = {
             base_url_map: baseUrlMapObj,
             credentials: credentialsObj,
             incoming_api_key: incomingApiKey || undefined,
-            body: openaiRequest,
-            request_headers: { "x-memoryx-real-provider": rawProvider },
+            body: parsedBody,
+            request_format: requestFormat,
+            request_headers: { "x-memoryx-real-provider": realProvider },
             search_query: searchQuery,
-            agent_id: agentId,
+            agent_id: this.cachedAgentId,
             available_models: this.availableProviders.map((p) => `${p.provider}/${p.model}`),
         };
-        const pathLog = (req.url || "/").split("?")[0] || "/";
-        log(`[Sidecar] ${reqId} ${method} ${pathLog} model=${openaiRequest.model ?? "-"} stream=${stream} → proxy ${proxyUrl}`, { console: true });
-        const FETCH_TIMEOUT = 75_000;
+        const pathLog = url.split("?")[0] || "/";
+        log(`[Sidecar] ${reqId} ${method} ${pathLog} fmt=${requestFormat} provider=${realProvider} model=${parsedBody.model ?? "-"} stream=${stream}`, { console: true });
+        const FETCH_TIMEOUT = stream ? 20_000 : 90_000;
+        const REASONING_CHUNK_TIMEOUT = 120_000;
         const CHUNK_TIMEOUT = 30_000;
         const fetchAbort = new AbortController();
         const fetchTimer = setTimeout(() => fetchAbort.abort(), FETCH_TIMEOUT);
+        req.on("close", () => {
+            if (!res.writableEnded) {
+                log(`[Sidecar] ${reqId} client closed connection, aborting upstream`, { console: true });
+                fetchAbort.abort();
+            }
+        });
         let proxyResponse = null;
         try {
             proxyResponse = await fetch(proxyUrl, {
                 method: "POST",
-                headers: { "Content-Type": "application/json", "X-API-Key": memoryxApiKey },
+                headers: { "Content-Type": "application/json", "X-API-Key": this.cachedMemoryxApiKey },
                 body: JSON.stringify(proxyRequestBody),
                 signal: fetchAbort.signal,
             });
@@ -180,34 +315,45 @@ export class SidecarServer {
             const status = proxyResponse?.status ?? 502;
             if (!detail)
                 detail = proxyResponse?.statusText || "MemoryX proxy unavailable";
-            log(`[Sidecar] ${reqId} ← ${status} fast-fail: ${detail.slice(0, 200)}`, { console: true });
+            log(`[Sidecar] ${reqId} proxy failed (${status}), trying upstream fallback…`, { console: true });
+            const fallbackOk = await this.fallbackToUpstream(url, res, reqId, parsedBody, requestFormat, incomingApiKey, req.headers["anthropic-version"] || "", realProvider);
+            if (fallbackOk)
+                return;
+            log(`[Sidecar] ${reqId} ← ${status} all routes failed: ${detail.slice(0, 200)}`, { console: true });
             res.writeHead(status, { "Content-Type": "application/json" });
             res.end(typeof detail === "string" && detail.startsWith("{") ? detail : JSON.stringify({ error: detail }));
             return;
         }
         const proxy = proxyResponse;
-        if (openaiRequest.stream && proxy.body) {
+        if (parsedBody.stream && proxy.body) {
             const reader = proxy.body.getReader();
-            const readWithTimeout = () => {
+            const readWithTimeout = (timeout) => {
                 let timer;
                 return Promise.race([
                     reader.read().then((r) => { if (timer)
                         clearTimeout(timer); return r; }),
                     new Promise((_, rej) => {
-                        timer = setTimeout(() => rej(new Error("chunk timeout")), CHUNK_TIMEOUT);
+                        timer = setTimeout(() => rej(new Error("chunk timeout")), timeout);
                     }),
                 ]);
             };
             let firstChunk;
             try {
-                firstChunk = await readWithTimeout();
+                firstChunk = await readWithTimeout(REASONING_CHUNK_TIMEOUT);
             }
             catch (firstErr) {
+                try {
+                    reader.cancel();
+                }
+                catch (_) { }
                 try {
                     reader.releaseLock();
                 }
                 catch (_) { }
-                log(`[Sidecar] ${reqId} err stream first chunk: ${firstErr?.message ?? "timeout"}`, { console: true });
+                log(`[Sidecar] ${reqId} stream first chunk failed, trying upstream fallback…`, { console: true });
+                const fallbackOk = await this.fallbackToUpstream(url, res, reqId, parsedBody, requestFormat, incomingApiKey, req.headers["anthropic-version"] || "", realProvider);
+                if (fallbackOk)
+                    return;
                 res.writeHead(502, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({ error: "MemoryX proxy stream failed" }));
                 return;
@@ -221,9 +367,10 @@ export class SidecarServer {
                 while (true) {
                     if (res.destroyed) {
                         log(`[Sidecar] ${reqId} client disconnected, aborting stream`, { console: true });
+                        fetchAbort.abort();
                         break;
                     }
-                    const { done, value } = await readWithTimeout();
+                    const { done, value } = await readWithTimeout(CHUNK_TIMEOUT);
                     if (done || !value)
                         break;
                     res.write(Buffer.from(value));
@@ -233,6 +380,10 @@ export class SidecarServer {
                 log(`[Sidecar] ${reqId} stream error: ${streamErr?.message ?? "unknown"}`, { console: true });
             }
             finally {
+                try {
+                    reader.cancel();
+                }
+                catch (_) { }
                 try {
                     reader.releaseLock();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t0ken.ai/memoryx-openclaw-plugin",
-  "version": "2.2.68",
+  "version": "2.2.70",
   "description": "MemoryX real-time memory capture and recall plugin for OpenClaw (powered by @t0ken.ai/memoryx-sdk)",
   "type": "module",
   "author": "MemoryX Team",