Workflows

import { Agent, createModel, runWorkflow, workflow, workflowTask } from "@usestratus/sdk";

const model = createModel();

const reviewer = new Agent({
  name: "reviewer",
  model,
  instructions: "Review the target carefully. Report concrete findings only.",
});

const synthesizer = new Agent({
  name: "synthesizer",
  model,
  instructions: "Merge independent findings into a concise final report.",
});

const auditWorkflow = workflow({
  name: "parallel-audit",
  run: async (ctx, files: string[]) => {
    const findings = await ctx.phase(
      "review files",
      files.map((file) =>
        workflowTask({
          id: file,
          name: `review ${file}`,
          agent: reviewer,
          input: `Audit ${file} for correctness, security, and missing tests.`,
          metadata: { file },
        }),
      ),
      { concurrency: 8, failFast: false },
    );

    const report = await ctx.synthesize(
      synthesizer,
      findings
        .map((finding) => `## ${finding.name}\n${finding.output || finding.error}`)
        .join("\n\n"),
    );

    return report.output;
  },
});

const result = await runWorkflow(auditWorkflow, [
  "src/routes/users.ts",
  "src/routes/billing.ts",
]);

console.log(result.output);
console.log(result.usage.totalTokens);

const results = await ctx.phase(
  "inspect endpoints",
  endpoints.map((endpoint) =>
    workflowTask({
      id: endpoint.path,
      agent: auditor,
      input: `Inspect ${endpoint.path} for missing auth checks.`,
      metadata: endpoint,
    }),
  ),
  {
    concurrency: 6,
    failFast: false,
  },
);

workflowTask({
  id: "billing",
  agent: reviewer,
  input: "Review the billing module.",
  maxTurns: 4,
});

workflowTask({
  id: "load-fixtures",
  execute: async () => {
    return JSON.stringify(await loadFixtures());
  },
});

import { streamWorkflow } from "@usestratus/sdk/core";

const { stream, result } = streamWorkflow(auditWorkflow, files);

for await (const event of stream) {
  if (event.type === "workflow_task_completed") {
    console.log(`${event.task.name}: ${event.task.status}`);
  }
}

const final = await result;
console.log(final.output);

const synthesis = await ctx.synthesize(
  synthesizer,
  results.map((result) => result.output).join("\n\n"),
);

return synthesis.output;

import { Agent, createModel, generateWorkflowDraft } from "@usestratus/sdk";

const drafter = new Agent({
  name: "workflow-drafter",
  model: createModel(),
  instructions: "Design safe Stratus workflow scripts with clear phases and budgets.",
});

const draft = await generateWorkflowDraft(drafter, "Audit every API route for missing auth checks", {
  constraints: ["Preview the script before running", "Use adversarial verification"],
  patterns: ["fan-out-and-synthesize", "adversarial-verification"],
});

console.log(draft.phases);
console.log(draft.script);

const report = await ctx.fanOutAndSynthesize({
  name: "inspect services",
  tasks: services.map((service) =>
    workflowTask({
      id: service.name,
      agent: reviewer,
      input: `Inspect ${service.path}.`,
    }),
  ),
  synthesizer,
  prompt: (results) => results.map((result) => result.output).join("\n\n"),
});

return report.output;

const checked = await ctx.adversarialVerify({
  name: "verify findings",
  findings: findings.map((finding) => ({
    id: finding.id,
    output: finding.output,
  })),
  verifier,
});

return checked.accepted.map((result) => result.output);

const first = await runWorkflow(auditWorkflow, files);

const second = await runWorkflow(auditWorkflow, files, {
  resumeFrom: first,
});

import { WorkflowRunManager } from "@usestratus/sdk";

const manager = new WorkflowRunManager();
const run = manager.start(auditWorkflow, files, {
  concurrency: 8,
});

run.onEvent((event) => {
  if (event.type === "workflow_phase_completed") {
    console.log(event.phase.name);
  }
});

await run.result;

const resumed = manager.resume(run);
await resumed.result;

import { workflow } from "@usestratus/sdk";

export default workflow({
  name: "auth-audit",
  run: async (ctx, args) => {
    // run phases here
    return "ready";
  },
});

import { discoverSavedWorkflows, loadWorkflowModule, runWorkflow } from "@usestratus/sdk";

const saved = await discoverSavedWorkflows({ cwd: process.cwd() });
const module = await loadWorkflowModule(saved[0].path);

const result = await runWorkflow(module.workflow!, { paths: ["src/routes"] });

const controller = new AbortController();

const result = await runWorkflow(auditWorkflow, files, {
  signal: controller.signal,
  concurrency: 8,
  maxConcurrency: 16,
  maxTasks: 1000,
  budget: {
    maxTotalTokens: 50_000,
    maxCostUsd: 10,
    maxDurationMs: 10 * 60_000,
  },
});