Tool Calling¶

Lernen Sie, LLMs zu evaluieren, die über vordefinierte Funktionen und Tools mit externen Systemen interagieren

Tool Calling ermöglicht es LLMs, mit externen Systemen zu interagieren, indem es während der Antwortgenerierung Zugang zu vordefinierten Funktionen bereitstellt. Dieses Guide behandelt die Evaluierung der Tool-Auswahl eines LLMs, wenn elluminate die Antwort generiert: Sie hängen Tool-Definitionen an ein Prompt-Template, elluminate generiert eine Antwort, in der das Modell Tool-Aufrufe auswählt (aber nicht ausführt), und Ihre Kriterien bewerten diese Auswahl.

Tool Calling oder Agentic Evaluations — welches Guide?

Nutzen Sie Tool Calling (dieses Guide), wenn elluminate die Antwort generieren soll und Sie eine einstufige Tool-Auswahl (ohne Ausführung) evaluieren wollen. Für mehrstufige Agenten, die Tools tatsächlich ausführen, nutzen Sie stattdessen Agentic Evaluations: Sie führen den Agenten selbst aus und laden seine Trajectory hoch.

Basic Usage¶

Ein Beispiel, das die Integration von Wetter-Tools für Echtzeitdatenzugriff zeigt:

    template, created = client.get_or_create_prompt_template(
        name="Weather Assistant with Tools v1",
        messages="""\
You are a helpful weather assistant. The user is asking: {{user_query}}.
Use the available weather tools to provide accurate information.
Respond in the units most customary of the location being queried.""",
        tools=[
            FunctionTool(  # (1)!
                type="function",
                function={
                    "name": "get_current_weather",
                    "description": "Get the current weather in a given location",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "location": {
                                "type": "string",
                                "description": "The city and state/country, e.g. Berlin, DE",
                            },
                            "unit": {
                                "type": "string",
                                "enum": ["celsius", "fahrenheit"],
                                "description": "The temperature unit to use",
                            },
                        },
                        "required": ["location", "unit"],
                        "additionalProperties": False,
                    },
                    "strict": True,
                },
            ),
        ],
        tool_choice="auto",  # (2)!
    )

Tools definieren: Setzen Sie tools auf Funktions-Tool-Definitionen unter Verwendung von OpenAIs FunctionTool-Typ. Diese Definitionen beschreiben jede Funktion und spezifizieren genau, welche Eingabedaten die Funktion erwartet und welche Ausgabedaten sie zurückgibt.
Template erstellen: Optional können Sie tool_choice setzen, um zu kontrollieren, wann das Modell Tools verwenden soll. Standardmäßig ist es "auto", wenn es weggelassen wird.

Sobald das Prompt-Template mit den Tool-Definitionen erstellt wurde, verläuft der Rest des Evaluierungsprozesses wie gewohnt. Experimente werden normal ausgeführt - das Modell erzeugt automatisch Tool-Aufrufe (führt sie jedoch nicht aus) - und die Kriterien evaluieren die gewählten Tools.

Tool-Aufrufe können in 'tool_calls' der Assistenten-Nachricht als Liste der aufgerufenen Tools gefunden werden:

for message in response.messages:
    if message.role == "assistant" and message.tool_calls:
        for tool_call in message.tool_calls:
            print(f"  - {tool_call.function.name}({tool_call.function.arguments})")

Tool-Ausführung

elluminate unterstützt derzeit nicht die Ausführung Ihrer Tools. Beim Durchführen von Experimenten sehen Sie den Tool-Aufruf, der ausgewählt wurde, aber nicht die tatsächliche Ausgabe oder Ergebnisse dieses Tools. Um die Ausführung von Tools zu evaluieren, lesen Sie den Abschnitt Fortgeschrittenes Beispiel unten, da besondere Sorgfalt erforderlich ist.

Vollständiges Grundbeispiel

"""v1.0 API: Tool Calling Example

Demonstrates how to define tools (functions) that the LLM can call during
generation. This example creates a weather assistant that can use a
get_current_weather tool.

v1.0 API changes:
- client.prompt_templates.aget_or_create() -> client.get_or_create_prompt_template()
- client.collections.aget_or_create() -> client.get_or_create_collection()
- client.criteria.aget_or_generate_many() -> template.get_or_generate_criteria()
- client.experiments.aget_or_create() -> client.run_experiment()
- Sync-first approach

INSIGHT: Tool definitions use OpenAI's FunctionTool format. The LLM decides
when to call tools based on the user query. elluminate captures tool calls
in the response messages, allowing you to evaluate tool usage patterns.
"""

from dotenv import load_dotenv
from elluminate import Client
from elluminate.schemas import RatingMode
from openai.types.beta import FunctionTool

load_dotenv(override=True)


def main():
    client = Client()
    llm_config = client.get_llm_config(name="GPT-4.1 Nano")

    print("v1.0: Tool Calling Example")
    print("=" * 50)

    # v1.0: get_or_create_prompt_template with tools as keyword arguments
    template, created = client.get_or_create_prompt_template(
        name="Weather Assistant with Tools v1",
        messages="""\
You are a helpful weather assistant. The user is asking: {{user_query}}.
Use the available weather tools to provide accurate information.
Respond in the units most customary of the location being queried.""",
        tools=[
            FunctionTool(  # (1)!
                type="function",
                function={
                    "name": "get_current_weather",
                    "description": "Get the current weather in a given location",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "location": {
                                "type": "string",
                                "description": "The city and state/country, e.g. Berlin, DE",
                            },
                            "unit": {
                                "type": "string",
                                "enum": ["celsius", "fahrenheit"],
                                "description": "The temperature unit to use",
                            },
                        },
                        "required": ["location", "unit"],
                        "additionalProperties": False,
                    },
                    "strict": True,
                },
            ),
        ],
        tool_choice="auto",  # (2)!
    )

    print(f"Template: {'Created' if created else 'Found existing'}")

    # v1.0: get_or_create_collection with add_many
    collection, created = client.get_or_create_collection(
        name="Weather Query Test Data v1",
    )
    if created:
        collection.add_many(
            variables=[
                {"user_query": "What's the weather like in London, UK and should I bring an umbrella?"},
                {"user_query": "Compare the current weather in Boston and San Francisco."},
            ]
        )
    print(f"Collection: {'Created' if created else 'Found existing'}")

    # v1.0: template.get_or_generate_criteria() - generates criteria from template
    # Returns (criteria_list, was_generated) - we just need to ensure criteria exist
    criteria, was_generated = template.get_or_generate_criteria()
    print(f"Criteria: {'Generated' if was_generated else 'Already existed'} ({len(criteria)} criteria)")

    # v1.0: run_experiment - creates and runs in one call
    # Criteria are already linked to the template via get_or_generate_criteria()
    print("\nRunning experiment...")
    experiment = client.run_experiment(
        name="Weather Tool Calling Experiment v1",
        prompt_template=template,
        collection=collection,
        description="Testing tool calling capabilities for weather queries",
        rating_mode=RatingMode.FAST,
        n_epochs=1,
        llm_config=llm_config,
    )

    print(f"\nExperiment completed: {experiment.name}")
    print(f"Total responses: {len(experiment.rated_responses)}")

    # Display results with tool calls
    for i, response in enumerate(experiment.responses(), 1):
        print(f"\n--- Example {i} ---")
        print(f"Query: {response.prompt.template_variables.input_values['user_query']}")
        print("Tool Calls:")
        for message in response.messages:
            if message.role == "assistant" and message.tool_calls:
                for tool_call in message.tool_calls:
                    print(f"  - {tool_call.function.name}({tool_call.function.arguments})")

    # Show aggregated results
    if experiment.result:
        print("\n--- Results ---")
        print(f"Pass rate: {experiment.result.mean_all_ratings.yes:.2%}")


# =========================================================================
# Migration Insights
# =========================================================================
#
# 1. TOOL DEFINITIONS
#    Both versions: Use OpenAI's FunctionTool format
#    v1.0: tools and tool_choice as keyword arguments (part of template identity)
#    The format is identical - FunctionTool with function dict
#
# 2. CRITERIA GENERATION
#    v0.x: client.criteria.aget_or_generate_many(template)
#    v1.0: template.get_or_generate_criteria()
#    Impact: More intuitive - criteria belong to templates conceptually
#    Returns (criteria_list, was_generated) tuple - criteria are linked to template
#
# 3. TOOL_CHOICE OPTIONS
#    Both versions support:
#    - "auto": LLM decides when to call tools
#    - "none": Disable tool calling
#    - "required": Force at least one tool call
#    - {"type": "function", "function": {"name": "..."}}: Force specific tool
#
# 4. TOOL CALL INSPECTION
#    Both versions: response.messages contains tool_calls
#    message.tool_calls is a list of ToolCall objects
#    Each has: id, type, function.name, function.arguments
#
# 5. STRICT MODE
#    The "strict": True in function parameters enforces schema validation
#    LLM must provide exactly the specified parameters, no extras
#    Recommended for production to ensure predictable tool calls
#
# 6. SDK ENHANCEMENT OPPORTUNITY
#    The tool call results are not automatically executed.
#    Consider adding a tool execution hook or callback mechanism
#    for automated tool calling workflows.
#


if __name__ == "__main__":
    main()

Tool-Definitionsmethoden¶

OpenAI Function Tool Format¶

Tools werden mit OpenAIs Standard-FunctionTool-Format definiert:

from openai.types.beta import FunctionTool

weather_tool = FunctionTool(
    type="function",
    function={
        "name": "get_current_weather",
        "description": "Get the current weather in a given location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string", 
                    "description": "The city and state/country, e.g. Berlin, DE"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "The temperature unit to use"
                }
            },
            "required": ["location", "unit"],
            "additionalProperties": False
        },
        "strict": True
    }
)

Tool Choice Konfiguration¶

Der tool_choice-Parameter kontrolliert, wann und wie das Modell verfügbare Tools verwendet:

Automatische Auswahl (tool_choice="auto") - Lassen Sie das Modell entscheiden, wann und welche Tools verwendet werden sollen.
Erforderliche Verwendung (tool_choice="required") - Zwingen Sie das Modell, mindestens ein Tool zu verwenden.
Deaktivierte Tools (tool_choice="none") - Deaktivieren Sie alle Tools für diese Antwort.

Spezifische Funktion: Zwingt das Modell, ein bestimmtes Tool aufzurufen.

tool_choice={
    "type": "function", 
    "function": {"name": "get_current_weather"}
}

Mehrstufige Tool-Nutzung evaluieren¶

Echter mehrstufiger Agent? Nutzen Sie Agentic Evaluations

Für einen Agenten, der in der Produktion Tools über viele Turns ausführt, ist Agentic Evaluations der unterstützte Weg: Führen Sie den Agenten in Ihrer eigenen Runtime aus und laden Sie seine Trajectory hoch, um Agent Trace, Ratings pro Criterion und agentische Metriken zu erhalten. Der manuelle Ansatz unten ist älter als dieses Feature — nutzen Sie ihn, wenn Sie einfach eine einzelne Tool-Konversation als eine elluminate-Antwort evaluieren möchten.

Die Evaluierung einer mehrstufigen Tool-Konversation folgt einem ähnlichen Prozess wie die Evaluierung eines einzelnen Prompts. Der einzige Unterschied besteht darin, dass Ihr Code anstatt den Prompt direkt zu inferenzieren eine beliebige Anzahl von Tool-Aufrufen durchführen kann, bevor er eine endgültige Antwort produziert. Die Evaluierung wird dann sowohl an der gesamten Tool-Kette als auch an der endgültigen Antwort durchgeführt. Dieser Abschnitt umreißt den prinzipiellen Ansatz; der folgende Abschnitt führt Sie durch ein vollständiges Beispiel.

Der erste Schritt ist nahezu identisch mit der Evaluierung eines einzelnen Prompts. Sie müssen elluminate mit Ihrem Prompt-Template laden, Kriterien hinzufügen oder generieren, sowie eine Collection mit repräsentativen Eingaben für Ihr System erstellen.

Feine Unterschiede

Tool-Definitionen als Bewertungskontext: Damit das Bewertungsmodell Zugang zu allen Tools und ihren Parameterbeschreibungen hat, müssen Sie die Tool-Definitionen zum Prompt-Template hinzufügen. Vom SDK aus kann dies über die Parameter tools und tool_choice bei allen create Methoden erfolgen. Das Frontend hat auch ein spezielles Feld zum Hinzufügen von Tool-Definitionen. Dies bietet dem Bewertungsmodell während der Bewertung wertvollen Kontext darüber, was jedes Tool und seine Parameter tun.
Maßgeschneiderte Kriterien für Tool-Aufrufe: Es kann vorteilhaft sein, Tools und ihre Parameter explizit namentlich in den Kriterien zu erwähnen. Dies hilft dem Bewertungsmodell zu wissen, auf welchen Teil des Tool-Aufrufs es sich während der Bewertung konzentrieren soll. Zum Beispiel ist "Wurde get_current_weather mit den Temperatur-units aufgerufen, die am häufigsten in location verwendet werden?" präziser als "Sind die Einheiten für die Stadt korrekt?".

Mit diesem Setup muss Ihr bestehender agentischer Code, da elluminate Tool-Aufrufe nicht ausführen kann, die Tool-Kette inferenzieren und die endgültige Antwort selbst produzieren. Dann müssen Sie die gesamte Kette von Tool-Aufrufen, Antworten sowie die endgültige Ausgabe manuell als eine einzige Antwort in elluminate hinzufügen. Wichtig ist, dass die Einbeziehung der gesamten Aufrufkette erforderlich ist, wenn Sie sowohl den Tool-Calling-Prozess als auch die endgültige Ausgabe Ihres Agenten evaluieren möchten.

Tool-Aufrufe manuell als Antwort hinzufügen

Das SDK bietet die Methode client.responses.add, um manuell eine Antwort hinzuzufügen. Diese Methode akzeptiert entweder einen String oder eine Liste von OpenAI-Completion-Nachrichten als Antwort. Wenn Sie eine Liste von Completion-Nachrichten bereitstellen, bilden sie alle zusammen die einzige Antwort. Dies ermöglicht es dem Bewertungsmodell, nicht nur die endgültige Ausgabe zu bewerten, sondern auch alle zwischenzeitlichen Tool-Aufrufe und Tool-Ergebnisse.

Die Methode client.responses.add_many funktioniert genau gleich, wird aber für das Bulk-Hinzufügen von Antworten verwendet.

Fortgeschrittenes Beispiel¶

Dieses fortgeschrittene Beispiel demonstriert, wie man eine mehrstufige Tool-Konversation evaluiert, indem man sie als eine einzige elluminate-Antwort aufzeichnet. Der Code hat Zugang zu grundlegenden Dateisystem-Tools, die es ermöglichen, Verzeichnisse zu navigieren, Dateien zu lesen und ihre Metadaten zu analysieren. Er wird mit grundlegenden Fragen wie "Was ist die größte Datei im System?" beauftragt und darauf evaluiert, ob er korrekt geantwortet hat und welche Methoden er während des Prozesses verwendet hat. (Für einen produktiven mehrstufigen Agenten ist Agentic Evaluations vorzuziehen.)

Manuelle Tool-Ausführung erforderlich

elluminate unterstützt keine Tool-Ausführung. Daher muss die Tool-Ausführung immer noch manuell in Ihrem Code behandelt werden. Sie müssen dann die gesamte Kette von Tool-Aufrufen, Tool-Ausgaben und endgültiger Antwort als manuell hinzugefügte Antwort an elluminate zurückgeben.

Tool-Funktionsimplementierung¶

Dieses Beispiel implementiert zunächst mehrere Dateisystem-Operationen als Python-Funktionen. Es gibt Funktionen, um das aktuelle Arbeitsverzeichnis zurückzugeben, Verzeichnisse zu wechseln, Dateien aufzulisten und andere Operationen.

Tool-Funktionsimplementierung

Aktuelles Verzeichnis: Gibt den aktuellen Arbeitsverzeichnispfad zurück
Verzeichnisnavigation: Ändert das aktuelle Arbeitsverzeichnis
Verzeichnis Auflistung: Listet alle Dateien und Verzeichnisse mit ihren Typen auf
Dateistatistiken: Ruft detaillierte Dateimetadaten einschließlich Größe und Zeitstempel ab
Datei Lesen: Liest und gibt den Inhalt von Textdateien zurück

Tool-Definitions-Setup¶

Tools werden mit OpenAIs FunctionTool-Format definiert, wobei jede Python-Funktion auf eine strukturierte Tool-Definition abgebildet wird. So erhält jede der oben definierten Python-Methoden ihre eigene FunctionTool-Definition, die ihren Namen, ihre Beschreibung und die akzeptierten Argumente festlegt.

Tool-Definitions-Setup

Inferenzierung mit Tools¶

Wie bereits erwähnt, muss die Tool-Ausführung außerhalb von elluminate behandelt werden. In einer for-Schleife im Skript inferenziert es die Prompt-Nachrichten und überprüft, ob ein Tool aufgerufen wurde. Wenn ja, führt es das Tool aus und sendet das Ergebnis zurück an das LLM. Wenn nein, verlässt es die Schleife mit der vollständigen Nachrichtenkonversation.

Multi-Turn-Konversationsbehandlung

OpenAI-Integration: Verwendet OpenAIs Chat-Completion-API mit den Tool-Definitionen. Tool-Choice ist auf den "auto"-Modus gesetzt.
Tool-Ausführungsschleife: Wenn Tools aufgerufen werden, führt sie diese automatisch aus und gibt die Ergebnisse als Fortsetzung der Nachrichtenkonversation zurück an das Modell.

Experiment-Setup und Evaluierung¶

Alles zusammengefügt integriert dieser Workflow den Tool-Ausführungscode mit elluminates Experiment-System. Ein Prompt-Template mit den FunctionTool-Definitionen und eine Sammlung repräsentativer Benutzeranfragen werden erstellt. Dann werden Kriterien manuell dem Prompt-Template zugewiesen. Einmal eingerichtet, wird der Tool-Ausführungscode für jede Eingabe in der Sammlung ausgeführt. Die vollständigen Nachrichtenkonversationen werden zurück in elluminate gespeichert und als Teil eines Experiments bewertet.

Vollständiger Experiment-Workflow

Prompt-Template: Definiert einen grundlegenden System-Prompt und einen Benutzer-Prompt, der mit einer user_query aus einer Sammlung gefüllt werden soll.
Nachrichten-Rendering: Um manuell zu inferenzieren, muss der user_query-Platzhalter im Prompt-Template ausgefüllt werden. Dies gibt die vollständig gerenderten Nachrichten zurück, die direkt an OpenAIs Completion-Client weitergegeben werden können.
Manuelle Tool-Ausführung: Behandelt die vollständige Tool-Calling-Konversation manuell außerhalb von elluminate
Antwortaufzeichnung: Fügt manuell die endgültige Tool-Calling-Konversation als Antwort zu elluminate hinzu
Experiment-Erstellung: Erstellt ein Experiment und bewertet die Antworten gegen die Kriterien des Prompt-Templates

Vollständiges fortgeschrittenes Beispiel

"""Tool Calling with Filesystem Operations Example (v1.0 API)

This example demonstrates how to test LLM tool calling capabilities using a
simulated filesystem. It uses pyfakefs to create a virtual filesystem for
safe testing without affecting real files.

Requires: pyfakefs, openai
"""

import datetime
import json
import os
import time
from typing import Any

from dotenv import load_dotenv
from elluminate import Client
from openai import AzureOpenAI, OpenAI
from openai.types.beta import FunctionTool
from openai.types.chat import ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam
from pyfakefs.fake_filesystem_unittest import Patcher

load_dotenv(override=True)


def get_openai_client() -> AzureOpenAI | OpenAI:
    if "AZURE_OPENAI_ENDPOINT" in os.environ:
        return AzureOpenAI(
            azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
            api_version=os.environ.get("OPENAI_API_VERSION"),
            api_key=os.environ.get("AZURE_OPENAI_API_KEY"),
        )
    else:
        return OpenAI()


# Tool functions
def pwd() -> str:
    return os.getcwd()


def chdir(directory: str) -> None:
    os.chdir(directory)


def list_dir() -> list[tuple[str, str]]:
    ret = []
    items = os.listdir(".")
    for item in items:
        if os.path.isfile(item):
            ret.append((item, "FILE"))
        elif os.path.isdir(item):
            ret.append((item, "DIRECTORY"))
    return ret


def file_stats(file_name: str) -> dict[str, Any]:
    stat_info = os.stat(file_name)
    return {
        "Size (bytes)": stat_info.st_size,
        "Last Modified": datetime.datetime.fromtimestamp(stat_info.st_mtime).strftime("%Y-%m-%d %H:%M:%S"),
        "Created At": datetime.datetime.fromtimestamp(stat_info.st_ctime).strftime("%Y-%m-%d %H:%M:%S"),
    }


def read_file(file_name: str) -> str:
    with open(file_name, "r") as file:
        return file.read()


# Tool definitions
tools = [
    FunctionTool(
        type="function",
        function={
            "name": "pwd",
            "description": "Get the current working directory path",
            "parameters": {"type": "object", "properties": {}, "required": []},
        },
    ),
    FunctionTool(
        type="function",
        function={
            "name": "chdir",
            "description": "Change the current working directory",
            "parameters": {
                "type": "object",
                "properties": {"directory": {"type": "string", "description": "The directory path to change to"}},
                "required": ["directory"],
            },
        },
    ),
    FunctionTool(
        type="function",
        function={
            "name": "list_dir",
            "description": "List all files and directories in the current directory",
            "parameters": {"type": "object", "properties": {}, "required": []},
        },
    ),
    FunctionTool(
        type="function",
        function={
            "name": "file_stats",
            "description": "Get detailed statistics about a specific file",
            "parameters": {
                "type": "object",
                "properties": {
                    "file_name": {"type": "string", "description": "The name of the file to get statistics for"}
                },
                "required": ["file_name"],
            },
        },
    ),
    FunctionTool(
        type="function",
        function={
            "name": "read_file",
            "description": "Read and return the contents of a text file",
            "parameters": {
                "type": "object",
                "properties": {"file_name": {"type": "string", "description": "The name of the file to read"}},
                "required": ["file_name"],
            },
        },
    ),
]

# Function mapping for tool execution
function_map = {
    "pwd": pwd,
    "chdir": chdir,
    "list_dir": list_dir,
    "file_stats": file_stats,
    "read_file": read_file,
}


def execute_function_call(function_call) -> str:
    """Execute a function call and return the result"""
    function_name = function_call.name
    arguments = json.loads(function_call.arguments)

    try:
        return str(function_map[function_name](**arguments))
    except Exception as e:
        return f"Error executing {function_name}: {str(e)}"


def chat_with_tools(openai_client, messages, max_iterations=30):
    """Run a conversation with tool calling enabled."""
    chdir("/")  # Reset directory
    responded_messages = []

    for iteration in range(1, max_iterations + 1):
        print(f"\n--- Iteration {iteration} ---")

        response = openai_client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages + responded_messages,
            tools=[tool.model_dump() for tool in tools],
            tool_choice="auto",
        )

        assistant_message = response.choices[0].message
        responded_messages.append(assistant_message.model_dump())

        if assistant_message.tool_calls:
            print("AI is calling tools...")
            for tool_call in assistant_message.tool_calls:
                print(f"Calling function: {tool_call.function.name}")
                print(f"Arguments: {tool_call.function.arguments}")
                function_result = execute_function_call(tool_call.function)
                print(f"Result: {function_result}")

                responded_messages.append(
                    {
                        "tool_call_id": tool_call.id,
                        "role": "tool",
                        "name": tool_call.function.name,
                        "content": function_result,
                    }
                )
        else:
            print("Final response:")
            print(assistant_message.content)
            return responded_messages

    print("Max iterations reached!")
    return responded_messages


def setup_filesystem(patcher):
    """Set up the fake filesystem with sample files"""
    patcher.fs.create_file(
        "/files/report.txt",
        contents="Annual sales report for 2024. Revenue increased by 15% compared to last year.",
    )
    patcher.fs.create_file("/files/notes.txt", contents="Meeting notes from project kickoff.")
    patcher.fs.create_file("/files/photo1.jpg", contents="[Binary image data would be here]")
    patcher.fs.create_file(
        "/logs/app.log",
        contents="2024-01-15 10:30:22 - Application started\n2024-01-15 10:31:45 - User logged in\n2024-01-15 11:22:10 - Error: Connection timeout",
    )
    time.sleep(2)
    patcher.fs.create_file("/files/cache.tmp", contents="Temporary cache data")
    time.sleep(1)
    patcher.fs.create_file(
        "/files/settings.json", contents='{"theme": "dark", "auto_save": true, "max_files": 100}'
    )


def main():
    client = Client()
    llm_config = client.get_llm_config(name="GPT-4.1 Nano")
    openai_client = get_openai_client()

    with Patcher() as patcher:
        setup_filesystem(patcher)

        # Create prompt template with tools
        template, _ = client.get_or_create_prompt_template(
            name="File System Explorer with Tools",
            messages=[
                ChatCompletionSystemMessageParam(
                    role="system",
                    content="You are a helpful file system assistant. Use the provided tools to explore and analyze the file system. Always start by checking the current directory and exploring the structure before answering questions. Ignore the /tmp and /var directories.",
                ),
                ChatCompletionUserMessageParam(role="user", content="{{user_query}}"),
            ],
            tools=tools,
            tool_choice="auto",
        )

        # Create collection with test cases
        collection, _ = client.get_or_create_collection(
            name="File System Query Test Data",
            defaults={
                "variables": [
                    {"user_query": "What is the largest file in the system?", "answer": "app.log"},
                    {"user_query": "Which file was created most recently?", "answer": "settings.json"},
                    {
                        "user_query": "Can you find all the text files (.txt) and tell me which one has the longest content?",
                        "answer": "report.txt",
                    },
                    {"user_query": "Which files has configuration information?", "answer": "settings.json"},
                ],
            },
        )

        # Create criterion set with criteria
        criterion_set, _ = client.get_or_create_criterion_set(
            name="File System Tool Calling Criteria",
            defaults={
                "criteria": [
                    "Did the response say the correct file was: {{answer}}?",
                    "Were at most 7 tool calls used?",
                    "Was 'list_dir' called on the /files directory by calling 'chdir' in to it?",
                    "Does the tool call trace NOT show any sign of confusion or misguidance?",
                ],
            },
        )
        criterion_set.link_template(template)

        # Create experiment
        experiment = client.create_experiment(
            name="File System Tool Calling Experiment",
            prompt_template=template,
            collection=collection,
            description="Testing tool calling capabilities for file system operations",
            llm_config=llm_config,
        )

        # Generate responses manually using OpenAI
        all_responses = []
        all_template_vars = []

        for template_vars in collection.items():
            rendered_messages = template.render_messages(user_query=template_vars.input_values["user_query"])

            # Handle tool calling conversation manually
            response_messages = chat_with_tools(openai_client, rendered_messages)
            all_responses.append(response_messages)
            all_template_vars.append(template_vars)

        # Add all responses to the experiment
        experiment.add_responses(
            responses=all_responses,
            template_variables=all_template_vars,
        )

        # Rate responses
        experiment.rate_responses()

        print("Finished all ratings. View the results from the frontend.")


if __name__ == "__main__":
    main()