@t0ken.ai/memoryx-openclaw-plugin 2.2.60 → 2.2.61

package/dist/proxy-redirect.js

@@ -0,0 +1,76 @@
+/**
+ * Redirect provider baseUrl to Sidecar and wrap config so reads always resolve to Sidecar.
+ */
+import { extractProviderCredentials } from "./proxy-credentials.js";
+import { log } from "./logger.js";
+export function createProxyRedirect(api, getSidecarBase, realProviderHeader) {
+    const applySidecarRedirect = (opts) => {
+        const sidecarBase = getSidecarBase();
+        const creds = extractProviderCredentials(api.config);
+        if (!api.config?.models?.providers || creds.size === 0) {
+            if (!opts?.quiet)
+                log(`[Proxy] No providers to redirect (providers exists: ${!!api.config?.models?.providers}, creds: ${creds.size})`, { console: true });
+            return;
+        }
+        const providers = api.config.models.providers;
+        let n = 0;
+        for (const providerId of creds.keys()) {
+            if (providerId === "memoryx-proxy")
+                continue;
+            const p = providers[providerId];
+            if (!p || typeof p !== "object")
+                continue;
+            p.baseUrl = sidecarBase;
+            if (!p.headers)
+                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). Use your configured model (e.g. zai/glm-5).`);
+            log(`[Proxy] Sidecar redirect applied for ${n} provider(s)`, { console: true });
+        }
+        if (n > 0) {
+            for (const providerId of creds.keys()) {
+                if (providerId === "memoryx-proxy")
+                    continue;
+                const p = providers[providerId];
+                const readBack = (p && typeof p === "object" && p.baseUrl) ? p.baseUrl : "<missing>";
+                const isSidecar = readBack === sidecarBase;
+                log(`[Proxy] Readback ${providerId}.baseUrl = ${readBack} ${isSidecar ? "(Sidecar ✓)" : "(NOT Sidecar!)"}`);
+            }
+        }
+    };
+    const wrapProvidersWithProxy = () => {
+        if (!api.config?.models?.providers || typeof api.config.models.providers !== "object")
+            return;
+        const creds = extractProviderCredentials(api.config);
+        if (creds.size === 0)
+            return;
+        const raw = api.config.models.providers;
+        const handler = {
+            get(target, prop) {
+                const val = target[prop];
+                if (val && typeof val === "object" && creds.has(prop) && prop !== "memoryx-proxy") {
+                    return new Proxy(val, {
+                        get(t, k) {
+                            if (k === "baseUrl")
+                                return getSidecarBase();
+                            if (k === "headers") {
+                                const h = t.headers && typeof t.headers === "object" ? { ...t.headers } : {};
+                                h[realProviderHeader] = prop;
+                                return h;
+                            }
+                            return t[k];
+                        },
+                    });
+                }
+                return val;
+            },
+        };
+        api.config.models.providers = new Proxy(raw, handler);
+        log(`[Proxy] Wrapped models.providers in Proxy so baseUrl/headers always resolve to Sidecar`);
+    };
+    return { applySidecarRedirect, wrapProvidersWithProxy };
+}

package/dist/sidecar.d.ts

@@ -0,0 +1,40 @@
+import type { ProviderCredentials } from "./types.js";
+import type { PluginConfig } from "./types.js";
+export type GetSDK = (config?: PluginConfig) => Promise<any>;
+export interface SidecarOptions {
+    proxyUrl: string;
+    getSDK: GetSDK;
+    pluginConfig?: PluginConfig;
+    onStarted?: (logFile: string) => void;
+}
+export declare class SidecarServer {
+    private server;
+    private credentials;
+    private defaultProvider;
+    private availableProviders;
+    private options;
+    constructor(credentials: Map<string, ProviderCredentials>, defaultProvider: {
+        model: string;
+        provider: string;
+    }, availableProviders: Array<{
+        provider: string;
+        model: string;
+    }>, options: SidecarOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getPort(): number;
+    /**
+     * 用持久化/合并后的真实上游 baseUrl 映射更新 credentials，避免重启后配置已是 localhost 时仍用旧缓存。
+     */
+    updateRealUpstreamBaseUrlMap(map: Map<string, string>): void;
+    /** For logging: redact headers (Authorization, x-api-key, etc. show as ***) */
+    private redactHeaders;
+    /** Build forward request headers from apiKey in OpenClaw style; does not overwrite user config */
+    private buildForwardHeaders;
+    /** 1) Exclude memoryx-proxy, use real provider config; 2) On proxy error fall back to direct; on direct error return error to caller. */
+    private handleRequest;
+    private directRequest;
+    private writeResponse;
+    private readBody;
+}
+//# sourceMappingURL=sidecar.d.ts.map

package/dist/sidecar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sidecar.d.ts","sourceRoot":"","sources":["../src/sidecar.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/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;IAwBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAa3B,OAAO,IAAI,MAAM;IAMjB;;OAEG;IACH,4BAA4B,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAU5D,+EAA+E;IAC/E,OAAO,CAAC,aAAa;IAUrB,kGAAkG;IAClG,OAAO,CAAC,mBAAmB;IAa3B,yIAAyI;YAC3H,aAAa;YAoLb,aAAa;YAwBb,aAAa;IAqB3B,OAAO,CAAC,QAAQ;CAQnB"}

package/dist/sidecar.js

@@ -0,0 +1,322 @@
+/**
+ * Local HTTP Sidecar: receives OpenClaw requests, forwards to MemoryX proxy or falls back to direct provider.
+ */
+import * as http from "http";
+import { SIDECAR_PORT } from "./constants.js";
+import { log, LOG_FILE } from "./logger.js";
+export class SidecarServer {
+    server = null;
+    credentials;
+    defaultProvider;
+    availableProviders;
+    options;
+    constructor(credentials, defaultProvider, availableProviders, options) {
+        this.credentials = credentials;
+        this.defaultProvider = defaultProvider;
+        this.availableProviders = availableProviders;
+        this.options = options;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            const server = http.createServer(async (req, res) => {
+                await this.handleRequest(req, res);
+            });
+            server.on("error", (err) => {
+                if (err.code === "EADDRINUSE") {
+                    log(`[Sidecar] Port ${SIDECAR_PORT} is in use. Free it or stop the other process using it.`, { console: true });
+                    reject(new Error(`Sidecar port ${SIDECAR_PORT} is in use. Ensure openclaw.json uses http://localhost:${SIDECAR_PORT} and no other service is bound to that port.`));
+                }
+                else {
+                    reject(err);
+                }
+            });
+            server.listen(SIDECAR_PORT, () => {
+                this.server = server;
+                const baseUrl = `http://localhost:${SIDECAR_PORT}`;
+                log(`[Sidecar] Started on port ${SIDECAR_PORT}. OpenClaw base URL: ${baseUrl} (proxy: ${this.options.proxyUrl})`);
+                log(`[Sidecar] Log file: ${LOG_FILE}`, { console: true });
+                this.options.onStarted?.(LOG_FILE);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    log(`[Sidecar] Stopped`);
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    getPort() {
+        return this.server?.address() && typeof this.server.address() === "object"
+            ? this.server.address().port
+            : SIDECAR_PORT;
+    }
+    /**
+     * 用持久化/合并后的真实上游 baseUrl 映射更新 credentials，避免重启后配置已是 localhost 时仍用旧缓存。
+     */
+    updateRealUpstreamBaseUrlMap(map) {
+        for (const [id, baseUrl] of map) {
+            const creds = this.credentials.get(id);
+            if (creds && baseUrl) {
+                this.credentials.set(id, { ...creds, baseUrl });
+            }
+        }
+        log(`[Sidecar] Updated real upstream baseUrl map for ${map.size} provider(s)`);
+    }
+    /** For logging: redact headers (Authorization, x-api-key, etc. show as ***) */
+    redactHeaders(h) {
+        const out = {};
+        const secretKeys = ["authorization", "x-api-key", "cookie"];
+        for (const [k, v] of Object.entries(h)) {
+            const lower = k.toLowerCase();
+            out[k] = secretKeys.some((s) => lower === s || lower.includes("api-key")) ? "***" : v;
+        }
+        return out;
+    }
+    /** Build forward request headers from apiKey in OpenClaw style; does not overwrite user config */
+    buildForwardHeaders(provider, apiKey) {
+        const h = { "Content-Type": "application/json" };
+        const key = (apiKey || "").trim();
+        if (!key)
+            return h;
+        if (provider === "anthropic") {
+            h["x-api-key"] = key;
+            h["anthropic-version"] = "2023-06-01";
+        }
+        else {
+            h["Authorization"] = `Bearer ${key}`;
+        }
+        return h;
+    }
+    /** 1) Exclude memoryx-proxy, use real provider config; 2) On proxy error fall back to direct; on direct error return error to caller. */
+    async handleRequest(req, res) {
+        const url = req.url || "/";
+        const method = req.method?.toUpperCase();
+        const { proxyUrl, getSDK, pluginConfig } = this.options;
+        if (url === "/health" && method === "GET") {
+            res.writeHead(200, { "Content-Type": "text/plain" });
+            res.end("OK");
+            return;
+        }
+        const reqId = `req-${Date.now()}`;
+        log(`[Sidecar] ${reqId} Incoming ${method} ${url}`);
+        let body;
+        try {
+            body = await this.readBody(req);
+        }
+        catch (e) {
+            res.writeHead(502, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: e?.message || "Read body failed" }));
+            return;
+        }
+        let openaiRequest;
+        try {
+            openaiRequest = JSON.parse(body || "{}");
+        }
+        catch {
+            openaiRequest = {};
+        }
+        const rawProvider = req.headers["x-memoryx-real-provider"]?.trim() || "";
+        const modelStr = openaiRequest.model || "";
+        let provider = rawProvider || (modelStr.includes("/") ? modelStr.split("/")[0] : "") || "";
+        if (provider === "memoryx-proxy") {
+            const real = this.availableProviders.find((p) => p.provider !== "memoryx-proxy");
+            provider = real ? real.provider : "";
+        }
+        if (!provider || !this.credentials.has(provider)) {
+            provider = this.defaultProvider?.provider || "";
+        }
+        if (!provider || !this.credentials.has(provider)) {
+            for (const [id] of this.credentials) {
+                if (id !== "memoryx-proxy") {
+                    provider = id;
+                    break;
+                }
+            }
+        }
+        let creds = provider ? this.credentials.get(provider) : undefined;
+        if (!creds?.baseUrl?.trim() || !(creds.apiKey ?? "").trim()) {
+            for (const [id, c] of this.credentials) {
+                if (id !== "memoryx-proxy" && (c.baseUrl || "").trim() && (c.apiKey ?? "").trim()) {
+                    provider = id;
+                    creds = c;
+                    break;
+                }
+            }
+        }
+        const baseUrl = (creds?.baseUrl || "").trim();
+        const apiKey = (creds?.apiKey ?? "").trim();
+        if (!baseUrl || !apiKey) {
+            res.writeHead(502, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "No upstream" }));
+            return;
+        }
+        const base = baseUrl.replace(/\/$/, "");
+        const pathFromOpenClaw = (url.split("?")[0] || "/").trim() || "/";
+        const targetUrl = base + (pathFromOpenClaw.startsWith("/") ? pathFromOpenClaw : "/" + pathFromOpenClaw);
+        const currentModel = openaiRequest.model || "";
+        if (!currentModel || currentModel === "auto" || currentModel.startsWith("memoryx-proxy/")) {
+            const firstId = creds?.models?.[0]?.id || creds?.models?.[0]?.name;
+            if (firstId)
+                openaiRequest.model = firstId;
+        }
+        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; proxy will fail and then fall back to direct */
+        }
+        const headers = this.buildForwardHeaders(provider, apiKey);
+        const messages = openaiRequest.messages || [];
+        const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+        const searchQuery = typeof lastUserMsg?.content === "string" ? lastUserMsg.content : "";
+        const proxyRequestBody = {
+            targetUrl,
+            headers,
+            body: openaiRequest,
+            searchQuery,
+            agent_id: agentId,
+            available_models: this.availableProviders.map((p) => `${p.provider}/${p.model}`),
+        };
+        const proxyReqHeaders = { "Content-Type": "application/json", "X-API-Key": memoryxApiKey ? "***" : "" };
+        log(`[Sidecar] ${reqId} → Proxy POST ${proxyUrl}`);
+        log(`[Sidecar] ${reqId} Proxy request headers: ${JSON.stringify(proxyReqHeaders)}`);
+        log(`[Sidecar] ${reqId} Proxy body: targetUrl=${targetUrl} model=${openaiRequest.model} stream=${!!openaiRequest.stream} searchQuery.length=${searchQuery.length} agent_id=${agentId || "(empty)"}`);
+        log(`[Sidecar] ${reqId} Forward headers (to upstream): ${JSON.stringify(this.redactHeaders(headers))}`);
+        let proxyResponse = null;
+        try {
+            proxyResponse = await fetch(proxyUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "X-API-Key": memoryxApiKey },
+                body: JSON.stringify(proxyRequestBody),
+            });
+        }
+        catch (e) {
+            proxyResponse = null;
+            log(`[Sidecar] ${reqId} Proxy fetch error: ${e?.message ?? String(e)}`, { console: true });
+        }
+        if (proxyResponse) {
+            log(`[Sidecar] ${reqId} Proxy response status=${proxyResponse.status} ${proxyResponse.statusText}`);
+        }
+        const proxyFailed = !proxyResponse || proxyResponse.status >= 500;
+        if (proxyFailed) {
+            log(`[Sidecar] ${reqId} Proxy failed, fallback to direct POST ${targetUrl}`, { console: true });
+            const directResponse = await this.directRequest(reqId, targetUrl, headers, openaiRequest);
+            this.writeResponse(res, directResponse);
+            return;
+        }
+        const proxy = proxyResponse;
+        if (openaiRequest.stream && proxy.body) {
+            const reader = proxy.body.getReader();
+            let firstChunk;
+            try {
+                firstChunk = await Promise.race([
+                    reader.read(),
+                    new Promise((_, rej) => setTimeout(() => rej(new Error("First chunk timeout")), 15000)),
+                ]);
+            }
+            catch (firstErr) {
+                reader.releaseLock();
+                log(`[Sidecar] ${reqId} Proxy stream first chunk failed: ${firstErr?.message ?? "timeout"}, fallback to direct ${targetUrl}`, { console: true });
+                const directResponse = await this.directRequest(reqId, targetUrl, headers, openaiRequest);
+                if (directResponse)
+                    log(`[Sidecar] ${reqId} Direct response status=${directResponse.status}`);
+                this.writeResponse(res, directResponse);
+                return;
+            }
+            res.writeHead(proxy.status, {
+                "Content-Type": proxy.headers.get("content-type") || "application/json",
+            });
+            try {
+                if (!firstChunk.done && firstChunk.value)
+                    res.write(Buffer.from(firstChunk.value));
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    res.write(Buffer.from(value));
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            res.end();
+            log(`[Sidecar] ${reqId} Proxy stream done, status=${proxy.status}`);
+            return;
+        }
+        if (!proxy.body) {
+            res.writeHead(proxy.status, {
+                "Content-Type": proxy.headers.get("content-type") || "application/json",
+            });
+            res.end();
+            return;
+        }
+        const text = await proxy.text();
+        log(`[Sidecar] ${reqId} Proxy done, status=${proxy.status} body.length=${text.length}`);
+        res.writeHead(proxy.status, {
+            "Content-Type": proxy.headers.get("content-type") || "application/json",
+        });
+        res.end(text);
+    }
+    async directRequest(reqId, targetUrl, headers, openaiRequest) {
+        log(`[Sidecar] ${reqId} Direct POST ${targetUrl} headers=${JSON.stringify(this.redactHeaders(headers))} model=${openaiRequest?.model} stream=${!!openaiRequest?.stream}`);
+        try {
+            const resp = await fetch(targetUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(openaiRequest),
+            });
+            log(`[Sidecar] ${reqId} Direct response status=${resp.status} ${resp.statusText}`);
+            return resp;
+        }
+        catch (e) {
+            log(`[Sidecar] ${reqId} Direct fetch error: ${e?.message ?? String(e)}`, { console: true });
+            return new Response(JSON.stringify({ error: e?.message || "Direct request failed" }), {
+                status: 502,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+    }
+    async writeResponse(res, directResponse) {
+        const contentType = directResponse.headers.get("content-type") || "application/json";
+        res.writeHead(directResponse.status, { "Content-Type": contentType });
+        const body = directResponse.body;
+        if (!body) {
+            res.end();
+            return;
+        }
+        const reader = body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                res.write(Buffer.from(value));
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        res.end();
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on("data", (chunk) => chunks.push(chunk));
+            req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+            req.on("error", reject);
+        });
+    }
+}

package/dist/tools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MemoryX OpenClaw tools: recall, forget, store, list, account_info, queue_status.
+ */
+import type { MemoryXPlugin } from "./plugin-core.js";
+export declare function registerTools(api: any, plugin: MemoryXPlugin): void;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAkXnE"}