@tenex-chat/backend 0.9.1

package/src/tools/implementations/schedule_task_once.ts

@@ -0,0 +1,128 @@
+import { resolveRecipientToPubkey } from "@/services/agents";
+import { SchedulerService } from "@/services/scheduling";
+import { formatDelay, formatExecuteAt, parseRelativeDelay } from "@/services/scheduling/utils";
+import type { ToolExecutionContext } from "@/tools/types";
+import type { AISdkTool } from "@/tools/types";
+import { logger } from "@/utils/logger";
+import { tool } from "ai";
+import { z } from "zod";
+
+/**
+ * Creates a tool for scheduling one-off tasks with relative delays
+ */
+export function createScheduleTaskOnceTool(context: ToolExecutionContext): AISdkTool {
+    const aiTool = tool({
+        description:
+            "Schedule a one-off task to execute after a relative delay (e.g., '5m' for 5 minutes, '2h' for 2 hours, '3d' for 3 days). The task runs once and is automatically deleted after execution.",
+        inputSchema: z.object({
+            title: z
+                .string()
+                .optional()
+                .describe("A human-readable title for the task (e.g., 'Follow up on PR review')"),
+            prompt: z.string().describe("The prompt/message to send when the task executes"),
+            delay: z
+                .string()
+                .describe(
+                    "Relative delay before execution. Format: Xm (minutes), Xh (hours), or Xd (days). Examples: '30m', '2h', '1d'"
+                ),
+            targetAgent: z
+                .string()
+                .nullable()
+                .optional()
+                .describe(
+                    "Target agent slug (e.g., 'architect'), name, npub, or hex pubkey. Defaults to self."
+                ),
+        }),
+        execute: async ({ title, prompt, delay, targetAgent }) => {
+            try {
+                // Parse the relative delay
+                const delayMs = parseRelativeDelay(delay);
+                if (delayMs === null) {
+                    return {
+                        success: false,
+                        error: `Invalid delay format: '${delay}'. Use format like '5m' (minutes), '2h' (hours), or '3d' (days).`,
+                    };
+                }
+
+                // Calculate the absolute execution time
+                const now = new Date();
+                const executeAt = new Date(now.getTime() + delayMs);
+
+                const schedulerService = SchedulerService.getInstance();
+
+                // Resolve target agent to pubkey if specified
+                let toPubkey: string;
+                if (targetAgent) {
+                    const resolved = resolveRecipientToPubkey(targetAgent);
+                    if (!resolved) {
+                        return {
+                            success: false,
+                            error: `Could not resolve target agent: ${targetAgent}. Use agent slug (e.g., 'architect'), name, npub, or hex pubkey.`,
+                        };
+                    }
+                    toPubkey = resolved;
+                } else {
+                    // Default to self if no target specified
+                    toPubkey = context.agent.pubkey;
+                }
+
+                // The agent scheduling the task is always the current agent
+                const fromPubkey = context.agent.pubkey;
+
+                // Add one-off task to scheduler
+                const taskId = await schedulerService.addOneoffTask(
+                    executeAt,
+                    prompt,
+                    fromPubkey,
+                    toPubkey,
+                    undefined, // projectId - let it be resolved from context
+                    title
+                );
+
+                logger.info(
+                    `Successfully created one-off task ${taskId} to execute at: ${executeAt.toISOString()}`
+                );
+
+                return {
+                    success: true,
+                    taskId,
+                    message: "One-off task scheduled successfully",
+                    title,
+                    delay,
+                    delayHuman: formatDelay(delay),
+                    executeAt: executeAt.toISOString(),
+                    executeAtFormatted: formatExecuteAt(executeAt.toISOString()),
+                    prompt,
+                    targetAgent: targetAgent || "self",
+                };
+            } catch (error: unknown) {
+                logger.error("Failed to schedule one-off task:", error);
+
+                return {
+                    success: false,
+                    error:
+                        error instanceof Error ? error.message : "Failed to schedule one-off task",
+                };
+            }
+        },
+    });
+
+    // Attach getHumanReadableContent as non-enumerable property
+    Object.defineProperty(aiTool, "getHumanReadableContent", {
+        value: (args: {
+            title?: string;
+            prompt: string;
+            delay: string;
+            targetAgent?: string | null;
+        }) => {
+            // Handle both undefined and null for targetAgent
+            const target = args.targetAgent ? ` for ${args.targetAgent}` : "";
+            const titlePart = args.title ? `'${args.title}' ` : "";
+            return `Scheduling one-off task ${titlePart}in ${formatDelay(args.delay)}${target}: ${args.prompt}`;
+        },
+        enumerable: false,
+        configurable: true,
+    });
+
+    return aiTool as AISdkTool;
+}

package/src/tools/implementations/schedule_tasks_list.ts

@@ -0,0 +1,79 @@
+import { getProjectContext } from "@/services/projects";
+import { SchedulerService } from "@/services/scheduling";
+import type { ToolExecutionContext } from "@/tools/types";
+import type { AISdkTool } from "@/tools/types";
+import { logger } from "@/utils/logger";
+import { tool } from "ai";
+import { z } from "zod";
+
+/**
+ * Creates a tool for listing scheduled tasks
+ */
+export function createListScheduledTasksTool(_context: ToolExecutionContext): AISdkTool {
+    const aiTool = tool({
+        description: "List all scheduled tasks (recurring and one-off) for the current project",
+        inputSchema: z.object({
+            // Status filter is simplified since we don't track all these states locally
+        }),
+        execute: async () => {
+            try {
+                const schedulerService = SchedulerService.getInstance();
+
+                // Get the current project ID from context
+                let projectId: string | undefined;
+                try {
+                    const projectCtx = getProjectContext();
+                    projectId = projectCtx.project.tagId();
+                } catch {
+                    // No project context available - this shouldn't happen in normal operation
+                    // but we handle it gracefully by returning no tasks
+                    logger.warn("No project context available when listing scheduled tasks");
+                }
+
+                // Get tasks from scheduler, filtered by current project
+                const tasks = await schedulerService.getTasks(projectId);
+
+                // Format tasks for output
+                const formattedTasks = tasks.map((task) => ({
+                    id: task.id,
+                    title: task.title,
+                    type: task.type || "cron", // Default to "cron" for backward compatibility
+                    prompt: task.prompt,
+                    createdAt: task.createdAt,
+                    schedule: task.type === "oneoff" ? undefined : task.schedule, // Only show schedule for cron tasks
+                    executeAt: task.executeAt, // Only present for one-off tasks
+                    lastRun: task.lastRun,
+                    nextRun: task.nextRun,
+                    toPubkey: task.toPubkey,
+                }));
+
+                logger.info(`Retrieved ${formattedTasks.length} scheduled tasks`);
+
+                return {
+                    success: true,
+                    tasks: formattedTasks,
+                    count: formattedTasks.length,
+                };
+            } catch (error: unknown) {
+                logger.error("Failed to list scheduled tasks:", error);
+
+                return {
+                    success: false,
+                    error:
+                        error instanceof Error ? error.message : "Failed to list scheduled tasks",
+                };
+            }
+        },
+    });
+
+    // Attach getHumanReadableContent as non-enumerable property
+    Object.defineProperty(aiTool, "getHumanReadableContent", {
+        value: () => {
+            return "Listing scheduled tasks for current project";
+        },
+        enumerable: false,
+        configurable: true,
+    });
+
+    return aiTool as AISdkTool;
+}

package/src/tools/implementations/search.ts

@@ -0,0 +1,160 @@
+/**
+ * Unified Search Tool
+ *
+ * Single search tool that queries across ALL project-scoped RAG collections
+ * (conversations, reports, lessons) and returns unified results with metadata
+ * that allows agents to dig deeper using other tools.
+ *
+ * Supports optional prompt-based LLM extraction for focused information retrieval.
+ */
+
+import type { AISdkTool, ToolExecutionContext } from "@/tools/types";
+import { getProjectContext, isProjectContextInitialized } from "@/services/projects";
+import { bootstrapSearchProviders, UnifiedSearchService } from "@/services/search";
+import { logger } from "@/utils/logger";
+import { tool } from "ai";
+import { z } from "zod";
+
+const searchSchema = z.object({
+    query: z.string().describe(
+        "Natural language search query. Searches across all project knowledge: " +
+        "reports (documentation, architecture), conversations (past discussions), " +
+        "and lessons (agent insights). Use descriptive natural language for best results."
+    ),
+    prompt: z
+        .string()
+        .optional()
+        .describe(
+            "Optional extraction prompt. When provided, a fast LLM processes the search results " +
+            "through the lens of this prompt to extract focused information. " +
+            "Example: 'What decisions were made about the database schema?' " +
+            "When absent, raw ranked results with metadata are returned."
+        ),
+    limit: z
+        .number()
+        .optional()
+        .default(10)
+        .describe("Maximum number of results to return across all collections. Defaults to 10."),
+    collections: z
+        .array(z.enum(["reports", "conversations", "lessons"]))
+        .optional()
+        .describe(
+            "Which collections to search. Defaults to all. " +
+            "Use to narrow search scope when you know where the information lives."
+        ),
+});
+
+type SearchInput = z.infer<typeof searchSchema>;
+
+async function executeSearch(
+    input: SearchInput,
+    context: ToolExecutionContext
+): Promise<Record<string, unknown>> {
+    const { query, prompt, limit = 10, collections } = input;
+
+    // Get project ID for scoping
+    let projectId: string;
+    if (isProjectContextInitialized()) {
+        try {
+            projectId = getProjectContext().project.tagId();
+        } catch {
+            return {
+                success: false,
+                error: "Project context not available. Cannot perform project-scoped search.",
+            };
+        }
+    } else {
+        return {
+            success: false,
+            error: "Project context not initialized. Cannot perform project-scoped search.",
+        };
+    }
+
+    logger.info("🔍 [SearchTool] Executing unified search", {
+        query,
+        prompt: prompt ? `${prompt.substring(0, 50)}...` : undefined,
+        limit,
+        collections: collections || "all",
+        projectId,
+        agent: context.agent.name,
+    });
+
+    // Ensure providers are bootstrapped (idempotent)
+    bootstrapSearchProviders();
+
+    const searchService = UnifiedSearchService.getInstance();
+
+    const result = await searchService.search({
+        query,
+        projectId,
+        limit,
+        prompt,
+        collections,
+    });
+
+    // Format results for agent consumption
+    return {
+        success: result.success,
+        query: result.query,
+        totalResults: result.totalResults,
+        collectionsSearched: result.collectionsSearched,
+        ...(result.collectionsErrored && { collectionsErrored: result.collectionsErrored }),
+        ...(result.warnings && { warnings: result.warnings }),
+        ...(result.extraction && { extraction: result.extraction }),
+        results: result.results.map((r) => ({
+            source: r.source,
+            id: r.id,
+            relevanceScore: Math.round(r.relevanceScore * 1000) / 1000,
+            title: r.title,
+            summary: r.summary,
+            ...(r.createdAt && { createdAt: r.createdAt }),
+            ...(r.updatedAt && { updatedAt: r.updatedAt }),
+            ...(r.author && { author: r.author }),
+            ...(r.authorName && { authorName: r.authorName }),
+            ...(r.tags?.length && { tags: r.tags }),
+            retrievalTool: r.retrievalTool,
+            retrievalArg: r.retrievalArg,
+        })),
+    };
+}
+
+export function createSearchTool(context: ToolExecutionContext): AISdkTool {
+    const aiTool = tool({
+        description:
+            "Search across ALL project knowledge — reports, conversations, and lessons — using " +
+            "natural language semantic search. Returns ranked results with metadata and retrieval " +
+            "instructions. Each result includes a `retrievalTool` and `retrievalArg` that you can " +
+            "use to fetch the full document (e.g., call report_read with the slug, lesson_get with " +
+            "the event ID, or conversation_get with the conversation ID).\n\n" +
+            "Optionally provide a `prompt` parameter to have an LLM extract focused information " +
+            "from the search results, rather than reviewing them manually.\n\n" +
+            "This is the primary discovery tool for finding information across the project. Use " +
+            "conversation_search for deep exploration of specific conversation content.",
+
+        inputSchema: searchSchema,
+
+        execute: async (input: SearchInput) => {
+            return await executeSearch(input, context);
+        },
+    });
+
+    Object.defineProperty(aiTool, "getHumanReadableContent", {
+        value: ({ query, prompt, limit, collections }: SearchInput) => {
+            const parts = [`Searching project knowledge for "${query}"`];
+            if (prompt) parts.push(`prompt: "${prompt.substring(0, 40)}..."`);
+            if (collections?.length) parts.push(`in: ${collections.join(", ")}`);
+            if (limit && limit !== 10) parts.push(`limit: ${limit}`);
+            return parts.join(", ");
+        },
+        enumerable: false,
+        configurable: true,
+    });
+
+    Object.defineProperty(aiTool, "hasSideEffects", {
+        value: false,
+        enumerable: false,
+        configurable: true,
+    });
+
+    return aiTool as AISdkTool;
+}