Workflow builder

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

const loadTicket = createStep({
  id: 'loadTicket',
  inputSchema: z.object({ ticketId: z.string() }),
  outputSchema: z.object({ kind: z.enum(['bug', 'question']), text: z.string() }),
  async execute({ inputData }) {
    const kind = inputData.ticketId.startsWith('BUG') ? ('bug' as const) : ('question' as const);
    return { kind, text: `Ticket ${inputData.ticketId}` };
  },
});

const notify = createStep({
  id: 'notify',
  inputSchema: z.object({}).passthrough(),
  outputSchema: z.object({ sent: z.boolean() }),
  sideEffects: 'external',
  onError: 'park',
  async execute({ once, getInitData }) {
    const { ticketId } = getInitData<{ ticketId: string }>();
    await once(`notify:${ticketId}`, () =>
      Channels.email.send({ to: { email: '[email protected]' }, subject: `Ticket ${ticketId} triaged`, text: 'See the run.' })
    );
    return { sent: true };
  },
});

export default createWorkflow({ name: 'ticket-triage', inputSchema: z.object({ ticketId: z.string() }) })
  .then(loadTicket)
  .agentStep('summarise', { agentId: '$self', prompt: template('Summarise: ${stepResults.loadTicket.text}') })
  .switch([[eq(step(loadTicket).path('kind'), lit('bug')), 'triage']])
  .agentStep('triage', { agentId: '$self', prompt: template('Triage this bug: ${stepResults.summarise.text}') })
  .then(notify)
  .commit();

import { z } from 'zod';
import { createStep } from 'lua-cli';

const draft = z.object({ to: z.string(), body: z.string() });

export const sendEmails = createStep({
  id: 'sendEmails',
  description: 'Send each draft once',
  inputSchema: z.object({ drafts: z.array(draft) }),
  outputSchema: z.object({ sent: z.number() }),
  timeoutSeconds: 120,
  retry: { maxAttempts: 3, backoffSeconds: 10, backoff: 'exponential', maxBackoffSeconds: 60 },
  sideEffects: 'external',
  onError: 'park',
  async execute({ inputData, once, log, occurrenceId, state }) {
    let sent = 0;
    for (const d of inputData.drafts) {
      const ok = await once(`send:${d.to}`, async () => true);
      if (ok) sent++;
    }
    await state.set('lastOccurrence', occurrenceId);
    log(`sent ${sent}`);
    return { sent };
  },
});

import { z } from 'zod';
import { createStep, createWorkflow, template } from 'lua-cli';

const prepareRefund = createStep({
  id: 'prepareRefund',
  inputSchema: z.object({ ticketId: z.string(), amount: z.number() }),
  outputSchema: z.object({ ticketId: z.string(), amount: z.number() }),
  async execute({ inputData }) {
    return inputData;
  },
});

const issueRefund = createStep({
  id: 'issueRefund',
  inputSchema: z.object({ approved: z.boolean(), decision: z.string(), text: z.string() }).passthrough(),
  outputSchema: z.object({ refunded: z.boolean() }),
  async execute({ inputData, getStepResult }) {
    if (!inputData.approved) return { refunded: false };
    const { amount } = getStepResult<{ ticketId: string; amount: number }>('prepareRefund');
    return { refunded: amount > 0 };
  },
});

export default createWorkflow({ name: 'refund', inputSchema: z.object({ ticketId: z.string(), amount: z.number() }) })
  .then(prepareRefund)
  .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 }, 'deny'],
    onDeny: 'continue',
    editablePaths: ['amount'],
    editedPayloadSchema: z.object({ ticketId: z.string(), amount: z.number().positive().max(500) }),
  })
  .then(issueRefund)
  .commit();

import { z } from 'zod';
import { createStep, createWorkflow } from 'lua-cli';

const openPr = createStep({
  id: 'openPr',
  inputSchema: z.object({ repo: z.string() }),
  outputSchema: z.object({ prNumber: z.number() }),
  async execute() {
    return { prNumber: 42 };
  },
});

export default createWorkflow({ name: 'pr-review', inputSchema: z.object({ repo: z.string() }) })
  .then(openPr)
  .waitForSignal('review', {
    signal: 'github.review',
    schema: z.object({ state: z.enum(['approved', 'changes_requested', 'commented']) }),
    timeoutHours: 168,
    acceptedSources: ['webhook'],
    onTimeout: 'continue',
  })
  .commit();

import { z } from 'zod';
import { createWorkflow, defineWorkflow, template, fromInit } from 'lua-cli';

const reviewRound = defineWorkflow(
  { name: 'review-round', inputSchema: z.object({ prNumber: z.number() }) },
  (wf) => wf.agentStep('review', { agentId: '$self', prompt: template('Review PR ${initData.prNumber}') }).commit()
);

export default createWorkflow({
  name: 'ticket-to-pr',
  inputSchema: z.object({ prNumber: z.number(), repo: z.string() }),
  workspace: { kind: 'git', repo: 'https://github.com/acme/app', ref: 'main', credentialsRef: 'github' },
  connections: [{ key: 'github', integrationType: 'github', required: true }],
})
  .workflow('round', reviewRound, { prNumber: fromInit('prNumber') }, { workspace: 'inherit', retry: { maxAttempts: 2 } })
  .commit();

import { z } from 'zod';
import { createWorkflow, template, stepOf, gt, lit, fromStep } from 'lua-cli';

const Angle = z.object({ summary: z.string(), confidence: z.number() });

export default createWorkflow({ name: 'brief', inputSchema: z.object({ topic: z.string() }) })
  .parallel(['techAngle', 'marketAngle'])
  .agentStep('techAngle', { agentId: '$self', prompt: template('Technical angle on ${initData.topic}'), outputSchema: Angle })
  .agentStep('marketAngle', { agentId: '$self', prompt: template('Market angle on ${initData.topic}'), outputSchema: Angle })
  .switch([[gt(stepOf<typeof Angle>('techAngle').path('confidence'), lit(0.6)), 'merge']], 'lowConfidence')
  .map({ brief: fromStep('techAngle', 'summary') }, { id: 'merge' })
  .agentStep('lowConfidence', { agentId: '$self', prompt: 'Say that confidence was too low to publish.' })
  .commit();

import { z } from 'zod';
import { createStep, step, stepOf, init, state, lit, eq, lt, and, inSet, exists } from 'lua-cli';

const Review = z.object({ verdict: z.enum(['pass', 'revise']), round: z.number() });

const fetchSources = createStep({
  id: 'fetchSources',
  inputSchema: z.object({}),
  outputSchema: z.object({ urls: z.array(z.string()), count: z.number() }),
  async execute() {
    return { urls: [], count: 0 };
  },
});

const review = stepOf<typeof Review>('reviewFix');

export const needsAnotherRound = and(eq(review.path('verdict'), lit('revise')), lt(review.path('round'), lit(2)));
export const hasSources = exists(step(fetchSources).path('urls'));
export const isBug = inSet(init<string>('kind'), ['bug', 'regression']);
export const firstAttempt = eq(state<number>('attempts'), lit(0));

import { z } from 'zod';
import { createStep, createWorkflow, fromInit, fromStep, value, fromRequest, rows, fromKnowledge, template, env } from 'lua-cli';

const fetchRows = createStep({
  id: 'fetchRows',
  inputSchema: z.object({}),
  outputSchema: z.object({ rows: z.array(z.object({ id: z.string() })) }),
  async execute() {
    return { rows: [] };
  },
});

export default createWorkflow({ name: 'mapping-demo', inputSchema: z.object({ region: z.string() }) })
  .then(fetchRows)
  .map(
    {
      region: fromInit('region'),
      all: fromStep(fetchRows),
      firstPage: rows(fetchRows, 'rows', { offset: 0, limit: 100 }),
      startedBy: fromRequest('userId'),
      mode: value('nightly'),
      policy: fromKnowledge({ source: 'org-docs', query: 'refund policy', topK: 3 }),
    },
    { id: 'shape' }
  )
  .agentStep('summarise', {
    agentId: env.template('SUMMARY_AGENT_ID'),
    prompt: template('Summarise ${stepResults.fetchRows.rows} for ${initData.region} (run ${requestContext.runId})'),
  })
  .commit();