Build workflows

import { defineWorkflow } from "@meetluno/luno/workflow";
import { z } from "zod";
import { researchSignup } from "../actions/research-signup";
import { postBrief } from "../actions/post-brief";

export default defineWorkflow({
  slug: "signup-pipeline",
  name: "Signup pipeline",
  description: "Researches a signup and posts a brief.",
  input: z.object({ name: z.string(), email: z.string().email() }),
  output: z.object({ posted: z.boolean() }),
})
  .then(researchSignup) // { name, email } → { brief }
  .map(({ inputData }) => ({ text: inputData.brief }))
  .then(postBrief) // { text } → { posted }
  .commit();

  .then(double)
  .then(double.as("double-again"))
  .then(postBrief.scope("user"))

import { createStep } from "@meetluno/luno/workflow";
import { z } from "zod";

const buildPrompt = createStep({
  id: "build-prompt",
  inputSchema: z.object({ subject: z.string(), sender: z.string() }),
  outputSchema: z.object({ prompt: z.string() }),
  execute: async ({ inputData }) => ({
    prompt: `Summarize this inbox item in one sentence.\nFrom: ${inputData.sender}\nSubject: ${inputData.subject}`,
  }),
});

import { agentStep, defineWorkflow } from "@meetluno/luno/workflow";
import { z } from "zod";
import support from "../agents/support";

type Item = { subject: string; sender: string };

export default defineWorkflow({
  slug: "summarize-inbox",
  name: "Summarize inbox",
  description: "Asks support to summarize an inbox item in one sentence.",
  input: z.object({ subject: z.string(), sender: z.string() }),
  output: z.object({ summary: z.string() }),
})
  .then(
    agentStep(support, {
      // Annotating inputData types the step's input; `.then` checks it against the previous step.
      prompt: ({ inputData }: { inputData: Item }) =>
        `Summarize this inbox item in one sentence.\nFrom: ${inputData.sender}\nSubject: ${inputData.subject}`,
    }),
  )
  .map(({ inputData }) => ({ summary: inputData.text }))
  .commit();

import { defineWorkflow, llmStep } from "@meetluno/luno/workflow";
import { z } from "zod";

const Category = z.object({
  category: z.enum(["pun", "dad-joke", "one-liner", "observational", "absurdist"]),
});

export default defineWorkflow({
  slug: "joke-flow",
  name: "Joke flow",
  description: "Generates a joke and classifies its category.",
  input: z.object({}),
  output: z.object({ joke: z.string(), category: Category.shape.category }),
})
  .then(
    llmStep("joke", {
      prompt: "Tell me a funny joke. Reply with only the joke.",
      model: "google/gemini-3.5-flash",
    }),
  )
  .then(
    llmStep("classify", {
      prompt: ({ inputData }: { inputData: string }) => `Classify this joke:\n\n${inputData}`,
      model: "google/gemini-3.5-flash",
      outputSchema: Category,
    }),
  )
  .map(({ inputData, getStepResult }) => ({
    joke: z.string().parse(getStepResult("joke")),
    category: inputData.category,
  }))
  .commit();

import { defineWorkflow, workflowStep } from "@meetluno/luno/workflow";
import { z } from "zod";
import enrichLead from "./enrich-lead";

export default defineWorkflow({
  slug: "signup-pipeline",
  name: "Signup pipeline",
  description: "Enriches a lead via a sub-workflow and returns a score.",
  input: z.object({ email: z.string().email() }),
  output: z.object({ score: z.number() }),
})
  .then(workflowStep(enrichLead)) // enrich-lead: { email } → { score, … }
  .map(({ inputData }) => ({ score: inputData.score }))
  .commit();

luno workflows runs get <parentRunId> --include steps,trace,children

  .map(
    ({ inputData, getInitData }) => ({
      message: getInitData().message,
      priority: inputData.priority,
    }),
    { id: "build-ticket" },
  )

  .then(triage) // → { priority, message }
  .branch([
    [async ({ inputData }) => inputData.priority === "urgent", pageOnCall],
    [async ({ inputData }) => inputData.priority !== "urgent", queueForReview],
  ])
  .map(({ inputData }) => ({ paged: inputData["page-on-call"] !== undefined }))

  // Process every item, five at a time.
  .map(({ inputData }) => inputData.items) // → Item[]
  .foreach(processItem, { concurrency: 5 }) // → ProcessedItem[]

  // Poll an export until it is ready.
  .dountil(checkExportStatus, async ({ inputData }) => inputData.status === "ready")

const charge = createStep({
  id: "charge",
  inputSchema: z.object({ id: z.string(), amount: z.number() }),
  outputSchema: z.object({ charged: z.boolean() }),
  execute: async ({ inputData }) => {
    try {
      await chargeCard.run({ amount: inputData.amount });
      return { charged: true };
    } catch {
      await notifyBillingFailed.run({ id: inputData.id });
      return { charged: false };
    }
  },
});

  .parallel([enrichLead, scoreLead]) // both receive { leadId }
  .map(({ inputData }) => ({
    company: enrichLead.output.parse(inputData["enrich-lead"]).company,
    score: scoreLead.output.parse(inputData["score-lead"]).score,
  }))

import { councilStep, defineWorkflow } from "@meetluno/luno/workflow";
import { z } from "zod";
import judge from "../agents/judge";
import optimist from "../agents/optimist";
import skeptic from "../agents/skeptic";

const verdict = z.object({ ship: z.boolean(), reasons: z.array(z.string()) });

export default defineWorkflow({
  slug: "launch-review",
  name: "Launch review",
  description: "Asks a council of agents whether a feature is ready to ship.",
  input: z.object({ spec: z.string() }),
  output: verdict,
})
  .then(
    councilStep("launch-council", {
      members: [optimist, skeptic],
      prompt: ({ inputData }: { inputData: { spec: string } }) =>
        `Is this feature ready to ship?\n\n${inputData.spec}`,
      synthesize: judge,
      output: verdict,
    }),
  )
  .commit();

const progress = z.object({ processed: z.array(z.string()) });

const markDone = createStep({
  id: "mark-done",
  inputSchema: z.object({ id: z.string() }),
  outputSchema: z.object({ id: z.string() }),
  stateSchema: progress,
  execute: async ({ inputData, state, setState }) => {
    await setState({ processed: [...state.processed, inputData.id] });
    return inputData;
  },
});

export default defineWorkflow({
  slug: "process-item",
  name: "Process item",
  description: "Processes one item and tracks progress.",
  input: z.object({ id: z.string() }),
  output: z.object({ count: z.number() }),
  state: progress,
  initialState: { processed: [] },
})
  .then(markDone)
  .sleep("1h")
  .map(({ state }) => ({ count: state.processed.length }))
  .commit();

export default defineWorkflow({
  slug: "daily-report",
  // ...
  schedule: { cron: "0 9 * * 1-5", timezone: "Europe/Madrid", input: { region: "eu" } },
});

export default defineWorkflow({
  slug: "delayed-followup",
  name: "Delayed followup",
  description: "Sends welcome email, waits an hour, then sends a followup.",
  input: z.object({ email: z.string().email() }),
  output: z.object({ sent: z.boolean() }),
})
  .then(sendWelcome) // { email } → { email }
  .sleep("1h")
  .then(sendFollowup) // { email } → { sent }
  .commit();

import { defineWorkflow, hookStep } from "@meetluno/luno/workflow";
import { z } from "zod";

export default defineWorkflow({
  slug: "approval-flow",
  name: "Approval flow",
  description: "Requests approval and waits for the decision.",
  input: z.object({ id: z.string() }),
  output: z.object({ approved: z.boolean() }),
})
  .then(requestApproval) // { id } → { id }
  .then(
    hookStep("approval", {
      schema: z.object({ approved: z.boolean() }),
      // Send the link by email or chat; anyone holding it can resume the run.
      onSuspend: ({ resumeUrl }) => console.info(`Approve or deny: ${resumeUrl}`),
    }),
  )
  .commit();

import { hookStep, isHookExpired } from "@meetluno/luno/workflow";
import { z } from "zod";

hookStep("intake", {
  schema: z.object({
    bio: z.string().max(1000).describe("A few lines about you"),
    team: z.enum(["eng", "sales"]),
    remote: z.boolean(),
  }),
  responders: { email: (input: { email: string }) => input.email }, // or { emails: ["a@b.com"] }
  expiresIn: "3d", // default 7 days for responder hooks; a Date also works
  onSuspend: async ({ responderLinks }) => {
    for (const { email, url } of responderLinks ?? []) await sendEmail(email, url);
  },
});
// Next step: if (isHookExpired(answer)) { /* nobody answered in time */ }

createStep({
  id: "build-prompt",
  inputSchema: z.object({ message: z.string() }),
  outputSchema: z.object({ prompt: z.string() }),
  execute: async ({ inputData }) => ({
    prompt: `${getWorkflowRunInfo().trigger ?? "api"}: ${inputData.message}`,
  }),
});

export default defineWorkflow({
  slug: "daily-digest",
  name: "Daily digest",
  description: "Sends a personal daily digest once per subscriber.",
  subscription: { mode: "subscribable" },
  input: z.object({}),
  output: z.object({ sent: z.boolean() }),
})
  // Runs once per subscriber, as that subscriber.
  .then(sendDigest.scope("user"))
  .commit();

export default defineWorkflow({
  slug: "standup",
  // ...
  subscription: { mode: "subscribable" },
  schedule: {
    cron: "0 9 * * 1-5",
    timezone: "Europe/Madrid", // fallback for subscribers with no timezone
    perSubscriber: true,
    respectWorkingHours: true,
    skipHolidays: true,
  },
});