Tools / Function Calling

1
class WeatherAPI {
2
  // we can use literals to denote the name of the tool
3
  // the field can be named anything we want! "api_name" "tool" "function_name"
4
  // whatever you feel the LLM would understand best
5
  api_name "weather_request"
6
  city string @description("the user's city")
7
  timeOfDay string @description("As an ISO8601 timestamp")
8
}
9
10
function UseTool(user_message: string) -> WeatherAPI {
11
  client "openai/gpt-5-mini"
12
  prompt #"
13
    Given a message, extract info.
14
    {# special macro to print the functions return type. #}
15
    {{ ctx.output_format }}
16
17
    {{ _.role('user') }}
18
    {{ user_message }}
19
  "#
20
}

1
function UseTool(user_message: string) -> WeatherAPI | MyOtherAPI {
2
  .... // same thing
3
}

1
function UseTool(user_message: string) -> (WeatherAPI | MyOtherAPI)[] {
2
  client "openai/gpt-5-mini"
3
  prompt #"
4
    Given a message, extract info.
5
    {# special macro to print the functions return type. #}
6
    {{ ctx.output_format }}
7
8
    {{ _.role('user') }}
9
    {{ user_message }}
10
  "#
11
}

1
class GetWeather {
2
  tool_name "get_weather" @description("Use this tool to get the current weather forecast for a specific city.")
3
  city string @description("The city for which to get the weather.")
4
}
5
6
class GetTimezone {
7
  tool_name "get_timezone" @description("Use this tool to find the current timezone of a specific city.")
8
  city string @description("The city for which to find the timezone.")
9
}
10
11
function ChooseTool(query: string) -> GetWeather | GetTimezone {
12
  client "openai/gpt-5"
13
  prompt #"
14
    Given the user query, determine the primary intent and select the appropriate tool to call.
15
16
    {# special macro to add tool structures + descriptions here #}
17
    {{ ctx.output_format }} 
18
19
    {{ _.role('user') }}
20
    {{ query }}
21
  "#
22
}

1
class WeatherAPI {
2
  @@dynamic // params defined from code
3
}
4
5
function UseTool(user_message: string) -> WeatherAPI {
6
  client "openai/gpt-5-mini"
7
  prompt #"
8
    Given a message, extract info.
9
    {# special macro to print the functions return type. #}
10
    {{ ctx.output_format }}
11
12
    {{ _.role('user') }}
13
    {{ user_message }}
14
  "#
15
}

1
import asyncio
2
import inspect
3
4
from baml_client import b
5
from baml_client.type_builder import TypeBuilder
6
from baml_client.types import WeatherAPI
7
8
async def get_weather(city: str, time_of_day: str):
9
    print(f"Getting weather for {city} at {time_of_day}")
10
    return 42
11
12
async def main():
13
    tb = TypeBuilder()
14
    type_map = {int: tb.int(), float: tb.float(), str: tb.string()}
15
    signature = inspect.signature(get_weather)
16
    for param_name, param in signature.parameters.items():
17
        tb.WeatherAPI.add_property(param_name, type_map[param.annotation])
18
    tool = b.UseTool("What's the weather like in San Francisco this afternoon?", { "tb": tb })
19
    print(tool)
20
    weather = await get_weather(**tool.model_dump())
21
    print(weather)
22
23
if __name__ == '__main__':
24
    asyncio.run(main())

1
class WeatherAPI {
2
  intent "weather_request"
3
  city string
4
  time string @description("Current time in ISO8601 format")
5
}
6
7
class CalculatorAPI {
8
  intent "basic_calculator"
9
  operation "add" | "subtract" | "multiply" | "divide"
10
  numbers float[]
11
}
12
13
function SelectTool(message: string) -> WeatherAPI | CalculatorAPI {
14
  client "openai/gpt-5"
15
  prompt #"
16
    Given a message, extract info.
17
18
    {{ ctx.output_format }}
19
20
    {{ _.role("user") }} {{ message }}
21
  "#
22
}