stagent 0.9.6 → 0.11.0

package/src/app/api/tables/[id]/enrich/__tests__/route.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { mockCreateEnrichmentWorkflow } = vi.hoisted(() => ({
+  mockCreateEnrichmentWorkflow: vi.fn(),
+}));
+
+vi.mock("@/lib/tables/enrichment", () => ({
+  createEnrichmentWorkflow: mockCreateEnrichmentWorkflow,
+}));
+
+import { POST } from "../route";
+
+function makeRequest(body: unknown): Request {
+  return new Request("http://test/api/tables/tbl_x/enrich", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+const params = Promise.resolve({ id: "tbl_x" });
+
+describe("POST /api/tables/[id]/enrich", () => {
+  beforeEach(() => {
+    mockCreateEnrichmentWorkflow.mockReset();
+  });
+
+  it("rejects requests with missing required fields (400)", async () => {
+    const res = await POST(makeRequest({}) as never, {
+      params,
+    });
+    expect(res.status).toBe(400);
+    expect(mockCreateEnrichmentWorkflow).not.toHaveBeenCalled();
+  });
+
+  it("returns 202 with workflowId and rowCount on success", async () => {
+    mockCreateEnrichmentWorkflow.mockResolvedValueOnce({
+      workflowId: "wf_123",
+      rowCount: 3,
+    });
+
+    const res = await POST(
+      makeRequest({
+        prompt: "Find LinkedIn for {{row.name}}",
+        targetColumn: "linkedin",
+      }) as never,
+      { params }
+    );
+
+    expect(res.status).toBe(202);
+    const json = (await res.json()) as { workflowId: string; rowCount: number };
+    expect(json.workflowId).toBe("wf_123");
+    expect(json.rowCount).toBe(3);
+    expect(mockCreateEnrichmentWorkflow).toHaveBeenCalledWith(
+      "tbl_x",
+      expect.objectContaining({
+        prompt: "Find LinkedIn for {{row.name}}",
+        targetColumn: "linkedin",
+      })
+    );
+  });
+
+  it("caps batchSize to 200 before delegating", async () => {
+    mockCreateEnrichmentWorkflow.mockResolvedValueOnce({
+      workflowId: "wf_456",
+      rowCount: 200,
+    });
+
+    await POST(
+      makeRequest({
+        prompt: "Enrich {{row.name}}",
+        targetColumn: "linkedin",
+        batchSize: 5000,
+      }) as never,
+      { params }
+    );
+
+    const callArg = mockCreateEnrichmentWorkflow.mock.calls[0][1] as {
+      batchSize: number;
+    };
+    expect(callArg.batchSize).toBe(200);
+  });
+
+  it("rejects batchSize less than 1", async () => {
+    const res = await POST(
+      makeRequest({
+        prompt: "x",
+        targetColumn: "linkedin",
+        batchSize: 0,
+      }) as never,
+      { params }
+    );
+    expect(res.status).toBe(400);
+    expect(mockCreateEnrichmentWorkflow).not.toHaveBeenCalled();
+  });
+
+  it("returns 404 when the table is missing", async () => {
+    mockCreateEnrichmentWorkflow.mockRejectedValueOnce(
+      new Error("Table tbl_x not found")
+    );
+
+    const res = await POST(
+      makeRequest({
+        prompt: "x",
+        targetColumn: "linkedin",
+      }) as never,
+      { params }
+    );
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 400 when the column does not exist on the table", async () => {
+    mockCreateEnrichmentWorkflow.mockRejectedValueOnce(
+      new Error('Column "ghost" does not exist on table tbl_x')
+    );
+
+    const res = await POST(
+      makeRequest({
+        prompt: "x",
+        targetColumn: "ghost",
+      }) as never,
+      { params }
+    );
+    expect(res.status).toBe(400);
+  });
+
+  it("forwards filter, agentProfile, and projectId to the generator", async () => {
+    mockCreateEnrichmentWorkflow.mockResolvedValueOnce({
+      workflowId: "wf_789",
+      rowCount: 1,
+    });
+
+    await POST(
+      makeRequest({
+        prompt: "x",
+        targetColumn: "linkedin",
+        filter: { column: "linkedin", operator: "is_empty" },
+        agentProfile: "researcher",
+        projectId: "proj_1",
+      }) as never,
+      { params }
+    );
+
+    const callArg = mockCreateEnrichmentWorkflow.mock.calls[0][1] as {
+      filter: unknown;
+      agentProfile: string;
+      projectId: string;
+    };
+    expect(callArg.filter).toEqual({ column: "linkedin", operator: "is_empty" });
+    expect(callArg.agentProfile).toBe("researcher");
+    expect(callArg.projectId).toBe("proj_1");
+  });
+});

package/src/app/api/tables/[id]/enrich/plan/route.ts

@@ -0,0 +1,98 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { previewEnrichmentPlan } from "@/lib/tables/enrichment";
+
+const MAX_BATCH_SIZE = 200;
+
+const filterSchema = z.object({
+  column: z.string().min(1),
+  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(),
+});
+
+const previewRequestSchema = z.object({
+  targetColumn: z.string().min(1).max(128),
+  promptMode: z.enum(["auto", "custom"]).optional(),
+  prompt: z.string().min(1).max(8192).optional(),
+  filter: filterSchema.optional(),
+  agentProfile: z.string().min(1).max(128).optional(),
+  agentProfileOverride: z.string().min(1).max(128).optional(),
+  batchSize: z.number().int().min(1).optional(),
+}).superRefine((value, ctx) => {
+  const mode = value.promptMode ?? (value.prompt ? "custom" : "auto");
+  if (mode === "custom" && !value.prompt?.trim()) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["prompt"],
+      message: "Custom enrichment requires a prompt",
+    });
+  }
+});
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const parsed = previewRequestSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json(
+      {
+        error: parsed.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message,
+        })),
+      },
+      { status: 400 }
+    );
+  }
+
+  const { batchSize, ...rest } = parsed.data;
+  const cappedBatchSize =
+    batchSize !== undefined ? Math.min(batchSize, MAX_BATCH_SIZE) : undefined;
+
+  try {
+    const preview = await previewEnrichmentPlan(id, {
+      ...rest,
+      batchSize: cappedBatchSize,
+    });
+    return NextResponse.json(preview);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+
+    if (/not found/i.test(message)) {
+      return NextResponse.json({ error: message }, { status: 404 });
+    }
+    if (/does not exist|unsupported/i.test(message)) {
+      return NextResponse.json({ error: message }, { status: 400 });
+    }
+
+    console.error("[tables/enrich/plan] POST error:", err);
+    return NextResponse.json(
+      { error: "Failed to build enrichment plan" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tables/[id]/enrich/route.ts

@@ -0,0 +1,147 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { createEnrichmentWorkflow } from "@/lib/tables/enrichment";
+
+const MAX_BATCH_SIZE = 200;
+
+const filterSchema = z.object({
+  column: z.string().min(1),
+  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(),
+});
+
+const enrichRequestSchema = z.object({
+  targetColumn: z.string().min(1).max(128),
+  promptMode: z.enum(["auto", "custom"]).optional(),
+  prompt: z.string().min(1).max(8192).optional(),
+  filter: filterSchema.optional(),
+  agentProfile: z.string().min(1).max(128).optional(),
+  agentProfileOverride: z.string().min(1).max(128).optional(),
+  projectId: z.string().nullable().optional(),
+  // Reject non-positive ints; the upper bound is *clamped* in the handler so
+  // callers asking for too much get a working (smaller) batch instead of a 400.
+  batchSize: z.number().int().min(1).optional(),
+  itemVariable: z.string().min(1).max(64).optional(),
+  workflowName: z.string().min(1).max(256).optional(),
+  plan: z
+    .object({
+      promptMode: z.enum(["auto", "custom"]),
+      strategy: z.enum([
+        "single-pass-lookup",
+        "single-pass-classify",
+        "research-and-synthesize",
+      ]),
+      agentProfile: z.string().min(1),
+      reasoning: z.string(),
+      steps: z.array(
+        z.object({
+          id: z.string().min(1),
+          name: z.string().min(1),
+          purpose: z.string().min(1),
+          prompt: z.string().min(1),
+          agentProfile: z.string().min(1).optional(),
+        })
+      ),
+      targetContract: z.object({
+        columnName: z.string().min(1),
+        columnLabel: z.string().min(1),
+        dataType: z.enum(["text", "number", "boolean", "select", "url", "email"]),
+        allowedOptions: z.array(z.string()).optional(),
+      }),
+      eligibleRowCount: z.number().int().min(0),
+      sampleBindings: z.array(z.record(z.string(), z.unknown())),
+    })
+    .optional(),
+}).superRefine((value, ctx) => {
+  const hasPlan = Boolean(value.plan);
+  const mode = value.promptMode ?? (value.prompt ? "custom" : "auto");
+  if (!hasPlan && mode === "custom" && !value.prompt?.trim()) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["prompt"],
+      message: "Custom enrichment requires a prompt",
+    });
+  }
+});
+
+/**
+ * POST /api/tables/[id]/enrich
+ *
+ * Kicks off a row-driven enrichment workflow for a user table. The workflow
+ * runs fire-and-forget (TDR-001); the response includes the workflow id and
+ * the number of rows that will actually be processed (already-populated rows
+ * are filtered out for idempotency).
+ *
+ * Status codes:
+ *  - 202: workflow created and queued
+ *  - 400: invalid body, unknown column, or other validation failure
+ *  - 404: table not found
+ *  - 500: unexpected error
+ */
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const parsed = enrichRequestSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json(
+      {
+        error: parsed.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message,
+        })),
+      },
+      { status: 400 }
+    );
+  }
+
+  const { batchSize, ...rest } = parsed.data;
+  const cappedBatchSize =
+    batchSize !== undefined ? Math.min(batchSize, MAX_BATCH_SIZE) : undefined;
+
+  try {
+    const result = await createEnrichmentWorkflow(id, {
+      ...rest,
+      batchSize: cappedBatchSize,
+    });
+    return NextResponse.json(result, { status: 202 });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+
+    if (/not found/i.test(message)) {
+      return NextResponse.json({ error: message }, { status: 404 });
+    }
+    if (/does not exist|unsupported/i.test(message)) {
+      return NextResponse.json({ error: message }, { status: 400 });
+    }
+
+    console.error("[tables/enrich] POST error:", err);
+    return NextResponse.json(
+      { error: "Failed to start enrichment workflow" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tables/[id]/enrich/runs/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listRecentEnrichmentRuns } from "@/lib/tables/enrichment";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const searchParams = req.nextUrl.searchParams;
+  const rawLimit = Number(searchParams.get("limit") ?? "5");
+  const limit = Number.isFinite(rawLimit)
+    ? Math.min(Math.max(Math.trunc(rawLimit), 1), 10)
+    : 5;
+
+  try {
+    const runs = await listRecentEnrichmentRuns(id, limit);
+    return NextResponse.json(runs);
+  } catch (err) {
+    console.error("[tables/enrich/runs] GET error:", err);
+    return NextResponse.json(
+      { error: "Failed to load recent enrichment runs" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tasks/[id]/execute/route.ts

@@ -2,16 +2,15 @@ import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { tasks, projects } from "@/lib/db/schema";
 import { eq, and } from "drizzle-orm";
-import { executeTaskWithAgent, classifyTaskProfile } from "@/lib/agents/router";
-import { DEFAULT_AGENT_RUNTIME } from "@/lib/agents/runtime/catalog";
+import { classifyTaskProfile } from "@/lib/agents/router";
 import { validateRuntimeProfileAssignment } from "@/lib/agents/profiles/assignment-validation";
 import {
   BudgetLimitExceededError,
   enforceTaskBudgetGuardrails,
 } from "@/lib/settings/budget-guardrails";
 import { ensureFreshScan } from "@/lib/environment/auto-scan";
-import { getAllExecutions } from "@/lib/agents/execution-manager";
-import { licenseManager } from "@/lib/license/manager";
+import { resolveTaskExecutionTarget } from "@/lib/agents/runtime/execution-target";
+import { startTaskExecution } from "@/lib/agents/task-dispatch";
 
 export async function POST(
   _req: NextRequest,
@@ -49,6 +48,7 @@ export async function POST(
   }
 
   const task = claimed[0];
+  let taskProfile = task.agentProfile;
 
   // Auto-scan environment if the task's project has a workingDirectory
   if (task.projectId) {
@@ -61,26 +61,64 @@ export async function POST(
     }
   }
 
-  // Auto-classify profile if none was set
-  if (!task.agentProfile) {
+  let executionTarget;
+  try {
+    executionTarget = await resolveTaskExecutionTarget({
+      title: task.title,
+      description: task.description,
+      requestedRuntimeId: task.assignedAgent,
+      profileId: taskProfile,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    db.update(tasks)
+      .set({
+        status: "failed",
+        result: message,
+        updatedAt: new Date(),
+      })
+      .where(eq(tasks.id, id))
+      .run();
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+
+  // Auto-classify profile if none was set. Use the resolved runtime so the
+  // chosen profile is compatible with the runtime we will actually launch.
+  if (!taskProfile) {
     const autoProfile = classifyTaskProfile(
       task.title,
       task.description,
-      task.assignedAgent ?? DEFAULT_AGENT_RUNTIME
+      executionTarget.effectiveRuntimeId
     );
     db.update(tasks)
       .set({ agentProfile: autoProfile, updatedAt: new Date() })
       .where(eq(tasks.id, id))
       .run();
+    taskProfile = autoProfile;
+    try {
+      executionTarget = await resolveTaskExecutionTarget({
+        title: task.title,
+        description: task.description,
+        requestedRuntimeId: task.assignedAgent,
+        profileId: taskProfile,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      db.update(tasks)
+        .set({
+          status: "failed",
+          result: message,
+          updatedAt: new Date(),
+        })
+        .where(eq(tasks.id, id))
+        .run();
+      return NextResponse.json({ error: message }, { status: 400 });
+    }
   }
 
   const compatibilityError = validateRuntimeProfileAssignment({
-    profileId: task.agentProfile ?? classifyTaskProfile(
-      task.title,
-      task.description,
-      task.assignedAgent ?? DEFAULT_AGENT_RUNTIME
-    ),
-    runtimeId: task.assignedAgent,
+    profileId: taskProfile,
+    runtimeId: executionTarget.effectiveRuntimeId,
     context: "Task profile",
   });
   if (compatibilityError) {
@@ -95,27 +133,8 @@ export async function POST(
     return NextResponse.json({ error: compatibilityError }, { status: 400 });
   }
 
-  // Pre-check parallel workflow limit before fire-and-forget
-  const parallelLimit = licenseManager.getLimit("parallelWorkflows");
-  if (Number.isFinite(parallelLimit) && getAllExecutions().size >= parallelLimit) {
-    // Revert task to queued since we can't execute it
-    db.update(tasks)
-      .set({ status: "queued", updatedAt: new Date() })
-      .where(eq(tasks.id, id))
-      .run();
-    return NextResponse.json(
-      {
-        error: `Parallel workflow limit reached (${getAllExecutions().size}/${parallelLimit}). Wait for a running task to finish or upgrade.`,
-        limitType: "parallelWorkflows",
-        current: getAllExecutions().size,
-        max: parallelLimit,
-      },
-      { status: 429 }
-    );
-  }
-
   // Fire-and-forget — task already marked as running
-  executeTaskWithAgent(id, task.assignedAgent ?? DEFAULT_AGENT_RUNTIME).catch(
+  startTaskExecution(id, { requestedRuntimeId: task.assignedAgent }).catch(
     (err) => console.error(`Task ${id} execution error:`, err)
   );
 

package/src/app/api/tasks/[id]/respond/route.ts

@@ -43,25 +43,41 @@ export async function POST(
     return NextResponse.json({ error: "Already responded" }, { status: 409 });
   }
 
-  // Validate updatedInput keys against the original tool input to prevent injection
+  // Validate updatedInput keys against the original tool input to prevent injection.
+  // AskUserQuestion is a special case: the original toolInput describes the question
+  // (`question`, `options?`) but the response carries the user's `answer` — a key not
+  // present in the original. Allow a tightly-scoped `{answer: string}` shape.
   let sanitizedUpdatedInput = updatedInput;
+  const isQuestion = notification.toolName === "AskUserQuestion";
   if (updatedInput !== undefined && updatedInput !== null && typeof updatedInput === "object" && !Array.isArray(updatedInput)) {
-    try {
-      const originalToolInput = typeof notification.toolInput === "string" ? JSON.parse(notification.toolInput) : (notification.toolInput ?? {});
-      if (typeof originalToolInput === "object" && originalToolInput !== null) {
-        const allowedKeys = new Set(Object.keys(originalToolInput));
-        const inputRecord = updatedInput as Record<string, unknown>;
-        const extraKeys = Object.keys(inputRecord).filter((k) => !allowedKeys.has(k));
-        if (extraKeys.length > 0) {
-          return NextResponse.json(
-            { error: `updatedInput contains disallowed keys: ${extraKeys.join(", ")}` },
-            { status: 400 }
-          );
+    if (isQuestion) {
+      const inputRecord = updatedInput as Record<string, unknown>;
+      const keys = Object.keys(inputRecord);
+      const extraKeys = keys.filter((k) => k !== "answer");
+      if (extraKeys.length > 0 || typeof inputRecord.answer !== "string") {
+        return NextResponse.json(
+          { error: "AskUserQuestion response must be { answer: string }" },
+          { status: 400 }
+        );
+      }
+    } else {
+      try {
+        const originalToolInput = typeof notification.toolInput === "string" ? JSON.parse(notification.toolInput) : (notification.toolInput ?? {});
+        if (typeof originalToolInput === "object" && originalToolInput !== null) {
+          const allowedKeys = new Set(Object.keys(originalToolInput));
+          const inputRecord = updatedInput as Record<string, unknown>;
+          const extraKeys = Object.keys(inputRecord).filter((k) => !allowedKeys.has(k));
+          if (extraKeys.length > 0) {
+            return NextResponse.json(
+              { error: `updatedInput contains disallowed keys: ${extraKeys.join(", ")}` },
+              { status: 400 }
+            );
+          }
         }
+      } catch {
+        // If we can't parse the original notification data, reject updatedInput entirely
+        sanitizedUpdatedInput = undefined;
       }
-    } catch {
-      // If we can't parse the original notification data, reject updatedInput entirely
-      sanitizedUpdatedInput = undefined;
     }
   }
 

package/src/app/api/tasks/[id]/resume/route.ts

@@ -2,13 +2,13 @@ import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { tasks } from "@/lib/db/schema";
 import { eq, and, inArray } from "drizzle-orm";
-import { resumeTaskWithAgent } from "@/lib/agents/router";
 import { MAX_RESUME_COUNT } from "@/lib/constants/task-status";
-import { DEFAULT_AGENT_RUNTIME } from "@/lib/agents/runtime/catalog";
 import {
   BudgetLimitExceededError,
   enforceTaskBudgetGuardrails,
 } from "@/lib/settings/budget-guardrails";
+import { resolveResumeExecutionTarget } from "@/lib/agents/runtime/execution-target";
+import { resumeTaskExecution } from "@/lib/agents/task-dispatch";
 
 export async function POST(
   _req: NextRequest,
@@ -67,8 +67,29 @@ export async function POST(
     );
   }
 
+  try {
+    await resolveResumeExecutionTarget({
+      requestedRuntimeId: task.assignedAgent,
+      effectiveRuntimeId: task.effectiveRuntimeId,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    db.update(tasks)
+      .set({
+        status: "failed",
+        result: message,
+        updatedAt: new Date(),
+      })
+      .where(eq(tasks.id, id))
+      .run();
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+
   // Fire-and-forget
-  resumeTaskWithAgent(id, task.assignedAgent ?? DEFAULT_AGENT_RUNTIME).catch((err) =>
+  resumeTaskExecution(id, {
+    requestedRuntimeId: task.assignedAgent,
+    effectiveRuntimeId: task.effectiveRuntimeId,
+  }).catch((err) =>
     console.error(`Task ${id} resume error:`, err)
   );