@t0ken.ai/memoryx-openclaw-plugin 2.2.69 → 2.2.71

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const PLUGIN_VERSION = "2.2.69";
+export declare const PLUGIN_VERSION = "2.2.71";
 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.69";
+export const PLUGIN_VERSION = "2.2.71";
 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,CAiCN"}
+{"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,CAqCN"}

package/dist/hooks.js

@@ -1,5 +1,5 @@
+import { log } from "./logger.js";
 export function registerHooks(api, plugin, wrapProvidersWithProxy, applySidecarRedirect, shouldApplyProxy) {
-    let proxyApplied = false;
     api.on("message_received", async (event) => {
         const { content } = event;
         if (content && plugin)
@@ -13,12 +13,19 @@ export function registerHooks(api, plugin, wrapProvidersWithProxy, applySidecarR
                 await plugin.onMessage("assistant", fullContent);
         }
     });
+    // Don't override the model — let OpenClaw resolve the real model normally.
+    // The provider's baseUrl is patched to the sidecar in service.start
+    // (runtimeConfigSnapshot), so requests route through:
+    //   sidecar → gateway → actual provider.
+    // Overriding to "auto" broke after config hot-reloads reset the baseUrl
+    // patch, causing "auto" to hit the real API (which rejects it as invalid).
+    api.on("before_model_resolve", async () => {
+        if (!shouldApplyProxy())
+            return undefined;
+        log(`[Proxy] before_model_resolve → passthrough (baseUrl redirect active)`);
+        return undefined;
+    });
     api.on("before_agent_start", async (_event) => {
-        if (!proxyApplied && shouldApplyProxy()) {
-            wrapProvidersWithProxy();
-            applySidecarRedirect({ quiet: true });
-            proxyApplied = 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,wBAsGE;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,25 +49,58 @@ export default {
         let sidecar = null;
         const getSidecarBase = () => sidecar ? `http://localhost:${sidecar.getPort()}` : sidecarBaseUrl;
         const { applySidecarRedirect, wrapProvidersWithProxy } = createProxyRedirect(api, getSidecarBase, realProviderHeader);
-        let cachedShouldProxy = null;
-        const shouldApplyProxy = () => {
-            if (cachedShouldProxy !== null)
-                return cachedShouldProxy;
-            const creds = extractProviderCredentials(api.config);
-            cachedShouldProxy = getDefaultModelAndProvider(creds, api.config).provider === "memoryx-gateway";
-            return cachedShouldProxy;
-        };
+        // 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,
@@ -77,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/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";
@@ -34,6 +35,12 @@ export declare class SidecarServer {
     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;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;YAIP,aAAa;IAsL3B,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";
@@ -95,8 +96,119 @@ export class SidecarServer {
     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 } = this.options;
         if (url === "/health" && method === "GET") {
@@ -104,8 +216,15 @@ export class SidecarServer {
             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);
@@ -116,43 +235,44 @@ 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;
+        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 rawProvider = req.headers["x-memoryx-real-provider"]?.trim() || "";
         const authHeader = req.headers["authorization"]?.trim() || "";
         const incomingApiKey = authHeader.startsWith("Bearer ")
             ? authHeader.slice(7).trim()
-            : authHeader;
+            : 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 : "";
         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: 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 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;
@@ -195,13 +315,17 @@ 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 = (timeout) => {
                 let timer;
@@ -226,7 +350,10 @@ export class SidecarServer {
                     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;

package/package.json

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