Write a tool loop

import json
import os
 
from openai import OpenAI
 
client = OpenAI(base_url="https://app.syntic.ai/v1", api_key=os.environ["SYNTIC_API_KEY"])
 
# 1. The functions the model may call. Replace the bodies with real lookups.
def current_weather(city: str) -> dict:
    sample = {"Lisbon": (21, "sunny"), "Oslo": (4, "sleet")}
    temp, sky = sample.get(city, (15, "cloudy"))
    return {"city": city, "temp_c": temp, "sky": sky}
 
def convert_c_to_f(celsius: float) -> dict:
    return {"fahrenheit": round(celsius * 9 / 5 + 32, 1)}
 
FUNCTIONS = {"current_weather": current_weather, "convert_c_to_f": convert_c_to_f}
 
# 2. How the functions are described to the model.
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "current_weather",
            "description": "Current temperature in Celsius and sky conditions for a city.",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string", "description": "City name, e.g. Lisbon"}},
                "required": ["city"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "convert_c_to_f",
            "description": "Convert a temperature from Celsius to Fahrenheit.",
            "parameters": {
                "type": "object",
                "properties": {"celsius": {"type": "number"}},
                "required": ["celsius"],
            },
        },
    },
]
 
MAX_ROUNDS = 6
 
 
def run_tool(call) -> str:
    fn = FUNCTIONS.get(call.function.name)
    if fn is None:
        return json.dumps({"error": f"unknown tool {call.function.name}"})
    try:
        args = json.loads(call.function.arguments or "{}")
        return json.dumps(fn(**args))
    except Exception as exc:  # report the failure to the model instead of crashing
        return json.dumps({"error": f"{type(exc).__name__}: {exc}"})
 
 
def run(question: str) -> str:
    messages = [
        {"role": "system", "content": "You are a concise weather assistant. Use the tools for any facts."},
        {"role": "user", "content": question},
    ]
    for _ in range(MAX_ROUNDS):
        reply = client.chat.completions.create(
            model="Amara S1.2", stream=False, messages=messages, tools=TOOLS, max_tokens=1024,
        )
        message = reply.choices[0].message
 
        # 3. No tool requested: this is the final answer.
        if not message.tool_calls:
            return message.content
 
        # 4. Keep the assistant turn exactly as received, then answer each call.
        messages.append(message.model_dump(exclude_none=True))
        for call in message.tool_calls:
            messages.append({"role": "tool", "tool_call_id": call.id, "content": run_tool(call)})
 
    return "Stopped: the task needed more tool rounds than allowed."
 
 
print(run("Is it warmer in Lisbon or Oslo right now? Give both in Fahrenheit."))

import OpenAI from 'openai'
 
const client = new OpenAI({ baseURL: 'https://app.syntic.ai/v1', apiKey: process.env.SYNTIC_API_KEY })
 
// 1. The functions the model may call.
const FUNCTIONS = {
  current_weather: ({ city }) => {
    const sample = { Lisbon: [21, 'sunny'], Oslo: [4, 'sleet'] }
    const [temp, sky] = sample[city] ?? [15, 'cloudy']
    return { city, temp_c: temp, sky }
  },
  convert_c_to_f: ({ celsius }) => ({ fahrenheit: Math.round((celsius * 9 / 5 + 32) * 10) / 10 }),
}
 
// 2. How the functions are described to the model.
const TOOLS = [
  {
    type: 'function',
    function: {
      name: 'current_weather',
      description: 'Current temperature in Celsius and sky conditions for a city.',
      parameters: {
        type: 'object',
        properties: { city: { type: 'string', description: 'City name, e.g. Lisbon' } },
        required: ['city'],
      },
    },
  },
  {
    type: 'function',
    function: {
      name: 'convert_c_to_f',
      description: 'Convert a temperature from Celsius to Fahrenheit.',
      parameters: { type: 'object', properties: { celsius: { type: 'number' } }, required: ['celsius'] },
    },
  },
]
 
const MAX_ROUNDS = 6
 
async function runTool(call) {
  const fn = FUNCTIONS[call.function.name]
  if (!fn) return JSON.stringify({ error: `unknown tool ${call.function.name}` })
  try {
    return JSON.stringify(await fn(JSON.parse(call.function.arguments || '{}')))
  } catch (err) {
    return JSON.stringify({ error: String(err) })
  }
}
 
export async function run(question) {
  const messages = [
    { role: 'system', content: 'You are a concise weather assistant. Use the tools for any facts.' },
    { role: 'user', content: question },
  ]
  for (let round = 0; round < MAX_ROUNDS; round++) {
    const reply = await client.chat.completions.create({
      model: 'Amara S1.2',
      stream: false,
      messages,
      tools: TOOLS,
      max_tokens: 1024,
    })
    const message = reply.choices[0].message
 
    // 3. No tool requested: final answer.
    if (!message.tool_calls?.length) return message.content
 
    // 4. Append the assistant turn unchanged, then one tool message per call.
    messages.push(message)
    const results = await Promise.all(message.tool_calls.map(runTool))
    message.tool_calls.forEach((call, i) =>
      messages.push({ role: 'tool', tool_call_id: call.id, content: results[i] }),
    )
  }
  return 'Stopped: the task needed more tool rounds than allowed.'
}
 
console.log(await run('Is it warmer in Lisbon or Oslo right now? Give both in Fahrenheit.'))