Przejdź do głównej treści
Polski— Wybierz język
Menu

Architektura wywoływania funkcji w Responses API

Lekcja 1 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Architektura wywoływania funkcji w Responses API
  2. Zasada fundamentalna
  3. Anatomia odpowiedzi
  4. Pełna pętla
  5. Kluczowe różnice względem Chat Completions
  6. Kiedy model wywołuje funkcję?
  7. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 na podstawie dokumentacji OpenAI: narzędzie Code Interpreter wymaga teraz parametru container (dodano do wszystkich przykładów), części tekstowe wejścia używają typu input_text, a wyszukiwanie w sieci korzysta z narzędzia web_search (web_search_preview to obecnie przestarzałe narzędzie bez filtrów domenowych). Wygenerowane pliki pobiera się za pomocą funkcji fichiers_generes i telecharger z Lekcji 10. Źródła: Code Interpreter · Wyszukiwanie w sieci.

Architektura wywoływania funkcji w Responses API

Wywoływanie funkcji to mechanizm rdzenny, który pozwala modelom OpenAI interagować ze światem zewnętrznym. W Responses API mechanizm ten został przeprojektowany, aby był bardziej odporny, przewidywalny i natywnie zintegrowany z wbudowanymi narzędziami, takimi jak Wyszukiwanie w sieci (Web Search) i Interpreter Kodu (Code Interpreter).

Zasada fundamentalna

Model nigdy nie wykonuje żadnych działań bezpośrednio. Emituje ustrukturyzowane intencje, które Twój kod przechwytuje i realizuje. Brzmi to jak ograniczenie techniczne, ale w rzeczywistości jest to wybór projektowy, który umożliwia wszystko inne.

Rozważ alternatywę. Gdyby model sam wykonywał działania, musiałbyś przekazać mu poświadczenia do bazy danych, klucze API i uprawnienia do zapisu – i nie miałbyś żadnego punktu kontrolnego, w którym mógłbyś cokolwiek zweryfikować. Dzięki rozdzieleniu każda intencja przechodzi przez Twój kod: walidujesz argumenty, egzekwujesz reguły biznesowe i w razie potrzeby odmawiasz wykonania. Model proponuje, Twój kod decyduje, a ta granica pozwala wdrożyć wywoływanie funkcji w środowisku produkcyjnym bez utraty kontroli.

from openai import OpenAI

client = OpenAI()

# Deklaracja niestandardowego narzędzia
tools = [{
    "type": "function",
    "name": "rechercher_client",
    "description": "Search for a client in the CRM by name or email",
    "parameters": {
        "type": "object",
        "properties": {
            "terme": {
                "type": "string",
                "description": "Client name, email, or ID"
            },
            "champ": {
                "type": "string",
                "enum": ["nom", "email", "id"],
                "description": "Field to search in"
            }
        },
        "required": ["terme"]
    }
}]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Find the client Jean Dupont",
    tools=tools
)

Anatomia odpowiedzi

Odpowiedź nie zawiera albo tekstu, albo wywołań narzędzi: output to lista heterogeniczna, która może mieszać oba te elementy. Nawyk, który musisz wyrobić sobie od pierwszej linii kodu, to iterowanie po tej liście, zamiast odczytywania output[0]. Model, który wyjaśnia swoje rozumowanie przed wywołaniem funkcji, generuje dokładnie taki przypadek, a kod odczytujący tylko pierwszy element przestanie działać w dniu, w którym model zacznie dodawać komentarze.

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

call_id jest kluczowe: łączy wywołanie z jego wynikiem, gdy odsyłasz odpowiedź z powrotem do modelu. Przy pojedynczym wywołaniu ledwo to zauważysz; przy trzech wywołaniach równoległych jest to jedyny sposób, by nie przypisać pogody z Lyon do zapytania o Marsylię. Zawsze zwracaj wynik z call_id, które otrzymałeś, nigdy z ID zrekonstruowanym po Twojej stronie.

Pełna pętla

Ten czterostopniowy cykl jest niezmienny: obowiązuje dla jednej funkcji czy dwudziestu, dla prostego wywołania lub agenta łączącego dziesięć narzędzi. Cała złożoność, z którą spotkasz się później – równoległość, błędy, mechanizmy awaryjne – polega na instrumentowaniu tej pętli, nigdy na jej zastępowaniu.

import json

# 1. Pierwsze wywołanie z zadeklarowanymi narzędziami
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the balance for client [email protected]?",
    tools=tools
)

# 2. Wykrycie i wykonanie wywołań funkcji
resultats = []
for item in response.output:
    if item.type == "function_call":
        if item.name == "rechercher_client":
            args = json.loads(item.arguments)
            resultat = votre_crm.rechercher(args["terme"])
            resultats.append({
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(resultat)
            })

# 3. Odesłanie wyników z powrotem do modelu
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)

# 4. Model formułuje swoją naturalną odpowiedź
print(response_finale.output_text)

Kluczowe różnice względem Chat Completions

Responses API wprowadza kilka ulepszeń architektonicznych.

Natywna obsługa wbudowanych narzędzi

Wbudowane narzędzia deklaruje się dokładnie tak samo jak własne funkcje, ale są one wykonywane po stronie OpenAI. Praktyczny skutek jest przyjemny: nie piszesz dla nich żadnej pętli. Model wywołuje narzędzie, otrzymuje wynik i kontynuuje działanie, wszystko w ramach jednej rundy komunikacji. Pętla opisana powyżej dotyczy wyłącznie Twoich funkcji – tych uruchamianych na Twojej maszynie.

# Mieszanie narzędzi wbudowanych i niestandardowych
tools = [
    {"type": "web_search"},
    {"type": "code_interpreter", "container": {"type": "auto"}},
    {
        "type": "function",
        "name": "ma_fonction",
        "description": "My custom function",
        "parameters": {"type": "object", "properties": {}}
    }
]

Stabilne identyfikatory wywołań

Każde wywołanie funkcji otrzymuje unikalne call_id, które pozwala precyzyjnie śledzić, który wynik odpowiada któremu wywołaniu, nawet przy wywołaniach równoległych.

Uproszczony przepływ

Nie ma potrzeby ręcznego zarządzania rolami assistant i tool w wiadomościach. Pole input bezpośrednio akceptuje konkatenację poprzednich danych wyjściowych z wynikami funkcji.

Kiedy model wywołuje funkcję?

Model decyduje się na wywołanie funkcji, gdy żądanie użytkownika wymaga informacji, których model nie posiada, gdy opis funkcji odpowiada zidentyfikowanej potrzebie oraz gdy wymagane parametry można wywnioskować z kontekstu.

Trzy warunki muszą więc zostać spełnione jednocześnie, co jest przydatne podczas debugowania: gdy funkcja nie zostanie wywołana, mimo że powinna, przyczyną jest prawie zawsze ten drugi – opis, który nie obejmuje sposobu, w jaki użytkownik sformułował swoje żądanie. Parametr tool_choice pozwala wymusić zachowanie, gdy opis nie wystarcza:

# Pozwól modelowi zadecydować
tool_choice = "auto"

# Wymuś wywołanie konkretnej funkcji
tool_choice = {"type": "function", "name": "rechercher_client"}

# Zabroń wszystkich wywołań funkcji
tool_choice = "none"

# Wymagaj co najmniej jednego wywołania bez określania którego
tool_choice = "required"

Kluczowe wnioski

  • Wywoływanie funkcji to protokół intencji, a nie protokół wykonania
  • Pętla wywołaj-wykonaj-odślij jest wzorcem fundamentalnym
  • Narzędzia wbudowane i niestandardowe współistnieją w tej samej tablicy tools
  • call_id zapewnia śledzalność każdego wywołania
  • tool_choice pozwala precyzyjnie kontrolować zachowanie modelu