Workflows

import {
  // V2 API (recommended)
  flow,
  FlowBuilder,

  // Workflow class
  Workflow,

  // Step helpers
  createStep,
  createAgentStep,
  createFunctionStep,
  createConnectorStep,

  // Legacy (deprecated)
  createWorkflow,
  WorkflowBuilder,
} from '@runflow-ai/sdk';

const builder = flow({
  id: 'my-workflow',
  name: 'My Workflow',         // optional
  description: 'Description',  // optional
  inputSchema: z.object({ text: z.string() }),
  outputSchema: z.any(),
});

// Simple handler
.step('name', async (input, ctx) => ({ result: input.value * 2 }))

// With options
.step('name', {
  handler: async (input, ctx) => ({ result: input.value * 2 }),
  outputSchema: z.object({ result: z.number() }),  // runtime validation
  when: (ctx) => ctx.results.previous.flag === true,  // conditional
  retry: { maxAttempts: 3, backoff: 'exponential', delay: 1000 },
})

.agent('analyze', myAgent, {
  prompt: 'Direct prompt text',
  // or
  promptTemplate: 'Analyze: {{input.text}}',
  when: (ctx) => ctx.input.needsAnalysis,
  retry: { maxAttempts: 2, backoff: 'fixed', delay: 500 },
})

.branch('route', {
  condition: (ctx) => ctx.results.classify.urgent,
  onTrue: async (input, ctx) => ({ path: 'urgent' }),
  onFalse: async (input, ctx) => ({ path: 'normal' }),
  unwrap: true,  // default: true
})

.switch('route', {
  on: (ctx) => ctx.results.classify.category,
  cases: {
    billing: async (input) => ({ dept: 'billing' }),
    sales: async (input) => ({ dept: 'sales' }),
  },
  default: async (input) => ({ dept: 'general' }),
  unwrap: true,  // default: true
})

.parallel('enrich', [
  createFunctionStep('a', async () => ({ a: true })),
  createFunctionStep('b', async () => ({ b: true })),
], { waitForAll: true })

.foreach('process', {
  handler: async (item, ctx) => ({ processed: item }),
  concurrency: 5,
})

.map((output) => output.items)

.connector('create', 'hubspot', 'contacts', 'create', {
  email: '{{input.email}}',
})

.output((results, input) => ({
  id: input.id,
  response: results.process.text,
}))

const workflow = builder.build();
const result = await workflow.execute(input);

const result = await workflow.execute({ text: 'hello' });

const graph = workflow.toGraph();
// { id, name, nodes: GraphNode[], edges: GraphEdge[] }

// Create an agent step for use in .branch(), .switch(), .parallel()
const step = createAgentStep('id', agent, {
  prompt: '...',
  promptTemplate: '...',
});

// Create a function step
const step = createFunctionStep('id', async (input, ctx) => {
  return { processed: true };
});

// Create a connector step
const step = createConnectorStep('id', 'hubspot', 'contacts', 'create', {
  email: '{{input.email}}',
});