Tool Calling with the VoidAI API

import json
import os

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["VOIDAI_API_KEY"],
    base_url="https://api.voidai.app/v1",
    timeout=30.0,
    max_retries=0,
)
model = os.environ.get("VOIDAI_MODEL", "gpt-4o-mini")

# Example data for a fictional project, not universal style rules.
CONVENTIONS = {
    "python": {"indent": "4 spaces", "line_length": 88},
    "javascript": {"indent": "2 spaces", "semicolons": "required"},
}

tools = [{
    "type": "function",
    "function": {
        "name": "get_project_convention",
        "description": "Read this project's formatting convention for a language.",
        "parameters": {
            "type": "object",
            "properties": {
                "language": {
                    "type": "string",
                    "enum": ["python", "javascript"],
                },
            },
            "required": ["language"],
            "additionalProperties": False,
        },
    },
}]


def run_tool(call):
    # Dispatch only the function this application deliberately exposes.
    if call.type != "function" or call.function.name != "get_project_convention":
        return {"error": "Unknown tool"}

    raw = call.function.arguments
    if len(raw) > 4096:
        return {"error": "Arguments are too large"}
    try:
        arguments = json.loads(raw)
    except json.JSONDecodeError:
        return {"error": "Arguments must be valid JSON"}

    if not isinstance(arguments, dict) or set(arguments) != {"language"}:
        return {"error": "Expected only a language argument"}
    language = arguments["language"]
    if not isinstance(language, str) or language not in CONVENTIONS:
        return {"error": "Choose python or javascript"}
    return CONVENTIONS[language]


messages = [{
    "role": "user",
    "content": "Use the project conventions to compare Python and JavaScript indentation.",
}]
request_ids = []
MAX_ROUNDS = 4
MAX_CALLS_PER_ROUND = 8

for _ in range(MAX_ROUNDS):
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        tools=tools,
        tool_choice="auto",
        max_tokens=512,
    )
    request_ids.append(response.id)
    if not response.choices:
        raise RuntimeError("The response contained no choices")

    choice = response.choices[0]
    if choice.finish_reason in {"length", "content_filter"}:
        raise RuntimeError("The response stopped before the example could finish")
    message = choice.message
    calls = message.tool_calls or []
    if not calls:
        print(message.content or "No text was returned.")
        break
    if len(calls) > MAX_CALLS_PER_ROUND:
        raise RuntimeError("Tool-call limit reached")

    messages.append(message.model_dump(exclude_none=True))
    for call in calls:
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(run_tool(call)),
        })
else:
    raise RuntimeError("Round limit reached; inspect the conversation before continuing")