Calling Functions

1. Create a new function that will handle the abstract task of calling one of our four functions and returning its result. This is the signature I used:

   def call_function(tool_call, verbose: bool = False) -> dict:
   

   I put this function in call_function.py – the same module where I defined the list of available functions. As always, organize your code as you see fit.

   The tool_call argument is one of the tool-call objects from message.tool_calls. The three things we care about are:

   • tool_call.function.name: the name of the function (a string)
   • tool_call.function.arguments: the arguments, as a JSON string
   • tool_call.id: a unique ID for this call (we'll need it when we send the result back)

2. At the top of the function, parse the arguments from their JSON-string form into a real dictionary (remember to import json):

   function_name = tool_call.function.name
   function_args = json.loads(tool_call.function.arguments or "{}")
   

3. If verbose is specified, print the function name and args:

   print(f" - Calling function: {function_name}({function_args})")
   

   Otherwise, just print the name:

   print(f" - Calling function: {function_name}")
   

4. We'll need to determine which of the four functions to call (if any). To make this ergonomic, define a mapping of function names to actual functions. You can use a dict for this:

   from collections.abc import Callable
   
   function_map: dict[str, Callable[..., str]] = {
       "get_file_content": get_file_content,
       # etc.
   }
   

5. When we send a function's result back to the model, we do it with a special tool message. It's a dictionary with three keys:

   • "role": "tool"
   • "tool_call_id": set to tool_call.id (this is how the model matches a result to the request it made)
   • "content": the string result of the function

   If the provided function name is not found in your mapping, return a tool message describing the error:

   return {
       "role": "tool",
       "tool_call_id": tool_call.id,
       "content": f"Error: Unknown function: {function_name}",
   }
   

6. Assuming the function name is valid, we need to inject the working_directory argument (the LLM doesn't know about it). Set "working_directory" to "./calculator" in the function_args dictionary.

7. Now we get to actually call the function!

   • The values in your map of function name -> function are callable functions, so you can just call the one you need, e.g., function_map[function_name]().
   • The syntax to pass a dictionary into a function using keyword arguments is some_function(**some_args).
   • Assign the result to a variable, e.g. result. Remember that all of our LLM-callable functions return strings.

8. Return a tool message containing the result:

   return {
       "role": "tool",
       "tool_call_id": tool_call.id,
       "content": result,
   }
   

9. Back in your main module – or wherever you handle the response from the LLM – instead of simply printing the name of the function that the model decided to call, use call_function and assign its result to a variable, e.g. result_message.

   1. The returned tool message should have a non-empty "content". If it doesn't, raise an exception.
   2. If verbose mode is in effect, print the result of the function call like this:

      print(f"-> {result_message['content']}")
      

10. Test your program. You should 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 a directory's contents.
    • Get a file's contents.
    • Write some text to a file (don't overwrite anything important; maybe create a new file).
    • Execute the calculator app's tests (tests.py).

Submit the CLI tests.