Calling

Okay, now our agent can choose which function to call; it's time to actually call the function.

Assignment

Create a new function that will handle the abstract task of calling one of our four functions. This is my definition:
```
def call_function(function_call_part, verbose=False):
```
function_call_part is a types.FunctionCall object that has, most importantly:
- A name property (the name of the function, a string)
- An args property (a dict of named arguments to the function)
If verbose is specified, print the function name and args:
```
print(f"Calling function: {function_call_part.name}({function_call_part.args})")
```
Otherwise, just print the name:
```
print(f" - Calling function: {function_call_part.name}")
```
Based on the name, actually call the function and capture the result. I used a dictionary of function name (string) -> function to accomplish this.
- Be sure to manually add the working_directory argument to the given dictionary of keyword arguments, because the LLM doesn't provide that one. The working directory should be ./calculator.
- The syntax to pass a dictionary into a function using keyword arguments is some_function(**some_args).

If the function name is invalid, return a types.Content object that explains the error:

return types.Content(
    role="tool",
    parts=[
        types.Part.from_function_response(
            name=function_name,
            response={"error": f"Unknown function: {function_name}"},
        )
    ],
)

Return types.Content with a from_function_response part describing the result of the function call:
```
return types.Content(
    role="tool",
    parts=[
        types.Part.from_function_response(
            name=function_name,
            response={"result": function_result},
        )
    ],
)
```
Note that from_function_response requires the response to be a dictionary, so we just shove the string result into a "result" field.
Back where you handle the response from the model (i.e., generate_content), instead of simply printing the name of the function the LLM decides to call, use call_function.
- The types.Content that we return from call_function should have a .parts[0].function_response.response within.
- If it doesn't, raise a fatal exception of some sort.
- If it does, append the function call's response (.parts[0]) to a list – we'll use this later.
- If verbose was set, print the result of the function call like this:
```
print(f"-> {function_call_result.parts[0].function_response.response}")
```
Test your program. You should now be able to execute each function given a prompt that asks for it. Try some different prompts and use the --verbose flag to make sure all the functions work.
- List the directory contents
- Get a file's contents
- Write file contents (don't overwrite anything important; maybe create a new file)
- Execute the calculator app's tests (tests.py)

We aren't passing the function call results back to the LLM just yet.

Run and submit the CLI tests.