verybot 0.1.3

package/dist/tools/delegate.js

@@ -0,0 +1,216 @@
+import { randomUUID } from "crypto";
+import { tool } from "ai";
+import { z } from "zod";
+import { Session } from "../brain/session.js";
+import { buildSystemPrompt } from "../brain/context.js";
+import { runLoop } from "../brain/loop.js";
+import { createMemorySearchTool } from "./memory.js";
+import { emit } from "../events.js";
+import { logger } from "../logger.js";
+import { BrowserManager } from "../computer/browser/manager.js";
+import { createBrowserTools, BROWSER_TOOL_NAMES } from "../computer/browser/tools.js";
+import { DEFAULT_WORKER_TIMEOUT_S } from "../config/agent-config.js";
+/**
+ * Creates delegation tools:
+ * - `delegate`      — fires a worker in background, returns channel ID immediately
+ * - `read_channel`  — reads all messages from a channel (available to orchestrator AND workers)
+ */
+export function createDelegationTools(registry, channelStore, delegationStore, sessionStore, orchestratorId, sessionKey, memoryStore, embeddingProvider, memoryMaxResults, onWorkerComplete, browserConfig, 
+/** Human-readable session label for logs (team name instead of UUID). */
+sessionLabel) {
+    const delegatable = registry.delegatableWorkers();
+    const orchestratorName = registry.getOrchestrator().name;
+    const idToName = registry.buildIdToNameMap();
+    const delegate = tool({
+        description: `Delegate a task to a specialized worker agent. Returns immediately with a channel ID — the worker runs in the background. ` +
+            `You will be automatically notified when workers finish. Use read_channel to see results. ` +
+            `Available workers: ${delegatable.join(", ")}. ` +
+            `You can fire multiple delegations in the same step — they all run concurrently. ` +
+            `Pass contextChannels to give the worker read access to other workers' channels.`,
+        inputSchema: z.object({
+            worker: z
+                .string()
+                .describe(`Which worker to delegate to. One of: ${delegatable.join(", ")}`),
+            task: z
+                .string()
+                .describe("Self-contained task description for the worker"),
+            contextChannels: z
+                .array(z.string())
+                .optional()
+                .describe("Channel IDs the worker can read for context from other workers"),
+        }),
+        execute: async ({ worker, task, contextChannels }) => {
+            const resolved = registry.resolveWorker(worker);
+            if (!resolved) {
+                return `Unknown worker: ${worker}. Available: ${delegatable.join(", ")}`;
+            }
+            const { agentConfig, model, tools: workerBaseTools } = resolved;
+            const agentId = agentConfig.id;
+            const agentName = agentConfig.name;
+            // Create channel for this delegation
+            const channelId = channelStore.createChannel();
+            channelStore.post(channelId, orchestratorId, "task", task);
+            // Record in delegation store (uses DB id for storage)
+            const delegationId = randomUUID().slice(0, 8);
+            delegationStore.insert({
+                id: delegationId,
+                agentId,
+                sessionKey,
+                task,
+                channelId,
+                status: "running",
+                createdAt: Date.now(),
+            });
+            // Worker tools: base (filtered) + memory_search (read-only) + read_channel
+            // Give worker its own browser instance (temp profile) so it doesn't conflict with others
+            const hasBrowserTools = BROWSER_TOOL_NAMES.some((n) => n in workerBaseTools);
+            let workerBrowser = null;
+            const workerTools = { ...workerBaseTools };
+            if (hasBrowserTools && browserConfig) {
+                // Strip shared browser tools, replace with per-worker instance
+                for (const n of BROWSER_TOOL_NAMES)
+                    delete workerTools[n];
+                workerBrowser = new BrowserManager({ ...browserConfig, profileDir: "temp" });
+                Object.assign(workerTools, createBrowserTools(workerBrowser));
+            }
+            if (memoryStore) {
+                workerTools.memory_search = createMemorySearchTool(memoryStore, embeddingProvider, memoryMaxResults);
+            }
+            // Workers can read channels (their own + any context channels)
+            workerTools.read_channel = createReadChannelTool(channelStore, idToName);
+            // Build context hint about available channels
+            let channelHint = "";
+            if (contextChannels?.length) {
+                channelHint = `\n\nYou have access to read_channel. Context channels from other workers: ${contextChannels.join(", ")}. Call read_channel to see their results before starting your work.`;
+            }
+            const system = buildSystemPrompt({
+                identity: agentConfig.identity,
+                hasMemory: memoryStore !== null,
+            });
+            // Worker key extends parent key: {parentSessionKey}:{workerName}:{timestamp}
+            const workerSessionKey = `${sessionKey}:${agentName}:${Date.now()}`;
+            const session = new Session(workerSessionKey);
+            session.append({ role: "user", content: task + channelHint });
+            logger.info(`[delegate] ${orchestratorId} -> ${agentName}: ${task.slice(0, 200)} (channel: ${channelId})`);
+            emit("agent", {
+                sessionKey,
+                delegation: { agentId, agentName, channelId, status: "started" },
+            });
+            // Fire worker in background with timeout — does NOT await
+            const workerMaxSteps = agentConfig.maxSteps > 0 ? agentConfig.maxSteps : undefined;
+            const workerLabel = sessionLabel ? `worker:${sessionLabel}:${agentName}` : undefined;
+            // Extract team name from sessionLabel (format: "TeamName:channel:id...") for worker metadata
+            const teamName = sessionLabel?.split(":")[0];
+            const timeoutMs = (agentConfig.timeout ?? DEFAULT_WORKER_TIMEOUT_S) * 1_000;
+            withTimeout(runWorker(agentId, agentName, model, system, session, workerTools, workerSessionKey, workerMaxSteps, workerLabel), timeoutMs, `Worker ${agentName} timed out after ${timeoutMs / 1_000}s`).then(({ text: result, responseMessages }) => {
+                // Persist worker session with full tool call detail
+                for (const msg of responseMessages)
+                    session.append(msg);
+                sessionStore.save(session).then(() => {
+                    // Enrich worker session metadata for UI display
+                    sessionStore.updateMetadata(workerSessionKey, {
+                        channelType: "worker",
+                        agentId,
+                        agentName,
+                        ...(teamName ? { teamName } : {}),
+                    });
+                }).catch((err) => {
+                    logger.warn(`[delegate] Failed to save worker session ${workerSessionKey}: ${err instanceof Error ? err.message : err}`);
+                });
+                // Close the worker's own browser instance
+                cleanupWorkerBrowser(workerBrowser, agentName);
+                channelStore.post(channelId, agentId, "result", result);
+                delegationStore.markCompleted(delegationId, result);
+                logger.info(`[delegate] ${agentName} completed (${result.length} chars, channel: ${channelId})`);
+                emit("agent", {
+                    sessionKey,
+                    delegation: { agentId, agentName, channelId, status: "completed", resultLength: result.length },
+                });
+                onWorkerComplete(sessionKey, channelId);
+            }, (err) => {
+                const error = err instanceof Error ? err.message : String(err);
+                // Persist worker session even on failure for debugging
+                sessionStore.save(session).then(() => {
+                    sessionStore.updateMetadata(workerSessionKey, {
+                        channelType: "worker",
+                        agentId,
+                        agentName,
+                        ...(teamName ? { teamName } : {}),
+                    });
+                }).catch((saveErr) => {
+                    logger.warn(`[delegate] Failed to save worker session ${workerSessionKey}: ${saveErr instanceof Error ? saveErr.message : saveErr}`);
+                });
+                // Close the worker's own browser instance even on failure
+                cleanupWorkerBrowser(workerBrowser, agentName);
+                channelStore.post(channelId, agentId, "error", error);
+                delegationStore.markFailed(delegationId, error);
+                logger.error(`[delegate] ${agentName} failed: ${error} (channel: ${channelId})`);
+                emit("agent", {
+                    sessionKey,
+                    delegation: { agentId, agentName, channelId, status: "failed", error },
+                });
+                onWorkerComplete(sessionKey, channelId);
+            });
+            return `Delegated to ${agentName}. Channel: ${channelId}`;
+        },
+    });
+    const readChannel = createReadChannelTool(channelStore, idToName);
+    return { delegate, read_channel: readChannel };
+}
+/** Standalone read_channel tool — reused by both orchestrator and workers. */
+function createReadChannelTool(channelStore, nameMap) {
+    return tool({
+        description: "Read all messages from a delegation channel. Returns the full conversation log " +
+            "including tasks, results, and errors posted by any agent.",
+        inputSchema: z.object({
+            channelId: z
+                .string()
+                .describe("The channel ID to read"),
+        }),
+        execute: async ({ channelId }) => {
+            const messages = channelStore.read(channelId);
+            if (messages.length === 0)
+                return `Channel ${channelId}: no messages yet.`;
+            return messages
+                .map((m) => `[${nameMap?.get(m.sender) ?? m.sender}] (${m.role}): ${m.content}`)
+                .join("\n\n");
+        },
+    });
+}
+const DEFAULT_WORKER_MAX_STEPS = 20;
+/** Run a worker's loop — returned promise settles when done. */
+async function runWorker(agentId, agentName, model, system, session, tools, workerSessionKey, maxSteps, sessionLabel) {
+    try {
+        return await runLoop({
+            model,
+            system,
+            messages: session.getMessages(),
+            tools,
+            sessionKey: workerSessionKey,
+            sessionLabel,
+            agentId,
+            maxSteps: maxSteps ?? DEFAULT_WORKER_MAX_STEPS,
+            silent: true,
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        logger.error(`[delegate] ${agentName} worker failed: ${error}`);
+        throw err;
+    }
+}
+/** Close the browser if the worker had it open. No-op if no browser or already closed. */
+function cleanupWorkerBrowser(browserManager, agentName) {
+    if (!browserManager?.isLaunched())
+        return;
+    browserManager.close().catch((err) => {
+        logger.warn(`[delegate] ${agentName} browser cleanup failed: ${err instanceof Error ? err.message : err}`);
+    });
+}
+/** Race a promise against a timeout. */
+function withTimeout(promise, ms, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), ms);
+        promise.then((val) => { clearTimeout(timer); resolve(val); }, (err) => { clearTimeout(timer); reject(err); });
+    });
+}

package/dist/tools/fs.d.ts

@@ -0,0 +1,4 @@
+import { type Tool } from "ai";
+export declare function createFsTools(opts?: {
+    sandboxed?: boolean;
+}): Record<string, Tool>;

package/dist/tools/fs.js

@@ -0,0 +1,335 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { readFile, writeFile, mkdir, readdir } from "fs/promises";
+import { execSync } from "child_process";
+import { dirname, resolve } from "path";
+import { sanitizeEnv } from "../security/env-filter.js";
+import { logger } from "../logger.js";
+/* ------------------------------------------------------------------ */
+/*  Constants                                                          */
+/* ------------------------------------------------------------------ */
+const MAX_OUTPUT = 10_000;
+const DEFAULT_LINE_LIMIT = 2_000;
+const DEFAULT_SEARCH_LIMIT = 200;
+const EXEC_TIMEOUT = 15_000;
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+function sliceLines(text, offset, limit) {
+    const lines = text.split("\n");
+    const start = Math.max(0, offset);
+    const end = Math.min(lines.length, start + limit);
+    return lines
+        .slice(start, end)
+        .map((line, i) => `${start + i + 1}\t${line}`)
+        .join("\n");
+}
+function truncate(text, max = MAX_OUTPUT) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max) + "\n…[truncated]";
+}
+/** Truncate output to N lines (for limiting search results in JS). */
+function truncateLines(text, maxLines) {
+    const lines = text.split("\n");
+    if (lines.length <= maxLines)
+        return text;
+    return lines.slice(0, maxLines).join("\n") + "\n…[truncated]";
+}
+let rgAvailable = null;
+function isRipgrepAvailable() {
+    if (rgAvailable === null) {
+        try {
+            execSync("rg --version", { stdio: "ignore", timeout: 3_000 });
+            rgAvailable = true;
+        }
+        catch {
+            rgAvailable = false;
+        }
+    }
+    return rgAvailable;
+}
+function shellEscape(arg) {
+    if (arg.includes("\0")) {
+        throw new Error("Null bytes not allowed in shell arguments");
+    }
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+/* ------------------------------------------------------------------ */
+/*  Tools                                                              */
+/* ------------------------------------------------------------------ */
+const readTool = tool({
+    description: "Read a file from the filesystem. Returns numbered lines. " +
+        "Use offset/limit for large files.",
+    inputSchema: z.object({
+        path: z.string().describe("Absolute or relative file path"),
+        offset: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("0-based line offset to start reading from"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Max number of lines to return"),
+    }),
+    execute: async ({ path, offset, limit }) => {
+        try {
+            const content = await readFile(resolve(path), "utf-8");
+            const lineOffset = offset ?? 0;
+            const lineLimit = limit ?? DEFAULT_LINE_LIMIT;
+            return truncate(sliceLines(content, lineOffset, lineLimit));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`read failed: ${msg}`);
+            return `Error: ${msg}`;
+        }
+    },
+});
+const writeTool = tool({
+    description: "Write content to a file. Creates parent directories if needed. " +
+        "Overwrites existing files.",
+    inputSchema: z.object({
+        path: z.string().describe("Absolute or relative file path"),
+        content: z.string().describe("File content to write"),
+    }),
+    execute: async ({ path, content }) => {
+        try {
+            const resolved = resolve(path);
+            await mkdir(dirname(resolved), { recursive: true });
+            await writeFile(resolved, content, "utf-8");
+            return `Wrote ${content.split("\n").length} lines to ${resolved}`;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`write failed: ${msg}`);
+            return `Error: ${msg}`;
+        }
+    },
+});
+const editTool = tool({
+    description: "Edit a file by replacing an exact text match. " +
+        "oldText must appear exactly once in the file.",
+    inputSchema: z.object({
+        path: z.string().describe("Absolute or relative file path"),
+        oldText: z.string().min(1).describe("Exact text to find (must be unique in file)"),
+        newText: z.string().describe("Replacement text"),
+    }),
+    execute: async ({ path, oldText, newText }) => {
+        try {
+            const resolved = resolve(path);
+            const content = await readFile(resolved, "utf-8");
+            const occurrences = content.split(oldText).length - 1;
+            if (occurrences === 0) {
+                return "Error: oldText not found in file";
+            }
+            if (occurrences > 1) {
+                return `Error: oldText found ${occurrences} times — must be unique. Provide more surrounding context.`;
+            }
+            // Use function replacement to avoid special pattern interpretation ($&, $`, etc.)
+            const updated = content.replace(oldText, () => newText);
+            await writeFile(resolved, updated, "utf-8");
+            return `Edited ${resolved} — replaced 1 occurrence`;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`edit failed: ${msg}`);
+            return `Error: ${msg}`;
+        }
+    },
+});
+const grepTool = tool({
+    description: "Search file contents using ripgrep (rg) or grep. " +
+        "Returns matching lines with file paths and line numbers.",
+    inputSchema: z.object({
+        pattern: z.string().describe("Search pattern (regex unless literal=true)"),
+        path: z
+            .string()
+            .optional()
+            .describe("Directory or file to search (default: cwd)"),
+        glob: z
+            .string()
+            .optional()
+            .describe("File glob filter, e.g. '*.ts'"),
+        ignoreCase: z
+            .boolean()
+            .optional()
+            .describe("Case-insensitive search"),
+        literal: z
+            .boolean()
+            .optional()
+            .describe("Treat pattern as literal string, not regex"),
+        context: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Lines of context around each match"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Max number of result lines to return"),
+    }),
+    execute: async ({ pattern, path, glob: fileGlob, ignoreCase, literal, context, limit }) => {
+        const searchPath = resolve(path ?? ".");
+        const maxLines = limit ?? DEFAULT_SEARCH_LIMIT;
+        try {
+            let cmd;
+            if (isRipgrepAvailable()) {
+                const args = ["rg", "--no-heading", "-n"];
+                if (ignoreCase)
+                    args.push("-i");
+                if (literal)
+                    args.push("-F");
+                if (context)
+                    args.push("-C", String(context));
+                if (fileGlob)
+                    args.push("--glob", fileGlob);
+                args.push("--", pattern, searchPath);
+                cmd = args.map(shellEscape).join(" ");
+            }
+            else {
+                const args = ["grep", "-rn"];
+                if (ignoreCase)
+                    args.push("-i");
+                if (literal)
+                    args.push("-F");
+                if (context)
+                    args.push("-C", String(context));
+                if (fileGlob)
+                    args.push("--include", fileGlob);
+                args.push("--", pattern, searchPath);
+                cmd = args.map(shellEscape).join(" ");
+            }
+            const output = execSync(cmd, {
+                encoding: "utf-8",
+                timeout: EXEC_TIMEOUT,
+                maxBuffer: 2 * 1024 * 1024,
+                env: sanitizeEnv(),
+            });
+            return truncate(truncateLines(output || "No matches found", maxLines));
+        }
+        catch (err) {
+            // grep/rg exit code 1 = no matches (not an error)
+            const code = err.status;
+            if (code === 1)
+                return "No matches found";
+            const stderr = err.stderr ?? "";
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`grep failed: ${msg}`);
+            return `Error: ${stderr || msg}`.slice(0, MAX_OUTPUT);
+        }
+    },
+});
+const findTool = tool({
+    description: "Find files by name pattern. Uses the system `find` command. " +
+        "Returns matching file paths.",
+    inputSchema: z.object({
+        pattern: z
+            .string()
+            .describe("Filename glob pattern, e.g. '*.ts' or 'index.*'"),
+        path: z
+            .string()
+            .optional()
+            .describe("Directory to search in (default: cwd)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Max number of results"),
+    }),
+    execute: async ({ pattern, path, limit }) => {
+        const searchPath = resolve(path ?? ".");
+        const maxResults = limit ?? DEFAULT_SEARCH_LIMIT;
+        try {
+            const cmd = [
+                "find",
+                shellEscape(searchPath),
+                "-name",
+                shellEscape(pattern),
+                "-not",
+                "-path",
+                shellEscape("*/node_modules/*"),
+                "-not",
+                "-path",
+                shellEscape("*/.git/*"),
+            ].join(" ");
+            const output = execSync(cmd, {
+                encoding: "utf-8",
+                timeout: EXEC_TIMEOUT,
+                maxBuffer: 2 * 1024 * 1024,
+                env: sanitizeEnv(),
+            });
+            return truncate(truncateLines(output || "No files found", maxResults));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`find failed: ${msg}`);
+            return `Error: ${msg}`.slice(0, MAX_OUTPUT);
+        }
+    },
+});
+const lsTool = tool({
+    description: "List directory contents with type indicators. " +
+        "Directories end with /, symlinks with @.",
+    inputSchema: z.object({
+        path: z
+            .string()
+            .optional()
+            .describe("Directory to list (default: cwd)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Max number of entries to return"),
+    }),
+    execute: async ({ path, limit }) => {
+        const dirPath = resolve(path ?? ".");
+        const maxEntries = limit ?? DEFAULT_SEARCH_LIMIT;
+        try {
+            const entries = await readdir(dirPath, { withFileTypes: true });
+            const lines = entries.slice(0, maxEntries).map((entry) => {
+                if (entry.isDirectory())
+                    return `${entry.name}/`;
+                if (entry.isSymbolicLink())
+                    return `${entry.name}@`;
+                return entry.name;
+            });
+            if (entries.length > maxEntries) {
+                lines.push(`…and ${entries.length - maxEntries} more`);
+            }
+            return lines.join("\n") || "(empty directory)";
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`ls failed: ${msg}`);
+            return `Error: ${msg}`;
+        }
+    },
+});
+/* ------------------------------------------------------------------ */
+/*  Export                                                             */
+/* ------------------------------------------------------------------ */
+const SANDBOX_ERROR = "Error: This tool is disabled in sandbox mode. Use bash instead (cat, tee, grep, find, ls).";
+function sandboxGuard(t) {
+    return { ...t, execute: async () => SANDBOX_ERROR };
+}
+export function createFsTools(opts) {
+    const wrap = opts?.sandboxed ? sandboxGuard : (t) => t;
+    return {
+        read: wrap(readTool),
+        write: wrap(writeTool),
+        edit: wrap(editTool),
+        grep: wrap(grepTool),
+        find: wrap(findTool),
+        ls: wrap(lsTool),
+    };
+}

package/dist/tools/integration-toggle.d.ts

@@ -0,0 +1,14 @@
+import type { IntegrationRegistry } from "../integrations/registry.js";
+/**
+ * Create enable_integration and disable_integration tools.
+ * These mutate the session's active integrations set so that
+ * subsequent runs include/exclude the integration tools.
+ */
+export declare function createIntegrationToggleTools(registry: IntegrationRegistry, activeIntegrations: Set<string>): {
+    enable_integration: import("ai").Tool<{
+        name: string;
+    }, string>;
+    disable_integration: import("ai").Tool<{
+        name: string;
+    }, string>;
+};

package/dist/tools/integration-toggle.js

@@ -0,0 +1,47 @@
+import { tool } from "ai";
+import { z } from "zod";
+/**
+ * Create enable_integration and disable_integration tools.
+ * These mutate the session's active integrations set so that
+ * subsequent runs include/exclude the integration tools.
+ */
+export function createIntegrationToggleTools(registry, activeIntegrations) {
+    const available = registry.names;
+    const availableList = available.join(", ");
+    const enableIntegration = tool({
+        description: `Enable an integration for this session. Available: ${availableList}. ` +
+            `Once enabled, the integration's tools will be available in subsequent messages.`,
+        inputSchema: z.object({
+            name: z.string().describe("Integration name to enable"),
+        }),
+        execute: async ({ name }) => {
+            const normalized = name.toLowerCase();
+            if (!registry.has(normalized)) {
+                return `Unknown integration "${name}". Available: ${availableList}`;
+            }
+            if (activeIntegrations.has(normalized)) {
+                return `Integration "${normalized}" is already enabled.`;
+            }
+            activeIntegrations.add(normalized);
+            const integration = registry.get(normalized);
+            const toolNames = Object.keys(integration.tools.tools).join(", ");
+            return `Integration "${normalized}" enabled. Tools now available: ${toolNames}`;
+        },
+    });
+    const disableIntegration = tool({
+        description: `Disable an integration for this session. ` +
+            `Once disabled, the integration's tools will no longer be available.`,
+        inputSchema: z.object({
+            name: z.string().describe("Integration name to disable"),
+        }),
+        execute: async ({ name }) => {
+            const normalized = name.toLowerCase();
+            if (!activeIntegrations.has(normalized)) {
+                return `Integration "${normalized}" is not currently enabled.`;
+            }
+            activeIntegrations.delete(normalized);
+            return `Integration "${normalized}" disabled.`;
+        },
+    });
+    return { enable_integration: enableIntegration, disable_integration: disableIntegration };
+}

package/dist/tools/memory.d.ts

@@ -0,0 +1,13 @@
+import { type Tool } from "ai";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+/**
+ * Create a session-scoped memory_search tool.
+ * Called per-run so results are restricted to the current session's memories.
+ */
+export declare function createMemorySearchTool(store: MemoryStore, embeddingProvider: EmbeddingProvider | null, maxResults: number, teamId?: string): Tool;
+/**
+ * Create a session-scoped memory_save tool.
+ * Allows the agent to explicitly persist facts when the user asks to remember something.
+ */
+export declare function createMemorySaveTool(store: MemoryStore, embeddingProvider: EmbeddingProvider | null, sessionKey: string, teamId?: string): Tool;