stagent 0.1.9 → 0.1.11

package/src/lib/workflows/assist-builder.ts

@@ -0,0 +1,248 @@
+import type { WorkflowDefinition, WorkflowStep, WorkflowPattern } from "./types";
+import type { TaskAssistResponse, TaskAssistBreakdownStep } from "@/lib/agents/runtime/task-assist-types";
+import { validateWorkflowDefinition } from "./definition-validation";
+
+interface AssistBuilderInput {
+  mainTask: {
+    title: string;
+    description: string;
+    agentProfile?: string;
+  };
+  assistResponse: TaskAssistResponse;
+  overrides?: {
+    pattern?: WorkflowPattern;
+    steps?: Partial<WorkflowStep>[];
+    loopConfig?: { maxIterations?: number; timeBudgetMs?: number };
+    swarmConfig?: { workerConcurrencyLimit?: number };
+  };
+}
+
+function stepId(index: number): string {
+  return `step_${index + 1}`;
+}
+
+function buildStep(
+  index: number,
+  name: string,
+  prompt: string,
+  options?: {
+    agentProfile?: string;
+    requiresApproval?: boolean;
+    dependsOn?: string[];
+  }
+): WorkflowStep {
+  return {
+    id: stepId(index),
+    name,
+    prompt,
+    agentProfile: options?.agentProfile,
+    requiresApproval: options?.requiresApproval,
+    dependsOn: options?.dependsOn,
+  };
+}
+
+function resolveProfile(
+  suggestedProfile: string | undefined,
+  fallbackProfile: string | undefined
+): string | undefined {
+  const profile = suggestedProfile ?? fallbackProfile;
+  if (!profile || profile === "auto") return undefined;
+  return profile;
+}
+
+function breakdownToSteps(
+  mainTask: AssistBuilderInput["mainTask"],
+  breakdown: TaskAssistBreakdownStep[],
+  pattern: WorkflowPattern
+): WorkflowStep[] {
+  const steps: WorkflowStep[] = [];
+
+  // Step 1 is always the main task
+  steps.push(
+    buildStep(0, mainTask.title, mainTask.description, {
+      agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+    })
+  );
+
+  // Remaining steps from breakdown
+  for (let i = 0; i < breakdown.length; i++) {
+    const sub = breakdown[i];
+    const dependsOn = sub.dependsOn?.map((depIdx) => stepId(depIdx));
+    steps.push(
+      buildStep(i + 1, sub.title, sub.description, {
+        agentProfile: resolveProfile(sub.suggestedProfile, undefined),
+        requiresApproval: pattern === "checkpoint" ? sub.requiresApproval : undefined,
+        dependsOn,
+      })
+    );
+  }
+
+  return steps;
+}
+
+function buildSequenceDefinition(
+  mainTask: AssistBuilderInput["mainTask"],
+  assist: TaskAssistResponse,
+  pattern: "sequence" | "planner-executor" | "checkpoint"
+): WorkflowDefinition {
+  const steps = breakdownToSteps(mainTask, assist.breakdown, pattern);
+  return { pattern, steps };
+}
+
+function buildParallelDefinition(
+  mainTask: AssistBuilderInput["mainTask"],
+  assist: TaskAssistResponse
+): WorkflowDefinition {
+  const breakdown = assist.breakdown;
+
+  // Steps with no dependsOn are branches; steps with dependsOn are synthesis
+  const hasSynthesis = breakdown.some((s) => s.dependsOn && s.dependsOn.length > 0);
+
+  const steps: WorkflowStep[] = [];
+
+  // Main task as first branch
+  steps.push(
+    buildStep(0, mainTask.title, mainTask.description, {
+      agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+    })
+  );
+
+  // Add breakdown items as branches (no dependsOn) or synthesis (with dependsOn)
+  for (let i = 0; i < breakdown.length; i++) {
+    const sub = breakdown[i];
+    const dependsOn = sub.dependsOn?.map((depIdx) => stepId(depIdx));
+    steps.push(
+      buildStep(i + 1, sub.title, sub.description, {
+        agentProfile: resolveProfile(sub.suggestedProfile, undefined),
+        dependsOn,
+      })
+    );
+  }
+
+  // Auto-generate synthesis step if none exists
+  if (!hasSynthesis) {
+    const branchIds = steps.map((s) => s.id);
+    steps.push(
+      buildStep(steps.length, "Synthesize results", "Combine and synthesize the results from all parallel branches into a coherent summary.", {
+        dependsOn: branchIds,
+      })
+    );
+  }
+
+  return { pattern: "parallel", steps };
+}
+
+function buildLoopDefinition(
+  mainTask: AssistBuilderInput["mainTask"],
+  assist: TaskAssistResponse,
+  overrides?: AssistBuilderInput["overrides"]
+): WorkflowDefinition {
+  const loopConfig = {
+    maxIterations: overrides?.loopConfig?.maxIterations
+      ?? assist.suggestedLoopConfig?.maxIterations
+      ?? 5,
+    timeBudgetMs: overrides?.loopConfig?.timeBudgetMs
+      ?? assist.suggestedLoopConfig?.timeBudgetMs,
+    agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+  };
+
+  const steps: WorkflowStep[] = [
+    buildStep(0, mainTask.title, mainTask.description, {
+      agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+    }),
+  ];
+
+  return { pattern: "loop", steps, loopConfig };
+}
+
+function buildSwarmDefinition(
+  mainTask: AssistBuilderInput["mainTask"],
+  assist: TaskAssistResponse,
+  overrides?: AssistBuilderInput["overrides"]
+): WorkflowDefinition {
+  const breakdown = assist.breakdown;
+  const steps: WorkflowStep[] = [];
+
+  // Step 1 = mayor (main task)
+  steps.push(
+    buildStep(0, mainTask.title, mainTask.description, {
+      agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+    })
+  );
+
+  // Steps 2..N-1 = workers (from breakdown)
+  for (let i = 0; i < breakdown.length; i++) {
+    const sub = breakdown[i];
+    steps.push(
+      buildStep(i + 1, sub.title, sub.description, {
+        agentProfile: resolveProfile(sub.suggestedProfile, undefined),
+      })
+    );
+  }
+
+  // Step N = refinery (auto-generated)
+  steps.push(
+    buildStep(steps.length, "Refine and merge results", "Review all worker outputs, resolve conflicts, and produce a unified final result.", {})
+  );
+
+  const swarmConfig = {
+    workerConcurrencyLimit: overrides?.swarmConfig?.workerConcurrencyLimit
+      ?? assist.suggestedSwarmConfig?.workerConcurrencyLimit
+      ?? 2,
+  };
+
+  return { pattern: "swarm", steps, swarmConfig };
+}
+
+/**
+ * Convert an AI Assist response into a validated WorkflowDefinition.
+ * Pure function — no side effects.
+ */
+export function buildWorkflowDefinitionFromAssist(
+  input: AssistBuilderInput
+): WorkflowDefinition {
+  const pattern = input.overrides?.pattern ?? input.assistResponse.recommendedPattern as WorkflowPattern;
+  const { mainTask, assistResponse, overrides } = input;
+
+  let definition: WorkflowDefinition;
+
+  switch (pattern) {
+    case "sequence":
+    case "planner-executor":
+    case "checkpoint":
+      definition = buildSequenceDefinition(mainTask, assistResponse, pattern);
+      break;
+    case "parallel":
+      definition = buildParallelDefinition(mainTask, assistResponse);
+      break;
+    case "loop":
+      definition = buildLoopDefinition(mainTask, assistResponse, overrides);
+      break;
+    case "swarm":
+      definition = buildSwarmDefinition(mainTask, assistResponse, overrides);
+      break;
+    default:
+      // Fallback to sequence for unknown patterns
+      definition = buildSequenceDefinition(mainTask, assistResponse, "sequence");
+  }
+
+  // Apply step-level overrides
+  if (overrides?.steps) {
+    for (let i = 0; i < overrides.steps.length && i < definition.steps.length; i++) {
+      const stepOverride = overrides.steps[i];
+      if (stepOverride) {
+        Object.assign(definition.steps[i], stepOverride);
+      }
+    }
+  }
+
+  // Validate
+  const validationError = validateWorkflowDefinition(definition);
+  if (validationError) {
+    throw new Error(`Invalid workflow definition: ${validationError}`);
+  }
+
+  return definition;
+}
+
+export type { AssistBuilderInput };

package/src/lib/workflows/assist-session.ts

@@ -0,0 +1,78 @@
+import type { TaskAssistResponse } from "@/lib/agents/runtime/task-assist-types";
+
+const STORAGE_KEY = "stagent:workflow-from-assist";
+
+export interface WorkflowAssistState {
+  assistResult: TaskAssistResponse;
+  formState: {
+    title: string;
+    description: string;
+    projectId: string;
+    priority: string;
+    agentProfile: string;
+    assignedAgent: string;
+  };
+}
+
+export function saveAssistState(state: WorkflowAssistState): void {
+  try {
+    sessionStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+  } catch {
+    // sessionStorage may be unavailable (e.g. SSR)
+  }
+}
+
+export function loadAssistState(): WorkflowAssistState | null {
+  try {
+    const raw = sessionStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    return JSON.parse(raw) as WorkflowAssistState;
+  } catch {
+    return null;
+  }
+}
+
+export function clearAssistState(): void {
+  try {
+    sessionStorage.removeItem(STORAGE_KEY);
+  } catch {
+    // noop
+  }
+}
+
+const FORM_RESTORE_KEY = "stagent:task-form-restore";
+
+export interface TaskFormState {
+  title: string;
+  description: string;
+  projectId: string;
+  priority: string;
+  agentProfile: string;
+  assignedAgent: string;
+}
+
+export function saveTaskFormState(state: TaskFormState): void {
+  try {
+    sessionStorage.setItem(FORM_RESTORE_KEY, JSON.stringify(state));
+  } catch {
+    // noop
+  }
+}
+
+export function loadTaskFormState(): TaskFormState | null {
+  try {
+    const raw = sessionStorage.getItem(FORM_RESTORE_KEY);
+    if (!raw) return null;
+    return JSON.parse(raw) as TaskFormState;
+  } catch {
+    return null;
+  }
+}
+
+export function clearTaskFormState(): void {
+  try {
+    sessionStorage.removeItem(FORM_RESTORE_KEY);
+  } catch {
+    // noop
+  }
+}

package/src/lib/workflows/engine.ts

@@ -2,6 +2,7 @@ import { db } from "@/lib/db";
 import { workflows, tasks, agentLogs, notifications } from "@/lib/db/schema";
 import { eq } from "drizzle-orm";
 import { executeTaskWithRuntime } from "@/lib/agents/runtime";
+import { classifyTaskProfile } from "@/lib/agents/router";
 import type { WorkflowDefinition, WorkflowState, StepState, LoopState } from "./types";
 import { createInitialState } from "./types";
 import { executeLoop } from "./loop-executor";
@@ -47,6 +48,8 @@ export async function executeWorkflow(workflowId: string): Promise<void> {
     try {
       await executeLoop(workflowId, definition);
 
+      await syncSourceTaskStatus(workflowId, "completed");
+
       await db.insert(agentLogs).values({
         id: crypto.randomUUID(),
         taskId: null,
@@ -56,6 +59,8 @@ export async function executeWorkflow(workflowId: string): Promise<void> {
         timestamp: new Date(),
       });
     } catch (error) {
+      await syncSourceTaskStatus(workflowId, "failed");
+
       await db.insert(agentLogs).values({
         id: crypto.randomUUID(),
         taskId: null,
@@ -94,6 +99,9 @@ export async function executeWorkflow(workflowId: string): Promise<void> {
     state.completedAt = new Date().toISOString();
     await updateWorkflowState(workflowId, state, "completed");
 
+    // Sync parent task status
+    await syncSourceTaskStatus(workflowId, "completed");
+
     await db.insert(agentLogs).values({
       id: crypto.randomUUID(),
       taskId: null,
@@ -106,6 +114,9 @@ export async function executeWorkflow(workflowId: string): Promise<void> {
     state.status = "failed";
     await updateWorkflowState(workflowId, state, "failed");
 
+    // Sync parent task status
+    await syncSourceTaskStatus(workflowId, "failed");
+
     await db.insert(agentLogs).values({
       id: crypto.randomUUID(),
       taskId: null,
@@ -682,6 +693,12 @@ export async function executeChildTask(
     .from(workflows)
     .where(eq(workflows.id, workflowId));
 
+  // Resolve "auto" profile via multi-agent router
+  const resolvedProfile =
+    !agentProfile || agentProfile === "auto"
+      ? classifyTaskProfile(name, prompt, assignedAgent)
+      : agentProfile;
+
   const taskId = crypto.randomUUID();
   await db.insert(tasks).values({
     id: taskId,
@@ -693,7 +710,7 @@ export async function executeChildTask(
     status: "queued",
     priority: 1,
     assignedAgent: assignedAgent ?? null,
-    agentProfile: agentProfile ?? null,
+    agentProfile: resolvedProfile ?? null,
     createdAt: new Date(),
     updatedAt: new Date(),
   });
@@ -811,6 +828,35 @@ async function waitForApproval(
   return false; // Timeout — treat as denied
 }
 
+/**
+ * Sync the parent (source) task's status with the workflow's final status.
+ * The parent task is linked via `sourceTaskId` in the workflow's definition JSON.
+ */
+async function syncSourceTaskStatus(
+  workflowId: string,
+  status: "completed" | "failed"
+): Promise<void> {
+  try {
+    const result = await db
+      .select()
+      .from(workflows)
+      .where(eq(workflows.id, workflowId));
+
+    const workflow = Array.isArray(result) ? result[0] : undefined;
+    if (!workflow) return;
+
+    const def = JSON.parse(workflow.definition);
+    if (!def.sourceTaskId) return;
+
+    await db
+      .update(tasks)
+      .set({ status, updatedAt: new Date() })
+      .where(eq(tasks.id, def.sourceTaskId));
+  } catch (error) {
+    console.error(`[workflow-engine] Failed to sync source task status for workflow ${workflowId}:`, error);
+  }
+}
+
 /**
  * Update workflow state in the database.
  */