09 Human in the Loop

import { Studio } from "@anvia/studio";
import { supportAgent } from "../ai/support-agent";

new Studio([supportAgent]).start({ port: 4021 });

import { createHook } from "@anvia/core";
import { approvalRuntime } from "../approvals/runtime";

export function createApprovalHook(input: { userId: string; approvalRunId: string }) {
  return createHook({
    async onToolCall({ toolName, args, tool }) {
      if (toolName !== "refund_order") {
        return tool.run();
      }

      const approved = await approvalRuntime.waitForDecision({
        userId: input.userId,
        approvalRunId: input.approvalRunId,
        toolName,
        args,
      });

      return approved ? tool.run() : tool.skip("Refund was not approved.");
    },
  });
}

type ApprovalRequest = {
  userId: string;
  approvalRunId: string;
  toolName: string;
  args: string;
};

type ApprovalDecision = {
  approved: boolean;
  reason?: string;
};

export function createApprovalRuntime() {
  const waiters = new Map<string, (decision: ApprovalDecision) => void>();

  return {
    async waitForDecision(request: ApprovalRequest): Promise<boolean> {
      const approval = await db.approval.create({
        data: { ...request, status: "pending" },
      });

      await notifyReviewers({ approvalId: approval.id });

      const decision = await new Promise<ApprovalDecision>((resolve) => {
        waiters.set(approval.id, resolve);
      });

      waiters.delete(approval.id);
      return decision.approved;
    },

    async decide(input: { approvalId: string; approved: boolean; reason?: string }) {
      await db.approval.update({
        where: { id: input.approvalId },
        data: {
          status: input.approved ? "approved" : "rejected",
          decisionReason: input.reason,
          resolvedAt: new Date(),
        },
      });

      waiters.get(input.approvalId)?.({
        approved: input.approved,
        reason: input.reason,
      });
    },
  };
}

export const approvalRuntime = createApprovalRuntime();

const DecisionRequest = z.object({
  approved: z.boolean(),
  reason: z.string().optional(),
});

app.post("/approvals/:id/decision", async (request, reply) => {
  const decision = DecisionRequest.parse(request.body);
  const params = request.params as { id: string };

  await approvalRuntime.decide({
    approvalId: params.id,
    ...decision,
  });

  return reply.send({ ok: true });
});