verybot 0.1.3

package/dist/gateway/methods/teams.js

@@ -0,0 +1,374 @@
+import { randomUUID } from "crypto";
+import { emit } from "../../events.js";
+import { MAX_NAME_LENGTH, MAX_IDENTITY_LENGTH, MAX_MODEL_LENGTH, HEX_COLOR_RE } from "../../teams/store.js";
+import { DEFAULT_TEAM_ID, DEFAULT_WORKER_TIMEOUT_S } from "../../config/agent-config.js";
+import { searchMemory } from "../../memory/search.js";
+import { logger } from "../../logger.js";
+const VALID_ROLES = new Set(["orchestrator", "worker"]);
+const MAX_FACT_LENGTH = 2000;
+const MAX_PAGE_SIZE = 200;
+export function teamMethods(teamStore, memoryStore, embeddingProvider) {
+    return {
+        /** List all teams with their agents. */
+        "teams.list": async () => {
+            const teams = teamStore.listTeams();
+            const result = teams.map((team) => ({
+                ...team,
+                agents: teamStore.listAgentsByTeam(team.id),
+            }));
+            return { teams: result };
+        },
+        /** Return teams in the TeamConfig[] format used by the UI. */
+        "teams.configs": async () => {
+            return { teams: teamStore.toTeamConfigs() };
+        },
+        /**
+         * Save a single team (create or update) including its agents.
+         * Accepts a full TeamConfig; handles agent diff internally.
+         */
+        "teams.save": async (params) => {
+            const { team } = (params ?? {});
+            if (!team || typeof team !== "object")
+                throw new Error("team object is required");
+            validateTeamConfig(team);
+            teamStore.transaction(() => saveTeam(teamStore, team));
+            emit("teamChange", { action: "saved", teamId: team.id });
+            return { teams: teamStore.toTeamConfigs() };
+        },
+        /** Create a new team. */
+        "teams.create": async (params) => {
+            const { name, color } = (params ?? {});
+            if (!name || typeof name !== "string")
+                throw new Error("name is required");
+            const trimmed = name.trim();
+            if (trimmed.length === 0)
+                throw new Error("name cannot be empty");
+            if (trimmed.length > MAX_NAME_LENGTH)
+                throw new Error(`name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+            if (typeof color === "string" && color !== "" && !HEX_COLOR_RE.test(color))
+                throw new Error("color must be a valid hex color (e.g. #ef4444)");
+            const team = teamStore.createTeam({ name: trimmed, color: typeof color === "string" ? color : undefined });
+            emit("teamChange", { action: "created", team });
+            return { team };
+        },
+        /** Update a team (rename / recolor / workspace / variables). */
+        "teams.update": async (params) => {
+            const p = (params ?? {});
+            const id = p.id;
+            const name = p.name;
+            const color = p.color;
+            const workspace = p.workspace;
+            const variables = p.variables;
+            if (!id || typeof id !== "string")
+                throw new Error("id is required");
+            if (name !== undefined) {
+                if (typeof name !== "string" || name.trim().length === 0)
+                    throw new Error("name cannot be empty");
+            }
+            if (typeof color === "string" && color !== "" && !HEX_COLOR_RE.test(color))
+                throw new Error("color must be a valid hex color (e.g. #ef4444)");
+            if (workspace !== undefined && typeof workspace !== "string")
+                throw new Error("workspace must be a string");
+            const team = teamStore.updateTeam(id, {
+                name: name?.trim(),
+                color: typeof color === "string" ? color : undefined,
+                workspace: typeof workspace === "string" ? workspace : undefined,
+                variables: typeof variables === "object" && variables !== null ? variables : undefined,
+            });
+            if (!team)
+                throw new Error(`Team not found: ${id}`);
+            emit("teamChange", { action: "updated", team });
+            return { team };
+        },
+        /** Delete a team and all its agents. */
+        "teams.delete": async (params) => {
+            const { id } = (params ?? {});
+            if (!id || typeof id !== "string")
+                throw new Error("id is required");
+            const deleted = teamStore.deleteTeam(id);
+            if (!deleted)
+                throw new Error(`Team not found: ${id}`);
+            emit("teamChange", { action: "deleted", id });
+            return { teams: teamStore.toTeamConfigs() };
+        },
+        /** Add an agent to a team. */
+        "teams.createAgent": async (params) => {
+            const p = (params ?? {});
+            const teamId = p.teamId;
+            const name = p.name;
+            const role = p.role;
+            const model = p.model;
+            if (!teamId || typeof teamId !== "string")
+                throw new Error("teamId is required");
+            if (!name || typeof name !== "string")
+                throw new Error("name is required");
+            if (name.length > MAX_NAME_LENGTH)
+                throw new Error(`name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+            if (!role || !VALID_ROLES.has(role))
+                throw new Error("role must be 'orchestrator' or 'worker'");
+            if (!model || typeof model !== "string")
+                throw new Error("model is required");
+            if (model.length > MAX_MODEL_LENGTH)
+                throw new Error(`model exceeds maximum length of ${MAX_MODEL_LENGTH}`);
+            if (typeof p.identity === "string" && p.identity.length > MAX_IDENTITY_LENGTH)
+                throw new Error(`identity exceeds maximum length of ${MAX_IDENTITY_LENGTH}`);
+            const agent = teamStore.createAgent(teamId, {
+                name,
+                role: role,
+                model,
+                contextWindow: typeof p.contextWindow === "number" ? p.contextWindow : undefined,
+                maxSteps: typeof p.maxSteps === "number" ? p.maxSteps : undefined,
+                identity: typeof p.identity === "string" ? p.identity : undefined,
+                tools: Array.isArray(p.tools) ? p.tools.filter((t) => typeof t === "string") : undefined,
+                timeout: typeof p.timeout === "number" ? p.timeout : undefined,
+                templateId: typeof p.templateId === "string" ? p.templateId : (p.templateId === null ? null : undefined),
+            });
+            emit("teamChange", { action: "agentCreated", agent });
+            return { agent };
+        },
+        /** Update an agent's configuration. */
+        "teams.updateAgent": async (params) => {
+            const p = (params ?? {});
+            const id = p.id;
+            if (!id || typeof id !== "string")
+                throw new Error("id is required");
+            if (p.role !== undefined && !VALID_ROLES.has(p.role)) {
+                throw new Error("role must be 'orchestrator' or 'worker'");
+            }
+            const agent = teamStore.updateAgent(id, {
+                name: typeof p.name === "string" ? p.name : undefined,
+                role: VALID_ROLES.has(p.role) ? p.role : undefined,
+                model: typeof p.model === "string" ? p.model : undefined,
+                contextWindow: typeof p.contextWindow === "number" ? p.contextWindow : undefined,
+                maxSteps: typeof p.maxSteps === "number" ? p.maxSteps : undefined,
+                identity: typeof p.identity === "string" ? p.identity : undefined,
+                tools: Array.isArray(p.tools) ? p.tools.filter((t) => typeof t === "string") : undefined,
+                timeout: typeof p.timeout === "number" ? p.timeout : undefined,
+                templateId: typeof p.templateId === "string" ? p.templateId : (p.templateId === null ? null : undefined),
+            });
+            if (!agent)
+                throw new Error(`Agent not found: ${id}`);
+            emit("teamChange", { action: "agentUpdated", agent });
+            return { agent };
+        },
+        /** Remove an agent from a team. */
+        "teams.deleteAgent": async (params) => {
+            const { id } = (params ?? {});
+            if (!id || typeof id !== "string")
+                throw new Error("id is required");
+            const deleted = teamStore.deleteAgent(id);
+            if (!deleted)
+                throw new Error(`Agent not found: ${id}`);
+            emit("teamChange", { action: "agentDeleted", id });
+            return { status: "ok" };
+        },
+        /* ---------------------------------------------------------------- */
+        /*  Team memory methods                                              */
+        /*  All endpoints reject DEFAULT_TEAM_ID — global memory is managed  */
+        /*  by the agent automatically, not via the team memory UI.          */
+        /* ---------------------------------------------------------------- */
+        /** List memories for a team (paginated). */
+        "teams.memories.list": async (params) => {
+            if (!memoryStore)
+                throw new Error("Memory is not enabled");
+            const p = (params ?? {});
+            requireNonDefaultTeamId(p.teamId);
+            const limit = typeof p.limit === "number" ? Math.min(Math.max(1, p.limit), MAX_PAGE_SIZE) : 50;
+            const offset = typeof p.offset === "number" ? Math.max(0, p.offset) : 0;
+            return memoryStore.listByTeam(p.teamId, limit, offset);
+        },
+        /** Search memories scoped to a team (returns global + team). */
+        "teams.memories.search": async (params) => {
+            if (!memoryStore)
+                throw new Error("Memory is not enabled");
+            const p = (params ?? {});
+            requireNonDefaultTeamId(p.teamId);
+            if (!p.query || typeof p.query !== "string")
+                throw new Error("query is required");
+            const limit = typeof p.limit === "number" ? Math.min(Math.max(1, p.limit), MAX_PAGE_SIZE) : 20;
+            const facts = await searchMemory(memoryStore, p.query, {
+                limit,
+                teamId: p.teamId,
+                embeddingProvider: embeddingProvider ?? undefined,
+            });
+            return { facts };
+        },
+        /** Manually add a memory for a team. */
+        "teams.memories.add": async (params) => {
+            if (!memoryStore)
+                throw new Error("Memory is not enabled");
+            const p = (params ?? {});
+            requireNonDefaultTeamId(p.teamId);
+            if (!p.fact || typeof p.fact !== "string")
+                throw new Error("fact is required");
+            const trimmed = p.fact.trim();
+            if (trimmed.length === 0)
+                throw new Error("fact cannot be empty");
+            if (trimmed.length > MAX_FACT_LENGTH)
+                throw new Error(`fact exceeds maximum length of ${MAX_FACT_LENGTH}`);
+            let embedding;
+            if (embeddingProvider) {
+                embedding = await embeddingProvider.embed(trimmed) ?? undefined;
+            }
+            const saved = memoryStore.save({
+                id: randomUUID(),
+                fact: trimmed,
+                source: "manual",
+                timestamp: Date.now(),
+                teamId: p.teamId,
+                embedding,
+            });
+            return { saved };
+        },
+        /** Delete a single memory by ID (team-scoped for authorization). */
+        "teams.memories.delete": async (params) => {
+            if (!memoryStore)
+                throw new Error("Memory is not enabled");
+            const p = (params ?? {});
+            if (!p.id || typeof p.id !== "string")
+                throw new Error("id is required");
+            requireNonDefaultTeamId(p.teamId);
+            const deleted = memoryStore.deleteById(p.id, p.teamId);
+            if (!deleted)
+                throw new Error(`Memory not found or not owned by this team: ${p.id}`);
+            return { status: "ok" };
+        },
+    };
+}
+/* ------------------------------------------------------------------ */
+/*  Shared validation                                                 */
+/* ------------------------------------------------------------------ */
+/** Reject missing, empty, or default team IDs — team memory endpoints must target a real team. */
+function requireNonDefaultTeamId(teamId) {
+    if (!teamId || typeof teamId !== "string")
+        throw new Error("teamId is required");
+    if (teamId === DEFAULT_TEAM_ID)
+        throw new Error("Team memory is only available for non-default teams");
+}
+/* ------------------------------------------------------------------ */
+/*  Input validation for teams.save                                   */
+/* ------------------------------------------------------------------ */
+function validateAgentConfig(agent, label) {
+    if (typeof agent !== "object" || agent === null)
+        throw new Error(`${label} must be an object`);
+    const a = agent;
+    if (typeof a.name !== "string" || a.name.trim().length === 0)
+        throw new Error(`${label}.name is required`);
+    if (a.name.length > MAX_NAME_LENGTH)
+        throw new Error(`${label}.name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+    if (typeof a.model !== "string" || a.model.length === 0)
+        throw new Error(`${label}.model is required`);
+    if (a.model.length > MAX_MODEL_LENGTH)
+        throw new Error(`${label}.model exceeds maximum length of ${MAX_MODEL_LENGTH}`);
+    if (typeof a.identity === "string" && a.identity.length > MAX_IDENTITY_LENGTH) {
+        throw new Error(`${label}.identity exceeds maximum length of ${MAX_IDENTITY_LENGTH}`);
+    }
+}
+function validateTeamConfig(tc) {
+    const t = tc;
+    if (typeof t.id !== "string" || t.id.trim().length === 0)
+        throw new Error("team.id is required");
+    if (typeof t.name !== "string" || t.name.trim().length === 0)
+        throw new Error("team.name is required");
+    if (t.name.length > MAX_NAME_LENGTH)
+        throw new Error(`team.name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+    if (typeof t.color === "string" && t.color !== "" && !HEX_COLOR_RE.test(t.color)) {
+        throw new Error("team.color must be a valid hex color (e.g. #ef4444)");
+    }
+    if (t.workspace !== undefined && typeof t.workspace !== "string") {
+        throw new Error("team.workspace must be a string");
+    }
+    if (t.variables !== undefined) {
+        if (typeof t.variables !== "object" || t.variables === null || Array.isArray(t.variables)) {
+            throw new Error("team.variables must be an object of string key-value pairs");
+        }
+        for (const [k, v] of Object.entries(t.variables)) {
+            if (typeof v !== "string")
+                throw new Error(`team.variables["${k}"] must be a string`);
+        }
+    }
+    if (t.orchestrator) {
+        validateAgentConfig(t.orchestrator, "team.orchestrator");
+    }
+    if (Array.isArray(t.workers)) {
+        for (let j = 0; j < t.workers.length; j++) {
+            validateAgentConfig(t.workers[j], `team.workers[${j}]`);
+        }
+    }
+}
+/* ------------------------------------------------------------------ */
+/*  Save a single team: create or update team + reconcile agents      */
+/* ------------------------------------------------------------------ */
+function saveTeam(store, tc) {
+    const existing = store.getTeamById(tc.id);
+    if (existing) {
+        store.updateTeam(tc.id, {
+            name: tc.name?.trim(),
+            color: tc.color,
+            workspace: tc.workspace,
+            variables: tc.variables,
+        });
+    }
+    else {
+        store.createTeam({
+            id: tc.id,
+            name: tc.name?.trim() ?? tc.id,
+            color: tc.color ?? "",
+            workspace: tc.workspace ?? "",
+            variables: tc.variables ?? {},
+        });
+    }
+    syncAgents(store, tc.id, tc);
+}
+function syncAgents(store, teamId, tc) {
+    const existingAgents = store.listAgentsByTeam(teamId);
+    const existingById = new Map(existingAgents.map((a) => [a.id, a]));
+    // Collect all incoming agent configs (orchestrator + workers)
+    const incomingAgents = [];
+    if (tc.orchestrator?.id) {
+        incomingAgents.push({ config: tc.orchestrator, role: "orchestrator" });
+    }
+    for (const w of tc.workers ?? []) {
+        if (w.id)
+            incomingAgents.push({ config: w, role: "worker" });
+    }
+    const incomingAgentIds = new Set(incomingAgents.map((a) => a.config.id));
+    // If the orchestrator id changed, delete the old one first so the new one can be created
+    const existingOrchestrator = existingAgents.find((a) => a.role === "orchestrator");
+    const incomingOrchestrator = incomingAgents.find((a) => a.role === "orchestrator");
+    if (existingOrchestrator && incomingOrchestrator && existingOrchestrator.id !== incomingOrchestrator.config.id) {
+        store.updateAgent(existingOrchestrator.id, { role: "worker" });
+        store.deleteAgent(existingOrchestrator.id);
+    }
+    // Delete workers that were removed
+    for (const agent of existingAgents) {
+        if (!incomingAgentIds.has(agent.id) && agent.role === "worker") {
+            try {
+                store.deleteAgent(agent.id);
+            }
+            catch (err) {
+                logger.warn(`teams.save: failed to delete agent ${agent.id}: ${err}`);
+            }
+        }
+    }
+    // Create or update agents
+    for (const { config, role } of incomingAgents) {
+        const agentFields = {
+            name: config.name,
+            role,
+            model: config.model,
+            contextWindow: config.contextWindow,
+            maxSteps: config.maxSteps,
+            identity: config.identity,
+            tools: config.tools,
+            timeout: config.timeout ?? DEFAULT_WORKER_TIMEOUT_S,
+            templateId: config.templateId ?? null,
+        };
+        if (existingById.has(config.id)) {
+            store.updateAgent(config.id, agentFields);
+        }
+        else {
+            store.createAgent(teamId, { id: config.id, ...agentFields });
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { Agent } from "../../brain/agent.js";
+export declare function toolMethods(getAgent: () => Agent): {
+    "tools.list": () => Promise<{
+        tools: string[];
+    }>;
+};

package/dist/gateway/methods/tools.js

@@ -0,0 +1,7 @@
+export function toolMethods(getAgent) {
+    return {
+        "tools.list": async () => {
+            return { tools: getAgent().getToolNames() };
+        },
+    };
+}

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

@@ -0,0 +1,19 @@
+import type { Agent } from "../../brain/agent.js";
+import type { ConfigStore } from "../../config/store.js";
+export declare function whatsappMethods(getAgent: () => Agent, configStore: ConfigStore): {
+    /**
+     * Generate an opaque phoneId, save it to config, and trigger channel start.
+     * The WhatsApp channel will emit QR code events via the event bus.
+     */
+    "whatsapp.link": () => Promise<{
+        phoneId: `${string}-${string}-${string}-${string}-${string}`;
+    }>;
+    /** Clear the phoneId from config, stop the channel, and wipe auth state. */
+    "whatsapp.unlink": () => Promise<{
+        status: string;
+    }>;
+    /** Return whether WhatsApp is configured (has a non-empty phoneId). */
+    "whatsapp.status": () => Promise<{
+        linked: boolean;
+    }>;
+};

package/dist/gateway/methods/whatsapp.js

@@ -0,0 +1,35 @@
+import { randomUUID } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { logger } from "../../logger.js";
+import { WHATSAPP_AUTH_DIR } from "../../paths.js";
+export function whatsappMethods(getAgent, configStore) {
+    return {
+        /**
+         * Generate an opaque phoneId, save it to config, and trigger channel start.
+         * The WhatsApp channel will emit QR code events via the event bus.
+         */
+        "whatsapp.link": async () => {
+            const phoneId = randomUUID();
+            configStore.patch({ WHATSAPP_PHONE_ID: phoneId });
+            logger.info(`[whatsapp] link requested, phoneId=${phoneId}`);
+            await getAgent().forceConfigReload();
+            return { phoneId };
+        },
+        /** Clear the phoneId from config, stop the channel, and wipe auth state. */
+        "whatsapp.unlink": async () => {
+            configStore.patch({ WHATSAPP_PHONE_ID: "" });
+            logger.info("[whatsapp] unlink requested");
+            await getAgent().forceConfigReload();
+            // Remove Baileys auth state so next link starts a fresh QR session
+            await rm(WHATSAPP_AUTH_DIR, { recursive: true, force: true });
+            return { status: "unlinked" };
+        },
+        /** Return whether WhatsApp is configured (has a non-empty phoneId). */
+        "whatsapp.status": async () => {
+            const data = configStore.load();
+            const phoneId = data.WHATSAPP_PHONE_ID;
+            const linked = typeof phoneId === "string" && phoneId !== "";
+            return { linked };
+        },
+    };
+}

package/dist/gateway/rpc.d.ts

@@ -0,0 +1,38 @@
+import type { WebSocket } from "ws";
+import type { Agent } from "../brain/agent.js";
+import type { ConfigStore } from "../config/store.js";
+import type { TaskStore } from "../tasks/store.js";
+import type { TeamStore } from "../teams/store.js";
+import type { ScheduleStore } from "../scheduler/store.js";
+import type { ConnectedChannelRegistry } from "../scheduler/connected-channels.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import type { SkillManager } from "../skills/loader.js";
+import type { PromptTemplateStore } from "../prompt-templates/store.js";
+/** Per-call context passed from the WS layer to RPC methods. */
+export interface RpcContext {
+    /** The WebSocket that initiated this RPC call. */
+    ws: WebSocket;
+}
+export interface RpcOptions {
+    configStore?: ConfigStore;
+    /** Hot-restart callback: tears down current runtime and boots a new one. */
+    restart?: () => Promise<void>;
+    /** Getter for TaskStore (follows runtime swaps on hot restart). */
+    getTaskStore?: () => TaskStore;
+    /** Getter for TeamStore (follows runtime swaps on hot restart). */
+    getTeamStore?: () => TeamStore;
+    /** Getter for ScheduleStore (follows runtime swaps on hot restart). */
+    getScheduleStore?: () => ScheduleStore;
+    /** Getter for ConnectedChannelRegistry (follows runtime swaps on hot restart). */
+    getConnectedChannels?: () => ConnectedChannelRegistry;
+    /** Getter for SkillManager (follows runtime swaps on hot restart). */
+    getSkillManager?: () => SkillManager;
+    /** Getter for MemoryStore (follows runtime swaps on hot restart). */
+    getMemoryStore?: () => MemoryStore | null;
+    /** Getter for EmbeddingProvider (follows runtime swaps on hot restart). */
+    getEmbeddingProvider?: () => EmbeddingProvider | null;
+    /** Getter for PromptTemplateStore (follows runtime swaps on hot restart). */
+    getPromptTemplateStore?: () => PromptTemplateStore;
+}
+export declare function createRpcDispatcher(getAgent: () => Agent, opts?: RpcOptions): (method: string, params: unknown, ctx?: RpcContext) => Promise<unknown>;

package/dist/gateway/rpc.js

@@ -0,0 +1,75 @@
+import { chatMethods } from "./methods/chat.js";
+import { sessionMethods } from "./methods/sessions.js";
+import { configMethods } from "./methods/config.js";
+import { systemMethods } from "./methods/system.js";
+import { taskMethods } from "./methods/tasks.js";
+import { teamMethods } from "./methods/teams.js";
+import { schedulerMethods } from "./methods/scheduler.js";
+import { modelMethods } from "./methods/models.js";
+import { skillMethods } from "./methods/skills.js";
+import { toolMethods } from "./methods/tools.js";
+import { whatsappMethods } from "./methods/whatsapp.js";
+import { promptTemplateMethods } from "./methods/prompt-templates.js";
+export function createRpcDispatcher(getAgent, opts = {}) {
+    const { configStore, restart, getTaskStore, getTeamStore, getScheduleStore, getConnectedChannels, getSkillManager, getMemoryStore, getEmbeddingProvider, getPromptTemplateStore } = opts;
+    const staticMethods = {
+        ...chatMethods(getAgent),
+        ...sessionMethods(getAgent),
+        ...(configStore ? configMethods(configStore) : {}),
+        ...modelMethods(),
+    };
+    return async (method, params, ctx) => {
+        // 1. Static methods (no ctx or hot-restart dependency)
+        if (staticMethods[method])
+            return staticMethods[method](params);
+        // 2. Tool methods (derived from Agent)
+        if (method.startsWith("tools.")) {
+            const methods = toolMethods(getAgent);
+            if (methods[method])
+                return methods[method](params);
+        }
+        // 3. System methods (need ctx for per-client log subscriptions)
+        if (restart && method.startsWith("system.")) {
+            const methods = systemMethods(restart, ctx);
+            if (methods[method])
+                return methods[method](params);
+        }
+        // 4. Task methods (lazy for hot-restart safety)
+        if (getTaskStore && method.startsWith("tasks.")) {
+            const methods = taskMethods(getTaskStore());
+            if (methods[method])
+                return methods[method](params);
+        }
+        // 5. Team methods (lazy for hot-restart safety)
+        if (getTeamStore && method.startsWith("teams.")) {
+            const methods = teamMethods(getTeamStore(), getMemoryStore?.() ?? null, getEmbeddingProvider?.() ?? null);
+            if (methods[method])
+                return methods[method](params);
+        }
+        // 6. Prompt template methods (lazy for hot-restart safety)
+        if (getPromptTemplateStore && method.startsWith("promptTemplates.")) {
+            const methods = promptTemplateMethods(getPromptTemplateStore());
+            if (methods[method])
+                return methods[method](params);
+        }
+        // 7. Scheduler methods (lazy + ctx for hot-restart safety)
+        if (getScheduleStore && getConnectedChannels && method.startsWith("scheduler.")) {
+            const methods = schedulerMethods(getAgent, getScheduleStore, getConnectedChannels, ctx);
+            if (methods[method])
+                return methods[method](params);
+        }
+        // 7. Skill methods (lazy for hot-restart safety)
+        if (getSkillManager && method.startsWith("skills.")) {
+            const methods = skillMethods(getSkillManager);
+            if (methods[method])
+                return methods[method](params);
+        }
+        // 8. WhatsApp methods (link/unlink/status)
+        if (configStore && method.startsWith("whatsapp.")) {
+            const methods = whatsappMethods(getAgent, configStore);
+            if (methods[method])
+                return methods[method](params);
+        }
+        throw new Error(`Unknown method: ${method}`);
+    };
+}

package/dist/gateway/server.d.ts

@@ -0,0 +1,4 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import type { Agent } from "../brain/agent.js";
+import { type RpcOptions } from "./rpc.js";
+export declare function startGateway(port: number, token: string, getAgent: () => Agent, opts?: RpcOptions): import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;