verybot 0.1.8

package/dist/gateway/methods/scheduler.js

@@ -0,0 +1,129 @@
+import { broadcast, onClientClose } from "../broadcast.js";
+const VALID_STATUSES = new Set(["active", "paused", "completed", "failed"]);
+/** Validate that `teamId` belongs to a real team. */
+function validateTeamId(agent, teamId) {
+    if (!teamId)
+        throw new Error("Missing teamId");
+    const teams = agent.getTeams();
+    if (!teams.some((t) => t.id === teamId)) {
+        throw new Error(`Unknown team: "${teamId}"`);
+    }
+}
+export function schedulerMethods(getAgent, getScheduleStore, getConnectedChannels, ctx) {
+    return {
+        /** Connect a WS client to a team's scheduler. Returns session history + connection key. */
+        "scheduler.connect": async (params) => {
+            const { teamId } = params;
+            validateTeamId(getAgent(), teamId);
+            const connectedChannels = getConnectedChannels();
+            // Register this WS as a connected channel — send fn broadcasts via WS events
+            const connectionKey = connectedChannels.connect(teamId, {
+                channelType: "gateway",
+                channelId: `ws:${teamId}`,
+                send: async (text) => {
+                    broadcast("schedulerMessage", { teamId, role: "assistant", content: text });
+                },
+            });
+            // Auto-disconnect when the WS closes (prevents stale entries)
+            if (ctx?.ws) {
+                onClientClose(ctx.ws, () => {
+                    connectedChannels.disconnect(teamId, connectionKey);
+                });
+            }
+            // Return existing session history
+            const session = getAgent().getSchedulerSession(teamId);
+            const messages = session?.getMessages() ?? [];
+            return { connectionKey, messages };
+        },
+        /** Disconnect a WS client from a team's scheduler. */
+        "scheduler.disconnect": async (params) => {
+            const { teamId, connectionKey } = params;
+            if (!teamId || !connectionKey)
+                throw new Error("Missing teamId or connectionKey");
+            getConnectedChannels().disconnect(teamId, connectionKey);
+            return { status: "ok" };
+        },
+        /** Send a message to the team's scheduler session. */
+        "scheduler.send": async (params) => {
+            const { teamId, message } = params;
+            if (!message)
+                throw new Error("Missing message");
+            validateTeamId(getAgent(), teamId);
+            // Broadcast user message to OTHER clients (sender already has it via optimistic UI)
+            const excludeWs = ctx?.ws;
+            broadcast("schedulerMessage", { teamId, role: "user", content: message, senderInfo: "Web UI" }, excludeWs);
+            const reply = await getAgent().handleSchedulerMessage(teamId, message, "Web UI");
+            // Broadcast reply to OTHER clients (sender gets it via RPC response)
+            broadcast("schedulerMessage", { teamId, role: "assistant", content: reply }, excludeWs);
+            return { status: "ok", reply };
+        },
+        /** Get scheduler session history for a team. */
+        "scheduler.history": async (params) => {
+            const { teamId } = params;
+            validateTeamId(getAgent(), teamId);
+            const session = getAgent().getSchedulerSession(teamId);
+            return { messages: session?.getMessages() ?? [] };
+        },
+        /** List schedules for a team. */
+        "scheduler.list": async (params) => {
+            const { teamId, status } = params;
+            validateTeamId(getAgent(), teamId);
+            if (status && !VALID_STATUSES.has(status)) {
+                throw new Error(`Invalid status: "${status}". Must be one of: active, paused, completed, failed`);
+            }
+            const store = getScheduleStore();
+            const schedules = store.listByTeam(teamId, status);
+            return { schedules };
+        },
+        // --- Direct schedule CRUD (bypasses LLM) ---
+        /** Pause an active schedule. */
+        "scheduler.pause": async (params) => {
+            const { teamId, scheduleId } = params;
+            if (!scheduleId)
+                throw new Error("Missing scheduleId");
+            validateTeamId(getAgent(), teamId);
+            const store = getScheduleStore();
+            const schedule = store.getById(scheduleId);
+            if (!schedule || schedule.teamId !== teamId) {
+                throw new Error(`Schedule "${scheduleId}" not found for this team`);
+            }
+            if (schedule.status !== "active") {
+                throw new Error(`Schedule is not active (status: ${schedule.status})`);
+            }
+            store.update(scheduleId, { status: "paused" });
+            return { status: "ok" };
+        },
+        /** Resume a paused schedule. */
+        "scheduler.resume": async (params) => {
+            const { teamId, scheduleId } = params;
+            if (!scheduleId)
+                throw new Error("Missing scheduleId");
+            validateTeamId(getAgent(), teamId);
+            const store = getScheduleStore();
+            const schedule = store.getById(scheduleId);
+            if (!schedule || schedule.teamId !== teamId) {
+                throw new Error(`Schedule "${scheduleId}" not found for this team`);
+            }
+            if (schedule.status !== "paused") {
+                throw new Error(`Schedule is not paused (status: ${schedule.status})`);
+            }
+            const nextRun = store.computeNextRun(schedule);
+            store.update(scheduleId, { status: "active", nextRun });
+            return { status: "ok" };
+        },
+        /** Delete a schedule. */
+        "scheduler.delete": async (params) => {
+            const { teamId, scheduleId } = params;
+            if (!scheduleId)
+                throw new Error("Missing scheduleId");
+            validateTeamId(getAgent(), teamId);
+            const store = getScheduleStore();
+            const schedule = store.getById(scheduleId);
+            if (!schedule || schedule.teamId !== teamId) {
+                throw new Error(`Schedule "${scheduleId}" not found for this team`);
+            }
+            store.delete(scheduleId);
+            return { status: "ok" };
+        },
+    };
+}

package/dist/gateway/methods/sessions.d.ts

@@ -0,0 +1,44 @@
+import type { Agent } from "../../brain/agent.js";
+interface ListSessionsParams {
+    limit?: number;
+    offset?: number;
+    teamId?: string;
+}
+interface ClearOldSessionsParams {
+    keepLatest?: number;
+    teamId?: string;
+}
+export declare function sessionMethods(getAgent: () => Agent): {
+    "sessions.list": (params?: ListSessionsParams) => Promise<{
+        sessions: import("../../brain/session-store.js").SessionIndexEntry[];
+        total: number;
+        hasMore: boolean;
+        nextOffset: number | null;
+        ts: number;
+    }>;
+    "sessions.get": (params: {
+        sessionKey: string;
+    }) => Promise<{
+        messages: {
+            role: "system" | "user" | "assistant" | "tool";
+            content: string | (import("ai").TextPart | import("ai").ImagePart | import("ai").FilePart)[] | (import("ai").TextPart | import("ai").FilePart | import("@ai-sdk/provider-utils").ReasoningPart | import("ai").ToolCallPart | import("ai").ToolResultPart | import("ai").ToolApprovalRequest)[] | import("ai").ToolContent;
+        }[];
+    }>;
+    "sessions.rename": (params: {
+        sessionKey: string;
+        title: string;
+    }) => Promise<{
+        status: string;
+    }>;
+    "sessions.clear": (params: {
+        sessionKey: string;
+    }) => Promise<{
+        status: string;
+    }>;
+    "sessions.clearOld": (params?: ClearOldSessionsParams) => Promise<{
+        status: string;
+        keepLatest: number;
+        cleared: number;
+    }>;
+};
+export {};

package/dist/gateway/methods/sessions.js

@@ -0,0 +1,111 @@
+import { parseSessionKey } from "../../brain/session-key.js";
+import { logger } from "../../logger.js";
+const DEFAULT_KEEP_LATEST_SESSIONS = 300;
+function toOptionalPositiveInteger(value, fieldName) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`${fieldName} must be a positive integer`);
+    }
+    return value;
+}
+function toNonNegativeInteger(value, fieldName, defaultValue) {
+    if (value === undefined)
+        return defaultValue;
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${fieldName} must be a non-negative integer`);
+    }
+    return value;
+}
+function toOptionalString(value, fieldName) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`${fieldName} must be a string`);
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveSessionTeamId(session) {
+    if (session.teamId)
+        return session.teamId;
+    return parseSessionKey(session.key).teamId;
+}
+export function sessionMethods(getAgent) {
+    return {
+        "sessions.list": async (params) => {
+            const agent = getAgent();
+            const allSessions = agent.getStore().list();
+            const limit = toOptionalPositiveInteger(params?.limit, "limit");
+            const offset = toNonNegativeInteger(params?.offset, "offset", 0);
+            const teamId = toOptionalString(params?.teamId, "teamId");
+            const sessions = teamId
+                ? allSessions.filter((session) => resolveSessionTeamId(session) === teamId)
+                : allSessions;
+            const pagedSessions = limit === undefined
+                ? sessions.slice(offset)
+                : sessions.slice(offset, offset + limit);
+            // Enrich sessions with team name + color from the team store
+            const teams = agent.getTeams();
+            const teamById = new Map(teams.map((t) => [t.id, t]));
+            const enriched = pagedSessions.map((s) => {
+                const sessionTeamId = resolveSessionTeamId(s);
+                const team = sessionTeamId ? teamById.get(sessionTeamId) : undefined;
+                if (!team)
+                    return s;
+                return {
+                    ...s,
+                    ...(sessionTeamId && !s.teamId && { teamId: sessionTeamId }),
+                    ...(team.name && { teamName: team.name }),
+                    ...(team.color && { teamColor: team.color }),
+                };
+            });
+            const nextOffset = offset + enriched.length;
+            const hasMore = nextOffset < sessions.length;
+            return {
+                sessions: enriched,
+                total: sessions.length,
+                hasMore,
+                nextOffset: hasMore ? nextOffset : null,
+                ts: Date.now(),
+            };
+        },
+        "sessions.get": async (params) => {
+            if (!params?.sessionKey || typeof params.sessionKey !== "string") {
+                throw new Error("sessionKey is required and must be a string");
+            }
+            const session = await getAgent().getStore().load(params.sessionKey);
+            if (!session)
+                return { messages: [] };
+            const messages = session.getMessages().map((m) => ({
+                role: m.role,
+                content: m.content,
+            }));
+            return { messages };
+        },
+        "sessions.rename": async (params) => {
+            if (!params?.sessionKey || typeof params.sessionKey !== "string") {
+                throw new Error("sessionKey is required and must be a string");
+            }
+            if (!params?.title || typeof params.title !== "string") {
+                throw new Error("title is required and must be a string");
+            }
+            const ok = getAgent().getStore().rename(params.sessionKey, params.title);
+            if (!ok)
+                return { status: "not_found" };
+            logger.info(`[${params.sessionKey}] Session renamed to: ${params.title}`);
+            return { status: "ok" };
+        },
+        "sessions.clear": async (params) => {
+            logger.info(`[${params.sessionKey}] Session clear requested`);
+            await getAgent().clearSession(params.sessionKey);
+            return { status: "ok" };
+        },
+        "sessions.clearOld": async (params) => {
+            const keepLatest = toNonNegativeInteger(params?.keepLatest, "keepLatest", DEFAULT_KEEP_LATEST_SESSIONS);
+            const teamId = toOptionalString(params?.teamId, "teamId");
+            logger.info(`[sessions] Clear old requested (keepLatest=${keepLatest}${teamId ? `, teamId=${teamId}` : ""})`);
+            const cleared = await getAgent().clearOldSessions(keepLatest, teamId);
+            return { status: "ok", keepLatest, cleared };
+        },
+    };
+}

package/dist/gateway/methods/system.d.ts

@@ -0,0 +1,12 @@
+import { type LogEntry } from "../../logger.js";
+import type { RpcContext } from "../rpc.js";
+export declare function systemMethods(restart: () => Promise<void>, ctx?: RpcContext): {
+    /** Hot-restart all backend components. WebSocket connections stay alive. */
+    "system.restart": () => Promise<{
+        status: string;
+    }>;
+    /** Return buffered log history and subscribe the caller to real-time log events. */
+    "system.logs.subscribe": () => Promise<{
+        logs: LogEntry[];
+    }>;
+};

package/dist/gateway/methods/system.js

@@ -0,0 +1,39 @@
+import { emit } from "../../events.js";
+import { onClientClose } from "../broadcast.js";
+import { logger, getLogBuffer, addLogSubscriber } from "../../logger.js";
+export function systemMethods(restart, ctx) {
+    return {
+        /** Hot-restart all backend components. WebSocket connections stay alive. */
+        "system.restart": async () => {
+            logger.info("Hot restart requested via RPC");
+            emit("system", { action: "restarting" });
+            // Run restart in background so the RPC response is sent first
+            setTimeout(async () => {
+                try {
+                    await restart();
+                    emit("system", { action: "restarted" });
+                    logger.info("Hot restart complete");
+                }
+                catch (err) {
+                    logger.error(`Hot restart failed: ${err}`);
+                    emit("system", { action: "restart_failed", error: String(err) });
+                }
+            }, 0);
+            return { status: "restarting" };
+        },
+        /** Return buffered log history and subscribe the caller to real-time log events. */
+        "system.logs.subscribe": async () => {
+            const ws = ctx?.ws;
+            if (ws) {
+                const send = (entry) => {
+                    if (ws.readyState === ws.OPEN) {
+                        ws.send(JSON.stringify({ type: "event", event: "log", payload: entry }));
+                    }
+                };
+                const unsub = addLogSubscriber(send);
+                onClientClose(ws, unsub);
+            }
+            return { logs: getLogBuffer() };
+        },
+    };
+}

package/dist/gateway/methods/tasks.d.ts

@@ -0,0 +1,40 @@
+import type { TaskStore } from "../../tasks/store.js";
+import type { TeamStore } from "../../teams/store.js";
+import { type TaskAttachment } from "../../tasks/types.js";
+export declare function taskMethods(taskStore: TaskStore, _teamStore?: TeamStore | null): {
+    "tasks.list": (params: unknown) => Promise<{
+        tasks: import("../../tasks/types.js").Task[];
+    }>;
+    "tasks.create": (params: unknown) => Promise<{
+        task: import("../../tasks/types.js").Task;
+    }>;
+    "tasks.update": (params: unknown) => Promise<{
+        task: import("../../tasks/types.js").Task;
+    }>;
+    "tasks.delete": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    "tasks.reorder": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    "tasks.archiveDone": (params: unknown) => Promise<{
+        archived: number;
+    }>;
+    "tasks.listComments": (params: unknown) => Promise<{
+        comments: import("../../tasks/types.js").TaskComment[];
+    }>;
+    "tasks.addComment": (params: unknown) => Promise<{
+        comment: import("../../tasks/types.js").TaskComment;
+    }>;
+    "tasks.updateComment": (params: unknown) => Promise<{
+        comment: import("../../tasks/types.js").TaskComment;
+    }>;
+    "tasks.deleteComment": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    "tasks.uploadAttachment": (params: unknown) => Promise<TaskAttachment>;
+    "tasks.getAttachment": (params: unknown) => Promise<{
+        data: string;
+        type: string;
+    }>;
+};

package/dist/gateway/methods/tasks.js

@@ -0,0 +1,151 @@
+import { writeFile, readFile } from "node:fs/promises";
+import { join, basename, extname } from "node:path";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { emit } from "../../events.js";
+import { logger } from "../../logger.js";
+import { ATTACHMENTS_DIR } from "../../paths.js";
+import { CreateTaskSchema, UpdateTaskSchema, ListTasksSchema, ReorderTasksSchema, ListTaskCommentsSchema, AddTaskCommentSchema, UpdateTaskCommentSchema, DeleteTaskCommentSchema, MAX_FILE_SIZE, ALLOWED_IMAGE_TYPES, EXT_FOR_MIME, } from "../../tasks/types.js";
+/** Reverse lookup: file extension -> MIME type */
+const MIME_FOR_EXT = Object.fromEntries(Object.entries(EXT_FOR_MIME).map(([mime, ext]) => [ext, mime]));
+/** Max base64 string length for MAX_FILE_SIZE bytes */
+const MAX_BASE64_LENGTH = Math.ceil(MAX_FILE_SIZE * 4 / 3) + 4;
+const STATUS_KEY_RE = /^\w+$/;
+const UploadAttachmentSchema = z.object({
+    name: z.string().min(1).max(255),
+    type: z.string(),
+    data: z.string().min(1),
+});
+const GetAttachmentSchema = z.object({
+    id: z.string().min(1),
+});
+const ArchiveDoneSchema = z.object({
+    teamId: z.string().optional(),
+    status: z.string().regex(STATUS_KEY_RE).optional(),
+});
+const DEFAULT_DONE_STATUS = "done";
+function resolveDoneStatus(status) {
+    if (status)
+        return status;
+    return DEFAULT_DONE_STATUS;
+}
+export function taskMethods(taskStore, _teamStore) {
+    return {
+        "tasks.list": async (params) => {
+            const filter = ListTasksSchema.parse(params ?? {});
+            return { tasks: taskStore.list(filter) };
+        },
+        "tasks.create": async (params) => {
+            const input = CreateTaskSchema.parse(params);
+            const task = taskStore.create(input, { updatedBy: "user" });
+            emit("taskChange", { action: "created", task });
+            return { task };
+        },
+        "tasks.update": async (params) => {
+            const { id, ...updates } = UpdateTaskSchema.parse(params);
+            const task = taskStore.update(id, updates, { updatedBy: "user" });
+            if (!task)
+                throw new Error(`Task not found: ${id}`);
+            emit("taskChange", { action: "updated", task });
+            return { task };
+        },
+        "tasks.delete": async (params) => {
+            const { id } = z.object({ id: z.string().min(1) }).parse(params);
+            const deleted = taskStore.delete(id);
+            if (!deleted)
+                throw new Error(`Task not found: ${id}`);
+            emit("taskChange", { action: "deleted", id });
+            return { status: "ok" };
+        },
+        "tasks.reorder": async (params) => {
+            const { status, orderedIds } = ReorderTasksSchema.parse(params);
+            taskStore.reorder(status, orderedIds);
+            emit("taskChange", { action: "reordered", status });
+            return { status: "ok" };
+        },
+        "tasks.archiveDone": async (params) => {
+            const { teamId, status } = ArchiveDoneSchema.parse(params ?? {});
+            const doneStatus = resolveDoneStatus(status);
+            const count = taskStore.archiveDone(teamId, doneStatus, "user");
+            emit("taskChange", { action: "archived", count });
+            return { archived: count };
+        },
+        "tasks.listComments": async (params) => {
+            const { taskId } = ListTaskCommentsSchema.parse(params);
+            const task = taskStore.getById(taskId);
+            if (!task)
+                throw new Error(`Task not found: ${taskId}`);
+            return { comments: taskStore.listComments(taskId) };
+        },
+        "tasks.addComment": async (params) => {
+            const { taskId, content } = AddTaskCommentSchema.parse(params);
+            const comment = taskStore.addComment(taskId, content, { actor: "user" });
+            if (!comment)
+                throw new Error(`Task not found: ${taskId}`);
+            emit("taskChange", { action: "commentAdded", taskId, comment });
+            return { comment };
+        },
+        "tasks.updateComment": async (params) => {
+            const { id, content } = UpdateTaskCommentSchema.parse(params);
+            const comment = taskStore.updateComment(id, content, { actor: "user" });
+            if (!comment)
+                throw new Error(`Comment not found: ${id}`);
+            emit("taskChange", { action: "commentUpdated", taskId: comment.taskId, comment });
+            return { comment };
+        },
+        "tasks.deleteComment": async (params) => {
+            const { id } = DeleteTaskCommentSchema.parse(params);
+            const comment = taskStore.deleteComment(id, { actor: "user" });
+            if (!comment)
+                throw new Error(`Comment not found: ${id}`);
+            emit("taskChange", { action: "commentDeleted", taskId: comment.taskId, id: comment.id });
+            return { status: "ok" };
+        },
+        "tasks.uploadAttachment": async (params) => {
+            const { name, type, data } = UploadAttachmentSchema.parse(params);
+            if (!ALLOWED_IMAGE_TYPES.has(type)) {
+                throw new Error("Unsupported image type. Allowed: png, jpg, gif, webp");
+            }
+            // Pre-check base64 string length to avoid unnecessary memory allocation
+            if (data.length > MAX_BASE64_LENGTH) {
+                throw new Error(`File exceeds ${MAX_FILE_SIZE / (1024 * 1024)}MB limit`);
+            }
+            const buf = Buffer.from(data, "base64");
+            if (buf.length > MAX_FILE_SIZE) {
+                throw new Error(`File exceeds ${MAX_FILE_SIZE / (1024 * 1024)}MB limit`);
+            }
+            const id = randomUUID();
+            const ext = EXT_FOR_MIME[type] ?? ".bin";
+            const diskName = `${id}${ext}`;
+            const filePath = join(ATTACHMENTS_DIR, diskName);
+            await writeFile(filePath, buf);
+            logger.info(`Attachment saved: ${diskName} (${buf.length} bytes)`);
+            const attachment = {
+                id: diskName,
+                name: name.replace(/[<>"'&]/g, "_").slice(0, 255),
+                type,
+                size: buf.length,
+                createdAt: Date.now(),
+            };
+            return attachment;
+        },
+        "tasks.getAttachment": async (params) => {
+            const { id } = GetAttachmentSchema.parse(params);
+            // Guard against path traversal
+            const safe = basename(id);
+            if (safe !== id || id.startsWith(".")) {
+                throw new Error("Invalid attachment id");
+            }
+            const filePath = join(ATTACHMENTS_DIR, safe);
+            let buf;
+            try {
+                buf = await readFile(filePath);
+            }
+            catch {
+                throw new Error("Attachment not found");
+            }
+            const ext = extname(filePath);
+            return { data: buf.toString("base64"), type: MIME_FOR_EXT[ext] ?? "application/octet-stream" };
+        },
+    };
+}

package/dist/gateway/methods/teams.d.ts

@@ -0,0 +1,69 @@
+import type { TeamStore } from "../../teams/store.js";
+import type { TeamConfig, TaskStatusConfig } from "../../config/agent-config.js";
+import type { MemoryStore } from "../../memory/store.js";
+import type { EmbeddingProvider } from "../../memory/embedding.js";
+export declare function teamMethods(teamStore: TeamStore, memoryStore?: MemoryStore | null, embeddingProvider?: EmbeddingProvider | null): {
+    /** List all teams with their agents. */
+    "teams.list": () => Promise<{
+        teams: {
+            agents: import("../../teams/types.js").AgentRow[];
+            id: string;
+            name: string;
+            color: string;
+            workspace: string;
+            statuses?: TaskStatusConfig[];
+            createdAt: number;
+            updatedAt: number;
+        }[];
+    }>;
+    /** Return teams in the TeamConfig[] format used by the UI. */
+    "teams.configs": () => Promise<{
+        teams: TeamConfig[];
+    }>;
+    /**
+     * Save a single team (create or update) including its agents.
+     * Accepts a full TeamConfig; handles agent diff internally.
+     */
+    "teams.save": (params: unknown) => Promise<{
+        teams: TeamConfig[];
+    }>;
+    /** Create a new team. */
+    "teams.create": (params: unknown) => Promise<{
+        team: import("../../teams/types.js").Team;
+    }>;
+    /** Update a team (rename / recolor / workspace / variables / statuses). */
+    "teams.update": (params: unknown) => Promise<{
+        team: import("../../teams/types.js").Team;
+    }>;
+    /** Delete a team and all its agents. */
+    "teams.delete": (params: unknown) => Promise<{
+        teams: TeamConfig[];
+    }>;
+    /** Add an agent to a team. */
+    "teams.createAgent": (params: unknown) => Promise<{
+        agent: import("../../teams/types.js").AgentRow;
+    }>;
+    /** Update an agent's configuration. */
+    "teams.updateAgent": (params: unknown) => Promise<{
+        agent: import("../../teams/types.js").AgentRow;
+    }>;
+    /** Remove an agent from a team. */
+    "teams.deleteAgent": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    /** List memories for a team (paginated). */
+    "teams.memories.list": (params: unknown) => Promise<{
+        entries: import("../../memory/types.js").MemoryEntry[];
+        total: number;
+    }>;
+    /** Search memories scoped to a team (returns global + team). */
+    "teams.memories.search": (params: unknown) => Promise<{
+        facts: string[];
+    }>;
+    /** Manually add a memory for a team. */
+    "teams.memories.add": (params: unknown) => Promise<import("../../memory/explicit.js").SaveExplicitMemoryResult>;
+    /** Delete a single memory by ID (team-scoped for authorization). */
+    "teams.memories.delete": (params: unknown) => Promise<{
+        status: string;
+    }>;
+};