stagent 0.9.5 → 0.10.0

package/src/app/api/settings/providers/route.ts

@@ -1,17 +1,39 @@
 import { NextResponse } from "next/server";
+import { readStagentCodexAuthState } from "@/lib/agents/runtime/openai-codex-auth";
 import { getRuntimeSetupStates } from "@/lib/settings/runtime-setup";
 import { getRoutingPreference } from "@/lib/settings/routing";
 import { getAuthSettings } from "@/lib/settings/auth";
 import { getOpenAIAuthSettings } from "@/lib/settings/openai-auth";
+import { getOpenAILoginState } from "@/lib/settings/openai-login-manager";
 
 export async function GET() {
-  const [runtimeStates, routingPreference, anthropicAuth, openaiAuth] =
-    await Promise.all([
-      getRuntimeSetupStates(),
-      getRoutingPreference(),
-      getAuthSettings(),
-      getOpenAIAuthSettings(),
-    ]);
+  const [routingPreference, anthropicAuth, initialOpenaiAuth] = await Promise.all([
+    getRoutingPreference(),
+    getAuthSettings(),
+    getOpenAIAuthSettings(),
+  ]);
+
+  let openaiAuth = initialOpenaiAuth;
+  if (openaiAuth.method === "oauth") {
+    try {
+      const current = await readStagentCodexAuthState({ refreshToken: true });
+      openaiAuth = {
+        ...openaiAuth,
+        oauthConnected: current.connected,
+        account: current.account,
+        rateLimits: current.rateLimits,
+      };
+    } catch {
+      openaiAuth = {
+        ...openaiAuth,
+        oauthConnected: false,
+        account: null,
+        rateLimits: null,
+      };
+    }
+  }
+
+  const runtimeStates = await getRuntimeSetupStates();
 
   const anthropicConfigured =
     runtimeStates["claude-code"].configured ||
@@ -42,9 +64,14 @@ export async function GET() {
       },
       openai: {
         configured: openaiConfigured,
+        authMethod: openaiAuth.method,
         hasKey: openaiAuth.hasKey,
         apiKeySource: openaiAuth.apiKeySource,
-        dualBilling: false,
+        oauthConnected: openaiAuth.oauthConnected,
+        account: openaiAuth.account,
+        rateLimits: openaiAuth.rateLimits,
+        login: getOpenAILoginState(),
+        dualBilling: openaiAuth.oauthConnected && openaiAuth.hasKey,
         runtimes: [
           runtimeStates["openai-codex-app-server"],
           runtimeStates["openai-direct"],

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

@@ -10,8 +10,6 @@ import {
   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";
 
 export async function POST(
   _req: NextRequest,
@@ -95,25 +93,6 @@ 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(
     (err) => console.error(`Task ${id} execution error:`, err)

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

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { workflows } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { resumeWorkflow } from "@/lib/workflows/engine";
+
+/**
+ * POST /api/workflows/[id]/resume
+ *
+ * Manually resume a workflow that was paused at a delay step. Called by the
+ * "Resume Now" button in WorkflowStatusView to skip the remaining delay. The
+ * scheduler tick also calls resumeWorkflow() directly (not through this route)
+ * when workflows.resume_at is reached.
+ *
+ * Response codes:
+ *   202 Accepted   — resume dispatched (fire-and-forget)
+ *   404 Not Found  — workflow does not exist
+ *   409 Conflict   — workflow is not in paused state (already resumed, racing
+ *                    scheduler, or was never paused). resumeWorkflow handles
+ *                    this internally with its atomic status transition, so the
+ *                    conflict is reported here for correct UX feedback.
+ */
+export async function POST(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+
+  const [workflow] = await db
+    .select()
+    .from(workflows)
+    .where(eq(workflows.id, id));
+
+  if (!workflow) {
+    return NextResponse.json({ error: "Workflow not found" }, { status: 404 });
+  }
+
+  if (workflow.status !== "paused") {
+    return NextResponse.json(
+      {
+        error: `Workflow is not paused (current status: ${workflow.status})`,
+        status: workflow.status,
+      },
+      { status: 409 },
+    );
+  }
+
+  // Fire-and-forget. resumeWorkflow performs its own atomic status check, so
+  // if the scheduler tick beats this request by microseconds, the DB UPDATE
+  // will match zero rows and resumeWorkflow returns silently without harm.
+  resumeWorkflow(id).catch((error) => {
+    console.error(`Workflow ${id} resume failed:`, error);
+  });
+
+  return NextResponse.json(
+    { status: "resuming", workflowId: id },
+    { status: 202 },
+  );
+}

package/src/app/api/workflows/[id]/status/route.ts

@@ -3,6 +3,11 @@ import { db } from "@/lib/db";
 import { workflows, tasks, documents } from "@/lib/db/schema";
 import { eq, and, inArray, count, desc, sql as drizzleSql } from "drizzle-orm";
 import { parseWorkflowState } from "@/lib/workflows/engine";
+import type {
+  WorkflowStatusResponse,
+  NonLoopPattern,
+  StepWithState,
+} from "@/lib/workflows/types";
 
 /** Collect output documents for workflow step tasks + input documents from parent task */
 async function getWorkflowDocuments(
@@ -97,15 +102,18 @@ export async function GET(
   const sourceTaskId: string | undefined = definition.sourceTaskId;
   const { stepDocuments, parentDocuments } = await getWorkflowDocuments(state, sourceTaskId);
 
-  // Loop pattern returns loop-specific data instead of step states
+  // Loop pattern returns loop-specific data instead of step states.
+  // The `satisfies` annotation enforces the TDR-031 contract: the loop arm
+  // of WorkflowStatusResponse cannot emit `workflowState` or `resumeAt`, and
+  // its `steps` field is raw WorkflowStep[] (not StepWithState[]).
   if (definition.pattern === "loop") {
-    return NextResponse.json({
+    const loopBody = {
       id: workflow.id,
       name: workflow.name,
       status: workflow.status,
       projectId: workflow.projectId,
       definition: workflow.definition,
-      pattern: definition.pattern,
+      pattern: "loop" as const,
       loopConfig: definition.loopConfig,
       swarmConfig: definition.swarmConfig,
       loopState,
@@ -114,18 +122,23 @@ export async function GET(
       parentDocuments,
       runNumber: workflow.runNumber,
       runHistory,
-    });
+    } satisfies WorkflowStatusResponse;
+    return NextResponse.json(loopBody);
   }
 
-  return NextResponse.json({
+  // Non-loop arm: sequence, parallel, swarm, planner-executor, checkpoint all
+  // share the step-state rendering path. `satisfies` enforces that this branch
+  // cannot accidentally emit `loopState`, and that every step has `.state`.
+  const nonLoopBody = {
     id: workflow.id,
     name: workflow.name,
     status: workflow.status,
+    resumeAt: workflow.resumeAt ?? null,
     projectId: workflow.projectId,
     definition: workflow.definition,
-    pattern: definition.pattern,
+    pattern: definition.pattern as NonLoopPattern,
     swarmConfig: definition.swarmConfig,
-    steps: definition.steps.map((step, i) => ({
+    steps: definition.steps.map((step, i): StepWithState => ({
       ...step,
       state: state?.stepStates[i] ?? { stepId: step.id, status: "pending" },
     })),
@@ -134,5 +147,6 @@ export async function GET(
     parentDocuments,
     runNumber: workflow.runNumber,
     runHistory,
-  });
+  } satisfies WorkflowStatusResponse;
+  return NextResponse.json(nonLoopBody);
 }

package/src/app/api/workspace/context/route.ts

@@ -1,6 +1,8 @@
 import { NextResponse } from "next/server";
 import { getWorkspaceContext } from "@/lib/environment/workspace-context";
 
+export const dynamic = "force-dynamic";
+
 export function GET() {
   const context = getWorkspaceContext();
   return NextResponse.json(context, {