What is Inngest?

const ticketChannel = realtime.channel({
  name: ({ ticketId }: { ticketId: string }) => `ticket:${ticketId}`,
  topics: { status: { schema: z.object({ message: z.string() }) } },
});

export const answerTicket = inngest.createFunction(
  { id: "answer-ticket", triggers: { event: "support/ticket.created" } },
  async ({ event, step, group }) => {
    const { ticketId } = event.data;
    const channel = ticketChannel({ ticketId });

    // Each step's result is saved. A retry skips steps that already finished.
    const context = await step.run("load-context", () =>
      loadTicketContext(ticketId)
    );

    // Pick variant A or B, then draft the answer with that strategy.
    const { result: answer } = await group.experiment("answer-style", {
      variants: {
        concise: () =>
          step.run("draft-concise", () => draftAnswer(context, "concise")),
        detailed: () =>
          step.run("draft-detailed", () => draftAnswer(context, "detailed")),
      },
      select: experiment.weighted({ concise: 50, detailed: 50 }),
    });

    // Stream progress to the customer's browser.
    await step.realtime.publish("drafted", channel.status, {
      message: "Checking your account…",
    });

    // Run diagnostics in an isolated Sandbox.
    const sandbox = await step.sandbox.create("create-sandbox", {
      name: `diagnose-${ticketId}`,
      vcpu: 1,
      memoryMb: 1024,
    });
    const diagnostics = await sandbox.commands.run(
      "run-diagnostics",
      "./diagnose.sh",
      { timeout: "30s" }
    );
    await sandbox.destroy("destroy-sandbox");

    await step.run("send-reply", () =>
      sendReply(ticketId, `${answer}\n\n${diagnostics.stdout}`)
    );
  }
);

# Requires the inngest release after 0.5.19 (for group.experiment).
import inngest
from inngest.experimental import experiment, realtime

from .stubs import draft_answer, load_ticket_context, send_reply

inngest_client = inngest.Inngest(app_id="support-app")

@inngest_client.create_function(
    fn_id="answer-ticket",
    trigger=inngest.TriggerEvent(event="support/ticket.created"),
)
async def answer_ticket(ctx: inngest.Context) -> None:
    ticket_id = str(ctx.event.data["ticketId"])

    # Each step's result is saved. A retry skips steps that already finished.
    async def load_context() -> dict[str, list[str]]:
        return await load_ticket_context(ticket_id)

    context = await ctx.step.run("load-context", load_context)

    async def draft_concise() -> str:
        return await draft_answer(context, "concise")

    async def draft_detailed() -> str:
        return await draft_answer(context, "detailed")

    # Pick variant A or B, then draft the answer with that strategy.
    selected = await ctx.group.experiment(
        "answer-style",
        variants={
            "concise": lambda: ctx.step.run("draft-concise", draft_concise),
            "detailed": lambda: ctx.step.run("draft-detailed", draft_detailed),
        },
        select=experiment.bucket(
            ctx.run_id, weights={"concise": 50, "detailed": 50}
        ),
    )
    answer = str(selected.result)

    # Stream progress to the customer's browser.
    async def publish_status() -> None:
        await realtime.publish(
            client=inngest_client,
            channel=f"ticket:{ticket_id}",
            topic="status",
            data={"message": "Checking your account…"},
        )

    await ctx.step.run("drafted", publish_status)

    # Sandboxes aren't available in Python yet, so this version skips the
    # diagnostics step.
    async def reply() -> None:
        await send_reply(ticket_id, answer)

    await ctx.step.run("send-reply", reply)

import (
	"context"
	"encoding/json"

	"github.com/inngest/inngestgo"
	"github.com/inngest/inngestgo/realtime"
	"github.com/inngest/inngestgo/step"
)

type TicketCreated struct {
	TicketID string `json:"ticketId"`
}

func AnswerTicket(client inngestgo.Client) (inngestgo.ServableFunction, error) {
	return inngestgo.CreateFunction(
		client,
		inngestgo.FunctionOpts{ID: "answer-ticket"},
		inngestgo.EventTrigger("support/ticket.created", nil),
		func(ctx context.Context, input inngestgo.Input[TicketCreated]) (any, error) {
			ticketID := input.Event.Data.TicketID

			// Each step's result is saved. A retry skips steps that already finished.
			tc, err := step.Run(ctx, "load-context", func(ctx context.Context) (TicketContext, error) {
				return loadTicketContext(ctx, ticketID)
			})
			if err != nil {
				return nil, err
			}

			answer, err := step.Run(ctx, "draft-answer", func(ctx context.Context) (string, error) {
				return draftAnswer(ctx, tc)
			})
			if err != nil {
				return nil, err
			}

			// Stream progress to the customer's browser.
			_, err = step.Run(ctx, "drafted", func(ctx context.Context) (any, error) {
				data, err := json.Marshal(map[string]string{"message": "Checking your account…"})
				if err != nil {
					return nil, err
				}
				return nil, realtime.Publish(ctx, "ticket:"+ticketID, "status", data)
			})
			if err != nil {
				return nil, err
			}

			// Sandboxes and experiments aren't available in Go yet, so this
			// version drafts one answer and skips the diagnostics step.
			_, err = step.Run(ctx, "send-reply", func(ctx context.Context) (any, error) {
				return nil, sendReply(ctx, ticketID, answer)
			})
			return nil, err
		},
	)
}