verybot 0.1.3

package/dist/tools/memory.js

@@ -0,0 +1,65 @@
+import { randomUUID } from "crypto";
+import { tool } from "ai";
+import { z } from "zod";
+import { searchMemory } from "../memory/search.js";
+/**
+ * Create a session-scoped memory_search tool.
+ * Called per-run so results are restricted to the current session's memories.
+ */
+export function createMemorySearchTool(store, embeddingProvider, maxResults, teamId) {
+    return tool({
+        description: "Search long-term memory for facts about this user. " +
+            "ALWAYS call BEFORE responding to personal questions (name, location, preferences, history). " +
+            "Call multiple times with different queries to gather all relevant facts. " +
+            "When in doubt, search — it is fast.",
+        inputSchema: z.object({
+            query: z
+                .string()
+                .describe("What to search for, e.g. 'favorite food' or 'project details'"),
+        }),
+        execute: async ({ query }) => {
+            const facts = await searchMemory(store, query, {
+                limit: maxResults,
+                embeddingProvider,
+                teamId,
+            });
+            if (facts.length === 0)
+                return "No relevant memories found.";
+            return facts.map((f, i) => `${i + 1}. ${f}`).join("\n");
+        },
+    });
+}
+/**
+ * Create a session-scoped memory_save tool.
+ * Allows the agent to explicitly persist facts when the user asks to remember something.
+ */
+export function createMemorySaveTool(store, embeddingProvider, sessionKey, teamId) {
+    return tool({
+        description: "Save a fact about the user to long-term memory. Use this when the user " +
+            "explicitly asks you to remember something, or shares personal information " +
+            "they expect you to retain (name, location, preferences, etc.). " +
+            "Each call saves ONE atomic fact — call multiple times for multiple facts.",
+        inputSchema: z.object({
+            fact: z
+                .string()
+                .describe("A single factual statement to remember, e.g. 'User lives in Singapore' " +
+                "or 'User's favorite food is noodles'"),
+        }),
+        execute: async ({ fact }) => {
+            const embedding = embeddingProvider
+                ? await embeddingProvider.embed(fact)
+                : undefined;
+            const saved = store.save({
+                id: randomUUID(),
+                fact,
+                source: sessionKey,
+                timestamp: Date.now(),
+                embedding,
+                teamId,
+            });
+            return saved
+                ? `Saved: "${fact}"`
+                : `Already known: "${fact}"`;
+        },
+    });
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,6 @@
+import type { Tool, ToolSet } from "ai";
+export declare class ToolRegistry {
+    private tools;
+    register(name: string, tool: Tool): void;
+    getAll(): ToolSet;
+}

package/dist/tools/registry.js

@@ -0,0 +1,9 @@
+export class ToolRegistry {
+    tools = new Map();
+    register(name, tool) {
+        this.tools.set(name, tool);
+    }
+    getAll() {
+        return Object.fromEntries(this.tools);
+    }
+}

package/dist/tools/schedule.d.ts

@@ -0,0 +1,8 @@
+import { type ToolSet } from "ai";
+import type { ScheduleStore } from "../scheduler/store.js";
+/**
+ * Create schedule management tools scoped to a team.
+ * These let the LLM create, list, delete, pause, resume schedules
+ * and set the team's timezone.
+ */
+export declare function createScheduleTools(store: ScheduleStore, teamId: string, availableIntegrations: string[]): ToolSet;

package/dist/tools/schedule.js

@@ -0,0 +1,219 @@
+import { randomUUID } from "crypto";
+import { tool } from "ai";
+import { z } from "zod";
+import { Cron } from "croner";
+/**
+ * Create schedule management tools scoped to a team.
+ * These let the LLM create, list, delete, pause, resume schedules
+ * and set the team's timezone.
+ */
+export function createScheduleTools(store, teamId, availableIntegrations) {
+    const integrationsList = availableIntegrations.length > 0
+        ? `Available integrations: ${availableIntegrations.join(", ")}.`
+        : "No integrations available.";
+    const createSchedule = tool({
+        description: `Create a scheduled task. Create IMMEDIATELY when user asks — do NOT ask for confirmation. ` +
+            `One-shot: provide runAt (ISO 8601). Recurring: provide cron (e.g. "0 9 * * *"). ` +
+            `Convert relative times to absolute timestamps using current time. ` +
+            `${integrationsList}`,
+        inputSchema: z.object({
+            prompt: z.string().describe("The exact message or instruction to execute when this task fires. " +
+                "For reminders: write the actual reminder text the user should see (e.g. 'Time to call Sarah!' not 'Reminder from Assistant'). " +
+                "For data tasks: write a clear instruction (e.g. 'Check BTC price and report current value')."),
+            type: z.enum(["one_shot", "recurring"]).describe("one_shot for reminders, recurring for repeating tasks"),
+            cron: z.string().optional().describe("Cron expression for recurring tasks (e.g. '0 9 * * *')"),
+            runAt: z.string().optional().describe("ISO 8601 timestamp for one-shot tasks (e.g. '2026-02-08T15:30:00')"),
+            timezone: z.string().optional().describe("IANA timezone (e.g. 'America/New_York'). Uses saved team timezone if omitted."),
+            integrations: z.string().optional().describe("Comma-separated integration names to enable for this task"),
+            conditional: z.boolean().optional().describe("If true, the agent can skip delivery if nothing noteworthy happened"),
+        }),
+        execute: async (params) => {
+            // Resolve timezone: user param > saved setting > UTC default
+            const tz = params.timezone || store.getTimezone(teamId) || "UTC";
+            // Validate timezone
+            try {
+                Intl.DateTimeFormat(undefined, { timeZone: tz });
+            }
+            catch {
+                return `Invalid timezone "${tz}". Use IANA format like "America/New_York" or "Asia/Shanghai".`;
+            }
+            const type = params.type;
+            // Validate cron for recurring
+            if (type === "recurring") {
+                if (!params.cron) {
+                    return "Recurring schedules require a cron expression.";
+                }
+                try {
+                    new Cron(params.cron);
+                }
+                catch (err) {
+                    return `Invalid cron expression "${params.cron}": ${err instanceof Error ? err.message : err}`;
+                }
+            }
+            // Validate runAt for one-shot
+            if (type === "one_shot") {
+                if (!params.runAt) {
+                    return "One-shot schedules require a runAt timestamp.";
+                }
+                const runDate = new Date(params.runAt);
+                if (isNaN(runDate.getTime())) {
+                    return `Invalid timestamp "${params.runAt}". Use ISO 8601 format.`;
+                }
+                if (runDate.getTime() <= Date.now()) {
+                    return `The time "${params.runAt}" is in the past. Provide a future time.`;
+                }
+            }
+            // Compute nextRun
+            let nextRun = null;
+            if (type === "one_shot" && params.runAt) {
+                nextRun = new Date(params.runAt).toISOString();
+            }
+            else if (type === "recurring" && params.cron) {
+                try {
+                    const job = new Cron(params.cron, { timezone: tz });
+                    const next = job.nextRun();
+                    nextRun = next ? next.toISOString() : null;
+                }
+                catch {
+                    return "Failed to compute next run time from cron expression.";
+                }
+            }
+            const now = new Date().toISOString();
+            const id = randomUUID();
+            store.create({
+                id,
+                teamId,
+                prompt: params.prompt,
+                type,
+                cron: params.cron ?? null,
+                runAt: params.runAt ?? null,
+                timezone: tz,
+                integrations: params.integrations ?? "",
+                conditional: params.conditional ?? false,
+                status: "active",
+                nextRun,
+                lastRun: null,
+                failCount: 0,
+                createdAt: now,
+                updatedAt: now,
+            });
+            const nextRunFormatted = nextRun
+                ? new Date(nextRun).toLocaleString("en-US", { timeZone: tz })
+                : "unknown";
+            return `Schedule created (${type}). ID: ${id}\nNext run: ${nextRunFormatted} (${tz})`;
+        },
+    });
+    const listSchedules = tool({
+        description: "List all scheduled tasks for the current team.",
+        inputSchema: z.object({
+            status: z.enum(["active", "paused", "completed", "failed"]).optional()
+                .describe("Filter by status. Omit to show all."),
+        }),
+        execute: async ({ status }) => {
+            const schedules = store.listByTeam(teamId, status);
+            if (schedules.length === 0) {
+                return status ? `No ${status} schedules found.` : "No schedules found.";
+            }
+            const tz = store.getTimezone(teamId) ?? "UTC";
+            const lines = schedules.map((s) => {
+                const nextStr = s.nextRun
+                    ? new Date(s.nextRun).toLocaleString("en-US", { timeZone: tz })
+                    : "—";
+                const typeStr = s.type === "recurring" ? `recurring (${s.cron})` : "one-shot";
+                const condStr = s.conditional ? " [conditional]" : "";
+                return `- **${s.id.slice(0, 8)}** [${s.status}] ${typeStr}${condStr}\n  "${s.prompt.slice(0, 80)}"\n  Next: ${nextStr}`;
+            });
+            return lines.join("\n\n");
+        },
+    });
+    const deleteSchedule = tool({
+        description: "Delete a scheduled task by its ID.",
+        inputSchema: z.object({
+            id: z.string().describe("Schedule ID (full or first 8 chars)"),
+        }),
+        execute: async ({ id }) => {
+            const schedule = resolveScheduleId(store, teamId, id);
+            if (!schedule)
+                return `Schedule "${id}" not found or does not belong to this team.`;
+            store.delete(schedule.id);
+            return `Schedule "${schedule.id.slice(0, 8)}" deleted.`;
+        },
+    });
+    const pauseSchedule = tool({
+        description: "Pause an active scheduled task. It will not fire until resumed.",
+        inputSchema: z.object({
+            id: z.string().describe("Schedule ID (full or first 8 chars)"),
+        }),
+        execute: async ({ id }) => {
+            const schedule = resolveScheduleId(store, teamId, id);
+            if (!schedule)
+                return `Schedule "${id}" not found or does not belong to this team.`;
+            if (schedule.status !== "active")
+                return `Schedule is not active (status: ${schedule.status}).`;
+            store.update(schedule.id, { status: "paused" });
+            return `Schedule "${schedule.id.slice(0, 8)}" paused.`;
+        },
+    });
+    const resumeSchedule = tool({
+        description: "Resume a paused scheduled task.",
+        inputSchema: z.object({
+            id: z.string().describe("Schedule ID (full or first 8 chars)"),
+        }),
+        execute: async ({ id }) => {
+            const schedule = resolveScheduleId(store, teamId, id);
+            if (!schedule)
+                return `Schedule "${id}" not found or does not belong to this team.`;
+            if (schedule.status !== "paused")
+                return `Schedule is not paused (status: ${schedule.status}).`;
+            // Recompute next run
+            let nextRun = null;
+            if (schedule.type === "recurring" && schedule.cron) {
+                nextRun = store.computeNextRun(schedule);
+            }
+            else if (schedule.type === "one_shot" && schedule.runAt) {
+                // For one-shots, use original runAt if still in the future
+                const runDate = new Date(schedule.runAt);
+                nextRun = runDate.getTime() > Date.now() ? runDate.toISOString() : new Date().toISOString();
+            }
+            store.update(schedule.id, { status: "active", nextRun });
+            return `Schedule "${schedule.id.slice(0, 8)}" resumed. Next run: ${nextRun ?? "now"}`;
+        },
+    });
+    const setTimezone = tool({
+        description: `Set your timezone for scheduled tasks. Use IANA timezone names like "America/New_York", "Asia/Shanghai", "Europe/London".`,
+        inputSchema: z.object({
+            timezone: z.string().describe('IANA timezone name (e.g. "America/New_York")'),
+        }),
+        execute: async ({ timezone }) => {
+            try {
+                Intl.DateTimeFormat(undefined, { timeZone: timezone });
+            }
+            catch {
+                return `Invalid timezone "${timezone}". Use IANA format like "America/New_York" or "Asia/Shanghai".`;
+            }
+            store.setTimezone(teamId, timezone);
+            return `Timezone set to "${timezone}".`;
+        },
+    });
+    return {
+        create_schedule: createSchedule,
+        list_schedules: listSchedules,
+        delete_schedule: deleteSchedule,
+        pause_schedule: pauseSchedule,
+        resume_schedule: resumeSchedule,
+        set_timezone: setTimezone,
+    };
+}
+/** Resolve a schedule ID (full or short) that belongs to the given team. */
+function resolveScheduleId(store, teamId, id) {
+    // Try exact match first
+    const exact = store.getById(id);
+    if (exact && exact.teamId === teamId)
+        return exact;
+    // Try short ID prefix match
+    const all = store.listByTeam(teamId);
+    const matches = all.filter((s) => s.id.startsWith(id));
+    if (matches.length === 1)
+        return matches[0];
+    return null;
+}

package/dist/tools/speak.d.ts

@@ -0,0 +1,10 @@
+import { type ToolSet } from "ai";
+export interface TTSConfig {
+    enabled: boolean;
+    voice: string;
+}
+/**
+ * Create TTS tools: speak (synthesize + play) and speech_control (pause/resume/stop).
+ * Returns null when TTS is disabled.
+ */
+export declare function createSpeakTools(config: TTSConfig): ToolSet | null;

package/dist/tools/speak.js

@@ -0,0 +1,56 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { synthesize } from "../tts/edge.js";
+import { playAudio, pauseAudio, resumeAudio, stopAudio } from "../tts/speak.js";
+import { logger } from "../logger.js";
+const PREVIEW_LENGTH = 80;
+/**
+ * Create TTS tools: speak (synthesize + play) and speech_control (pause/resume/stop).
+ * Returns null when TTS is disabled.
+ */
+export function createSpeakTools(config) {
+    if (!config.enabled)
+        return null;
+    const speak = tool({
+        description: "Speak text aloud through the computer's speakers. " +
+            "Keep spoken text concise and conversational. " +
+            "Do NOT speak code blocks, URLs, or long technical output — use text for those.",
+        inputSchema: z.object({
+            text: z.string().describe("The text to speak aloud"),
+            voice: z
+                .string()
+                .optional()
+                .describe("Edge TTS voice name (e.g. en-US-GuyNeural). Defaults to config voice."),
+        }),
+        execute: async ({ text, voice }) => {
+            try {
+                // voice param overrides; otherwise auto-detect from text content
+                const audioPath = await synthesize(text, voice);
+                playAudio(audioPath);
+                const preview = text.length > PREVIEW_LENGTH
+                    ? `${text.slice(0, PREVIEW_LENGTH)}...`
+                    : text;
+                return `Spoke: "${preview}"`;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.error(`TTS failed: ${msg}`);
+                return `TTS error: ${msg}`;
+            }
+        },
+    });
+    const speechControl = tool({
+        description: "Control ongoing speech playback. Use this to pause, resume, or stop the current TTS audio.",
+        inputSchema: z.object({
+            action: z.enum(["pause", "resume", "stop"]).describe("The playback control action"),
+        }),
+        execute: async ({ action }) => {
+            switch (action) {
+                case "pause": return pauseAudio();
+                case "resume": return resumeAudio();
+                case "stop": return stopAudio();
+            }
+        },
+    });
+    return { speak, speech_control: speechControl };
+}

package/dist/tools/tasks.d.ts

@@ -0,0 +1,29 @@
+import type { TaskStore } from "../tasks/store.js";
+/**
+ * Creates AI-facing tools for task management.
+ * Non-default teams are scoped to their own tasks only.
+ * The default team has access to all tasks across all teams.
+ */
+export declare function createTaskTools(taskStore: TaskStore, teamId?: string): {
+    task_create: import("ai").Tool<{
+        title: string;
+        description?: string | undefined;
+        assignee?: string | undefined;
+        priority?: "low" | "medium" | "high" | undefined;
+    }, string>;
+    task_update: import("ai").Tool<{
+        id: string;
+        status?: "done" | "backlog" | "todo" | "in_progress" | "archived" | undefined;
+        title?: string | undefined;
+        description?: string | null | undefined;
+        assignee?: string | null | undefined;
+        priority?: "low" | "medium" | "high" | undefined;
+    }, string>;
+    task_list: import("ai").Tool<{
+        status?: "done" | "backlog" | "todo" | "in_progress" | "archived" | undefined;
+        team?: string | undefined;
+    }, string>;
+    task_delete: import("ai").Tool<{
+        id: string;
+    }, string>;
+};

package/dist/tools/tasks.js

@@ -0,0 +1,92 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { TASK_STATUSES, TASK_PRIORITIES } from "../tasks/types.js";
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+import { emit } from "../events.js";
+/**
+ * Creates AI-facing tools for task management.
+ * Non-default teams are scoped to their own tasks only.
+ * The default team has access to all tasks across all teams.
+ */
+export function createTaskTools(taskStore, teamId) {
+    /** Non-default teams can only access their own tasks. */
+    const scoped = !!teamId && teamId !== DEFAULT_TEAM_ID;
+    const createTask = tool({
+        description: "Create a new task for the team. Returns the created task with its ID.",
+        inputSchema: z.object({
+            title: z.string().describe("Short task title"),
+            description: z.string().optional().describe("Optional detailed description"),
+            assignee: z.string().optional().describe("Agent ID or 'user' to assign to"),
+            priority: z.enum(TASK_PRIORITIES).optional().describe("Task priority: low, medium, or high"),
+        }),
+        execute: async ({ title, description, assignee, priority }) => {
+            const task = taskStore.create({ title, description, teamId, assignee, priority });
+            emit("taskChange", { action: "created", task });
+            return `Task created: [${task.id}] ${task.title} (${task.priority}, ${task.status})`;
+        },
+    });
+    const updateTask = tool({
+        description: "Update an existing task. Set status to in_progress when starting work, done when completing.",
+        inputSchema: z.object({
+            id: z.string().describe("Task ID to update"),
+            status: z.enum(TASK_STATUSES).optional().describe("New status: backlog, todo, in_progress, done, archived"),
+            title: z.string().optional().describe("New title"),
+            description: z.string().nullable().optional().describe("New description (null to clear)"),
+            assignee: z.string().nullable().optional().describe("New assignee (agent ID, 'user', or null to unassign)"),
+            priority: z.enum(TASK_PRIORITIES).optional().describe("New priority"),
+        }),
+        execute: async ({ id, status, title, description, assignee, priority }) => {
+            if (scoped) {
+                const existing = taskStore.getById(id);
+                if (!existing || existing.teamId !== teamId)
+                    return `Task not found: ${id}`;
+            }
+            const task = taskStore.update(id, { status, title, description, assignee, priority });
+            if (!task)
+                return `Task not found: ${id}`;
+            emit("taskChange", { action: "updated", task });
+            return `Task updated: [${task.id}] ${task.title} — ${task.status} (${task.priority})`;
+        },
+    });
+    const listTasks = tool({
+        description: "List tasks. ALWAYS call fresh — never rely on cached results. " +
+            "Only include filters the user explicitly requests. Returns all tasks when called with no parameters.",
+        inputSchema: z.object({
+            status: z.enum(TASK_STATUSES).optional().describe("Filter by status"),
+            team: z.string().optional().describe("Filter by team ID"),
+        }),
+        execute: async ({ status, team }) => {
+            const effectiveTeamId = scoped ? teamId : team;
+            const tasks = taskStore.list({ teamId: effectiveTeamId, status });
+            if (tasks.length === 0)
+                return "No tasks found.";
+            return tasks
+                .map((t) => `[${t.id}] ${t.title} — ${t.status} (${t.priority}, team: ${t.teamId}${t.assignee ? `, assigned: ${t.assignee}` : ""})`)
+                .join("\n");
+        },
+    });
+    const deleteTask = tool({
+        description: "Permanently delete a task by ID.",
+        inputSchema: z.object({
+            id: z.string().describe("Task ID to delete"),
+        }),
+        execute: async ({ id }) => {
+            if (scoped) {
+                const existing = taskStore.getById(id);
+                if (!existing || existing.teamId !== teamId)
+                    return `Task not found: ${id}`;
+            }
+            const deleted = taskStore.delete(id);
+            if (!deleted)
+                return `Task not found: ${id}`;
+            emit("taskChange", { action: "deleted", id });
+            return `Task deleted: ${id}`;
+        },
+    });
+    return {
+        task_create: createTask,
+        task_update: updateTask,
+        task_list: listTasks,
+        task_delete: deleteTask,
+    };
+}

package/dist/tools/teams.d.ts

@@ -0,0 +1,7 @@
+import { type ToolSet } from "ai";
+import type { TeamStore } from "../teams/store.js";
+/**
+ * Creates AI-facing tools for team and worker management.
+ * Only available to the default team orchestrator.
+ */
+export declare function createTeamManagementTools(teamStore: TeamStore): ToolSet;