@vectorize-io/hindsight-openclaw 0.4.4

package/README.md

@@ -0,0 +1,35 @@
+# Hindsight Memory Plugin for OpenClaw
+
+Biomimetic long-term memory for [OpenClaw](https://openclaw.ai) using [Hindsight](https://vectorize.io/hindsight). Automatically captures conversations and intelligently recalls relevant context.
+
+## Quick Start
+
+```bash
+# 1. Configure your LLM provider
+export OPENAI_API_KEY="sk-your-key"
+clawdbot config set 'agents.defaults.models."openai/gpt-4o-mini"' '{}'
+
+# 2. Install and enable the plugin
+clawdbot plugins install @vectorize-io/hindsight-openclaw
+
+# 3. Start OpenClaw
+clawdbot gateway
+```
+
+That's it! The plugin will automatically start capturing and recalling memories.
+
+## Documentation
+
+For full documentation, configuration options, troubleshooting, and development guide, see:
+
+**[OpenClaw Integration Documentation](https://vectorize.io/hindsight/sdks/integrations/openclaw)**
+
+## Links
+
+- [Hindsight Documentation](https://vectorize.io/hindsight)
+- [OpenClaw Documentation](https://openclaw.ai)
+- [GitHub Repository](https://github.com/vectorize-io/hindsight)
+
+## License
+
+MIT

package/clawdbot.plugin.json

@@ -0,0 +1,49 @@
+{
+  "id": "hindsight-openclaw",
+  "name": "Hindsight Memory",
+  "kind": "memory",
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "daemonIdleTimeout": {
+        "type": "number",
+        "description": "Seconds before daemon shuts down from inactivity (0 = never)",
+        "default": 0
+      },
+      "embedPort": {
+        "type": "number",
+        "description": "Port for hindsight-embed server (auto-assigned if not specified)",
+        "default": 0
+      },
+      "bankMission": {
+        "type": "string",
+        "description": "Custom mission/context for the memory bank",
+        "default": "You are an AI assistant helping users across multiple communication channels (Telegram, Slack, Discord, etc.). Remember user preferences, instructions, and important context from conversations to provide personalized assistance."
+      },
+      "embedVersion": {
+        "type": "string",
+        "description": "hindsight-embed version to use (e.g. 'latest', '0.4.2', or empty for latest)",
+        "default": "latest"
+      }
+    },
+    "additionalProperties": false
+  },
+  "uiHints": {
+    "daemonIdleTimeout": {
+      "label": "Daemon Idle Timeout",
+      "placeholder": "0 (never timeout)"
+    },
+    "embedPort": {
+      "label": "Embed Server Port",
+      "placeholder": "0 (auto-assign)"
+    },
+    "bankMission": {
+      "label": "Bank Mission",
+      "placeholder": "Custom context for what this agent does..."
+    },
+    "embedVersion": {
+      "label": "Hindsight Embed Version",
+      "placeholder": "latest (or pin to specific version like 0.4.2)"
+    }
+  }
+}

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import type { RetainRequest, RetainResponse, RecallRequest, RecallResponse } from './types.js';
+export declare class HindsightClient {
+    private bankId;
+    private llmProvider;
+    private llmApiKey;
+    private llmModel?;
+    private embedVersion;
+    constructor(llmProvider: string, llmApiKey: string, llmModel?: string, embedVersion?: string);
+    setBankId(bankId: string): void;
+    setBankMission(mission: string): Promise<void>;
+    private getEnv;
+    retain(request: RetainRequest): Promise<RetainResponse>;
+    recall(request: RecallRequest): Promise<RecallResponse>;
+}

package/dist/client.js

@@ -0,0 +1,91 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class HindsightClient {
+    bankId = 'default'; // Always use default bank
+    llmProvider;
+    llmApiKey;
+    llmModel;
+    embedVersion;
+    constructor(llmProvider, llmApiKey, llmModel, embedVersion = 'latest') {
+        this.llmProvider = llmProvider;
+        this.llmApiKey = llmApiKey;
+        this.llmModel = llmModel;
+        this.embedVersion = embedVersion || 'latest';
+    }
+    setBankId(bankId) {
+        this.bankId = bankId;
+    }
+    async setBankMission(mission) {
+        if (!mission || mission.trim().length === 0) {
+            return;
+        }
+        const escapedMission = mission.replace(/'/g, "'\\''"); // Escape single quotes
+        const embedPackage = this.embedVersion ? `hindsight-embed@${this.embedVersion}` : 'hindsight-embed@latest';
+        const cmd = `uvx ${embedPackage} bank mission ${this.bankId} '${escapedMission}'`;
+        try {
+            const { stdout } = await execAsync(cmd, { env: this.getEnv() });
+            console.log(`[Hindsight] Bank mission set: ${stdout.trim()}`);
+        }
+        catch (error) {
+            // Don't fail if mission set fails - bank might not exist yet, will be created on first retain
+            console.warn(`[Hindsight] Could not set bank mission (bank may not exist yet): ${error}`);
+        }
+    }
+    getEnv() {
+        const env = {
+            ...process.env,
+            HINDSIGHT_EMBED_LLM_PROVIDER: this.llmProvider,
+            HINDSIGHT_EMBED_LLM_API_KEY: this.llmApiKey,
+        };
+        if (this.llmModel) {
+            env.HINDSIGHT_EMBED_LLM_MODEL = this.llmModel;
+        }
+        return env;
+    }
+    async retain(request) {
+        const content = request.content.replace(/'/g, "'\\''"); // Escape single quotes
+        const docId = request.document_id || 'conversation';
+        const embedPackage = this.embedVersion ? `hindsight-embed@${this.embedVersion}` : 'hindsight-embed@latest';
+        const cmd = `uvx ${embedPackage} memory retain ${this.bankId} '${content}' --doc-id '${docId}' --async`;
+        try {
+            const { stdout } = await execAsync(cmd, { env: this.getEnv() });
+            console.log(`[Hindsight] Retained (async): ${stdout.trim()}`);
+            // Return a simple response
+            return {
+                message: 'Memory queued for background processing',
+                document_id: docId,
+                memory_unit_ids: [],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to retain memory: ${error}`);
+        }
+    }
+    async recall(request) {
+        const query = request.query.replace(/'/g, "'\\''"); // Escape single quotes
+        const maxTokens = request.max_tokens || 1024;
+        const embedPackage = this.embedVersion ? `hindsight-embed@${this.embedVersion}` : 'hindsight-embed@latest';
+        const cmd = `uvx ${embedPackage} memory recall ${this.bankId} '${query}' --output json --max-tokens ${maxTokens}`;
+        try {
+            const { stdout } = await execAsync(cmd, { env: this.getEnv() });
+            // Parse JSON output - returns { entities: {...}, results: [...] }
+            const response = JSON.parse(stdout);
+            const results = response.results || [];
+            return {
+                results: results.map((r) => ({
+                    content: r.text || r.content || '',
+                    score: 1.0, // CLI doesn't return scores
+                    metadata: {
+                        document_id: r.document_id,
+                        chunk_id: r.chunk_id,
+                        ...r.metadata,
+                    },
+                })),
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to recall memories: ${error}`);
+        }
+    }
+}

package/dist/embed-manager.d.ts

@@ -0,0 +1,18 @@
+export declare class HindsightEmbedManager {
+    private process;
+    private port;
+    private baseUrl;
+    private embedDir;
+    private llmProvider;
+    private llmApiKey;
+    private llmModel?;
+    private daemonIdleTimeout;
+    private embedVersion;
+    constructor(port: number, llmProvider: string, llmApiKey: string, llmModel?: string, daemonIdleTimeout?: number, // Default: never timeout
+    embedVersion?: string);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private waitForReady;
+    getBaseUrl(): string;
+    isRunning(): boolean;
+}

package/dist/embed-manager.js

@@ -0,0 +1,120 @@
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { homedir } from 'os';
+export class HindsightEmbedManager {
+    process = null;
+    port;
+    baseUrl;
+    embedDir;
+    llmProvider;
+    llmApiKey;
+    llmModel;
+    daemonIdleTimeout;
+    embedVersion;
+    constructor(port, llmProvider, llmApiKey, llmModel, daemonIdleTimeout = 0, // Default: never timeout
+    embedVersion = 'latest' // Default: latest
+    ) {
+        this.port = 8889; // hindsight-embed uses fixed port 8889
+        this.baseUrl = `http://127.0.0.1:8889`;
+        this.embedDir = join(homedir(), '.clawdbot', 'hindsight-embed');
+        this.llmProvider = llmProvider;
+        this.llmApiKey = llmApiKey;
+        this.llmModel = llmModel;
+        this.daemonIdleTimeout = daemonIdleTimeout;
+        this.embedVersion = embedVersion || 'latest';
+    }
+    async start() {
+        console.log(`[Hindsight] Starting hindsight-embed daemon...`);
+        // Build environment variables
+        const env = {
+            ...process.env,
+            HINDSIGHT_EMBED_LLM_PROVIDER: this.llmProvider,
+            HINDSIGHT_EMBED_LLM_API_KEY: this.llmApiKey,
+            HINDSIGHT_EMBED_DAEMON_IDLE_TIMEOUT: this.daemonIdleTimeout.toString(),
+        };
+        if (this.llmModel) {
+            env['HINDSIGHT_EMBED_LLM_MODEL'] = this.llmModel;
+        }
+        // Start hindsight-embed daemon (it manages itself)
+        const embedPackage = this.embedVersion ? `hindsight-embed@${this.embedVersion}` : 'hindsight-embed@latest';
+        const startDaemon = spawn('uvx', [embedPackage, 'daemon', 'start'], {
+            env,
+            stdio: 'pipe',
+        });
+        // Collect output
+        let output = '';
+        startDaemon.stdout?.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            console.log(`[Hindsight] ${text.trim()}`);
+        });
+        startDaemon.stderr?.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            console.error(`[Hindsight] ${text.trim()}`);
+        });
+        // Wait for daemon start command to complete
+        await new Promise((resolve, reject) => {
+            startDaemon.on('exit', (code) => {
+                if (code === 0) {
+                    console.log('[Hindsight] Daemon start command completed');
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Daemon start failed with code ${code}: ${output}`));
+                }
+            });
+            startDaemon.on('error', (error) => {
+                reject(error);
+            });
+        });
+        // Wait for server to be ready
+        await this.waitForReady();
+        console.log('[Hindsight] Daemon is ready');
+    }
+    async stop() {
+        console.log('[Hindsight] Stopping hindsight-embed daemon...');
+        const embedPackage = this.embedVersion ? `hindsight-embed@${this.embedVersion}` : 'hindsight-embed@latest';
+        const stopDaemon = spawn('uvx', [embedPackage, 'daemon', 'stop'], {
+            stdio: 'pipe',
+        });
+        await new Promise((resolve) => {
+            stopDaemon.on('exit', () => {
+                console.log('[Hindsight] Daemon stopped');
+                resolve();
+            });
+            stopDaemon.on('error', (error) => {
+                console.error('[Hindsight] Error stopping daemon:', error);
+                resolve(); // Resolve anyway
+            });
+            // Timeout after 5 seconds
+            setTimeout(() => {
+                console.log('[Hindsight] Daemon stop timeout');
+                resolve();
+            }, 5000);
+        });
+    }
+    async waitForReady(maxAttempts = 30) {
+        console.log('[Hindsight] Waiting for daemon to be ready...');
+        for (let i = 0; i < maxAttempts; i++) {
+            try {
+                const response = await fetch(`${this.baseUrl}/health`);
+                if (response.ok) {
+                    console.log('[Hindsight] Daemon health check passed');
+                    return;
+                }
+            }
+            catch {
+                // Not ready yet
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        throw new Error('Hindsight daemon failed to become ready within 30 seconds');
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    isRunning() {
+        return this.process !== null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { MoltbotPluginAPI } from './types.js';
+import { HindsightClient } from './client.js';
+export default function (api: MoltbotPluginAPI): void;
+export declare function getClient(): HindsightClient | null;

package/dist/index.js

@@ -0,0 +1,313 @@
+import { HindsightEmbedManager } from './embed-manager.js';
+import { HindsightClient } from './client.js';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Module-level state
+let embedManager = null;
+let client = null;
+let initPromise = null;
+let isInitialized = false;
+// Global access for hooks (Moltbot loads hooks separately)
+if (typeof global !== 'undefined') {
+    global.__hindsightClient = {
+        getClient: () => client,
+        waitForReady: async () => {
+            if (isInitialized)
+                return;
+            if (initPromise)
+                await initPromise;
+        },
+    };
+}
+// Get directory of current module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Default bank name
+const BANK_NAME = 'openclaw';
+// Provider mapping: moltbot provider name -> hindsight provider name
+const PROVIDER_MAP = {
+    anthropic: 'anthropic',
+    openai: 'openai',
+    'openai-codex': 'openai',
+    gemini: 'gemini',
+    groq: 'groq',
+    ollama: 'ollama',
+};
+// Environment variable mapping
+const ENV_KEY_MAP = {
+    anthropic: 'ANTHROPIC_API_KEY',
+    openai: 'OPENAI_API_KEY',
+    'openai-codex': 'OPENAI_API_KEY',
+    gemini: 'GEMINI_API_KEY',
+    groq: 'GROQ_API_KEY',
+    ollama: '', // No key needed for local ollama
+};
+function detectLLMConfig(api) {
+    // Get models from config (agents.defaults.models is a dictionary of models)
+    const models = api.config.agents?.defaults?.models;
+    if (!models || Object.keys(models).length === 0) {
+        throw new Error('No models configured in Moltbot. Please configure at least one model in agents.defaults.models');
+    }
+    // Try all configured models to find one with an available API key
+    const configuredModels = Object.keys(models);
+    for (const modelKey of configuredModels) {
+        const [moltbotProvider, ...modelParts] = modelKey.split('/');
+        const model = modelParts.join('/');
+        const hindsightProvider = PROVIDER_MAP[moltbotProvider];
+        if (!hindsightProvider) {
+            continue; // Skip unsupported providers
+        }
+        const envKey = ENV_KEY_MAP[moltbotProvider];
+        const apiKey = envKey ? process.env[envKey] || '' : '';
+        // For ollama, no key is needed
+        if (hindsightProvider === 'ollama') {
+            return { provider: hindsightProvider, apiKey: '', model, envKey: '' };
+        }
+        // If we found a key, use this provider
+        if (apiKey) {
+            return { provider: hindsightProvider, apiKey, model, envKey };
+        }
+    }
+    // No API keys found for any provider - show helpful error
+    const configuredProviders = configuredModels
+        .map(m => m.split('/')[0])
+        .filter(p => PROVIDER_MAP[p]);
+    const keyInstructions = configuredProviders
+        .map(p => {
+        const envVar = ENV_KEY_MAP[p];
+        return envVar ? `  • ${envVar} (for ${p})` : null;
+    })
+        .filter(Boolean)
+        .join('\n');
+    throw new Error(`No API keys found for Hindsight memory plugin.\n\n` +
+        `Configured providers in Moltbot: ${configuredProviders.join(', ')}\n\n` +
+        `Please set one of these environment variables:\n${keyInstructions}\n\n` +
+        `You can set them in your shell profile (~/.zshrc or ~/.bashrc):\n` +
+        `  export ANTHROPIC_API_KEY="your-key-here"\n\n` +
+        `Or run Moltbot with the environment variable:\n` +
+        `  ANTHROPIC_API_KEY="your-key" clawdbot start\n\n` +
+        `Alternatively, configure ollama provider which doesn't require an API key.`);
+}
+function getPluginConfig(api) {
+    const config = api.config.plugins?.entries?.['hindsight-openclaw']?.config || {};
+    const defaultMission = 'You are an AI assistant helping users across multiple communication channels (Telegram, Slack, Discord, etc.). Remember user preferences, instructions, and important context from conversations to provide personalized assistance.';
+    return {
+        bankMission: config.bankMission || defaultMission,
+        embedPort: config.embedPort || 0,
+        daemonIdleTimeout: config.daemonIdleTimeout !== undefined ? config.daemonIdleTimeout : 0,
+        embedVersion: config.embedVersion || 'latest',
+    };
+}
+export default function (api) {
+    try {
+        console.log('[Hindsight] Plugin loading...');
+        // Detect LLM configuration from Moltbot
+        console.log('[Hindsight] Detecting LLM config...');
+        const llmConfig = detectLLMConfig(api);
+        if (llmConfig.provider === 'ollama') {
+            console.log(`[Hindsight] ✓ Using provider: ${llmConfig.provider}, model: ${llmConfig.model || 'default'} (no API key required)`);
+        }
+        else {
+            console.log(`[Hindsight] ✓ Using provider: ${llmConfig.provider}, model: ${llmConfig.model || 'default'} (API key: ${llmConfig.envKey})`);
+        }
+        console.log('[Hindsight] Getting plugin config...');
+        const pluginConfig = getPluginConfig(api);
+        if (pluginConfig.bankMission) {
+            console.log(`[Hindsight] Custom bank mission configured: "${pluginConfig.bankMission.substring(0, 50)}..."`);
+        }
+        console.log(`[Hindsight] Daemon idle timeout: ${pluginConfig.daemonIdleTimeout}s (0 = never timeout)`);
+        // Determine port
+        const port = pluginConfig.embedPort || Math.floor(Math.random() * 10000) + 10000;
+        console.log(`[Hindsight] Port: ${port}`);
+        // Initialize in background (non-blocking)
+        console.log('[Hindsight] Starting initialization in background...');
+        initPromise = (async () => {
+            try {
+                // Initialize embed manager
+                console.log('[Hindsight] Creating HindsightEmbedManager...');
+                embedManager = new HindsightEmbedManager(port, llmConfig.provider, llmConfig.apiKey, llmConfig.model, pluginConfig.daemonIdleTimeout, pluginConfig.embedVersion);
+                // Start the embedded server
+                console.log('[Hindsight] Starting embedded server...');
+                await embedManager.start();
+                // Initialize client
+                console.log('[Hindsight] Creating HindsightClient...');
+                client = new HindsightClient(llmConfig.provider, llmConfig.apiKey, llmConfig.model, pluginConfig.embedVersion);
+                // Use openclaw bank
+                console.log(`[Hindsight] Using bank: ${BANK_NAME}`);
+                client.setBankId(BANK_NAME);
+                // Set bank mission
+                if (pluginConfig.bankMission) {
+                    console.log(`[Hindsight] Setting bank mission...`);
+                    await client.setBankMission(pluginConfig.bankMission);
+                }
+                isInitialized = true;
+                console.log('[Hindsight] ✓ Ready');
+            }
+            catch (error) {
+                console.error('[Hindsight] Initialization error:', error);
+                throw error;
+            }
+        })();
+        // Don't await - let it initialize in background
+        // Register background service for cleanup
+        console.log('[Hindsight] Registering service...');
+        api.registerService({
+            id: 'hindsight-memory',
+            async start() {
+                // Wait for background init if still pending
+                console.log('[Hindsight] Service start called - ensuring initialization complete...');
+                if (initPromise)
+                    await initPromise;
+            },
+            async stop() {
+                try {
+                    console.log('[Hindsight] Service stopping...');
+                    if (embedManager) {
+                        await embedManager.stop();
+                        embedManager = null;
+                    }
+                    client = null;
+                    isInitialized = false;
+                    console.log('[Hindsight] Service stopped');
+                }
+                catch (error) {
+                    console.error('[Hindsight] Service stop error:', error);
+                    throw error;
+                }
+            },
+        });
+        console.log('[Hindsight] Plugin loaded successfully');
+        // Register agent_end hook for auto-retention
+        console.log('[Hindsight] Registering agent_end hook...');
+        // Store session key for retention
+        let currentSessionKey;
+        // Auto-recall: Inject relevant memories before agent processes the message
+        api.on('before_agent_start', async (context) => {
+            try {
+                // Capture session key
+                if (context.sessionKey) {
+                    currentSessionKey = context.sessionKey;
+                    console.log('[Hindsight] Captured session key:', currentSessionKey);
+                }
+                // Get the user's latest message for recall
+                let prompt = context.prompt;
+                if (!prompt || typeof prompt !== 'string' || prompt.length < 5) {
+                    return; // Skip very short messages
+                }
+                // Extract actual message from Telegram format: [Telegram ... GMT+1] actual message
+                const telegramMatch = prompt.match(/\[Telegram[^\]]+\]\s*(.+)$/);
+                if (telegramMatch) {
+                    prompt = telegramMatch[1].trim();
+                }
+                if (prompt.length < 5) {
+                    return; // Skip very short messages after extraction
+                }
+                // Wait for client to be ready
+                const clientGlobal = global.__hindsightClient;
+                if (!clientGlobal) {
+                    console.log('[Hindsight] Client global not available, skipping auto-recall');
+                    return;
+                }
+                await clientGlobal.waitForReady();
+                const client = clientGlobal.getClient();
+                if (!client) {
+                    console.log('[Hindsight] Client not initialized, skipping auto-recall');
+                    return;
+                }
+                console.log('[Hindsight] Auto-recall for prompt:', prompt.substring(0, 50));
+                // Recall relevant memories (up to 1024 tokens)
+                const response = await client.recall({
+                    query: prompt,
+                    max_tokens: 1024,
+                });
+                if (!response.results || response.results.length === 0) {
+                    console.log('[Hindsight] No memories found for auto-recall');
+                    return;
+                }
+                // Format memories as JSON with all fields from recall
+                const memoriesJson = JSON.stringify(response.results, null, 2);
+                const contextMessage = `<hindsight_memories>
+${memoriesJson}
+</hindsight_memories>`;
+                console.log(`[Hindsight] Auto-recall: Injecting ${response.results.length} memories`);
+                // Inject context before the user message
+                return { prependContext: contextMessage };
+            }
+            catch (error) {
+                console.error('[Hindsight] Auto-recall error:', error);
+                return;
+            }
+        });
+        api.on('agent_end', async (event) => {
+            try {
+                console.log('[Hindsight Hook] agent_end triggered');
+                // Check event success and messages
+                if (!event.success || !Array.isArray(event.messages) || event.messages.length === 0) {
+                    console.log('[Hindsight Hook] Skipping: success:', event.success, 'messages:', event.messages?.length);
+                    return;
+                }
+                // Wait for client to be ready
+                const clientGlobal = global.__hindsightClient;
+                if (!clientGlobal) {
+                    console.warn('[Hindsight] Client global not found, skipping retain');
+                    return;
+                }
+                await clientGlobal.waitForReady();
+                const client = clientGlobal.getClient();
+                if (!client) {
+                    console.warn('[Hindsight] Client not initialized, skipping retain');
+                    return;
+                }
+                // Format messages into a transcript
+                const transcript = event.messages
+                    .map((msg) => {
+                    const role = msg.role || 'unknown';
+                    let content = '';
+                    // Handle different content formats
+                    if (typeof msg.content === 'string') {
+                        content = msg.content;
+                    }
+                    else if (Array.isArray(msg.content)) {
+                        content = msg.content
+                            .filter((block) => block.type === 'text')
+                            .map((block) => block.text)
+                            .join('\n');
+                    }
+                    return `[role: ${role}]\n${content}\n[${role}:end]`;
+                })
+                    .join('\n\n');
+                if (!transcript.trim() || transcript.length < 10) {
+                    console.log('[Hindsight Hook] Transcript too short, skipping');
+                    return;
+                }
+                // Use session key as document ID
+                const documentId = currentSessionKey || 'default-session';
+                // Retain to Hindsight
+                await client.retain({
+                    content: transcript,
+                    document_id: documentId,
+                    metadata: {
+                        retained_at: new Date().toISOString(),
+                        message_count: event.messages.length,
+                    },
+                });
+                console.log(`[Hindsight] Retained ${event.messages.length} messages for session ${documentId}`);
+            }
+            catch (error) {
+                console.error('[Hindsight] Error retaining messages:', error);
+            }
+        });
+        console.log('[Hindsight] Hook registered');
+    }
+    catch (error) {
+        console.error('[Hindsight] Plugin loading error:', error);
+        if (error instanceof Error) {
+            console.error('[Hindsight] Error stack:', error.stack);
+        }
+        throw error;
+    }
+}
+// Export client getter for tools
+export function getClient() {
+    return client;
+}

package/dist/moltbot-types.d.ts

@@ -0,0 +1,27 @@
+declare module 'moltbot/plugin-sdk' {
+    interface HookEvent {
+        type: 'command' | 'session' | 'agent' | 'gateway' | 'tool_result_persist';
+        action?: string;
+        sessionKey?: string;
+        timestamp?: string;
+        messages?: string[];
+        context?: {
+            sessionEntry?: {
+                messages?: Array<{
+                    role: string;
+                    content: string;
+                }>;
+            };
+            sessionId?: string;
+            sessionKey?: string;
+            sessionFile?: string;
+            commandSource?: string;
+            senderId?: string;
+            workspaceDir?: string;
+            bootstrapFiles?: string[];
+            cfg?: any;
+        };
+    }
+    type HookHandler = (event: HookEvent) => Promise<void>;
+    function registerPluginHooksFromDir(api: any, dir: string): void;
+}

package/dist/moltbot-types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Type definitions for moltbot plugin SDK
+// These are minimal types based on the documentation

package/dist/types.d.ts

@@ -0,0 +1,72 @@
+export interface MoltbotPluginAPI {
+    config: MoltbotConfig;
+    registerService(config: ServiceConfig): void;
+    on(event: string, handler: (context: any) => void | Promise<void | {
+        prependContext?: string;
+    }>): void;
+}
+export interface MoltbotConfig {
+    agents?: {
+        defaults?: {
+            models?: {
+                [modelName: string]: {
+                    alias?: string;
+                };
+            };
+        };
+    };
+    plugins?: {
+        entries?: {
+            [pluginId: string]: {
+                enabled?: boolean;
+                config?: PluginConfig;
+            };
+        };
+    };
+}
+export interface PluginConfig {
+    bankMission?: string;
+    embedPort?: number;
+    daemonIdleTimeout?: number;
+    embedVersion?: string;
+}
+export interface ServiceConfig {
+    id: string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export interface RetainRequest {
+    content: string;
+    document_id?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RetainResponse {
+    message: string;
+    document_id: string;
+    memory_unit_ids: string[];
+}
+export interface RecallRequest {
+    query: string;
+    max_tokens?: number;
+}
+export interface RecallResponse {
+    results: MemoryResult[];
+}
+export interface MemoryResult {
+    content: string;
+    score: number;
+    metadata?: {
+        document_id?: string;
+        created_at?: string;
+        source?: string;
+    };
+}
+export interface CreateBankRequest {
+    name: string;
+    background_context?: string;
+}
+export interface CreateBankResponse {
+    bank_id: string;
+    name: string;
+    created_at: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// Moltbot plugin API types (minimal subset needed for this plugin)
+export {};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@vectorize-io/hindsight-openclaw",
+  "version": "0.4.4",
+  "description": "Hindsight memory plugin for OpenClaw - biomimetic long-term memory with fact extraction",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "clawdbot": {
+    "extensions": [
+      "./dist/index.js"
+    ]
+  },
+  "keywords": [
+    "openclaw",
+    "memory",
+    "ai",
+    "agent",
+    "hindsight",
+    "long-term-memory"
+  ],
+  "author": "Vectorize <support@vectorize.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vectorize-io/hindsight.git",
+    "directory": "hindsight-integrations/openclaw"
+  },
+  "files": [
+    "dist",
+    "clawdbot.plugin.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "dependencies": {
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/ui": "^4.0.18",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}