stagent 0.9.5 → 0.10.0

package/src/lib/chat/tools/__tests__/workflow-tools-dedup.test.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+interface WorkflowRow {
+  id: string;
+  name: string;
+  definition: string | null;
+  projectId: string | null;
+}
+
+const { mockWorkflowRows } = vi.hoisted(() => ({
+  mockWorkflowRows: { value: [] as WorkflowRow[] },
+}));
+
+// Minimal drizzle query builder stub — supports
+//   db.select({...}).from(table).where(...)
+// by returning a thenable that resolves to mockWorkflowRows.value.
+vi.mock("@/lib/db", () => {
+  const builder = {
+    from() {
+      return this;
+    },
+    where() {
+      return this;
+    },
+    then<TResolve>(resolve: (rows: WorkflowRow[]) => TResolve) {
+      return Promise.resolve(mockWorkflowRows.value).then(resolve);
+    },
+  };
+  return {
+    db: {
+      select: () => builder,
+    },
+  };
+});
+
+// Stub the schema import so drizzle-orm doesn't try to read a real table.
+vi.mock("@/lib/db/schema", () => ({
+  workflows: { projectId: "projectId" },
+  tasks: {},
+  agentLogs: {},
+  notifications: {},
+  documents: {},
+  workflowDocumentInputs: {},
+}));
+
+// Stub drizzle-orm operators used in workflow-tools.ts — the tests only
+// care about the return value of the builder, not the operator objects.
+vi.mock("drizzle-orm", () => ({
+  eq: () => ({}),
+  and: () => ({}),
+  desc: () => ({}),
+  inArray: () => ({}),
+  like: () => ({}),
+}));
+
+import { findSimilarWorkflows } from "../workflow-tools";
+
+function setRows(rows: WorkflowRow[]) {
+  mockWorkflowRows.value = rows;
+}
+
+describe("findSimilarWorkflows", () => {
+  beforeEach(() => {
+    setRows([]);
+  });
+
+  it("returns [] when projectId is null (no cross-project dedup)", async () => {
+    setRows([
+      {
+        id: "wf1",
+        name: "Research Customer Feedback",
+        definition: JSON.stringify({
+          pattern: "sequence",
+          steps: [{ id: "s1", name: "Research customer feedback", prompt: "do research" }],
+        }),
+        projectId: null,
+      },
+    ]);
+
+    const result = await findSimilarWorkflows(
+      null,
+      "Research Customer Feedback",
+      JSON.stringify({ pattern: "sequence", steps: [] })
+    );
+    expect(result).toEqual([]);
+  });
+
+  it("returns [] when no workflows exist in the project", async () => {
+    setRows([]);
+    const result = await findSimilarWorkflows(
+      "proj_a",
+      "Any name",
+      JSON.stringify({ pattern: "sequence", steps: [] })
+    );
+    expect(result).toEqual([]);
+  });
+
+  it("matches exact name (case-insensitive) with similarity 1.0", async () => {
+    setRows([
+      {
+        id: "wf1",
+        name: "Research Customer Feedback",
+        definition: null,
+        projectId: "proj_a",
+      },
+    ]);
+
+    const result = await findSimilarWorkflows(
+      "proj_a",
+      "research customer feedback",
+      JSON.stringify({ pattern: "sequence", steps: [] })
+    );
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      id: "wf1",
+      similarity: 1,
+    });
+    expect(result[0].reason).toContain("Same name");
+  });
+
+  it("matches on Jaccard similarity over step names + prompts (redesign scenario)", async () => {
+    // Simulates the bug scenario: LLM "redesigns" a workflow mid-conversation,
+    // using mostly the same vocabulary as the original. The definitions are
+    // near-identical (as redesigns typically are in practice) so Jaccard
+    // should exceed the 0.7 threshold.
+    const sharedSteps = [
+      { id: "s1", name: "Research customer cohort", prompt: "Investigate customer research cohort feedback insights" },
+      { id: "s2", name: "Interview protocol draft", prompt: "Draft customer interview questions protocol script" },
+      { id: "s3", name: "Synthesize findings", prompt: "Summarize customer research findings insights report" },
+    ];
+    setRows([
+      {
+        id: "wf1",
+        name: "Customer Discovery Pipeline",
+        definition: JSON.stringify({ pattern: "sequence", steps: sharedSteps }),
+        projectId: "proj_a",
+      },
+    ]);
+
+    const result = await findSimilarWorkflows(
+      "proj_a",
+      "Customer Discovery Workflow v2",
+      JSON.stringify({ pattern: "sequence", steps: sharedSteps })
+    );
+
+    expect(result.length).toBeGreaterThanOrEqual(1);
+    expect(result[0].id).toBe("wf1");
+    expect(result[0].similarity).toBeGreaterThanOrEqual(0.7);
+  });
+
+  it("does NOT match when names and step text are completely different", async () => {
+    setRows([
+      {
+        id: "wf1",
+        name: "Deploy frontend release",
+        definition: JSON.stringify({
+          pattern: "sequence",
+          steps: [{ id: "s1", name: "Deploy staging", prompt: "Push release artifact to staging environment" }],
+        }),
+        projectId: "proj_a",
+      },
+    ]);
+
+    const result = await findSimilarWorkflows(
+      "proj_a",
+      "Customer interview analysis",
+      JSON.stringify({
+        pattern: "sequence",
+        steps: [{ id: "s2", name: "Summarize interviews", prompt: "Pull insights from recent customer interviews" }],
+      })
+    );
+
+    expect(result).toEqual([]);
+  });
+
+  it("caps results at 3 and sorts by similarity descending", async () => {
+    // Four rows, all exact-name matches (similarity 1.0). Expect exactly 3 returned.
+    setRows(
+      Array.from({ length: 4 }).map((_, i) => ({
+        id: `wf${i}`,
+        name: "Duplicate Workflow",
+        definition: null,
+        projectId: "proj_a",
+      }))
+    );
+
+    const result = await findSimilarWorkflows(
+      "proj_a",
+      "Duplicate Workflow",
+      JSON.stringify({ pattern: "sequence", steps: [] })
+    );
+
+    expect(result).toHaveLength(3);
+    expect(result.every((r) => r.similarity === 1)).toBe(true);
+  });
+
+  it("handles malformed definition JSON without crashing", async () => {
+    setRows([
+      {
+        id: "wf1",
+        name: "Legit Workflow",
+        definition: "not-json-at-all",
+        projectId: "proj_a",
+      },
+    ]);
+
+    // Should not throw — just degrades to name-only comparison.
+    const result = await findSimilarWorkflows(
+      "proj_a",
+      "Legit Workflow",
+      "also not json"
+    );
+    expect(result).toHaveLength(1);
+    expect(result[0].similarity).toBe(1); // exact name match
+  });
+});

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

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@/lib/db";
 import { documents } 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 { access, stat, copyFile, mkdir } from "fs/promises";
 import { basename, extname, join } from "path";
 import crypto from "crypto";
@@ -105,6 +105,10 @@ export function documentTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(documents, documents.id, args.documentId);
+          if ("error" in resolved) return err(resolved.error);
+          const documentId = resolved.id;
+
           const doc = await db
             .select({
               id: documents.id,
@@ -122,10 +126,10 @@ export function documentTools(ctx: ToolContext) {
               updatedAt: documents.updatedAt,
             })
             .from(documents)
-            .where(eq(documents.id, args.documentId))
+            .where(eq(documents.id, documentId))
             .get();
 
-          if (!doc) return err(`Document not found: ${args.documentId}`);
+          if (!doc) return err(`Document not found: ${documentId}`);
           ctx.onToolResult?.("get_document", doc);
           return ok(doc);
         } catch (e) {
@@ -204,13 +208,17 @@ export function documentTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(documents, documents.id, args.documentId);
+          if ("error" in resolved) return err(resolved.error);
+          const documentId = resolved.id;
+
           const doc = await db
             .select()
             .from(documents)
-            .where(eq(documents.id, args.documentId))
+            .where(eq(documents.id, documentId))
             .get();
 
-          if (!doc) return err(`Document not found: ${args.documentId}`);
+          if (!doc) return err(`Document not found: ${documentId}`);
 
           const updates: Record<string, unknown> = { updatedAt: new Date() };
 
@@ -232,10 +240,10 @@ export function documentTools(ctx: ToolContext) {
           await db
             .update(documents)
             .set(updates)
-            .where(eq(documents.id, args.documentId));
+            .where(eq(documents.id, documentId));
 
           if (args.reprocess) {
-            processDocument(args.documentId).catch(() => {});
+            processDocument(documentId).catch(() => {});
           }
 
           const updatedFields = [];
@@ -243,7 +251,7 @@ export function documentTools(ctx: ToolContext) {
           if (args.reprocess) updatedFields.push("processingStatus");
 
           const result = {
-            documentId: args.documentId,
+            documentId,
             updatedFields,
             processingStatus: args.reprocess ? "queued" : doc.status,
           };
@@ -264,13 +272,17 @@ export function documentTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(documents, documents.id, args.documentId);
+          if ("error" in resolved) return err(resolved.error);
+          const documentId = resolved.id;
+
           const doc = await db
             .select()
             .from(documents)
-            .where(eq(documents.id, args.documentId))
+            .where(eq(documents.id, documentId))
             .get();
 
-          if (!doc) return err(`Document not found: ${args.documentId}`);
+          if (!doc) return err(`Document not found: ${documentId}`);
 
           // Check task linkage
           if (doc.taskId && !args.cascadeDelete) {
@@ -285,7 +297,7 @@ export function documentTools(ctx: ToolContext) {
             // File may already be deleted
           }
 
-          await db.delete(documents).where(eq(documents.id, args.documentId));
+          await db.delete(documents).where(eq(documents.id, documentId));
 
           const result = {
             success: true,
@@ -308,6 +320,10 @@ export function documentTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(documents, documents.id, args.documentId);
+          if ("error" in resolved) return err(resolved.error);
+          const documentId = resolved.id;
+
           const doc = await db
             .select({
               id: documents.id,
@@ -316,10 +332,10 @@ export function documentTools(ctx: ToolContext) {
               extractedText: documents.extractedText,
             })
             .from(documents)
-            .where(eq(documents.id, args.documentId))
+            .where(eq(documents.id, documentId))
             .get();
 
-          if (!doc) return err(`Document not found: ${args.documentId}`);
+          if (!doc) return err(`Document not found: ${documentId}`);
           if (doc.status !== "ready")
             return err(`Document not ready (status: ${doc.status}). Wait for preprocessing to complete.`);
           if (!doc.extractedText)

package/src/lib/chat/tools/helpers.ts

@@ -2,6 +2,11 @@
  * Shared helpers and types for Stagent chat MCP tools.
  */
 
+import { db } from "@/lib/db";
+import { like } from "drizzle-orm";
+import type { SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
+import type { SQLiteColumn } from "drizzle-orm/sqlite-core";
+
 /** Context passed to each tool factory — provides project scoping and entity callbacks. */
 export interface ToolContext {
   projectId?: string | null;
@@ -22,3 +27,37 @@ export function err(message: string) {
     isError: true as const,
   };
 }
+
+/**
+ * Resolve an entity ID that may be a prefix (8+ chars) to the full UUID.
+ * Uses LIKE 'prefix%' which hits the primary key B-tree index on SQLite.
+ *
+ * Fast path: IDs >=32 chars are returned as-is (already full UUIDs).
+ */
+export async function resolveEntityId(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  table: SQLiteTableWithColumns<any>,
+  idColumn: SQLiteColumn,
+  rawId: string,
+): Promise<{ id: string } | { error: string }> {
+  // Full UUIDs are 36 chars (with hyphens) or 32 (without) — skip prefix search
+  if (rawId.length >= 32) {
+    return { id: rawId };
+  }
+
+  const matches = await db
+    .select({ id: idColumn })
+    .from(table)
+    .where(like(idColumn, `${rawId}%`))
+    .limit(2);
+
+  if (matches.length === 0) {
+    return { error: `No entity found matching ID prefix: ${rawId}` };
+  }
+  if (matches.length > 1) {
+    return {
+      error: `Ambiguous ID prefix "${rawId}" matches multiple entities: ${matches.map((m) => m.id).join(", ")}. Use the full ID.`,
+    };
+  }
+  return { id: matches[0].id as string };
+}

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

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@/lib/db";
 import { notifications } from "@/lib/db/schema";
 import { eq, isNull, desc } from "drizzle-orm";
-import { ok, err, type ToolContext } from "./helpers";
+import { ok, err, resolveEntityId, type ToolContext } from "./helpers";
 
 export function notificationTools(_ctx: ToolContext) {
   return [
@@ -73,13 +73,17 @@ export function notificationTools(_ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(notifications, notifications.id, args.notificationId);
+          if ("error" in resolved) return err(resolved.error);
+          const notificationId = resolved.id;
+
           const notification = await db
             .select()
             .from(notifications)
-            .where(eq(notifications.id, args.notificationId))
+            .where(eq(notifications.id, notificationId))
             .get();
 
-          if (!notification) return err(`Notification not found: ${args.notificationId}`);
+          if (!notification) return err(`Notification not found: ${notificationId}`);
           if (notification.response) return err("Already responded to this notification");
 
           const responseData = {
@@ -98,7 +102,7 @@ export function notificationTools(_ctx: ToolContext) {
               respondedAt: new Date(),
               read: true,
             })
-            .where(eq(notifications.id, args.notificationId));
+            .where(eq(notifications.id, notificationId));
 
           // Save permanent permission if requested
           if (args.behavior === "allow" && args.alwaysAllow && notification.toolName && notification.toolInput) {
@@ -115,7 +119,7 @@ export function notificationTools(_ctx: ToolContext) {
 
           return ok({
             message: `Notification ${args.behavior === "allow" ? "approved" : "denied"}`,
-            notificationId: args.notificationId,
+            notificationId,
             alwaysAllow: args.alwaysAllow ?? false,
           });
         } catch (e) {

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

@@ -85,5 +85,38 @@ export function projectTools(ctx: ToolContext) {
         }
       }
     ),
+
+    defineTool(
+      "delete_project",
+      "Permanently delete a project and all its resources (tasks, tables, schedules, " +
+        "documents, app instances). This is irreversible. Use to clean up orphaned or " +
+        "unwanted projects. Always confirm with the user before calling.",
+      {
+        projectId: z
+          .string()
+          .describe("The ID of the project to delete"),
+      },
+      async (args) => {
+        try {
+          const { deleteProjectCascade } = await import(
+            "@/lib/data/delete-project"
+          );
+
+          const deleted = deleteProjectCascade(args.projectId);
+          if (!deleted) {
+            return err(`Project "${args.projectId}" not found`);
+          }
+
+          return ok({
+            projectId: args.projectId,
+            message: `Project "${args.projectId}" and all its resources have been deleted.`,
+          });
+        } catch (e) {
+          return err(
+            e instanceof Error ? e.message : "Failed to delete project",
+          );
+        }
+      }
+    ),
   ];
 }

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

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@/lib/db";
 import { schedules } 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 { analyzePromptEfficiency } from "@/lib/schedules/prompt-analyzer";
 
 const VALID_SCHEDULE_STATUSES = [
@@ -69,6 +69,13 @@ export function scheduleTools(ctx: ToolContext) {
           .number()
           .optional()
           .describe("Auto-expire after this many hours"),
+        maxTurns: z
+          .number()
+          .int()
+          .min(10)
+          .max(500)
+          .optional()
+          .describe("Hard cap on turns per firing (10-500). Omit to inherit the system default."),
       },
       async (args) => {
         try {
@@ -147,6 +154,8 @@ export function scheduleTools(ctx: ToolContext) {
             recurs: true,
             status: "active",
             maxFirings: args.maxFirings ?? null,
+            maxTurns: args.maxTurns ?? null,
+            maxTurnsSetAt: args.maxTurns !== undefined ? now : null,
             firingCount: 0,
             expiresAt,
             nextFireAt,
@@ -184,13 +193,17 @@ export function scheduleTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(schedules, schedules.id, args.scheduleId);
+          if ("error" in resolved) return err(resolved.error);
+          const scheduleId = resolved.id;
+
           const schedule = await db
             .select()
             .from(schedules)
-            .where(eq(schedules.id, args.scheduleId))
+            .where(eq(schedules.id, scheduleId))
             .get();
 
-          if (!schedule) return err(`Schedule not found: ${args.scheduleId}`);
+          if (!schedule) return err(`Schedule not found: ${scheduleId}`);
           ctx.onToolResult?.("get_schedule", schedule);
           return ok(schedule);
         } catch (e) {
@@ -216,16 +229,28 @@ export function scheduleTools(ctx: ToolContext) {
           .describe("New status (use 'paused' to pause, 'active' to resume)"),
         assignedAgent: z.string().optional().describe("New runtime ID"),
         agentProfile: z.string().optional().describe("New agent profile"),
+        maxTurns: z
+          .number()
+          .int()
+          .min(10)
+          .max(500)
+          .optional()
+          .nullable()
+          .describe("Hard cap on turns per firing (10-500). Pass null to clear an override back to the system default."),
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(schedules, schedules.id, args.scheduleId);
+          if ("error" in resolved) return err(resolved.error);
+          const scheduleId = resolved.id;
+
           const existing = await db
             .select()
             .from(schedules)
-            .where(eq(schedules.id, args.scheduleId))
+            .where(eq(schedules.id, scheduleId))
             .get();
 
-          if (!existing) return err(`Schedule not found: ${args.scheduleId}`);
+          if (!existing) return err(`Schedule not found: ${scheduleId}`);
 
           const updates: Record<string, unknown> = { updatedAt: new Date() };
           if (args.name !== undefined) updates.name = args.name;
@@ -233,6 +258,10 @@ export function scheduleTools(ctx: ToolContext) {
           if (args.status !== undefined) updates.status = args.status;
           if (args.assignedAgent !== undefined) updates.assignedAgent = args.assignedAgent;
           if (args.agentProfile !== undefined) updates.agentProfile = args.agentProfile;
+          if (args.maxTurns !== undefined) {
+            updates.maxTurns = args.maxTurns;
+            updates.maxTurnsSetAt = args.maxTurns === null ? null : new Date();
+          }
 
           if (args.interval) {
             const { parseInterval, computeNextFireTime } = await import(
@@ -267,12 +296,12 @@ export function scheduleTools(ctx: ToolContext) {
           await db
             .update(schedules)
             .set(updates)
-            .where(eq(schedules.id, args.scheduleId));
+            .where(eq(schedules.id, scheduleId));
 
           const [schedule] = await db
             .select()
             .from(schedules)
-            .where(eq(schedules.id, args.scheduleId));
+            .where(eq(schedules.id, scheduleId));
 
           ctx.onToolResult?.("update_schedule", schedule);
           return ok(schedule);
@@ -290,16 +319,20 @@ export function scheduleTools(ctx: ToolContext) {
       },
       async (args) => {
         try {
+          const resolved = await resolveEntityId(schedules, schedules.id, args.scheduleId);
+          if ("error" in resolved) return err(resolved.error);
+          const scheduleId = resolved.id;
+
           const existing = await db
             .select()
             .from(schedules)
-            .where(eq(schedules.id, args.scheduleId))
+            .where(eq(schedules.id, scheduleId))
             .get();
 
-          if (!existing) return err(`Schedule not found: ${args.scheduleId}`);
+          if (!existing) return err(`Schedule not found: ${scheduleId}`);
 
-          await db.delete(schedules).where(eq(schedules.id, args.scheduleId));
-          return ok({ message: "Schedule deleted", scheduleId: args.scheduleId, name: existing.name });
+          await db.delete(schedules).where(eq(schedules.id, scheduleId));
+          return ok({ message: "Schedule deleted", scheduleId, name: existing.name });
         } catch (e) {
           return err(e instanceof Error ? e.message : "Failed to delete schedule");
         }

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(