@eight-atulya/atulya-openclaw 0.8.0

package/README.md

@@ -0,0 +1,116 @@
+# Atulya Memory Plugin for OpenClaw
+
+Biomimetic long-term memory for [OpenClaw](https://openclaw.ai) using [Atulya](https://github.com/eight-atulya/atulya). Automatically captures conversations and intelligently recalls relevant context.
+
+## Quick Start
+
+```bash
+# 1. Configure your LLM provider for memory extraction
+# Option A: OpenAI
+export OPENAI_API_KEY="sk-your-key"
+
+# Option B: Claude Code (no API key needed)
+export ATULYA_API_LLM_PROVIDER=claude-code
+
+# Option C: OpenAI Codex (no API key needed)
+export ATULYA_API_LLM_PROVIDER=openai-codex
+
+# 2. Install and enable the plugin
+openclaw plugins install @eight-atulya/atulya-openclaw
+
+# 3. Start OpenClaw
+openclaw gateway
+```
+
+That's it! The plugin will automatically start capturing and recalling memories.
+
+## Features
+
+- **Auto-capture** and **auto-recall** of memories each turn
+- **Memory isolation** — configurable per agent, channel, user, or provider via `dynamicBankGranularity`
+- **Retention controls** — choose which message roles to retain and toggle auto-retain on/off
+
+## Configuration
+
+Optional settings in `~/.openclaw/openclaw.json` under `plugins.entries.atulya-openclaw.config`:
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `apiPort` | `9077` | Port for the local Atulya daemon |
+| `daemonIdleTimeout` | `0` | Seconds before daemon shuts down from inactivity (0 = never) |
+| `embedPort` | `0` | Port for `atulya-embed` server (`0` = auto-assign) |
+| `embedVersion` | `"latest"` | atulya-embed version |
+| `embedPackagePath` | — | Local path to `atulya-embed` package for development |
+| `bankMission` | — | Agent identity/purpose stored on the memory bank. Helps the engine understand context for better fact extraction. Set once per bank — not a recall prompt. |
+| `llmProvider` | auto-detect | LLM provider override for memory extraction (`openai`, `anthropic`, `gemini`, `groq`, `ollama`, `openai-codex`, `claude-code`) |
+| `llmModel` | provider default | LLM model override used with `llmProvider` |
+| `llmApiKeyEnv` | provider standard env var | Custom env var name for the provider API key |
+| `dynamicBankId` | `true` | Enable per-context memory banks |
+| `bankIdPrefix` | — | Prefix for bank IDs (e.g. `"prod"`) |
+| `dynamicBankGranularity` | `["agent", "channel", "user"]` | Fields used to derive bank ID. Options: `agent`, `channel`, `user`, `provider` |
+| `excludeProviders` | `[]` | Message providers to skip for recall/retain (e.g. `slack`, `telegram`, `discord`) |
+| `autoRecall` | `true` | Auto-inject memories before each turn. Set to `false` when the agent has its own recall tool. |
+| `autoRetain` | `true` | Auto-retain conversations after each turn |
+| `retainRoles` | `["user", "assistant"]` | Which message roles to retain. Options: `user`, `assistant`, `system`, `tool` |
+| `retainEveryNTurns` | `1` | Retain every Nth turn. `1` = every turn (default). Values > 1 enable chunked retention with a sliding window. |
+| `retainOverlapTurns` | `0` | Extra prior turns included when chunked retention fires. Window = `retainEveryNTurns + retainOverlapTurns`. Only applies when `retainEveryNTurns > 1`. |
+| `recallBudget` | `"mid"` | Recall effort: `low`, `mid`, or `high`. Higher budgets use more retrieval strategies. |
+| `recallMaxTokens` | `1024` | Max tokens for recall response. Controls how much memory context is injected per turn. |
+| `recallTypes` | `["world", "experience"]` | Memory types to recall. Options: `world`, `experience`, `observation`. Excludes verbose `observation` entries by default. |
+| `recallRoles` | `["user", "assistant"]` | Roles included when building prior context for recall query composition. Options: `user`, `assistant`, `system`, `tool`. |
+| `recallTopK` | — | Max number of memories to inject per turn. Applied after API response as a hard cap. |
+| `recallContextTurns` | `1` | Number of user turns to include when composing recall query context. `1` keeps latest-message-only behavior. |
+| `recallMaxQueryChars` | `800` | Maximum character length for the composed recall query before calling recall. |
+| `recallPromptPreamble` | built-in string | Prompt text placed above recalled memories in the injected `<atulya_memories>` block. |
+| `atulyaApiUrl` | — | External Atulya API URL (skips local daemon) |
+| `atulyaApiToken` | — | Auth token for external API |
+
+## Documentation
+
+For full documentation, configuration options, troubleshooting, and development guide, see:
+
+**[OpenClaw Integration Documentation](https://github.com/eight-atulya/atulya/blob/main/atulya-docs/docs/sdks/integrations/openclaw.md)**
+
+## Development
+
+To test local changes to the Atulya package before publishing:
+
+1. Add `embedPackagePath` to your plugin config in `~/.openclaw/openclaw.json`:
+```json
+{
+  "plugins": {
+    "entries": {
+      "atulya-openclaw": {
+        "enabled": true,
+        "config": {
+          "embedPackagePath": "/path/to/atulya-wt3/atulya-embed"
+        }
+      }
+    }
+  }
+}
+```
+
+2. The plugin will use `uv run --directory <path> atulya-embed` instead of `uvx atulya-embed@latest`
+
+3. To use a specific profile for testing:
+```bash
+# Check daemon status
+uvx atulya-embed@latest -p openclaw daemon status
+
+# View logs
+tail -f ~/.atulya/profiles/openclaw.log
+
+# List profiles
+uvx atulya-embed@latest profile list
+```
+
+## Links
+
+- [Atulya Documentation](https://github.com/eight-atulya/atulya/tree/main/atulya-docs)
+- [OpenClaw Documentation](https://openclaw.ai)
+- [GitHub Repository](https://github.com/eight-atulya/atulya)
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,34 @@
+import type { RetainRequest, RetainResponse, RecallRequest, RecallResponse } from './types.js';
+export interface AtulyaClientOptions {
+    llmModel?: string;
+    embedVersion?: string;
+    embedPackagePath?: string;
+    apiUrl?: string;
+    apiToken?: string;
+}
+export declare class AtulyaClient {
+    private bankId;
+    private llmModel?;
+    private embedVersion;
+    private embedPackagePath?;
+    private apiUrl?;
+    private apiToken?;
+    constructor(opts: AtulyaClientOptions);
+    private get httpMode();
+    /**
+     * Get the command and base args to run atulya-embed.
+     * Returns [command, ...baseArgs] for use with execFile/spawn (no shell).
+     */
+    private getEmbedCommand;
+    private httpHeaders;
+    setBankId(bankId: string): void;
+    setBankMission(mission: string): Promise<void>;
+    private setBankMissionHttp;
+    private setBankMissionSubprocess;
+    retain(request: RetainRequest): Promise<RetainResponse>;
+    private retainHttp;
+    private retainSubprocess;
+    recall(request: RecallRequest, timeoutMs?: number): Promise<RecallResponse>;
+    private recallHttp;
+    private recallSubprocess;
+}

package/dist/client.js

@@ -0,0 +1,214 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { writeFile, mkdir, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { randomBytes } from 'crypto';
+const execFileAsync = promisify(execFile);
+const MAX_BUFFER = 5 * 1024 * 1024; // 5 MB — large transcripts can exceed default 1 MB
+const DEFAULT_TIMEOUT_MS = 15_000;
+/** Strip null bytes from strings — Node 22 rejects them in execFile() args */
+const sanitize = (s) => s.replace(/\0/g, '');
+/**
+ * Sanitize a string for use as a cross-platform filename.
+ * Replaces characters illegal on Windows or Unix with underscores.
+ */
+function sanitizeFilename(name) {
+    // Replace characters illegal on Windows (\/:*?"<>|) and control chars
+    return name.replace(/[\\/:*?"<>|\x00-\x1f]/g, '_').slice(0, 200) || 'content';
+}
+export class AtulyaClient {
+    bankId = 'default';
+    llmModel;
+    embedVersion;
+    embedPackagePath;
+    apiUrl;
+    apiToken;
+    constructor(opts) {
+        this.llmModel = opts.llmModel;
+        this.embedVersion = opts.embedVersion || 'latest';
+        this.embedPackagePath = opts.embedPackagePath;
+        this.apiUrl = opts.apiUrl?.replace(/\/$/, ''); // strip trailing slash
+        this.apiToken = opts.apiToken;
+    }
+    get httpMode() {
+        return !!this.apiUrl;
+    }
+    /**
+     * Get the command and base args to run atulya-embed.
+     * Returns [command, ...baseArgs] for use with execFile/spawn (no shell).
+     */
+    getEmbedCommand() {
+        if (this.embedPackagePath) {
+            return ['uv', 'run', '--directory', this.embedPackagePath, 'atulya-embed'];
+        }
+        const embedPackage = this.embedVersion ? `atulya-embed@${this.embedVersion}` : 'atulya-embed@latest';
+        return ['uvx', embedPackage];
+    }
+    httpHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.apiToken) {
+            headers['Authorization'] = `Bearer ${this.apiToken}`;
+        }
+        return headers;
+    }
+    setBankId(bankId) {
+        this.bankId = bankId;
+    }
+    // --- setBankMission ---
+    async setBankMission(mission) {
+        if (!mission || mission.trim().length === 0) {
+            return;
+        }
+        if (this.httpMode) {
+            return this.setBankMissionHttp(mission);
+        }
+        return this.setBankMissionSubprocess(mission);
+    }
+    async setBankMissionHttp(mission) {
+        try {
+            const url = `${this.apiUrl}/v1/default/banks/${encodeURIComponent(this.bankId)}`;
+            const res = await fetch(url, {
+                method: 'PUT',
+                headers: this.httpHeaders(),
+                body: JSON.stringify({ mission }),
+                signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => '');
+                throw new Error(`HTTP ${res.status}: ${body}`);
+            }
+            console.log(`[Atulya] Bank mission set via HTTP`);
+        }
+        catch (error) {
+            console.warn(`[Atulya] Could not set bank mission (bank may not exist yet): ${error}`);
+        }
+    }
+    async setBankMissionSubprocess(mission) {
+        const [cmd, ...baseArgs] = this.getEmbedCommand();
+        const args = [...baseArgs, '--profile', 'openclaw', 'bank', 'mission', this.bankId, sanitize(mission)];
+        try {
+            const { stdout } = await execFileAsync(cmd, args, { maxBuffer: MAX_BUFFER });
+            console.log(`[Atulya] 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(`[Atulya] Could not set bank mission (bank may not exist yet): ${error}`);
+        }
+    }
+    // --- retain ---
+    async retain(request) {
+        if (this.httpMode) {
+            return this.retainHttp(request);
+        }
+        return this.retainSubprocess(request);
+    }
+    async retainHttp(request) {
+        const url = `${this.apiUrl}/v1/default/banks/${encodeURIComponent(this.bankId)}/memories`;
+        const body = {
+            items: [{
+                    content: request.content,
+                    document_id: request.document_id || 'conversation',
+                    metadata: request.metadata,
+                }],
+            async: true,
+        };
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.httpHeaders(),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`Failed to retain memory (HTTP ${res.status}): ${text}`);
+        }
+        const data = await res.json();
+        console.log(`[Atulya] Retained via HTTP (async): ${JSON.stringify(data).substring(0, 200)}`);
+        return {
+            message: 'Memory queued for background processing',
+            document_id: request.document_id || 'conversation',
+            memory_unit_ids: [],
+        };
+    }
+    async retainSubprocess(request) {
+        const docId = request.document_id || 'conversation';
+        // Write content to a temp file to avoid E2BIG (ARG_MAX) errors when passing
+        // large conversations as arguments.
+        const tempDir = join(tmpdir(), `atulya_${randomBytes(8).toString('hex')}`);
+        const safeFilename = sanitizeFilename(docId);
+        const tempFile = join(tempDir, `${safeFilename}.txt`);
+        try {
+            await mkdir(tempDir, { recursive: true });
+            await writeFile(tempFile, sanitize(request.content), 'utf8');
+            const [cmd, ...baseArgs] = this.getEmbedCommand();
+            const args = [...baseArgs, '--profile', 'openclaw', 'memory', 'retain-files', this.bankId, tempFile, '--async'];
+            const { stdout } = await execFileAsync(cmd, args, { maxBuffer: MAX_BUFFER });
+            console.log(`[Atulya] Retained (async): ${stdout.trim()}`);
+            return {
+                message: 'Memory queued for background processing',
+                document_id: docId,
+                memory_unit_ids: [],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to retain memory: ${error}`, { cause: error });
+        }
+        finally {
+            await rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    // --- recall ---
+    async recall(request, timeoutMs) {
+        if (this.httpMode) {
+            return this.recallHttp(request, timeoutMs);
+        }
+        return this.recallSubprocess(request, timeoutMs);
+    }
+    async recallHttp(request, timeoutMs) {
+        const url = `${this.apiUrl}/v1/default/banks/${encodeURIComponent(this.bankId)}/memories/recall`;
+        // Defense-in-depth: truncate query to stay under API's 500-token limit
+        const MAX_QUERY_CHARS = 800;
+        const query = request.query.length > MAX_QUERY_CHARS
+            ? (console.warn(`[Atulya] Truncating recall query from ${request.query.length} to ${MAX_QUERY_CHARS} chars`),
+                request.query.substring(0, MAX_QUERY_CHARS))
+            : request.query;
+        const body = {
+            query,
+            max_tokens: request.max_tokens || 1024,
+        };
+        if (request.budget) {
+            body.budget = request.budget;
+        }
+        if (request.types) {
+            body.types = request.types;
+        }
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.httpHeaders(),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(timeoutMs ?? DEFAULT_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`Failed to recall memories (HTTP ${res.status}): ${text}`);
+        }
+        return res.json();
+    }
+    async recallSubprocess(request, timeoutMs) {
+        const query = sanitize(request.query);
+        const maxTokens = request.max_tokens || 1024;
+        const [cmd, ...baseArgs] = this.getEmbedCommand();
+        const args = [...baseArgs, '--profile', 'openclaw', 'memory', 'recall', this.bankId, query, '--output', 'json', '--max-tokens', String(maxTokens)];
+        try {
+            const { stdout } = await execFileAsync(cmd, args, {
+                maxBuffer: MAX_BUFFER,
+                timeout: timeoutMs ?? 30_000, // subprocess gets a longer default
+            });
+            return JSON.parse(stdout);
+        }
+        catch (error) {
+            throw new Error(`Failed to recall memories: ${error}`, { cause: error });
+        }
+    }
+}

package/dist/embed-manager.d.ts

@@ -0,0 +1,27 @@
+export declare class AtulyaEmbedManager {
+    private process;
+    private port;
+    private baseUrl;
+    private embedDir;
+    private llmProvider;
+    private llmApiKey;
+    private llmModel?;
+    private llmBaseUrl?;
+    private daemonIdleTimeout;
+    private embedVersion;
+    private embedPackagePath?;
+    constructor(port: number, llmProvider: string, llmApiKey: string, llmModel?: string, llmBaseUrl?: string, daemonIdleTimeout?: number, // Default: never timeout
+    embedVersion?: string, // Default: latest
+    embedPackagePath?: string);
+    /**
+     * Get the command to run atulya-embed (either local or from PyPI)
+     */
+    private getEmbedCommand;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private waitForReady;
+    getBaseUrl(): string;
+    isRunning(): boolean;
+    checkHealth(): Promise<boolean>;
+    private configureProfile;
+}

package/dist/embed-manager.js

@@ -0,0 +1,210 @@
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { homedir } from 'os';
+export class AtulyaEmbedManager {
+    process = null;
+    port;
+    baseUrl;
+    embedDir;
+    llmProvider;
+    llmApiKey;
+    llmModel;
+    llmBaseUrl;
+    daemonIdleTimeout;
+    embedVersion;
+    embedPackagePath;
+    constructor(port, llmProvider, llmApiKey, llmModel, llmBaseUrl, daemonIdleTimeout = 0, // Default: never timeout
+    embedVersion = 'latest', // Default: latest
+    embedPackagePath // Local path to atulya package
+    ) {
+        // Use the configured port (default: 9077 from config)
+        this.port = port;
+        this.baseUrl = `http://127.0.0.1:${port}`;
+        this.embedDir = join(homedir(), '.openclaw', 'atulya-embed');
+        this.llmProvider = llmProvider;
+        this.llmApiKey = llmApiKey;
+        this.llmModel = llmModel;
+        this.llmBaseUrl = llmBaseUrl;
+        this.daemonIdleTimeout = daemonIdleTimeout;
+        this.embedVersion = embedVersion || 'latest';
+        this.embedPackagePath = embedPackagePath;
+    }
+    /**
+     * Get the command to run atulya-embed (either local or from PyPI)
+     */
+    getEmbedCommand() {
+        if (this.embedPackagePath) {
+            // Local package: uv run --directory <path> atulya-embed
+            return ['uv', 'run', '--directory', this.embedPackagePath, 'atulya-embed'];
+        }
+        else {
+            // PyPI package: uvx atulya-embed@version
+            const embedPackage = this.embedVersion ? `atulya-embed@${this.embedVersion}` : 'atulya-embed@latest';
+            return ['uvx', embedPackage];
+        }
+    }
+    async start() {
+        console.log(`[Atulya] Starting atulya-embed daemon...`);
+        // Build environment variables using standard ATULYA_API_LLM_* variables
+        const env = {
+            ...process.env,
+            ATULYA_API_LLM_PROVIDER: this.llmProvider,
+            ATULYA_API_LLM_API_KEY: this.llmApiKey,
+            ATULYA_EMBED_DAEMON_IDLE_TIMEOUT: this.daemonIdleTimeout.toString(),
+        };
+        if (this.llmModel) {
+            env['ATULYA_API_LLM_MODEL'] = this.llmModel;
+        }
+        // Pass through base URL for OpenAI-compatible providers (OpenRouter, etc.)
+        if (this.llmBaseUrl) {
+            env['ATULYA_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['ATULYA_API_EMBEDDINGS_LOCAL_FORCE_CPU'] = '1';
+            env['ATULYA_API_RERANKER_LOCAL_FORCE_CPU'] = '1';
+        }
+        // Configure "openclaw" profile using atulya-embed configure (non-interactive)
+        console.log('[Atulya] Configuring "openclaw" profile...');
+        await this.configureProfile(env);
+        // Start atulya-embed daemon with openclaw profile
+        const embedCmd = this.getEmbedCommand();
+        const startDaemon = spawn(embedCmd[0], [...embedCmd.slice(1), 'daemon', '--profile', 'openclaw', 'start'], {
+            stdio: 'pipe',
+        });
+        // Collect output
+        let output = '';
+        startDaemon.stdout?.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            console.log(`[Atulya] ${text.trim()}`);
+        });
+        startDaemon.stderr?.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            console.error(`[Atulya] ${text.trim()}`);
+        });
+        // Wait for daemon start command to complete
+        await new Promise((resolve, reject) => {
+            startDaemon.on('exit', (code) => {
+                if (code === 0) {
+                    console.log('[Atulya] 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('[Atulya] Daemon is ready');
+    }
+    async stop() {
+        console.log('[Atulya] Stopping atulya-embed daemon...');
+        const embedCmd = this.getEmbedCommand();
+        const stopDaemon = spawn(embedCmd[0], [...embedCmd.slice(1), 'daemon', '--profile', 'openclaw', 'stop'], {
+            stdio: 'pipe',
+        });
+        await new Promise((resolve) => {
+            stopDaemon.on('exit', () => {
+                console.log('[Atulya] Daemon stopped');
+                resolve();
+            });
+            stopDaemon.on('error', (error) => {
+                console.error('[Atulya] Error stopping daemon:', error);
+                resolve(); // Resolve anyway
+            });
+            // Timeout after 5 seconds
+            setTimeout(() => {
+                console.log('[Atulya] Daemon stop timeout');
+                resolve();
+            }, 5000);
+        });
+    }
+    async waitForReady(maxAttempts = 30) {
+        console.log('[Atulya] 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('[Atulya] Daemon health check passed');
+                    return;
+                }
+            }
+            catch {
+                // Not ready yet
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        throw new Error('Atulya daemon failed to become ready within 30 seconds');
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    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 configureProfile(env) {
+        // Build profile create command args with --merge, --port and --env flags
+        // Use --merge to allow updating existing profile
+        const createArgs = ['profile', 'create', 'openclaw', '--merge', '--port', this.port.toString()];
+        // Add all environment variables as --env flags
+        const envVars = [
+            'ATULYA_API_LLM_PROVIDER',
+            'ATULYA_API_LLM_MODEL',
+            'ATULYA_API_LLM_API_KEY',
+            'ATULYA_API_LLM_BASE_URL',
+            'ATULYA_EMBED_DAEMON_IDLE_TIMEOUT',
+            'ATULYA_API_EMBEDDINGS_LOCAL_FORCE_CPU',
+            'ATULYA_API_RERANKER_LOCAL_FORCE_CPU',
+        ];
+        for (const envVar of envVars) {
+            if (env[envVar]) {
+                createArgs.push('--env', `${envVar}=${env[envVar]}`);
+            }
+        }
+        // Run profile create command (non-interactive, overwrites if exists)
+        const embedCmd = this.getEmbedCommand();
+        const create = spawn(embedCmd[0], [...embedCmd.slice(1), ...createArgs], {
+            stdio: 'pipe',
+        });
+        let output = '';
+        create.stdout?.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            console.log(`[Atulya] ${text.trim()}`);
+        });
+        create.stderr?.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            console.error(`[Atulya] ${text.trim()}`);
+        });
+        await new Promise((resolve, reject) => {
+            create.on('exit', (code) => {
+                if (code === 0) {
+                    console.log('[Atulya] Profile "openclaw" configured successfully');
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Profile create failed with code ${code}: ${output}`));
+                }
+            });
+            create.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import type { MoltbotPluginAPI, PluginConfig, PluginHookAgentContext, MemoryResult } from './types.js';
+import { AtulyaClient } from './client.js';
+/**
+ * Strip plugin-injected memory tags from content to prevent retain feedback loop.
+ * Removes <atulya_memories> and <relevant_memories> blocks that were injected
+ * during before_agent_start so they don't get re-stored into the memory bank.
+ */
+export declare function stripMemoryTags(content: string): string;
+/**
+ * Extract sender_id from OpenClaw's injected inbound metadata blocks.
+ * Checks both "Conversation info (untrusted metadata)" and "Sender (untrusted metadata)" blocks.
+ * Returns the first sender_id / id string found, or undefined if none.
+ */
+export declare function extractSenderIdFromText(text: string): string | undefined;
+/**
+ * Strip OpenClaw sender/conversation metadata envelopes from message content.
+ * These blocks are injected by OpenClaw but are noise for memory storage and recall.
+ */
+export declare function stripMetadataEnvelopes(content: string): string;
+/**
+ * Extract a recall query from a hook event's rawMessage or prompt.
+ *
+ * Prefers rawMessage (clean user text). Falls back to prompt, stripping
+ * envelope formatting (System: lines, [Channel ...] headers, [from: X] footers).
+ *
+ * Returns null when no usable query (< 5 chars) can be extracted.
+ */
+export declare function extractRecallQuery(rawMessage: string | undefined, prompt: string | undefined): string | null;
+export declare function composeRecallQuery(latestQuery: string, messages: any[] | undefined, recallContextTurns: number, recallRoles?: Array<'user' | 'assistant' | 'system' | 'tool'>): string;
+export declare function truncateRecallQuery(query: string, latestQuery: string, maxChars: number): string;
+export declare function deriveBankId(ctx: PluginHookAgentContext | undefined, pluginConfig: PluginConfig): string;
+export declare function formatMemories(results: MemoryResult[]): string;
+export default function (api: MoltbotPluginAPI): void;
+export declare function prepareRetentionTranscript(messages: any[], pluginConfig: PluginConfig, retainFullWindow?: boolean): {
+    transcript: string;
+    messageCount: number;
+} | null;
+export declare function sliceLastTurnsByUserBoundary(messages: any[], turns: number): any[];
+export declare function getClient(): AtulyaClient | null;