stagent 0.9.6 → 0.11.0

package/src/lib/chat/tools/table-tools.ts

@@ -25,6 +25,7 @@ import {
   importRows,
   createImportRecord,
 } from "@/lib/tables/import";
+import { createEnrichmentWorkflow } from "@/lib/tables/enrichment";
 import type { ColumnDef } from "@/lib/tables/types";
 
 export function tableTools(ctx: ToolContext) {
@@ -301,6 +302,76 @@ export function tableTools(ctx: ToolContext) {
       }
     ),
 
+    // ── Bulk row enrichment ──────────────────────────────────────────
+
+    defineTool(
+      "enrich_table",
+      `Bulk-enrich rows in a user table by running an agent task per row and writing the result back to a target column. Creates a row-driven loop workflow that fans out one task per matching row.
+
+The prompt may reference row fields with {{row.fieldName}} placeholders — they are passed to the agent as JSON context. To skip a row at agent-time, return the literal string "NOT_FOUND". Already-populated rows (target column has a non-empty value) are skipped automatically for idempotency.
+
+Returns the workflowId so the caller can poll status, plus the rowCount that will actually be processed.`,
+      {
+        tableId: z.string().describe("Table ID to enrich"),
+        prompt: z
+          .string()
+          .min(1)
+          .max(8192)
+          .describe(
+            "Per-row prompt template. Use {{row.fieldName}} to reference row fields. Instruct the agent to return NOT_FOUND when no value can be determined."
+          ),
+        targetColumn: z
+          .string()
+          .min(1)
+          .describe("Column name to write the agent's result into"),
+        filter: z
+          .object({
+            column: z.string(),
+            operator: z.enum([
+              "eq", "neq", "gt", "gte", "lt", "lte",
+              "contains", "starts_with", "in", "is_empty", "is_not_empty",
+            ]),
+            value: z
+              .union([z.string(), z.number(), z.boolean(), z.array(z.string())])
+              .optional(),
+          })
+          .optional()
+          .describe(
+            "Optional row filter — typically {column: targetColumn, operator: 'is_empty'} to enrich only blank cells"
+          ),
+        agentProfile: z
+          .string()
+          .optional()
+          .describe("Agent profile to use (defaults to 'sales-researcher')"),
+        projectId: z
+          .string()
+          .optional()
+          .describe("Project ID. Omit to use the active project."),
+        batchSize: z
+          .number()
+          .int()
+          .min(1)
+          .optional()
+          .describe("Maximum rows to process in this run (default 50, capped at 200)"),
+      },
+      async (args) => {
+        try {
+          const effectiveProjectId = args.projectId ?? ctx.projectId ?? undefined;
+          const result = await createEnrichmentWorkflow(args.tableId, {
+            prompt: args.prompt,
+            targetColumn: args.targetColumn,
+            filter: args.filter,
+            agentProfile: args.agentProfile,
+            projectId: effectiveProjectId,
+            batchSize: args.batchSize,
+          });
+          return ok(result);
+        } catch (e) {
+          return err(e instanceof Error ? e.message : "Failed to start enrichment");
+        }
+      }
+    ),
+
     // ── Creation operations ──────────────────────────────────────────
 
     defineTool(

package/src/lib/chat/tools/task-tools.ts

@@ -3,12 +3,13 @@ import { z } from "zod";
 import { db } from "@/lib/db";
 import { tasks } from "@/lib/db/schema";
 import { eq, and, desc } from "drizzle-orm";
-import { ok, err, type ToolContext } from "./helpers";
+import { ok, err, resolveEntityId, type ToolContext } from "./helpers";
 import {
   DEFAULT_AGENT_RUNTIME,
   isAgentRuntimeId,
   SUPPORTED_AGENT_RUNTIMES,
 } from "@/lib/agents/runtime/catalog";
+import { getProfile, listProfiles } from "@/lib/agents/profiles/registry";
 
 const VALID_TASK_STATUSES = [
   "planned",
@@ -19,6 +20,25 @@ const VALID_TASK_STATUSES = [
   "cancelled",
 ] as const;
 
+/**
+ * Zod refinement shared by create_task and update_task for the agentProfile
+ * field. Returns true for valid registered profile IDs. The error message
+ * lists a truncated sample of valid IDs from the registry so operators can
+ * self-correct without cross-referencing docs.
+ */
+function isValidAgentProfile(id: string): boolean {
+  return getProfile(id) !== undefined;
+}
+
+function agentProfileErrorMessage(invalid: string): string {
+  const valid = listProfiles()
+    .map((p) => p.id)
+    .sort();
+  const sample = valid.slice(0, 8).join(", ");
+  const more = valid.length > 8 ? `, and ${valid.length - 8} more` : "";
+  return `Invalid agentProfile "${invalid}". Valid profiles: ${sample}${more}. Run list_profiles (or inspect ~/.claude/skills/) to see the full set.`;
+}
+
 export function taskTools(ctx: ToolContext) {
   return [
     defineTool(
@@ -51,6 +71,14 @@ export function taskTools(ctx: ToolContext) {
             .orderBy(tasks.priority, desc(tasks.createdAt))
             .limit(50);
 
+          if (result.length === 0 && effectiveProjectId) {
+            return ok({
+              tasks: [],
+              note: `No tasks found in project ${effectiveProjectId}. ` +
+                `Use projectId: null to list tasks from any project, ` +
+                `or get_task <id> to look up a specific task directly.`,
+            });
+          }
           return ok(result);
         } catch (e) {
           return err(e instanceof Error ? e.message : "Failed to list tasks");
@@ -90,13 +118,19 @@ export function taskTools(ctx: ToolContext) {
           ),
         agentProfile: z
           .string()
+          .refine(isValidAgentProfile, {
+            message: "Invalid agentProfile (not in profile registry). See list_profiles.",
+          })
           .optional()
           .describe(
-            "Agent profile ID (e.g. general, code-reviewer, researcher, reddit-researcher)"
+            "Agent profile ID (e.g. general, code-reviewer, researcher). Validated against the profile registry."
           ),
       },
       async (args) => {
         try {
+          if (args.agentProfile !== undefined && !isValidAgentProfile(args.agentProfile)) {
+            return err(agentProfileErrorMessage(args.agentProfile));
+          }
           if (args.assignedAgent && !isAgentRuntimeId(args.assignedAgent)) {
             return err(
               `Invalid runtime "${args.assignedAgent}". Valid: ${SUPPORTED_AGENT_RUNTIMES.join(", ")}`
@@ -162,13 +196,23 @@ export function taskTools(ctx: ToolContext) {
           ),
         agentProfile: z
           .string()
+          .refine(isValidAgentProfile, {
+            message: "Invalid agentProfile (not in profile registry). See list_profiles.",
+          })
           .optional()
           .describe(
-            "Agent profile ID (e.g. general, code-reviewer, researcher, reddit-researcher)"
+            "Agent profile ID (e.g. general, code-reviewer, researcher). Validated against the profile registry."
           ),
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(tasks, tasks.id, args.taskId);
+          if ("error" in resolved) return err(resolved.error);
+          const taskId = resolved.id;
+
+          if (args.agentProfile !== undefined && !isValidAgentProfile(args.agentProfile)) {
+            return err(agentProfileErrorMessage(args.agentProfile));
+          }
           if (args.assignedAgent && !isAgentRuntimeId(args.assignedAgent)) {
             return err(
               `Invalid runtime "${args.assignedAgent}". Valid: ${SUPPORTED_AGENT_RUNTIMES.join(", ")}`
@@ -178,10 +222,10 @@ export function taskTools(ctx: ToolContext) {
           const existing = await db
             .select()
             .from(tasks)
-            .where(eq(tasks.id, args.taskId))
+            .where(eq(tasks.id, taskId))
             .get();
 
-          if (!existing) return err(`Task not found: ${args.taskId}`);
+          if (!existing) return err(`Task not found: ${taskId}`);
 
           const updates: Record<string, unknown> = { updatedAt: new Date() };
           if (args.title !== undefined) updates.title = args.title;
@@ -197,12 +241,12 @@ export function taskTools(ctx: ToolContext) {
           await db
             .update(tasks)
             .set(updates)
-            .where(eq(tasks.id, args.taskId));
+            .where(eq(tasks.id, taskId));
 
           const [task] = await db
             .select()
             .from(tasks)
-            .where(eq(tasks.id, args.taskId));
+            .where(eq(tasks.id, taskId));
 
           ctx.onToolResult?.("update_task", task);
           return ok(task);
@@ -220,13 +264,17 @@ export function taskTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(tasks, tasks.id, args.taskId);
+          if ("error" in resolved) return err(resolved.error);
+          const taskId = resolved.id;
+
           const task = await db
             .select()
             .from(tasks)
-            .where(eq(tasks.id, args.taskId))
+            .where(eq(tasks.id, taskId))
             .get();
 
-          if (!task) return err(`Task not found: ${args.taskId}`);
+          if (!task) return err(`Task not found: ${taskId}`);
           ctx.onToolResult?.("get_task", task);
           return ok(task);
         } catch (e) {
@@ -249,6 +297,10 @@ export function taskTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(tasks, tasks.id, args.taskId);
+          if ("error" in resolved) return err(resolved.error);
+          const taskId = resolved.id;
+
           if (args.assignedAgent && !isAgentRuntimeId(args.assignedAgent)) {
             return err(
               `Invalid runtime "${args.assignedAgent}". Valid: ${SUPPORTED_AGENT_RUNTIMES.join(", ")}`
@@ -258,26 +310,38 @@ export function taskTools(ctx: ToolContext) {
           const task = await db
             .select()
             .from(tasks)
-            .where(eq(tasks.id, args.taskId))
+            .where(eq(tasks.id, taskId))
             .get();
 
-          if (!task) return err(`Task not found: ${args.taskId}`);
+          if (!task) return err(`Task not found: ${taskId}`);
           if (task.status === "running") return err("Task is already running");
 
-          const runtimeId = args.assignedAgent ?? task.assignedAgent ?? DEFAULT_AGENT_RUNTIME;
+          if (task.agentProfile && !isValidAgentProfile(task.agentProfile)) {
+            return err(
+              `Task ${taskId} has an invalid agentProfile "${task.agentProfile}" (not in profile registry). ` +
+              `Fix with update_task { taskId, agentProfile: "<valid-id>" } before retrying. ` +
+              agentProfileErrorMessage(task.agentProfile).split(". ").slice(1).join(". ")
+            );
+          }
+
+          const runtimeId = args.assignedAgent ?? task.assignedAgent ?? null;
 
           // Set status to queued
           await db
             .update(tasks)
             .set({ status: "queued", assignedAgent: runtimeId, updatedAt: new Date() })
-            .where(eq(tasks.id, args.taskId));
+            .where(eq(tasks.id, taskId));
 
           // Fire-and-forget execution
           const { executeTaskWithAgent } = await import("@/lib/agents/router");
-          executeTaskWithAgent(args.taskId, runtimeId).catch(() => {});
+          executeTaskWithAgent(taskId, runtimeId).catch(() => {});
 
-          ctx.onToolResult?.("execute_task", { id: args.taskId, title: task.title });
-          return ok({ message: "Execution started", taskId: args.taskId, runtime: runtimeId });
+          ctx.onToolResult?.("execute_task", { id: taskId, title: task.title });
+          return ok({
+            message: "Execution started",
+            taskId,
+            runtime: runtimeId ?? DEFAULT_AGENT_RUNTIME,
+          });
         } catch (e) {
           return err(e instanceof Error ? e.message : "Failed to execute task");
         }
@@ -292,17 +356,21 @@ export function taskTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(tasks, tasks.id, args.taskId);
+          if ("error" in resolved) return err(resolved.error);
+          const taskId = resolved.id;
+
           const task = await db
             .select()
             .from(tasks)
-            .where(eq(tasks.id, args.taskId))
+            .where(eq(tasks.id, taskId))
             .get();
 
-          if (!task) return err(`Task not found: ${args.taskId}`);
+          if (!task) return err(`Task not found: ${taskId}`);
           if (task.status !== "running") return err(`Task is not running (status: ${task.status})`);
 
           const { getExecution } = await import("@/lib/agents/execution-manager");
-          const execution = getExecution(args.taskId);
+          const execution = getExecution(taskId);
           if (execution?.abortController) {
             execution.abortController.abort();
           }
@@ -310,9 +378,9 @@ export function taskTools(ctx: ToolContext) {
           await db
             .update(tasks)
             .set({ status: "cancelled", updatedAt: new Date() })
-            .where(eq(tasks.id, args.taskId));
+            .where(eq(tasks.id, taskId));
 
-          return ok({ message: "Task cancelled", taskId: args.taskId });
+          return ok({ message: "Task cancelled", taskId });
         } catch (e) {
           return err(e instanceof Error ? e.message : "Failed to cancel task");
         }