Responses API et function_call_output

La Responses API : le nouvel endpoint

La Responses API est le nouvel endpoint principal de xAI, distinct de l’endpoint Chat Completions compatible OpenAI. Elle introduit un format différent pour le function calling, avec le type function_call_output pour renvoyer les résultats d’outils.

Différences avec Chat Completions

L’endpoint Chat Completions (compatible OpenAI) utilise des messages de rôle tool pour renvoyer les résultats. La Responses API utilise un format différent, structuré autour de types d’événements.

Chat Completions (ancien format)

# Renvoi du résultat via un message de rôle "tool"
messages.append({
    "role": "tool",
    "tool_call_id": "call_abc123",
    "content": {temp: 22, city: Paris}
})

Responses API (nouveau format)

# Renvoi du résultat via un objet function_call_output
{
    "type": "function_call_output",
    "call_id": "call_abc123",
    "output": {temp: 22, city: Paris}
}

Les différences clés :

• type: "function_call_output" remplace role: "tool"
• call_id remplace tool_call_id
• output remplace content

Utiliser la Responses API avec le SDK OpenAI

Vous pouvez utiliser le SDK OpenAI pour appeler la Responses API de xAI :

from openai import OpenAI

client = OpenAI(
    api_key="votre-cle-api",
    base_url="https://api.x.ai/v1"
)

# Créer une réponse avec des outils
response = client.responses.create(
    model="grok-3",
    input="Quel temps fait-il à Paris ?",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Obtenir la météo d'une ville",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }]
)

Notez que la Responses API utilise input au lieu de messages, et la structure des outils est légèrement différente (pas d’objet function imbriqué).

Traiter la réponse

La réponse de la Responses API contient un tableau output avec les événements :

for item in response.output:
    if item.type == "function_call":
        print(f"Fonction : {item.name}")
        print(f"Arguments : {item.arguments}")
        print(f"Call ID : {item.call_id}")

        # Exécuter la fonction
        result = get_weather(city="Paris")

        # Continuer la conversation avec le résultat
        follow_up = client.responses.create(
            model="grok-3",
            input=[
                {"type": "function_call_output",
                 "call_id": item.call_id,
                 "output": json.dumps(result)}
            ],
            tools=tools,
            previous_response_id=response.id
        )

Le champ previous_response_id

La Responses API introduit un mécanisme de chaînage des conversations via previous_response_id. Plutôt que de renvoyer tout l’historique des messages, vous référencez simplement la réponse précédente :

# Première requête
response1 = client.responses.create(
    model="grok-3",
    input="Cherche la météo à Paris"
)

# Deuxième requête (chaînée)
response2 = client.responses.create(
    model="grok-3",
    input=[{
        "type": "function_call_output",
        "call_id": response1.output[0].call_id,
        "output": {temp: 22}
    }],
    previous_response_id=response1.id
)

Cela simplifie la gestion du contexte et réduit la taille des requêtes.

Stockage des messages côté serveur

Avec store_messages=True, xAI stocke les messages sur leurs serveurs :

response = client.responses.create(
    model="grok-3",
    input="Question de l'utilisateur",
    tools=tools,
    store_messages=True
)

Combiné avec previous_response_id, cela permet de maintenir des conversations longues sans renvoyer l’historique complet à chaque requête.

Quand utiliser la Responses API ?

• Nouvelles fonctionnalités : toutes les innovations xAI sont ajoutées en priorité à la Responses API
• Conversations longues : le chaînage via previous_response_id est plus efficace
• Outils serveur : certains outils intégrés ne sont disponibles que via la Responses API
• Projets xAI natifs : si vous n’avez pas besoin de compatibilité OpenAI

Gardez Chat Completions si vous avez un code existant compatible OpenAI ou si vous devez supporter plusieurs fournisseurs.

Points clés à retenir

• La Responses API utilise function_call_output au lieu du rôle tool
• Les champs changent : call_id au lieu de tool_call_id, output au lieu de content
• previous_response_id permet de chaîner les conversations sans renvoyer l’historique
• store_messages=True active le stockage côté serveur
• La Responses API est l’endpoint recommandé pour les nouveaux projets xAI
• Chat Completions reste disponible pour la rétro-compatibilité OpenAI