Agents

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 pretty big step; take your time!

Assignment

In generate_content, handle the results of any possible tool use:
1. This might already be happening, but make sure that with each call to client.models.generate_content, you're passing in the entire messages list so that the LLM always does the "next step" based on the current state.
2. After calling client's generate_content method, check the .candidates property of the response. It's a list of response variations (usually just one). It contains the equivalent of "I want to call get_files_info," so we need to add it to our conversation. Iterate over each candidate and add its .content to your messages list.
3. After you have the responses from each function call, use the types.Content constructor to convert the list of responses into a message with a role of user, and append it to your messages.
Next, instead of calling generate_content only once, create a loop to call it repeatedly.
1. Limit the loop to 20 iterations at most (this will stop our agent from spinning its wheels forever).
2. Use a try/except block and handle any errors accordingly.
3. After each call of generate_content, determine if the model is finished. It's finished only if no candidate contains a function call and response.text is non-empty. In that case, print the final response and break out of the loop; otherwise continue the loop.
4. If the model is not finished working, iterate again – unless the maximum number of iterations was reached.
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!

Run and submit the CLI tests.