Ship production AI agents in days, not months.

{
  id: "content-pipeline",

  run: async ({ topic }: { topic: string }) => {
    // Step 1: AI plans content strategy
    const { object: plan } = await generateObject({
      model: openai("o3-mini"),
      schema: contentPlanSchema,
      prompt: `Plan a comprehensive content strategy for: ${topic}`,
    });

    logger.info("Content plan", {
      pieces: plan.pieces.length,
    });

    // Step 2: Generate all content in parallel
    const results = await batch.triggerByTaskAndWait(
      plan.pieces.map((piece) => ({
        task: piece.type === "blog" ? writeBlog : writeThread,
        payload: {
          topic,
          angle: piece.angle,
          tone: plan.tone,
        },
      }))
    );

    // Step 3: Review and publish successful pieces
    const approved = results.runs.filter((r) => r.ok);

    await batch.triggerAndWait(
      approved.map((r) => ({
        task: publishContent,
        payload: r.output,
      }))
    );

    return {
      published: approved.length,
      total: plan.pieces.length,
    };
  },
}

// Human-in-the-loop approval workflow
export const contentApproval = task({
  id: "content-approval",

  run: async ({ draft }: { draft: ContentDraft }) => {
    // Generate content
    const content = await generateContent(draft);

    // Create approval token and notify
    const token = await wait.createToken({ timeout: "24h" });

    await notify.slack({
      channel: "#content-review",
      text: `New content needs approval`,
      actions: [
        { label: "Approve", url: approveUrl(token.id) },
        { label: "Reject", url: rejectUrl(token.id) },
      ],
    });

    // Wait for human decision
    const { data } = await wait.forToken<{ approved: boolean }>(token);

    if (!data.approved) {
      return { status: "rejected" };
    }

    await publishContent(content);

    return {
      status: "published",
    };
  },
});

// AI agent with tool calling – works with any model
export const researchAgent = task({
  id: "research-agent",

  run: async ({ topic }: { topic: string }) => {
    const messages: CoreMessage[] = [
      {
        role: "user",
        content: `Research: ${topic}`,
      },
    ];

    for (let i = 0; i < 10; i++) {
      const { text, toolCalls, steps } = await generateText({
        model: anthropic("claude-opus-4-20250514"),
        system: "You are a research assistant with web access.",
        messages,
        tools: { search, browse, analyze },
        maxSteps: 5,
      });

      if (!toolCalls.length) {
        return {
          summary: text,
          stepsUsed: steps.length,
        };
      }

      for (const call of toolCalls) {
        const result = await executeTool(call);

        messages.push({
          role: "tool",
          content: result,
        });
      }
    }

    throw new Error("Maximum iterations reached.");
  },
});

// Generate content with validated schema - can be used as AI tool
export const generateContent = schemaTask({
  id: "generate-content",

  schema: z.object({
    theme: z.string().describe("The theme of the content"),
    description: z
      .string()
      .describe("What the content should be about"),
  }),

  run: async ({ theme, description }) => {
    const { object } = await generateObject({
      model: openai("o3-mini"),

      schema: z.object({
        title: z.string(),
        body: z.string(),
        tags: z.array(z.string()),
        imagePrompt: z.string(),
      }),

      prompt: `Create content about ${theme}: ${description}`,
    });

    const { images } = await fal.subscribe("fal-ai/bananana", {
      input: {
        prompt: object.imagePrompt,
        aspect_ratio: "16:9",
      },
    });

    return {
      ...object,
      image: images[0].url,
    };
  },
});