Authoring Workflows

import { z } from 'zod';
import { createStep, createWorkflow, fromStep, template, step, eq, lit } from 'lua-cli';

const wf = createWorkflow({ name: 'my-flow', inputSchema: z.object({ id: z.string() }) })
  .then(loadThing)
  .agentStep('summarise', { agentId: '$self', prompt: template('Summarise ${stepResults.loadThing.text}') })
  .switch([[eq(step(loadThing).path('kind'), lit('bug')), 'triage']], 'done')
  .agentStep('triage', { agentId: '$self', prompt: template('Triage ${stepResults.summarise.text}') })
  .then(done)
  .commit();

const sendEmails = createStep({
  id: 'sendEmails',
  inputSchema: z.object({ drafts: z.array(draft) }),
  outputSchema: z.object({ sent: z.number() }),
  timeoutSeconds: 120,
  retry: { maxAttempts: 3, backoffSeconds: 10, backoff: 'exponential' },
  sideEffects: 'external',
  onError: 'park',
  async execute({ inputData, once, log }) {
    let sent = 0;
    for (const d of inputData.drafts) {
      const r = await once(d.to, () => Channels.email.send({ to: { email: d.to }, subject: 'Hello', body: d.body }));
      if (r) sent++;
    }
    log(`sent ${sent}`);
    return { sent };
  },
});

createWorkflow({ ... })
  .parallel(['techAngle', 'marketAngle'])                 // two arms, declared below
  .agentStep('techAngle', { ... })                          // placed by the parallel above, not a new entry
  .agentStep('marketAngle', { ... })
  .switch([[gt(stepOf<typeof angle>('techAngle').path('confidence'), lit(0.6)), 'merge']], 'lowConfidence')
  .map({ brief: fromStep('techAngle', 'summary') }, { id: 'merge' })   // inside the switch arm
  .agentStep('lowConfidence', { ... })                      // the switch's otherwise
  .commit();

import { step, stepOf, init, state, lit, eq, ne, gt, gte, lt, lte, inSet, notIn, exists, notExists, truthy, falsy, and, or, not } from 'lua-cli';

step(fetchSources).path('urls')                    // typed by the step's outputSchema
stepOf<typeof Review>('reviewFix').path('verdict')  // typed string ref for an agentStep id
init<string>('kind')                                // the run input
state<number>('attempts')                           // run state

and(eq(reviewRef.path('verdict'), lit('revise')), lt(reviewRef.path('round'), lit(2)))

.specialistStep('review', {
  role: {
    name: 'Reviewer',
    instructions: 'You are a sceptical reviewer. Check every claim against a source you can cite; flag anything unsupported. Never rewrite the draft - return findings only.',
    tools: ['searchWeb', 'fetchUrl'],
  },
  prompt: template('Review the draft: ${stepResults.draft.text}'),
  outputSchema: z.object({ findings: z.array(z.string()), verdict: z.enum(['pass', 'revise']) }),
})

.approval('approveRefund', {
  title: 'Refund request',
  details: template('Refund ${initData.amount} for ticket ${initData.ticketId}'),
  approver: { role: 'support-lead' },
  excludeInitiator: true,
  timeoutHours: 8,
  businessHours: { tz: 'Europe/London', calendar: 'mon-fri' },
  onTimeout: [{ escalateTo: { role: 'finance-controller' }, timeoutHours: 16 }, { escalateTo: 'org-admins', timeoutHours: 24 }, 'deny'],
  editable: true,
  editablePaths: ['amount'],
  editedPayloadSchema: z.object({ ticketId: z.string(), amount: z.number().positive().max(500) }),
  fourEyes: { edit: { role: 'support-lead' }, approve: { role: 'finance-controller' } },
})

{ approved: boolean, timedOut?: boolean, note?: string, editedPayload?: T, input: T, escalations?: number }

.waitForSignal('review', {
  signal: 'github.review',
  schema: z.object({ state: z.enum(['approved', 'changes_requested', 'commented']) }),
  timeoutHours: 168,
  acceptedSources: ['webhook'],
  onTimeout: 'continue',
})

import { LuaWebhook, Workflows } from 'lua-cli';

export default new LuaWebhook({
  name: 'github-pr-review',
  async execute({ headers, body }) {
    if (headers['x-github-event'] !== 'pull_request_review') return { ignored: true };
    const runId = /<!-- lua-run:(wfr_[A-Za-z0-9_-]+) -->/.exec(body.pull_request?.body ?? '')?.[1];
    if (!runId) return { ignored: true };
    const r = await Workflows.signal(runId, 'github.review', { state: body.review.state }, { dedupeKey: `review:${body.review.id}` });
    return { runId, accepted: r.accepted, reason: r.reason };
  },
});

.workflow('reviewRound', prReviewRound, { prNumber: fromStep('openPr', 'prNumber'), repo: fromInit('repo') }, { workspace: 'inherit' })

import { Workflows } from 'lua-cli';

const { runId, status, idempotentReplay } = await Workflows.start('outreach', { leads }, {
  idempotencyKey: `outreach:${batchId}`,
  correlationKey: batchId,
  tags: ['weekly'],
  budget: { maxCredits: 40 },
});

export default new LuaTrigger({
  name: 'linear-ready-for-agent',
  source: 'webhook',
  filter: (ctx) => ctx.payload?.type === 'Issue' && (ctx.payload.data?.labels ?? []).some((l) => l.name === 'ready-for-agent'),
  transform: (ctx) => ({
    startWorkflow: {
      name: 'ticket-to-pr',
      input: { ticketId: ctx.payload.data.identifier, title: ctx.payload.data.title },
      idempotencyKey: `linear:${ctx.payload.data.identifier}:ready-for-agent`,
    },
  }),
});

createWorkflow({
  name: 'vendor-invoices',
  inputSchema: z.object({ batchId: z.string() }),
  schedule: { type: 'cron', expression: '0 6 * * 1-5', timezone: env.template('FINANCE_TZ') },
})
  .agentStep('policyCheck', { agentId: env.template('FINANCE_AGENT_ID'), prompt: template('...') })