@xmemo/openclaw-memory 1.0.0

package/dist/src/client.js

@@ -0,0 +1,257 @@
+// Thin XMemo REST client. All memory operations are remote HTTP calls.
+// No local vector store or embedding model is required.
+function redactErrorMessage(message, apiKey) {
+    if (!apiKey) {
+        return message;
+    }
+    // Replace the literal key so it is never echoed in logs, CLI output, or tool results.
+    return message.replaceAll(apiKey, "***");
+}
+/** Structured HTTP error from the XMemo REST client. */
+export class XMemoClientError extends Error {
+    status;
+    pathname;
+    constructor(message, status, pathname) {
+        super(message);
+        this.status = status;
+        this.pathname = pathname;
+        this.name = "XMemoClientError";
+    }
+}
+export class XMemoClient {
+    baseUrl;
+    apiKey;
+    agentId;
+    agentInstanceId;
+    authMode;
+    constructor(baseUrl, apiKey, agentId, agentInstanceId, authMode = "api-key") {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+        this.agentInstanceId = agentInstanceId;
+        this.authMode = authMode;
+    }
+    isConfigured() {
+        return Boolean(this.apiKey);
+    }
+    headers() {
+        const headers = {
+            "Content-Type": "application/json",
+            "X-Memory-OS-Agent-ID": this.agentId,
+            "X-Memory-OS-Agent-Instance-ID": this.agentInstanceId,
+        };
+        if (this.authMode === "api-key" || this.authMode === "both") {
+            headers["X-API-Key"] = this.apiKey;
+        }
+        if (this.authMode === "bearer" || this.authMode === "both") {
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        return headers;
+    }
+    async request(pathname, options = {}) {
+        const url = `${this.baseUrl}${pathname}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                ...this.headers(),
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "unknown error");
+            const rawMessage = `XMemo ${pathname} failed (${response.status}): ${text}`;
+            throw new XMemoClientError(redactErrorMessage(rawMessage, this.apiKey), response.status, pathname);
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+            return (await response.json());
+        }
+        return {};
+    }
+    buildSearchParams(params) {
+        const search = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null || value === "") {
+                continue;
+            }
+            search.set(key, String(value));
+        }
+        const query = search.toString();
+        return query ? `?${query}` : "";
+    }
+    async remember(request, signal) {
+        return this.request("/v1/remember", {
+            method: "POST",
+            body: JSON.stringify(request),
+            signal,
+        });
+    }
+    async validateToken(signal) {
+        return this.request("/v1/auth/token/validate", {
+            method: "GET",
+            signal,
+        });
+    }
+    async recallContext(request, signal) {
+        return this.request("/v1/recall/context", {
+            method: "POST",
+            body: JSON.stringify(request),
+            signal,
+        });
+    }
+    async searchMemory(request, signal) {
+        const query = this.buildSearchParams({
+            query: request.query,
+            path: request.path,
+            bucket: request.bucket,
+            scope: request.scope,
+            team_id: request.team_id,
+            limit: request.max_items,
+            threshold: request.threshold,
+        });
+        return this.request(`/v1/memories/search${query}`, {
+            method: "GET",
+            signal,
+        });
+    }
+    async getMemory(id, signal) {
+        try {
+            return await this.request(`/v1/memories/${encodeURIComponent(id)}`, {
+                method: "GET",
+                signal,
+            });
+        }
+        catch (error) {
+            // Only fall back to search-by-id when the direct GET endpoint is missing or
+            // unavailable (404/405). Auth, timeout, and server errors should surface as-is.
+            if (!(error instanceof XMemoClientError) || (error.status !== 404 && error.status !== 405)) {
+                throw error;
+            }
+            const search = await this.searchMemory({
+                query: id,
+                bucket: undefined,
+                scope: null,
+                team_id: null,
+                max_items: 5,
+            }, signal);
+            const match = search.results.find((r) => r.id === id);
+            if (match) {
+                return {
+                    id: match.id,
+                    content: match.content,
+                    path: match.path,
+                    bucket: match.bucket,
+                    scope: match.scope,
+                    memory_type: match.memory_type,
+                };
+            }
+            throw error;
+        }
+    }
+    async updateMemory(id, request, signal) {
+        return this.request(`/v1/memories/${encodeURIComponent(id)}`, {
+            method: "PATCH",
+            body: JSON.stringify(request),
+            signal,
+        });
+    }
+    async forgetMemory(id, request, signal) {
+        return this.request(`/v1/memories/${encodeURIComponent(id)}/forget`, {
+            method: "POST",
+            body: JSON.stringify(request ?? {}),
+            signal,
+        });
+    }
+    async createReminder(request, signal) {
+        return this.request("/v1/reminders", {
+            method: "POST",
+            body: JSON.stringify(request),
+            signal,
+        });
+    }
+    async listReminders(params, signal) {
+        const query = this.buildSearchParams({
+            bucket: params?.bucket,
+            scope: params?.scope,
+            item_status: params?.item_status,
+        });
+        return this.request(`/v1/reminders${query}`, {
+            method: "GET",
+            signal,
+        });
+    }
+    async completeReminder(id, signal) {
+        return this.request(`/v1/reminders/${encodeURIComponent(id)}/complete`, {
+            method: "POST",
+            signal,
+        });
+    }
+    async recordEvent(request, signal) {
+        return this.request("/v1/timeline/events", {
+            method: "POST",
+            body: JSON.stringify(request),
+            signal,
+        });
+    }
+    async getTimeline(params, signal) {
+        const query = this.buildSearchParams({
+            bucket: params?.bucket,
+            scope: params?.scope,
+            limit: params?.limit,
+        });
+        return this.request(`/v1/timeline${query}`, {
+            method: "GET",
+            signal,
+        });
+    }
+    async saveRestartSnapshot(request, signal) {
+        return this.request("/v1/restart/snapshot", {
+            method: "POST",
+            body: JSON.stringify(request),
+            signal,
+        });
+    }
+    async restoreRestartSnapshot(request, signal) {
+        return this.request("/v1/restart/restore", {
+            method: "POST",
+            body: JSON.stringify(request ?? {}),
+            signal,
+        });
+    }
+    async getLedgerMonthlySummary(params, signal) {
+        const query = this.buildSearchParams({
+            month: params?.month,
+            year: params?.year,
+            currency: params?.currency,
+        });
+        return this.request(`/v1/me/ledger/monthly-summary${query}`, {
+            method: "GET",
+            signal,
+        });
+    }
+    async getAuditEvents(params, signal) {
+        const query = this.buildSearchParams({
+            action: params?.action,
+            target_id: params?.target_id,
+            limit: params?.limit,
+            since: params?.since,
+            until: params?.until,
+        });
+        return this.request(`/v1/audit/events${query}`, {
+            method: "GET",
+            signal,
+        });
+    }
+    async getAuditConsolidation(params, signal) {
+        const query = this.buildSearchParams({
+            action_type: params?.action_type,
+            limit: params?.limit,
+            since: params?.since,
+            until: params?.until,
+        });
+        return this.request(`/v1/audit/consolidation${query}`, {
+            method: "GET",
+            signal,
+        });
+    }
+}

package/dist/src/config.d.ts

@@ -0,0 +1,30 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
+export type XMemoAuthMode = "api-key" | "bearer" | "both";
+export type XMemoMemoryConfig = {
+    baseUrl: string;
+    apiKey: string | undefined;
+    bucket: string;
+    scope: string | undefined;
+    teamId: string | undefined;
+    agentId: string;
+    agentInstanceId: string;
+    authMode: XMemoAuthMode;
+    autoCapture: boolean;
+    captureMaxChars: number;
+    customTriggers: string[] | undefined;
+    recallMaxChars: number;
+    recallMaxItems: number;
+    recallMaxTokens: number;
+};
+export declare const DEFAULT_BASE_URL = "https://xmemo.dev";
+export declare const DEFAULT_BUCKET = "openclaw";
+export declare const DEFAULT_AGENT_ID = "openclaw";
+export declare const DEFAULT_AUTH_MODE: XMemoAuthMode;
+export declare const API_KEY_ENV_VARS: string[];
+export declare const BASE_URL_ENV_VARS: string[];
+export declare const AGENT_ID_ENV_VARS: string[];
+export declare const AGENT_INSTANCE_ID_ENV_VARS: string[];
+export declare function resolveXMemoBaseUrl(env?: NodeJS.ProcessEnv): string;
+export declare function resolveXMemoAgentId(env?: NodeJS.ProcessEnv): string;
+export declare function resolveXMemoAgentInstanceId(env?: NodeJS.ProcessEnv): string;
+export declare function resolveXMemoMemoryConfig(cfg: OpenClawConfig, env?: NodeJS.ProcessEnv): XMemoMemoryConfig;

package/dist/src/config.js

@@ -0,0 +1,108 @@
+import { randomUUID } from "node:crypto";
+import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { coerceSecretRef, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
+export const DEFAULT_BASE_URL = "https://xmemo.dev";
+export const DEFAULT_BUCKET = "openclaw";
+export const DEFAULT_AGENT_ID = "openclaw";
+export const DEFAULT_AUTH_MODE = "api-key";
+export const API_KEY_ENV_VARS = ["XMEMO_KEY", "MEMORY_OS_API_KEY", "MEMORY_OS_MCP_TOKEN"];
+export const BASE_URL_ENV_VARS = [
+    "XMEMO_BASE_URL",
+    "XMEMO_URL",
+    "MEMORY_OS_BASE_URL",
+    "MEMORY_OS_URL",
+];
+export const AGENT_ID_ENV_VARS = ["XMEMO_AGENT_ID", "MEMORY_OS_AGENT_ID"];
+export const AGENT_INSTANCE_ID_ENV_VARS = [
+    "XMEMO_AGENT_INSTANCE_ID",
+    "MEMORY_OS_AGENT_INSTANCE_ID",
+];
+function firstEnv(env, keys) {
+    for (const key of keys) {
+        const value = env[key];
+        if (value !== undefined && value !== "") {
+            return value;
+        }
+    }
+    return undefined;
+}
+function normalizeBaseUrl(input) {
+    if (!input) {
+        return DEFAULT_BASE_URL;
+    }
+    let url = input.trim();
+    if (url.endsWith("/")) {
+        url = url.slice(0, -1);
+    }
+    return url;
+}
+function normalizeAuthMode(input) {
+    if (input === "api-key" || input === "bearer" || input === "both") {
+        return input;
+    }
+    return DEFAULT_AUTH_MODE;
+}
+function resolveEnvSecretRef(value, env) {
+    const ref = coerceSecretRef(value);
+    if (ref && ref.source === "env") {
+        return firstEnv(env, [ref.id]);
+    }
+    return undefined;
+}
+function resolveApiKey(pluginConfig, env) {
+    // Prefer the modern `apiKey` config key; fall back to deprecated `token`.
+    const fromConfigString = normalizeSecretInputString(pluginConfig.apiKey) ??
+        normalizeSecretInputString(pluginConfig.token);
+    if (fromConfigString) {
+        return fromConfigString;
+    }
+    // Support canonical env SecretRef: { source: "env", provider: "default", id: "XMEMO_KEY" }.
+    // We only resolve env refs here; file/exec must not be silently ignored or falsely promised.
+    const fromEnvRef = resolveEnvSecretRef(pluginConfig.apiKey, env) ??
+        resolveEnvSecretRef(pluginConfig.token, env);
+    if (fromEnvRef) {
+        return fromEnvRef;
+    }
+    // Final fallback to well-known env vars.
+    return firstEnv(env, API_KEY_ENV_VARS);
+}
+export function resolveXMemoBaseUrl(env = process.env) {
+    return normalizeBaseUrl(firstEnv(env, BASE_URL_ENV_VARS));
+}
+export function resolveXMemoAgentId(env = process.env) {
+    return firstEnv(env, AGENT_ID_ENV_VARS) ?? DEFAULT_AGENT_ID;
+}
+let moduleInstanceId;
+export function resolveXMemoAgentInstanceId(env = process.env) {
+    // Prefer explicit env. OpenClaw plugins should not silently write JSON sidecars;
+    // if no stable id is configured, cache a single process-local id so repeated
+    // config resolves stay consistent across runtime/tools/cli/hooks.
+    const fromEnv = firstEnv(env, AGENT_INSTANCE_ID_ENV_VARS);
+    if (fromEnv) {
+        return fromEnv;
+    }
+    moduleInstanceId ??= `xmemo-${randomUUID()}`;
+    return moduleInstanceId;
+}
+export function resolveXMemoMemoryConfig(cfg, env = process.env) {
+    // Plugin config lives at plugins.entries["xmemo-memory"].config in resolved OpenClaw config.
+    const pluginConfig = resolvePluginConfigObject(cfg, "xmemo-memory") ?? {};
+    return {
+        baseUrl: normalizeBaseUrl(pluginConfig.baseUrl ?? resolveXMemoBaseUrl(env)),
+        apiKey: resolveApiKey(pluginConfig, env),
+        bucket: pluginConfig.bucket ?? DEFAULT_BUCKET,
+        scope: pluginConfig.scope ?? undefined,
+        teamId: pluginConfig.teamId ?? undefined,
+        agentId: pluginConfig.agentId ?? resolveXMemoAgentId(env),
+        agentInstanceId: resolveXMemoAgentInstanceId(env),
+        authMode: normalizeAuthMode(pluginConfig.authMode),
+        autoCapture: pluginConfig.autoCapture ?? false,
+        captureMaxChars: pluginConfig.captureMaxChars ?? 500,
+        customTriggers: Array.isArray(pluginConfig.customTriggers)
+            ? pluginConfig.customTriggers.filter((s) => typeof s === "string" && s.length > 0)
+            : undefined,
+        recallMaxChars: pluginConfig.recallMaxChars ?? 1000,
+        recallMaxItems: pluginConfig.recallMaxItems ?? 8,
+        recallMaxTokens: pluginConfig.recallMaxTokens ?? 1500,
+    };
+}

package/dist/src/memory-text.d.ts

@@ -0,0 +1 @@
+export declare function escapeMemoryForPrompt(text: string): string;

package/dist/src/memory-text.js

@@ -0,0 +1,12 @@
+// Pure text helpers for memory tool output.
+//
+// Kept separate from tools.ts so tests do not pull in plugin-sdk imports that
+// require a full dependency tree (e.g. undici via proxyline).
+export function escapeMemoryForPrompt(text) {
+    return text
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}

package/dist/src/prompt-section.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryPromptSectionBuilder } from "openclaw/plugin-sdk/memory-core-host-runtime-core";
+export declare const buildXMemoPromptSection: MemoryPromptSectionBuilder;

package/dist/src/prompt-section.js

@@ -0,0 +1,31 @@
+export const buildXMemoPromptSection = ({ availableTools }) => {
+    const lines = [];
+    lines.push("## XMemo for OpenClaw");
+    lines.push("XMemo is enabled as the active long-term memory backend. Relevant project context, decisions, and prior fixes may be injected automatically or retrieved with the memory tools.");
+    if (availableTools.has("memory_search")) {
+        lines.push("- Use `memory_search` to recall relevant memories before answering questions about prior work.");
+    }
+    if (availableTools.has("memory_store")) {
+        lines.push("- Use `memory_store` to persist durable decisions, conventions, bug fixes, and high-signal context.");
+    }
+    if (availableTools.has("memory_forget")) {
+        lines.push("- Use `memory_forget` to delete a memory by its path/id.");
+    }
+    if (availableTools.has("xmemo_memory_list")) {
+        lines.push("- Use `xmemo_memory_list` to browse recent memories stored in XMemo.");
+    }
+    if (availableTools.has("xmemo_memory_update")) {
+        lines.push("- Use `xmemo_memory_update` to edit an existing memory.");
+    }
+    if (availableTools.has("xmemo_todo_create")) {
+        lines.push("- Use `xmemo_todo_create` to track actionable follow-ups in XMemo.");
+    }
+    if (availableTools.has("xmemo_record_event")) {
+        lines.push("- Use `xmemo_record_event` to record lightweight timeline milestones or decisions.");
+    }
+    if (availableTools.has("xmemo_restart_snapshot_save")) {
+        lines.push("- Use `xmemo_restart_snapshot_save` to checkpoint session state for later recovery.");
+    }
+    lines.push("- Never store secrets, API keys, tokens, credentials, or sensitive customer data in XMemo.");
+    return lines;
+};

package/dist/src/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryPluginRuntime, OpenClawPluginApi } from "openclaw/plugin-sdk/memory-core-host-runtime-core";
+export declare function createXMemoMemoryRuntime(_api: OpenClawPluginApi): MemoryPluginRuntime;

package/dist/src/runtime.js

@@ -0,0 +1,41 @@
+import { XMemoClient } from "./client.js";
+import { resolveXMemoMemoryConfig } from "./config.js";
+import { XMemoSearchManager } from "./search-manager.js";
+export function createXMemoMemoryRuntime(_api) {
+    return {
+        async getMemorySearchManager(params) {
+            const cfg = resolveXMemoMemoryConfig(params.cfg);
+            if (!cfg.apiKey) {
+                return {
+                    manager: null,
+                    error: "XMemo is not configured. Set XMEMO_KEY or configure the plugin apiKey.",
+                };
+            }
+            try {
+                const client = new XMemoClient(cfg.baseUrl, cfg.apiKey ?? "", cfg.agentId, cfg.agentInstanceId, cfg.authMode);
+                const manager = new XMemoSearchManager(client, cfg);
+                return { manager };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { manager: null, error: `XMemo memory runtime failed: ${message}` };
+            }
+        },
+        resolveMemoryBackendConfig(params) {
+            const cfg = resolveXMemoMemoryConfig(params.cfg);
+            void cfg;
+            // OpenClaw core currently only recognizes "builtin" and "qmd" memory backends.
+            // XMemo is a custom remote memory provider; report it as builtin so the slot
+            // contract stays satisfied without adding a core type patch.
+            return {
+                backend: "builtin",
+            };
+        },
+        async closeMemorySearchManager() {
+            // Stateless HTTP client; nothing to close.
+        },
+        async closeAllMemorySearchManagers() {
+            // Stateless HTTP client; nothing to close.
+        },
+    };
+}

package/dist/src/search-manager.d.ts

@@ -0,0 +1,31 @@
+import type { MemoryEmbeddingProbeResult, MemoryProviderStatus, MemoryReadResult, MemorySearchManager, MemorySearchResult } from "openclaw/plugin-sdk/memory-core-host-engine-storage";
+import type { XMemoClient } from "./client.js";
+import type { XMemoMemoryConfig } from "./config.js";
+export declare class XMemoSearchManager implements MemorySearchManager {
+    private readonly client;
+    private readonly config;
+    private connected;
+    private lastError;
+    private lastProbeAtMs;
+    constructor(client: XMemoClient, config: XMemoMemoryConfig);
+    search(query: string, opts?: {
+        maxResults?: number;
+        minScore?: number;
+        sessionKey?: string;
+        signal?: AbortSignal;
+        sources?: Array<"memory" | "sessions">;
+    }): Promise<MemorySearchResult[]>;
+    readFile({ relPath, from, lines, }: {
+        relPath: string;
+        from?: number;
+        lines?: number;
+    }, signal?: AbortSignal): Promise<MemoryReadResult>;
+    probeConnectivity(signal?: AbortSignal): Promise<boolean>;
+    status(): MemoryProviderStatus;
+    sync(): Promise<void>;
+    getCachedEmbeddingAvailability(): MemoryEmbeddingProbeResult | null;
+    probeEmbeddingAvailability(): Promise<MemoryEmbeddingProbeResult>;
+    probeVectorStoreAvailability(): Promise<boolean>;
+    probeVectorAvailability(): Promise<boolean>;
+    close(): Promise<void>;
+}

package/dist/src/search-manager.js

@@ -0,0 +1,153 @@
+function memoryIdFromPath(relPath) {
+    // Accept paths like "bucket/id", "bucket/scope/id", or just "id".
+    // XMemo ids may be UUIDs or arbitrary strings; take the final non-empty segment.
+    const parts = relPath.split("/").filter(Boolean);
+    const last = parts[parts.length - 1];
+    return last;
+}
+export class XMemoSearchManager {
+    client;
+    config;
+    connected;
+    lastError;
+    lastProbeAtMs;
+    constructor(client, config) {
+        this.client = client;
+        this.config = config;
+    }
+    async search(query, opts = {}) {
+        if (!this.client.isConfigured()) {
+            return [];
+        }
+        const response = await this.client.recallContext({
+            query: query.slice(0, this.config.recallMaxChars),
+            bucket: this.config.bucket,
+            scope: this.config.scope ?? null,
+            team_id: this.config.teamId ?? null,
+            max_items: opts.maxResults ?? this.config.recallMaxItems,
+            max_tokens: this.config.recallMaxTokens,
+            prefer_working: true,
+        }, opts.signal);
+        this.connected = true;
+        this.lastError = undefined;
+        return (response.items ?? []).map((item, index) => {
+            const score = item.score ?? Math.max(0.5, 0.95 - index * 0.05);
+            // Encode the XMemo id into the path so readFile/forget tools can recover it.
+            const path = item.path ? `${item.path}/${item.id}` : `${this.config.bucket}/${item.id}`;
+            return {
+                path,
+                startLine: 1,
+                endLine: 1,
+                score,
+                snippet: item.content ?? item.snippet ?? "",
+                source: "memory",
+            };
+        });
+    }
+    async readFile({ relPath, from, lines, }, signal) {
+        if (!this.client.isConfigured()) {
+            return { text: "", path: relPath, truncated: false, from: 1, lines: 0 };
+        }
+        const id = memoryIdFromPath(relPath);
+        let text;
+        let path = relPath;
+        if (id) {
+            const memory = await this.client.getMemory(id, signal);
+            text = memory.content;
+            path = memory.path ?? relPath;
+        }
+        else {
+            const response = await this.client.searchMemory({
+                query: relPath,
+                path: relPath,
+                bucket: this.config.bucket,
+                scope: this.config.scope ?? null,
+                team_id: this.config.teamId ?? null,
+                max_items: 10,
+            }, signal);
+            text = response.results.map((r) => r.content).join("\n\n---\n\n");
+        }
+        this.connected = true;
+        this.lastError = undefined;
+        const allLines = text.split("\n");
+        const startFrom = Math.max(1, from ?? 1);
+        const lineCount = lines ?? allLines.length;
+        const sliced = allLines.slice(startFrom - 1, startFrom - 1 + lineCount);
+        const resultText = sliced.join("\n");
+        return {
+            text: resultText,
+            path,
+            truncated: sliced.length < allLines.length,
+            from: startFrom,
+            lines: sliced.length,
+        };
+    }
+    async probeConnectivity(signal) {
+        if (!this.client.isConfigured()) {
+            this.connected = false;
+            this.lastError = "not configured";
+            return false;
+        }
+        try {
+            await this.client.validateToken(signal);
+            this.connected = true;
+            this.lastError = undefined;
+            this.lastProbeAtMs = Date.now();
+            return true;
+        }
+        catch (error) {
+            this.connected = false;
+            this.lastError = error instanceof Error ? error.message : String(error);
+            this.lastProbeAtMs = Date.now();
+            return false;
+        }
+    }
+    status() {
+        return {
+            backend: "builtin",
+            provider: "xmemo-memory",
+            custom: {
+                baseUrl: this.config.baseUrl,
+                bucket: this.config.bucket,
+                scope: this.config.scope,
+                configured: this.client.isConfigured(),
+                connected: this.connected ?? false,
+                ...(this.lastError ? { lastError: this.lastError } : {}),
+            },
+        };
+    }
+    async sync() {
+        // XMemo is remote; there is no local index to sync.
+    }
+    getCachedEmbeddingAvailability() {
+        if (this.connected === undefined) {
+            return null;
+        }
+        return {
+            ok: this.connected,
+            error: this.lastError,
+            checked: this.lastProbeAtMs !== undefined,
+            cached: true,
+            checkedAtMs: this.lastProbeAtMs,
+        };
+    }
+    async probeEmbeddingAvailability() {
+        const ok = await this.probeConnectivity();
+        return {
+            ok,
+            error: this.lastError,
+            checked: true,
+            cached: false,
+            checkedAtMs: this.lastProbeAtMs,
+        };
+    }
+    async probeVectorStoreAvailability() {
+        return await this.probeConnectivity();
+    }
+    async probeVectorAvailability() {
+        return await this.probeConnectivity();
+    }
+    async close() {
+        // HTTP client is stateless.
+    }
+}

package/dist/src/tools.d.ts

@@ -0,0 +1,2 @@
+import { type OpenClawPluginApi } from "openclaw/plugin-sdk/memory-core-host-runtime-core";
+export declare function registerXMemoTools(api: OpenClawPluginApi): void;