The durable runtime for AI agents

export const SupportImpl = Support.implement({
  init: () => ({ history: [] as Message[] }),
  methods: {
    async handle({ message, orderId }) {
      this.history.push({ role: 'user', content: message })
      // Golem lets lookupOrder reach only the orders API:
      const reply = await llm.run(this.history, [lookupOrder])
      if (reply.refundRequested) {
        const approval = createWebhook()
        await notifyReviewer(approval.getUrl(), reply)
        // waits here for days if needed, using no CPU or memory:
        const { approved } = (await approval).json<Approval>()
        // refunded once if the payment API honors idempotency keys:
        if (approved) await refundOrder(orderId, reply.amount)
      }
      return reply.text
    },
  },
})

export const SupportImpl = Support.implement({
  init: () => Effect.succeed({ history: [] as Message[] }),
  methods: (state) => ({
    handle: ({ message, orderId }) => Effect.gen(function* () {
      state.history.push({ role: "user", content: message })
      // Golem lets lookupOrder reach only the orders API:
      const reply = yield* llm.run(state.history, [lookupOrder])
      if (reply.refundRequested) {
        const approval = yield* Webhook.create
        yield* notifyReviewer(approval.url, reply)
        // waits here for days if needed, using no CPU or memory:
        const payload = yield* approval.await
        const { approved } = yield* payload.decode(Approval)
        // refunded once if the payment API honors idempotency keys:
        if (approved) yield* refundOrder(orderId, reply.amount)
      }
      return reply.text
    }).pipe(Effect.orDie),
  }),
})

#[agent_implementation]
impl Support for SupportImpl {
  fn new() -> Self {
    Self { history: vec![] }
  }

  async fn handle(
    &mut self,
    message: String,
    order_id: String,
  ) -> String {
    self.history.push(Message::user(message));
    // Golem lets lookup_order reach only the orders API:
    let reply = llm::run(&self.history, &[lookup_order]).await;
    if reply.refund_requested {
      let approval = create_webhook().unwrap();
      notify_reviewer(approval.url(), &reply).await;
      // waits here for days if needed, using no CPU or memory:
      let Approval { approved } = approval.await.json().unwrap();
      // refunded once if the payment API honors idempotency keys:
      if approved {
        refund_order(order_id, reply.amount).await;
      }
    }
    reply.text
  }
}

@agentImplementation()
final class SupportAgentImpl(id: String) extends SupportAgent:
  private val history = ArrayBuffer.empty[Message]

  def handle(message: String, orderId: String): Future[String] =
    history += Message("user", message)
    // Golem lets lookupOrder reach only the orders API:
    llm.run(history.toList, List(lookupOrder)).flatMap: reply =>
      if reply.refundRequested then refund(orderId, reply)
      else Future.successful(reply.text)

  private def refund(orderId: String, reply: Reply) =
    val approval = HostApi.createWebhook()
    for
      _ <- notifyReviewer(approval.url, reply)
      // waits here for days if needed, using no CPU or memory:
      payload <- approval.await()
      approved = payload.json[Approval]().approved
      // refunded once if the payment API honors idempotency keys:
      _ <- if approved then refundOrder(orderId, reply.amount)
           else Future.unit
    yield reply.text

fn SupportAgent::new() -> SupportAgent {
  { history: [] }
}

pub async fn SupportAgent::handle(
  self : Self,
  message : String,
  order_id : String,
) -> String {
  self.history.push({ role: "user", content: message })
  // Golem lets lookup_order reach only the orders API:
  let reply = llm.run(self.history, [lookup_order])
  if reply.refund_requested {
    let approval = @webhook.create()
    notify_reviewer(approval.url(), reply)
    // waits here for days if needed, using no CPU or memory:
    let body = @json.parse(approval.wait().text())
    let { approved } : Approval = @json.from_json(body)
    // refunded once if the payment API honors idempotency keys:
    if approved { refund_order(order_id, reply.amount) }
  }
  reply.text
}

type state struct{ history []Message }

var impl = Support.Implement(func(SupportID) *state {
    return &state{}
})

var _ = impl.Handle(Handle, func(
    ctx *golem.Context[state], in HandleIn,
) string {
    s := ctx.State
    s.history = append(s.history, Message{"user", in.Message})
    // Golem lets lookupOrder reach only the orders API:
    reply := llm.Run(s.history, lookupOrder)
    if reply.RefundRequested {
        approval := golem.NewWebhook[Approval]()
        notifyReviewer(approval.URL(), reply)
        // waits here for days if needed, using no CPU or memory:
        decision := approval.MustAwait()
        // refunded once if the payment API honors idempotency keys:
        if decision.Approved {
            refundOrder(in.OrderID, reply.Amount)
        }
    }
    return reply.Text
})