@memorilabs/openclaw-memori 0.0.8 → 0.0.10

package/README.md

@@ -25,154 +25,181 @@
 
 ---
 
-## Why Memori for OpenClaw?
+# Memori for OpenClaw
 
-OpenClaw ships with a simple file-first memory system designed for lightweight experimentation. As deployments scale into production environments, teams often run into memory problems that need more structured, deterministic infrastructure.
+Memori gives OpenClaw agents a structured, long-term memory system. It automatically captures what happens and lets agents recall it on demand — so context survives across sessions without bloating the prompt.
 
-Memori provides a drop-in memory layer purpose-built for agentic systems running OpenClaw in production. It works through OpenClaw's plugin lifecycle, so you get persistent, structured memory without changing your agent logic.
+Instead of relying solely on natural-language memory, Memori structures persistent memory from both conversation and agent trace — the agent's actions, tool results, decisions, and outcomes — so it can recall what actually happened when it matters.
 
-## Common Challenges with Default OpenClaw Memory
+---
+
+## The problem
 
-### 1. Fact conflicts in long-running agents
+OpenClaw's default memory works for simple use cases, but breaks at scale:
 
-OpenClaw stores memory as plain markdown files. When facts change or contradict over time, there is no deterministic conflict resolution or lifecycle management.
+- Memory is stored as flat markdown files
+- Context is lost due to compaction
+- Important decisions and constraints disappear
+- No relationships between facts
+- Memory bleeds across users and projects
 
-Memori introduces structured memory with update logic, decay policies, and deterministic fact handling.
+---
 
-### 2. Context loss from token limits
+## What Memori changes
 
-As sessions grow, context must be compacted to fit within model token limits. Important details can be dropped during compression.
+Memori replaces flat memory with structured, scoped memory built from:
 
-Memori stores memory outside the prompt and retrieves the right facts at query time, eliminating compaction loss.
+- Agent execution (tool calls, results, decisions, outcomes)
 
-### 3. No relationship reasoning
+Instead of replaying history, agents retrieve exactly what they need.
 
-OpenClaw retrieves semantically similar text but does not model relationships between entities.
+---
 
-Memori builds structured memory graphs that let agents reason across linked facts, not just retrieve similar chunks.
+## How it works
 
-### 4. Cross-project noise
+Memori runs on two parallel systems:
 
-When multiple projects share memory storage, irrelevant context can bleed across workflows.
+### 1. Advanced augmentation
 
-Memori supports scoped memory namespaces to isolate projects and workflows.
+After each interaction, Memori converts raw session data into structured, reusable memories asynchronously.
 
-### 5. No user-level isolation
+- Transforms raw agent sessions into structured memory units
+- Captures the agent's actions, reasoning, tool usage, responses, corrections, and failures
+- Organizes into classes to enable efficient retrieval
+- Generates embeddings for semantic retrieval
+- Updates structured memory and the knowledge graph
 
-Default memory systems do not provide deterministic isolation across users.
+This is how structured memory is continuously built and updated over time.
 
-Memori enforces user-scoped memory boundaries for secure multi-user deployments.
+It runs **after the agent responds** and does not impact latency.
 
-## What Changes When You Add Memori?
+---
 
-The Memori plugin replaces OpenClaw's flat-file memory workflow with managed, structured memory that is scoped by `entity_id`, `process_id`, and `session_id` and enriched automatically through OpenClaw's existing hooks.
+### 2. Agent-controlled recall
 
-| Capability | What changes |
-| --- | --- |
-| **Structured memory storage** | Instead of raw markdown blobs, Memori stores conversations, facts, preferences, and knowledge-graph triples as structured records tied to an entity, process, and session. Facts are extracted as subject-predicate-object relationships, deduplicated over time, and connected into a graph so related memories stay queryable instead of being buried in text files. |
-| **Advanced Augmentation** | After each conversation, Memori processes the user and assistant exchange asynchronously in the background, identifies facts, preferences, skills, and attributes, generates embeddings for semantic search, and updates the knowledge graph without blocking the agent's response path. |
-| **Intelligent Recall** | Before the agent responds, Memori searches the current entity's stored facts and knowledge graph, ranks memories by semantic relevance and importance, and injects the most useful context into the prompt so durable knowledge survives context-window compression. |
-| **Production-ready observability** | Memori Cloud gives you dashboard visibility into memory creation, recalls, cache hit rate, sessions, quota usage, top subjects, per-memory retrieval metrics, and knowledge-graph relationships, so you can inspect what was stored and how recall is behaving in production. |
+Recall is **explicit and initiated by the agent**.
 
-The plugin still remains drop-in: OpenClaw handles the agent loop, while Memori adds recall, augmentation, sanitization, and observability around it.
+Memori separates memory creation from memory recall:
 
+- Creation is automatic (advanced augmentation)
+- Recall is intentional (agent-controlled)
 
-## Quickstart
+Agents decide:
 
-Get persistent memory running in your OpenClaw gateway in three steps.
+- When to recall
+- What scope to recall from
+- How much history to include
+
+Memori does not automatically inject memory into the prompt. The agent retrieves only the context it needs, keeping token usage efficient.
+
+Available tools:
+
+- **`memori_recall`** — query structured memory for facts, constraints, decisions, and patterns
+- **`memori_recall_summary`** — retrieve summaries and the daily brief
+- **`memori_feedback`** — report on memory quality to improve the system
+
+---
+
+## Quickstart
 
 ### Prerequisites
 
 - [OpenClaw](https://openclaw.ai) `v2026.3.2` or later
 - A Memori API key from [app.memorilabs.ai](https://app.memorilabs.ai)
-- An Entity ID to attribute memories to, such as a user ID, tenant ID, or agent name
-
-### 1. Install and Enable
+- An Entity ID to scope memory to a specific user, agent, or system
+- A Project ID to scope memory to a specific project or workspace
 
-Run the following commands in your terminal to install and enable the plugin:
+### 1. Install
 
 ```bash
-# 1. Install the plugin from npm
 openclaw plugins install @memorilabs/openclaw-memori
-
-# 2. Enable it in your workspace
 openclaw plugins enable openclaw-memori
-
-# 3. Restart the OpenClaw gateway
-openclaw gateway restart
 ```
 
 ### 2. Configure
 
-The plugin needs your Memori API key and an Entity ID to function. You can configure this via the OpenClaw CLI or your `openclaw.json` file.
+```bash
+openclaw memori init \
+  --api-key "YOUR_MEMORI_API_KEY" \
+  --entity-id "your-app-user-id" \
+  --project-id "my-project"
+```
 
-### Option A: Via OpenClaw CLI (Recommended)
+### 3. Verify
 
 ```bash
-openclaw config set plugins.entries.openclaw-memori.config.apiKey "YOUR_MEMORI_API_KEY"
-openclaw config set plugins.entries.openclaw-memori.config.entityId "your-app-user-id"
+openclaw gateway restart
+openclaw memori status --check
 ```
 
-### Option B: Via `openclaw.json`
-
-Add the following to your `~/.openclaw/openclaw.json` file:
-
-```json
-{
-  "plugins": {
-    "entries": {
-      "openclaw-memori": {
-        "enabled": true,
-        "config": {
-          "apiKey": "your-memori-api-key",
-          "entityId": "your-app-user-id"
-        }
-      }
-    }
-  }
-}
+Expected:
+
+```
+Status: Ready
 ```
 
-### Configuration Options
+### 4. Test the memory loop
 
-| Option     | Type     | Required | Description                                                                                         |
-| ---------- | -------- | -------- | --------------------------------------------------------------------------------------------------- |
-| `apiKey`   | `string` | **Yes**  | Your Memori API key.                                                                                |
-| `entityId` | `string` | **Yes**  | The unique identifier for the entity (e.g., user, agent, or tenant) to attribute these memories to. |
+1. Tell the agent something durable:
 
-### 3. Verify
+   > "I always use TypeScript and prefer functional patterns."
 
-Restart the gateway and inspect the logs:
+2. Start a new session and ask:
 
-```bash
-openclaw gateway restart
-openclaw gateway logs --filter "[Memori]"
-```
+   > "Write a hello world script in my preferred language."
 
-You should see:
+3. Confirm the agent used `memori_recall` to fetch your preferences:
+   ```
+   [Memori] memori_recall params: {"projectId":"my-project","query":"preferred programming language"}
+   ```
 
-```text
-[Memori] === INITIALIZING PLUGIN ===
-[Memori] Tracking Entity ID: your-app-user-id
-```
+If it works, you now have persistent memory across sessions.
+
+---
+
+## Memory model
+
+Memory is scoped to prevent noise and ensure relevance:
+
+- `entity_id` → user, agent, or system context
+- `project_id` → project or workspace context
+- `session_id` → specific session (requires `project_id`)
+- `date_start` / `date_end` → time-bounded recall (defaults to all-time if omitted)
+- `source` → type of memory (recall only)
+- `signal` → how the memory was derived (recall only)
+
+All timestamps are stored in **UTC**.
 
-To test the full memory loop:
+---
+
+## Agent behavior (read this)
+
+Agents should:
 
-1. Send a message with a durable preference:
-   `I always use TypeScript and prefer functional patterns.`
-2. Confirm augmentation ran:
-   `Augmentation successful!`
-3. Start a new session and ask:
-   `Write a hello world script.`
-4. Confirm recall ran:
-   `Successfully injected memory context.`
+- Retrieve a summary at the start of meaningful sessions
+- Use targeted recall (not broad queries)
+- Avoid recalling on every turn
+- Use memory only when context is needed
+- Send feedback when memory is missing or incorrect
+
+See SKILL.md for full behavior guidelines.
+
+---
 
-## How It Works
+## Typical workflow
 
-This plugin integrates with OpenClaw's event lifecycle to provide persistent memory without interfering with the agent's core logic:
+1. Start session → retrieve summary
+2. During task → targeted recall
+3. Missing context → send feedback
+4. End of session → memory is captured automatically
 
-1. **`before_prompt_build` (Intelligent Recall):** When a user sends a message, the plugin intercepts the event, queries the Memori API, and safely prepends relevant memories to the agent's system context.
-2. **`agent_end` (Advanced Augmentation):** Once the agent finishes generating its response, the plugin captures the final `user` and `assistant` messages, sanitizes them, and sends them to the Memori integration endpoint for long-term storage and entity mapping.
+---
+
+## Multi-agent ready
+
+The plugin is fully stateless and thread-safe. You can run it across multiple agents in the same gateway without shared state or concurrency issues.
+
+---
 
 ## Contributing
 

package/dist/cli/commands.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+export declare function registerCliCommands(api: OpenClawPluginApi): void;

package/dist/cli/commands.js

@@ -0,0 +1,143 @@
+import { createRecallClient } from '../utils/memori-client.js';
+import { CONFIG_KEY_MAP, readPluginConfig, writePluginConfig } from './config-file.js';
+function maskKey(key) {
+    if (key.length <= 8)
+        return '****';
+    return `****...${key.slice(-4)}`;
+}
+function isReady(cfg) {
+    return Boolean(cfg.apiKey && cfg.entityId && cfg.projectId);
+}
+export function registerCliCommands(api) {
+    api.registerCli(({ program }) => {
+        const memori = program
+            .command('memori')
+            .description('Memori memory plugin commands')
+            .configureHelp({ sortSubcommands: true });
+        // ── init ────────────────────────────────────────────────────────────────
+        memori
+            .command('init')
+            .description('Configure the Memori plugin with your API credentials')
+            .option('--api-key <key>', 'Memori API key (from app.memorilabs.ai)')
+            .option('--entity-id <id>', 'Entity ID to scope all memories to')
+            .option('--project-id <id>', 'Project ID to scope all memories to')
+            .action((opts) => {
+            const missing = [];
+            if (!opts.apiKey)
+                missing.push('--api-key');
+            if (!opts.entityId)
+                missing.push('--entity-id');
+            if (!opts.projectId)
+                missing.push('--project-id');
+            if (missing.length > 0) {
+                console.error(`Error: missing required option(s): ${missing.join(', ')}`);
+                console.error('\nUsage:\n  openclaw memori init --api-key <key> --entity-id <id> --project-id <id>');
+                process.exitCode = 1;
+                return;
+            }
+            writePluginConfig({
+                apiKey: opts.apiKey,
+                entityId: opts.entityId,
+                projectId: opts.projectId,
+            });
+            console.log('\nMemori configured successfully.\n');
+            console.log(`  API Key:    ${maskKey(opts.apiKey || '')}`);
+            console.log(`  Entity ID:  ${opts.entityId}`);
+            console.log(`  Project ID: ${opts.projectId}`);
+            console.log('\nRestart the gateway to apply changes:');
+            console.log('  openclaw gateway restart\n');
+        });
+        // ── status ──────────────────────────────────────────────────────────────
+        memori
+            .command('status')
+            .description('Show current configuration and verify API connectivity')
+            .option('--check', 'Test live API connectivity')
+            .action(async (opts) => {
+            const cfg = readPluginConfig();
+            const ready = isReady(cfg);
+            console.log('\nMemori Plugin Status');
+            console.log('─'.repeat(36));
+            console.log(`  API Key:    ${cfg.apiKey ? maskKey(cfg.apiKey) : '(not set)'}`);
+            console.log(`  Entity ID:  ${cfg.entityId ?? '(not set)'}`);
+            console.log(`  Project ID: ${cfg.projectId ?? '(not set)'}`);
+            console.log();
+            if (!ready) {
+                console.log('Status: Not configured.');
+                console.log('Run:    openclaw memori init --api-key <key> --entity-id <id> --project-id <id>\n');
+                process.exitCode = 1;
+                return;
+            }
+            if (opts.check) {
+                process.stdout.write('Checking API connectivity... ');
+                try {
+                    const client = createRecallClient(cfg.apiKey || '', cfg.entityId || '');
+                    await client.agentRecall({ projectId: cfg.projectId });
+                    console.log('OK');
+                }
+                catch (e) {
+                    console.log('FAILED');
+                    console.error(`  ${String(e)}\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+            }
+            console.log('Status: Ready\n');
+        });
+        // ── config ──────────────────────────────────────────────────────────────
+        const configCmd = memori
+            .command('config')
+            .description('Manage plugin configuration')
+            .configureHelp({ sortSubcommands: true });
+        const KEYS = Object.keys(CONFIG_KEY_MAP).join(', ');
+        configCmd
+            .command('show')
+            .description('Display current configuration')
+            .action(() => {
+            const cfg = readPluginConfig();
+            console.log('\nMemori Plugin Configuration');
+            console.log('─'.repeat(36));
+            console.log(`  api-key:    ${cfg.apiKey ? maskKey(cfg.apiKey) : '(not set)'}`);
+            console.log(`  entity-id:  ${cfg.entityId ?? '(not set)'}`);
+            console.log(`  project-id: ${cfg.projectId ?? '(not set)'}`);
+            console.log();
+        });
+        configCmd
+            .command('get')
+            .argument('<key>', `Config key — one of: ${KEYS}`)
+            .description('Get a specific config value')
+            .action((key) => {
+            if (!(key in CONFIG_KEY_MAP)) {
+                console.error(`Unknown key "${key}". Valid keys: ${KEYS}`);
+                process.exitCode = 1;
+                return;
+            }
+            const field = CONFIG_KEY_MAP[key];
+            const value = readPluginConfig()[field];
+            if (value === undefined) {
+                console.log('(not set)');
+            }
+            else {
+                console.log(field === 'apiKey' ? maskKey(value) : value);
+            }
+        });
+        configCmd
+            .command('set')
+            .argument('<key>', `Config key — one of: ${KEYS}`)
+            .argument('<value>', 'Value to set')
+            .description('Set a specific config value')
+            .action((key, value) => {
+            if (!(key in CONFIG_KEY_MAP)) {
+                console.error(`Unknown key "${key}". Valid keys: ${KEYS}`);
+                process.exitCode = 1;
+                return;
+            }
+            const field = CONFIG_KEY_MAP[key];
+            writePluginConfig({ [field]: value });
+            console.log(`Set ${key}.`);
+        });
+    }, {
+        descriptors: [
+            { name: 'memori', description: 'Memori memory plugin commands', hasSubcommands: true },
+        ],
+    });
+}

package/dist/cli/config-file.d.ts

@@ -0,0 +1,8 @@
+export interface MemoriCLIConfig {
+    apiKey?: string;
+    entityId?: string;
+    projectId?: string;
+}
+export declare function readPluginConfig(): MemoriCLIConfig;
+export declare function writePluginConfig(updates: Partial<MemoriCLIConfig>): void;
+export declare const CONFIG_KEY_MAP: Record<string, keyof MemoriCLIConfig>;

package/dist/cli/config-file.js

@@ -0,0 +1,64 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+const PLUGIN_ID = 'openclaw-memori';
+const CONFIG_PATH = join(homedir(), '.openclaw', 'openclaw.json');
+function readFullConfig() {
+    if (!existsSync(CONFIG_PATH))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    }
+    catch (e) {
+        throw new Error(`Failed to parse OpenClaw config at ${CONFIG_PATH}: ${String(e)}`);
+    }
+}
+function writeFullConfig(config) {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+function ensurePluginStructure(config) {
+    if (!config.plugins || typeof config.plugins !== 'object')
+        config.plugins = {};
+    const plugins = config.plugins;
+    if (!plugins.entries || typeof plugins.entries !== 'object')
+        plugins.entries = {};
+    const entries = plugins.entries;
+    if (!entries[PLUGIN_ID] || typeof entries[PLUGIN_ID] !== 'object')
+        entries[PLUGIN_ID] = {};
+    const entry = entries[PLUGIN_ID];
+    if (!entry.config || typeof entry.config !== 'object')
+        entry.config = {};
+}
+function getPluginConfigBlock(full) {
+    const plugins = full.plugins;
+    const entries = plugins?.entries;
+    const entry = entries?.[PLUGIN_ID];
+    return entry?.config;
+}
+export function readPluginConfig() {
+    const cfg = getPluginConfigBlock(readFullConfig());
+    if (!cfg)
+        return {};
+    return {
+        apiKey: cfg.apiKey,
+        entityId: cfg.entityId,
+        projectId: cfg.projectId,
+    };
+}
+export function writePluginConfig(updates) {
+    const full = readFullConfig();
+    ensurePluginStructure(full);
+    const entry = full.plugins.entries[PLUGIN_ID];
+    const cfg = entry.config;
+    for (const [key, value] of Object.entries(updates)) {
+        if (value)
+            cfg[key] = value;
+    }
+    writeFullConfig(full);
+}
+export const CONFIG_KEY_MAP = {
+    'api-key': 'apiKey',
+    'entity-id': 'entityId',
+    'project-id': 'projectId',
+};

package/dist/handlers/augmentation.js

@@ -1,5 +1,5 @@
 import { extractContext, initializeMemoriClient } from '../utils/index.js';
-import { cleanText, isSystemMessage } from '../sanitizer.js';
+import { cleanText, extractContentType, isSystemMessage } from '../sanitizer.js';
 import { AUGMENTATION_CONFIG, MESSAGE_CONSTANTS, ROLE } from '../constants.js';
 import { SDK_VERSION } from '../version.js';
 /**
@@ -73,7 +73,9 @@ function extractToolCalls(msg, toolResults) {
  */
 function parseUserMessage(msg) {
     const cleanedContent = cleanText(msg.content);
-    return cleanedContent ? { role: msg.role, content: cleanedContent } : null;
+    return cleanedContent
+        ? { role: msg.role, content: cleanedContent, type: extractContentType(msg.content) }
+        : null;
 }
 /**
  * Parses the most recent conversation turn from messages.
@@ -102,10 +104,15 @@ function parseTurnFromMessages(messages) {
                     assistantMessage = {
                         role: msg.role,
                         content: cleanedContent.replace(/^\[\[.*?\]\]\s*/, ''),
+                        type: extractContentType(msg.content),
                     };
                 }
                 else if (extractedTools.length > 0) {
-                    assistantMessage = { role: msg.role, content: MESSAGE_CONSTANTS.SILENT_REPLY };
+                    assistantMessage = {
+                        role: msg.role,
+                        content: MESSAGE_CONSTANTS.SILENT_REPLY,
+                        type: extractContentType(msg.content),
+                    };
                 }
             }
         }
@@ -164,8 +171,8 @@ export async function handleAugmentation(event, ctx, config, logger) {
             logger.info('Assistant used tool-based messaging. Using synthetic response.');
             turn.assistantMessage.content = MESSAGE_CONSTANTS.SYNTHETIC_RESPONSE;
         }
-        const payload = buildAugmentationPayload(turn.userMessage.content, turn.assistantMessage.content, turn.tools, event);
-        const context = extractContext(event, ctx, config.entityId);
+        const payload = buildAugmentationPayload(turn.userMessage, turn.assistantMessage, turn.tools, event);
+        const context = extractContext(event, ctx, config.entityId, config.projectId);
         const memoriClient = initializeMemoriClient(config.apiKey, context);
         await memoriClient.augmentation(payload);
         logger.info('Augmentation successful!');

package/dist/index.js

@@ -1,26 +1,33 @@
-import { handleRecall } from './handlers/recall.js';
 import { handleAugmentation } from './handlers/augmentation.js';
 import { PLUGIN_CONFIG } from './constants.js';
-import { MemoriLogger } from './utils/index.js';
+import { MemoriLogger, loadSkillsContent } from './utils/index.js';
+import { registerAllTools } from './tools/index.js';
+import { registerCliCommands } from './cli/commands.js';
 const memoriPlugin = {
     id: PLUGIN_CONFIG.ID,
     name: PLUGIN_CONFIG.NAME,
     description: 'Hosted memory backend',
     register(api) {
+        registerCliCommands(api);
         const rawConfig = api.pluginConfig;
         const config = {
             apiKey: rawConfig?.apiKey,
             entityId: rawConfig?.entityId,
+            projectId: rawConfig?.projectId,
         };
         if (!config.apiKey || !config.entityId) {
             api.logger.warn(`${PLUGIN_CONFIG.LOG_PREFIX} Missing apiKey or entityId in config. Plugin disabled.`);
             return;
         }
         const logger = new MemoriLogger(api);
+        const skillsContent = loadSkillsContent(api.resolvePath.bind(api));
         logger.info(`\n=== ${PLUGIN_CONFIG.LOG_PREFIX} INITIALIZING PLUGIN ===`);
         logger.info(`${PLUGIN_CONFIG.LOG_PREFIX} Tracking Entity ID: ${config.entityId}`);
-        api.on('before_prompt_build', (event, ctx) => handleRecall(event, ctx, config, logger));
+        if (skillsContent) {
+            api.on('before_prompt_build', () => ({ appendSystemContext: skillsContent }));
+        }
         api.on('agent_end', (event, ctx) => handleAugmentation(event, ctx, config, logger));
+        registerAllTools({ api, config, logger });
     },
 };
 export default memoriPlugin;

package/dist/sanitizer.d.ts

@@ -1,2 +1,3 @@
 export declare function isSystemMessage(text: string): boolean;
+export declare function extractContentType(rawContent: unknown): string;
 export declare function cleanText(rawContent: unknown): string;

package/dist/sanitizer.js

@@ -19,7 +19,7 @@ export function isSystemMessage(text) {
  *
  * OpenClaw wraps metadata in markdown code fences (triple tick).
  * The actual message is always after the LAST closing fence.
- * The message might aslo contain a timestamp prefix like: [Day YYYY-MM-DD HH:MM TZ], that will need to be removed
+ * The message might also contain a timestamp prefix like: [Day YYYY-MM-DD HH:MM TZ], that will need to be removed
  */
 function extractRawUserMessage(content) {
     let message = content;
@@ -49,11 +49,19 @@ function extractMessageText(content) {
     }
     return '';
 }
+export function extractContentType(rawContent) {
+    if (typeof rawContent === 'string' || !rawContent)
+        return 'text';
+    if (isMessageBlockArray(rawContent)) {
+        const primary = rawContent.find((block) => (block.type === 'text' || typeof block.text === 'string') && block.text);
+        return primary?.type ?? 'text';
+    }
+    return 'text';
+}
 export function cleanText(rawContent) {
     let text = extractMessageText(rawContent);
     if (!text)
         return '';
     text = extractRawUserMessage(text);
-    text = text.replace(/<memori_context>[\s\S]*?<\/memori_context>\s*/g, '');
     return text.trim();
 }

package/dist/tools/index.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDeps } from './types.js';
+export declare function registerAllTools(deps: ToolDeps): void;
+export type { ToolDeps };

package/dist/tools/index.js

@@ -0,0 +1,12 @@
+import { createMemoriSignupTool } from './memori-signup.js';
+import { createMemoriQuotaTool } from './memori-quota.js';
+import { createMemoriRecallTool } from './memori-recall.js';
+import { createMemoriRecallSummaryTool } from './memori-recall-summary.js';
+import { createMemoriFeedbackTool } from './memori-feedback.js';
+export function registerAllTools(deps) {
+    deps.api.registerTool(createMemoriSignupTool(deps));
+    deps.api.registerTool(createMemoriQuotaTool(deps));
+    deps.api.registerTool(createMemoriRecallTool(deps));
+    deps.api.registerTool(createMemoriRecallSummaryTool(deps));
+    deps.api.registerTool(createMemoriFeedbackTool(deps));
+}

package/dist/tools/memori-feedback.d.ts

@@ -0,0 +1,25 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriFeedbackTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            content: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(_toolCallId: string, params: {
+        content: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: null;
+    }>;
+};