@vectorize-io/hindsight-openclaw 0.4.5 → 0.4.7

package/README.md

@@ -7,13 +7,13 @@ Biomimetic long-term memory for [OpenClaw](https://openclaw.ai) using [Hindsight
 ```bash
 # 1. Configure your LLM provider
 export OPENAI_API_KEY="sk-your-key"
-clawdbot config set 'agents.defaults.models."openai/gpt-4o-mini"' '{}'
+openclaw config set 'agents.defaults.models."openai/gpt-4o-mini"' '{}'
 
 # 2. Install and enable the plugin
-clawdbot plugins install @vectorize-io/hindsight-openclaw
+openclaw plugins install @vectorize-io/hindsight-openclaw
 
 # 3. Start OpenClaw
-clawdbot gateway
+openclaw gateway
 ```
 
 That's it! The plugin will automatically start capturing and recalling memories.

package/dist/embed-manager.d.ts

@@ -6,13 +6,16 @@ export declare class HindsightEmbedManager {
     private llmProvider;
     private llmApiKey;
     private llmModel?;
+    private llmBaseUrl?;
     private daemonIdleTimeout;
     private embedVersion;
-    constructor(port: number, llmProvider: string, llmApiKey: string, llmModel?: string, daemonIdleTimeout?: number, // Default: never timeout
+    constructor(port: number, llmProvider: string, llmApiKey: string, llmModel?: string, llmBaseUrl?: string, daemonIdleTimeout?: number, // Default: never timeout
     embedVersion?: string);
     start(): Promise<void>;
     stop(): Promise<void>;
     private waitForReady;
     getBaseUrl(): string;
     isRunning(): boolean;
+    checkHealth(): Promise<boolean>;
+    private writeConfigEnv;
 }

package/dist/embed-manager.js

@@ -1,4 +1,5 @@
 import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 export class HindsightEmbedManager {
@@ -9,17 +10,19 @@ export class HindsightEmbedManager {
     llmProvider;
     llmApiKey;
     llmModel;
+    llmBaseUrl;
     daemonIdleTimeout;
     embedVersion;
-    constructor(port, llmProvider, llmApiKey, llmModel, daemonIdleTimeout = 0, // Default: never timeout
+    constructor(port, llmProvider, llmApiKey, llmModel, llmBaseUrl, 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.port = 8888; // hindsight-embed daemon uses same port as API
+        this.baseUrl = `http://127.0.0.1:8888`;
+        this.embedDir = join(homedir(), '.openclaw', 'hindsight-embed');
         this.llmProvider = llmProvider;
         this.llmApiKey = llmApiKey;
         this.llmModel = llmModel;
+        this.llmBaseUrl = llmBaseUrl;
         this.daemonIdleTimeout = daemonIdleTimeout;
         this.embedVersion = embedVersion || 'latest';
     }
@@ -35,6 +38,17 @@ export class HindsightEmbedManager {
         if (this.llmModel) {
             env['HINDSIGHT_EMBED_LLM_MODEL'] = this.llmModel;
         }
+        // Pass through base URL for OpenAI-compatible providers (OpenRouter, etc.)
+        if (this.llmBaseUrl) {
+            env['HINDSIGHT_API_LLM_BASE_URL'] = this.llmBaseUrl;
+        }
+        // On macOS, force CPU for embeddings/reranker to avoid MPS/Metal issues in daemon mode
+        if (process.platform === 'darwin') {
+            env['HINDSIGHT_API_EMBEDDINGS_LOCAL_FORCE_CPU'] = '1';
+            env['HINDSIGHT_API_RERANKER_LOCAL_FORCE_CPU'] = '1';
+        }
+        // Write env vars to ~/.hindsight/config.env for daemon persistence
+        await this.writeConfigEnv(env);
         // 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'], {
@@ -117,4 +131,78 @@ export class HindsightEmbedManager {
     isRunning() {
         return this.process !== null;
     }
+    async checkHealth() {
+        try {
+            const response = await fetch(`${this.baseUrl}/health`, { signal: AbortSignal.timeout(2000) });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async writeConfigEnv(env) {
+        const hindsightDir = join(homedir(), '.hindsight');
+        const embedConfigPath = join(hindsightDir, 'embed');
+        // Ensure directory exists
+        await fs.mkdir(hindsightDir, { recursive: true });
+        // Read existing config to preserve extra settings
+        let existingContent = '';
+        let extraSettings = [];
+        try {
+            existingContent = await fs.readFile(embedConfigPath, 'utf-8');
+            // Extract non-LLM settings (like FORCE_CPU flags)
+            const lines = existingContent.split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('#') &&
+                    !trimmed.startsWith('HINDSIGHT_EMBED_LLM_') &&
+                    !trimmed.startsWith('HINDSIGHT_API_LLM_') &&
+                    !trimmed.startsWith('HINDSIGHT_EMBED_BANK_ID') &&
+                    !trimmed.startsWith('HINDSIGHT_EMBED_DAEMON_IDLE_TIMEOUT')) {
+                    extraSettings.push(line);
+                }
+            }
+        }
+        catch {
+            // File doesn't exist yet, that's fine
+        }
+        // Build config file with header
+        const configLines = [
+            '# Hindsight Embed Configuration',
+            '# Generated by OpenClaw Hindsight plugin',
+            '',
+        ];
+        // Add LLM config
+        if (env.HINDSIGHT_EMBED_LLM_PROVIDER) {
+            configLines.push(`HINDSIGHT_EMBED_LLM_PROVIDER=${env.HINDSIGHT_EMBED_LLM_PROVIDER}`);
+        }
+        if (env.HINDSIGHT_EMBED_LLM_MODEL) {
+            configLines.push(`HINDSIGHT_EMBED_LLM_MODEL=${env.HINDSIGHT_EMBED_LLM_MODEL}`);
+        }
+        if (env.HINDSIGHT_EMBED_LLM_API_KEY) {
+            configLines.push(`HINDSIGHT_EMBED_LLM_API_KEY=${env.HINDSIGHT_EMBED_LLM_API_KEY}`);
+        }
+        if (env.HINDSIGHT_API_LLM_BASE_URL) {
+            configLines.push(`HINDSIGHT_API_LLM_BASE_URL=${env.HINDSIGHT_API_LLM_BASE_URL}`);
+        }
+        if (env.HINDSIGHT_EMBED_DAEMON_IDLE_TIMEOUT) {
+            configLines.push(`HINDSIGHT_EMBED_DAEMON_IDLE_TIMEOUT=${env.HINDSIGHT_EMBED_DAEMON_IDLE_TIMEOUT}`);
+        }
+        // Add platform-specific config (macOS FORCE_CPU flags)
+        if (env.HINDSIGHT_API_EMBEDDINGS_LOCAL_FORCE_CPU) {
+            configLines.push(`HINDSIGHT_API_EMBEDDINGS_LOCAL_FORCE_CPU=${env.HINDSIGHT_API_EMBEDDINGS_LOCAL_FORCE_CPU}`);
+        }
+        if (env.HINDSIGHT_API_RERANKER_LOCAL_FORCE_CPU) {
+            configLines.push(`HINDSIGHT_API_RERANKER_LOCAL_FORCE_CPU=${env.HINDSIGHT_API_RERANKER_LOCAL_FORCE_CPU}`);
+        }
+        // Add extra settings if they exist
+        if (extraSettings.length > 0) {
+            configLines.push('');
+            configLines.push('# Additional settings');
+            configLines.push(...extraSettings);
+        }
+        // Write to file
+        await fs.writeFile(embedConfigPath, configLines.join('\n') + '\n', 'utf-8');
+        console.log(`[Hindsight] Wrote config to ${embedConfigPath}`);
+    }
 }

package/dist/index.js

@@ -24,69 +24,65 @@ 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
+// Provider detection from standard env vars
+const PROVIDER_DETECTION = [
+    { name: 'openai', keyEnv: 'OPENAI_API_KEY', defaultModel: 'gpt-4o-mini' },
+    { name: 'anthropic', keyEnv: 'ANTHROPIC_API_KEY', defaultModel: 'claude-3-5-haiku-20241022' },
+    { name: 'gemini', keyEnv: 'GEMINI_API_KEY', defaultModel: 'gemini-2.5-flash' },
+    { name: 'groq', keyEnv: 'GROQ_API_KEY', defaultModel: 'openai/gpt-oss-20b' },
+    { name: 'ollama', keyEnv: '', defaultModel: 'llama3.2' },
+];
+function detectLLMConfig() {
+    // Override values from HINDSIGHT_API_LLM_* env vars (highest priority)
+    const overrideProvider = process.env.HINDSIGHT_API_LLM_PROVIDER;
+    const overrideModel = process.env.HINDSIGHT_API_LLM_MODEL;
+    const overrideKey = process.env.HINDSIGHT_API_LLM_API_KEY;
+    const overrideBaseUrl = process.env.HINDSIGHT_API_LLM_BASE_URL;
+    // If provider is explicitly set, use that (with overrides)
+    if (overrideProvider) {
+        if (!overrideKey && overrideProvider !== 'ollama') {
+            throw new Error(`HINDSIGHT_API_LLM_PROVIDER is set to "${overrideProvider}" but HINDSIGHT_API_LLM_API_KEY is not set.\n` +
+                `Please set: export HINDSIGHT_API_LLM_API_KEY=your-api-key`);
         }
-        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: '' };
+        const providerInfo = PROVIDER_DETECTION.find(p => p.name === overrideProvider);
+        return {
+            provider: overrideProvider,
+            apiKey: overrideKey || '',
+            model: overrideModel || (providerInfo?.defaultModel),
+            baseUrl: overrideBaseUrl,
+            source: 'HINDSIGHT_API_LLM_PROVIDER override',
+        };
+    }
+    // Auto-detect from standard provider env vars
+    for (const providerInfo of PROVIDER_DETECTION) {
+        const apiKey = providerInfo.keyEnv ? process.env[providerInfo.keyEnv] : '';
+        // Skip ollama in auto-detection (must be explicitly requested)
+        if (providerInfo.name === 'ollama') {
+            continue;
         }
-        // If we found a key, use this provider
         if (apiKey) {
-            return { provider: hindsightProvider, apiKey, model, envKey };
+            return {
+                provider: providerInfo.name,
+                apiKey,
+                model: overrideModel || providerInfo.defaultModel,
+                baseUrl: overrideBaseUrl, // Only use explicit HINDSIGHT_API_LLM_BASE_URL
+                source: `auto-detected from ${providerInfo.keyEnv}`,
+            };
         }
     }
-    // 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.`);
+    // No configuration found - show helpful error
+    throw new Error(`No LLM configuration found for Hindsight memory plugin.\n\n` +
+        `Option 1: Set a standard provider API key (auto-detect):\n` +
+        `  export OPENAI_API_KEY=sk-your-key        # Uses gpt-4o-mini\n` +
+        `  export ANTHROPIC_API_KEY=your-key       # Uses claude-3-5-haiku\n` +
+        `  export GEMINI_API_KEY=your-key          # Uses gemini-2.0-flash-exp\n` +
+        `  export GROQ_API_KEY=your-key            # Uses llama-3.3-70b-versatile\n\n` +
+        `Option 2: Override with Hindsight-specific config:\n` +
+        `  export HINDSIGHT_API_LLM_PROVIDER=openai\n` +
+        `  export HINDSIGHT_API_LLM_MODEL=gpt-4o-mini\n` +
+        `  export HINDSIGHT_API_LLM_API_KEY=sk-your-key\n` +
+        `  export HINDSIGHT_API_LLM_BASE_URL=https://openrouter.ai/api/v1  # Optional\n\n` +
+        `Tip: Use a cheap/fast model for memory extraction (e.g., gpt-4o-mini, claude-3-5-haiku, or free models on OpenRouter)`);
 }
 function getPluginConfig(api) {
     const config = api.config.plugins?.entries?.['hindsight-openclaw']?.config || {};
@@ -101,14 +97,16 @@ function getPluginConfig(api) {
 export default function (api) {
     try {
         console.log('[Hindsight] Plugin loading...');
-        // Detect LLM configuration from Moltbot
+        // Detect LLM configuration from environment
         console.log('[Hindsight] Detecting LLM config...');
-        const llmConfig = detectLLMConfig(api);
+        const llmConfig = detectLLMConfig();
+        const baseUrlInfo = llmConfig.baseUrl ? `, base URL: ${llmConfig.baseUrl}` : '';
+        const modelInfo = llmConfig.model || 'default';
         if (llmConfig.provider === 'ollama') {
-            console.log(`[Hindsight] ✓ Using provider: ${llmConfig.provider}, model: ${llmConfig.model || 'default'} (no API key required)`);
+            console.log(`[Hindsight] ✓ Using provider: ${llmConfig.provider}, model: ${modelInfo} (${llmConfig.source})`);
         }
         else {
-            console.log(`[Hindsight] ✓ Using provider: ${llmConfig.provider}, model: ${llmConfig.model || 'default'} (API key: ${llmConfig.envKey})`);
+            console.log(`[Hindsight] ✓ Using provider: ${llmConfig.provider}, model: ${modelInfo} (${llmConfig.source}${baseUrlInfo})`);
         }
         console.log('[Hindsight] Getting plugin config...');
         const pluginConfig = getPluginConfig(api);
@@ -125,7 +123,7 @@ export default function (api) {
             try {
                 // Initialize embed manager
                 console.log('[Hindsight] Creating HindsightEmbedManager...');
-                embedManager = new HindsightEmbedManager(port, llmConfig.provider, llmConfig.apiKey, llmConfig.model, pluginConfig.daemonIdleTimeout, pluginConfig.embedVersion);
+                embedManager = new HindsightEmbedManager(port, llmConfig.provider, llmConfig.apiKey, llmConfig.model, llmConfig.baseUrl, pluginConfig.daemonIdleTimeout, pluginConfig.embedVersion);
                 // Start the embedded server
                 console.log('[Hindsight] Starting embedded server...');
                 await embedManager.start();
@@ -154,10 +152,46 @@ export default function (api) {
         api.registerService({
             id: 'hindsight-memory',
             async start() {
+                console.log('[Hindsight] Service start called - checking daemon health...');
                 // Wait for background init if still pending
-                console.log('[Hindsight] Service start called - ensuring initialization complete...');
-                if (initPromise)
-                    await initPromise;
+                if (initPromise) {
+                    try {
+                        await initPromise;
+                    }
+                    catch (error) {
+                        console.error('[Hindsight] Initial initialization failed:', error);
+                        // Continue to health check below
+                    }
+                }
+                // Check if daemon is actually healthy (handles SIGUSR1 restart case)
+                if (embedManager && isInitialized) {
+                    const healthy = await embedManager.checkHealth();
+                    if (healthy) {
+                        console.log('[Hindsight] Daemon is healthy');
+                        return;
+                    }
+                    console.log('[Hindsight] Daemon is not responding - reinitializing...');
+                    // Reset state for reinitialization
+                    embedManager = null;
+                    client = null;
+                    isInitialized = false;
+                }
+                // Reinitialize if needed (fresh start or recovery from dead daemon)
+                if (!isInitialized) {
+                    console.log('[Hindsight] Reinitializing daemon...');
+                    const llmConfig = detectLLMConfig();
+                    const pluginConfig = getPluginConfig(api);
+                    const port = pluginConfig.embedPort || Math.floor(Math.random() * 10000) + 10000;
+                    embedManager = new HindsightEmbedManager(port, llmConfig.provider, llmConfig.apiKey, llmConfig.model, llmConfig.baseUrl, pluginConfig.daemonIdleTimeout, pluginConfig.embedVersion);
+                    await embedManager.start();
+                    client = new HindsightClient(llmConfig.provider, llmConfig.apiKey, llmConfig.model, pluginConfig.embedVersion);
+                    client.setBankId(BANK_NAME);
+                    if (pluginConfig.bankMission) {
+                        await client.setBankMission(pluginConfig.bankMission);
+                    }
+                    isInitialized = true;
+                    console.log('[Hindsight] Reinitialization complete');
+                }
             },
             async stop() {
                 try {
@@ -215,10 +249,10 @@ export default function (api) {
                     return;
                 }
                 console.log('[Hindsight] Auto-recall for prompt:', prompt.substring(0, 50));
-                // Recall relevant memories (up to 1024 tokens)
+                // Recall relevant memories (up to 512 tokens)
                 const response = await client.recall({
                     query: prompt,
-                    max_tokens: 1024,
+                    max_tokens: 512,
                 });
                 if (!response.results || response.results.length === 0) {
                     console.log('[Hindsight] No memories found for auto-recall');
@@ -227,7 +261,10 @@ export default function (api) {
                 // Format memories as JSON with all fields from recall
                 const memoriesJson = JSON.stringify(response.results, null, 2);
                 const contextMessage = `<hindsight_memories>
+Relevant memories from past conversations (score 1=highest, prioritize recent when conflicting):
 ${memoriesJson}
+
+User message: ${prompt}
 </hindsight_memories>`;
                 console.log(`[Hindsight] Auto-recall: Injecting ${response.results.length} memories`);
                 // Inject context before the user message

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@vectorize-io/hindsight-openclaw",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "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": {
+  "openclaw": {
     "extensions": [
       "./dist/index.js"
     ]
@@ -27,7 +27,7 @@
   },
   "files": [
     "dist",
-    "clawdbot.plugin.json",
+    "openclaw.plugin.json",
     "README.md"
   ],
   "scripts": {