Durable execution

// Excerpt: an agent loop in a method of ReportAgent
async ask({ question }) {
  this.messages.push({ role: "user", content: question });
  for (let step = 0; step < 12; step++) {
    // Your own function: an HTTP request to a model API
    const reply = await callModel(this.messages, [echoToolSchema]);
    this.messages.push(reply.message);
    if (!reply.toolCall) return reply.message.content;
 
    // A Golem tool call, through the tool's typed client
    const output = await echoClient.echo({ value: reply.toolCall.arguments.value });
    this.messages.push({ role: "tool", content: output });
  }
  return "Step limit reached";
},

// Excerpt: an agent loop in a method of ReportAgent (state is a Ref)
// echoClient = Tool.client(echo); callModel, echoToolSchema and Message are your own application code
ask: ({ question }) =>
  Effect.gen(function* () {
    const push = (message: Message) =>
      Ref.update(state, (s) => ({ ...s, messages: [...s.messages, message] }));
    yield* push({ role: "user", content: question });
    for (let step = 0; step < 12; step++) {
      // Your own Effect: an HTTP request to a model API
      const { messages } = yield* Ref.get(state);
      const reply = yield* callModel(messages, [echoToolSchema]);
      yield* push(reply.message);
      if (!reply.toolCall) return reply.message.content;
 
      // A Golem tool call, through the tool's typed client
      const output = yield* echoClient({ value: reply.toolCall.arguments.value });
      yield* push({ role: "tool", content: output });
    }
    return "Step limit reached";
  }).pipe(Effect.orDie),

// Excerpt: an agent loop in a method of ReportAgent
// call_model, echo_tool_schema, Message and Reply are your own application code
async fn ask(&mut self, question: String) -> String {
    self.messages.push(Message { role: "user".to_string(), content: question });
    for _ in 0..12 {
        // Your own function: an HTTP request to a model API
        let reply = call_model(&self.messages, &[echo_tool_schema()]).await;
        self.messages.push(reply.message.clone());
        let Some(tool_call) = reply.tool_call else { return reply.message.content };
 
        // A Golem tool call, through the tool's typed client
        let output = EchoClient::default().echo(tool_call.arguments.value).await.unwrap();
        self.messages.push(Message { role: "tool".to_string(), content: output });
    }
    "Step limit reached".to_string()
}

// Excerpt: an agent loop in a method of ReportAgentImpl (private var messages: List[Message])
// callModel, echoToolSchema, Message and Reply are your own application code
override def ask(question: String): Future[String] = {
  messages :+= Message("user", question)
  def loop(step: Int): Future[String] =
    if (step == 12) Future.successful("Step limit reached")
    else
      // Your own function: an HTTP request to a model API
      callModel(messages, List(echoToolSchema)).flatMap { reply =>
        messages :+= reply.message
        reply.toolCall match {
          case None => Future.successful(reply.message.content)
          case Some(call) =>
            // A Golem tool call, through the tool's typed client
            EchoClient().echo(call.arguments.value).flatMap {
              case Right(output) =>
                messages :+= Message("tool", output)
                loop(step + 1)
              case Left(error) => Future.failed(new IllegalStateException(error.toString))
            }
        }
      }
  loop(0)
}

// Excerpt: an agent loop in a method of ReportAgent (field messages : Array[Message])
// call_model, echo_tool_schema, Message and Reply are your own application code
pub async fn ReportAgent::ask(self : Self, question : String) -> String {
  self.messages.push({ role: "user", content: question })
  let echo = EchoClient::new()
  defer echo.drop()
  for _ in 0..<12 {
    // Your own function: an HTTP request to a model API
    let reply = call_model(self.messages, [echo_tool_schema])
    self.messages.push(reply.message)
    guard reply.tool_call is Some(call) else { return reply.message.content }
 
    // A Golem tool call, through the tool's typed client
    let output = echo.echo(call.value).unwrap()
    self.messages.push({ role: "tool", content: output })
  }
  "Step limit reached"
}

// Excerpt: an agent loop in the ask handler of ReportAgent (state has messages []Message)
// callModel, echoToolSchema, Message and ToolSchema are your own application code
agent.Handle(report.Ask, func(ctx *golem.Context[state], in report.AskIn) string {
	ctx.State.messages = append(ctx.State.messages, Message{Role: "user", Content: in.Question})
	for step := 0; step < 12; step++ {
		// Your own function: an HTTP request to a model API
		reply := callModel(ctx.State.messages, []ToolSchema{echoToolSchema})
		ctx.State.messages = append(ctx.State.messages, reply.Message)
		if reply.ToolCall == nil {
			return reply.Message.Content
		}
 
		// A Golem tool call, through the tool's typed client
		output := golem.Must(EchoBody.Call(func(a *EchoArgs) { a.Value = reply.ToolCall.Arguments.Value }))
		ctx.State.messages = append(ctx.State.messages, Message{Role: "tool", Content: output})
	}
	return "Step limit reached"
})