Agent Loop

So we've got some function-calling working, but it's not fair to call our program an "agent" yet for one simple reason:

It has no feedback loop.

A key part of an "agent," as defined by AI-influencer-hype-bros, is that it can continuously use its tools to iterate on its own results. So we're going to build two things:

A loop that will call the LLM over and over
A list of messages in the "conversation." It will look something like this:
- User: "Please fix the bug in the calculator"
- Model: "I want to call get_files_info..."
- Tool: "Here's the result of get_files_info..."
- Model: "I want to call get_file_content..."
- Tool: "Here's the result of get_file_content..."
- Model: "I want to call run_python_file..."
- Tool: "Here's the result of run_python_file..."
- Model: "I want to call write_file..."
- Tool: "Here's the result of write_file..."
- Model: "I want to call run_python_file..."
- Tool: "Here's the result of run_python_file..."
- Model: "I fixed the bug and then ran the calculator to ensure it's working."

This is a big step; take your time. (But you're also really close to the finish line now!)

Assignment

Wrap the entirety of your model-calling logic in a loop, so the agent can iterate on a task until it's done working and has a final response for the user.
- If you moved the client.models.generate_content request into a dedicated function, you'll be calling that function in the loop. If you're doing everything in main(), that's also fine – just take care that the loop is scoped correctly.
- Make sure to limit the loop iterations! This will stop the agent from spinning its wheels forever and burning through tons of tokens. I recommend starting with a limit of 20 iterations. You can use a for loop for this:
```
for _ in range(20):
    # call the model, handle responses, etc.
```
We need to ensure that, in each iteration of the loop, the model is aware of all the messages and tool requests that it has generated so far. Each response from the Gemini API has a .candidates property – a list of the model's response(s) to the last prompt (usually just one). Add all "candidates" to the conversation history so the model can see them in future iterations.
1. After each call to generate_content, check the .candidates property of the response. I recommend doing this early in the loop, before handling function calls.
2. If there are any "candidates" (there should be), iterate over them and append the .content property of each to the messages list.
The model will also need to see the results of any function calls that it makes. You should already be collecting a list of function results. Append that to the messages list at the end of each loop iteration, making a types.Content object with a role of "user" and parts set to the list of function results. It should look something like this:
```
messages.append(types.Content(role="user", parts=function_responses))
```

There are two separate appends each loop: first the model's candidate content, then the collected tool responses.

The loop ends when the model doesn't request any more function calls, i.e., when it has a final response for the user. You should already be handling this case – printing the .text property of the response if there's nothing in .function_calls. Just make sure that you also break out of the loop, or return from main(), at this point.
If the maximum number of iterations is reached and the model still hasn't produced a final response, print a message explaining what went wrong. You may also want to exit the program with a code of 1 to indicate failure.
Test your code (duh). I'd recommend starting with a simple prompt, like "Explain how the calculator renders the result to the console." This is what I got:

(aiagent) wagslane@MacBook-Pro-2 aiagent % uv run main.py "how does the calculator render results to the console?"
 - Calling function: get_files_info
 - Calling function: get_file_content
Final response:
Alright, I've examined the code in `main.py`. Here's how the calculator renders results to the console:

- **`print(to_print)`:** The core of the output is done using the `print()` function.
- **`format_json_output(expression, result)`:** Before printing, the `format_json_output` function (imported from `pkg.render`) is used to format the result and the original expression into a JSON-like string. This formatted string is then stored in the `to_print` variable.
- **Error handling:** The code includes error handling with `try...except` blocks. If there's an error during the calculation (e.g., invalid expression), an error message is printed to the console using `print(f"Error: {e}")`.

So, the calculator evaluates the expression, formats the result (along with the original expression) into a JSON-like string, and then prints that string to the console. It also prints error messages to the console if any errors occur.

You may or may not need to make adjustments to your system prompt to get the LLM to behave the way you want. You're a prompt engineer now, so act like one!

Submit the CLI tests.