Przejdź do głównej treści

Samouczek API GPT-6 Astra: zbuduj agenta do sprawdzania wydań z async narzędziami i sterowaniem

Użyj GPT-6 Astra przez OpenAI API, by zbudować w Pythonie agenta do sprawdzania wydań z async narzędziami, kontrolą rozumowania, Structured Outputs i śledzeniem kosztów, a następnie przetestuj użycie komputera i sterowanie.
Zaktualizowano 7 wrz 2026  · 14 min Czytać

Eksploruj z AI

ChatGPTClaudePerplexity

Gdy pierwszy raz dałem GPT-6 Astra wolne narzędzie i szybkie w tej samej turze, spodziewałem się tradycyjnej pętli synchronicznej: poprosi o wolne narzędzie i zablokuje mój kod, podczas gdy wszyscy będą czekać. Dokumentacja OpenAI o asynchronicznym wywoływaniu narzędzi mówiła, że Astra może zamiast tego dalej pracować, ale nie byłem przekonany. Aplikacja i tak zarządza pracą w tle, więc asynchroniczne wywoływanie narzędzi nie usuwa orkiestracji. Pytanie brzmi, czy zmienia dość dużo, by miało to znaczenie.

Nasz przegląd GPT-6 Astra omawia premierę i benchmarki, a przewodnik GPT-6 Astra vs. Claude Fable 5.1 porównuje jej wydajność i ceny z największym konkurentem. W tym samouczku uruchomimy GPT-6 Astra do zbudowania workflowu sprawdzającego wydanie, z pakietem testów, endpointem health i stałym testem przeglądarkowym. Osobne dema obejmują modelowe użycie komputera i sterowanie w trakcie tury.

Omówimy, jak:

  • Wykonać wywołanie API GPT-6 Astra
  • Zbudować synchroniczną pętlę wywoływania narzędzi jako punkt odniesienia
  • Przełączyć wolne sprawdzenia na asynchroniczne wywoływanie narzędzi
  • Uruchomić ograniczony test użycia komputera
  • Porównać sterowanie z punktem odniesienia „zakończ-potem-wznów” przez WebSocket
  • Podnieść wysiłek rozumowania tylko dla finalnej diagnozy
  • Zwrócić zweryfikowany raport go/no-go z ustrukturyzowanymi wynikami
  • Poprawnie obliczyć koszt API, łącznie z zapisami do cache
  • Obserwować przebieg na żywo w Streamlit
  • Obsłużyć przypadki brzegowe, które tworzą zadania async

TL;DR

GPT-6 Astra dodaje trzy funkcje API do standardowej pętli Responses: asynchroniczne wywoływanie narzędzi, sterowanie w trakcie tury przez WebSocket i zmiany wysiłku rozumowania w trakcie rozmowy. Cztery wnioski z połączenia ich w jednego agenta do sprawdzania wydań zmieniły sposób, w jaki bym go budował.

  • Asynchroniczne wywoływanie narzędzi skróciło czas oczekiwania, nie pracę modelu: liczba tur nadal zależy od sekwencji wywołań modelu.
  • Sterowanie zajęło mniej czasu niż punkt odniesienia „zakończ-potem-wznów”, choć test nie porównywał każdej polityki wznawiania.
  • Wyższy wysiłek rozumowania niekoniecznie zmienia diagnozę, mimo że zużywa więcej tokenów rozumowania.
  • Równoległe uruchamianie sprawdzeń może ujawnić warunki wyścigu, które sekwencyjna wersja by ukryła.

Te wyniki dotyczą tego sprawdzenia wydania, a nie każdego obciążenia agenta. Czas działania narzędzi, współdzielony stan i liczba tur modelu mogą zmienić rezultat.

Czym jest API GPT-6 Astra?

API GPT-6 Astra to sposób dostępu do nowego flagowego modelu OpenAI, wydanego 3 września 2026 r., poprzez Responses API. W tym samouczku liczy się powierzchnia: gpt-6-astra przyjmuje tekst i obrazy przez Responses API OpenAI. Jego wysiłek rozumowania mieści się w zakresie od low do max, bez opcji none

Przykłady w tym samouczku używają client.responses.create zamiast client.chat.completions.create, ale migracja wymaga też zmian w formatach żądań, wyjścia i wyników narzędzi. Usuń ustawienia własne temperature, top_p i log-probability, ponieważ Astra ich nie obsługuje. Zanim wykonasz pierwsze wywołanie, spójrzmy na ceny.

Ile kosztuje GPT-6 Astra?

Dla żądań z maksymalnie 272 000 tokenów wejściowych standardowa cena to 10 USD za milion zwykłych tokenów wejściowych i 50 USD za milion tokenów wyjściowych. Wejście z cache kosztuje 1 USD za milion, a zapisy do cache 12,50 USD za milion. 

Po przekroczeniu tego progu OpenAI stosuje mnożnik 2× dla stawek wejścia i cache oraz 1,5× dla wyjścia. Wyższe stawki dotyczą całego żądania, nie tylko tokenów powyżej progu. Żaden z przebiegów w tym samouczku nie zbliżył się do progu.

Co zbudujemy z użyciem API GPT-6 Astra?

Aplikacja stagingowa to mała tablica zadań Flask: strona główna, formularz dodawania zadania, przycisk oznaczania ukończenia i endpoint /health. Kompletny kod, łącznie z aplikacją stagingową, znajdziesz w tym repozytorium GitHub.

Tablica zadań stagingowa sprawdzana przez agenta, z listą zadań i formularzem dodawania

Przed testem pojawiają się trzy zasiane zadania. Obraz: autor.

Aplikacja ma jedną zamierzoną usterkę. Agent ma trzy sprawdzenia, ale tylko pakiet testów jest zaprojektowany, by je wyłapać.

Dlaczego aplikacja akceptuje puste tytuły zadań?

Endpoint tworzenia zadania nie odrzuca pustego tytułu. Zostawiłem to zachowanie, żeby agent miał znaną usterkę do znalezienia, bez ujawniania jej w promptcie.

Jakie sprawdzenia wydań może uruchomić agent?

Agent może wywołać trzy narzędzia:

  • run_test_suite uruchamia pytest, w tym test masowego importu z ok. 250 żądaniami HTTP. 

  • check_ui_flow używa Playwright, aby dodać zadanie i potwierdzić, że się pojawia. 

  • check_staging_health wysyła żądanie GET do /health

Wszystkie trzy działają na stagingu, bez mocków. Test przeglądarkowy używa stałego kodu; demo modelowego użycia komputera będzie później.

Jak skonfigurować API GPT-6 Astra w Pythonie

Potrzebujesz klucza OpenAI API z dostępem do gpt-6-astra. Utwórz klucz na platform.openai.com/api-keys i sprawdź, czy twój projekt ma gpt-6-astra włączony. W przestrzeniach Enterprise Astra jest domyślnie wyłączona na starcie.

Poniższe polecenia używają Windows PowerShell i instalują wszystkie pakiety potrzebne do tego samouczka, w tym realtime OpenAI do dema sterowania.

python -m venv .venv
.venv\Scripts\Activate.ps1
Copy-Item .env.example .env
pip install "openai[realtime]" flask pytest playwright pydantic matplotlib python-dotenv streamlit
playwright install chromium

Na macOS lub Linuksie podmień polecenie aktywacji na source .venv/bin/activate oraz kopiowania na cp .env.example .env

Następnie dodaj klucz API do nowego pliku .env: Otwórz właśnie skopiowany plik .env i dodaj OPENAI_API_KEY=sk-..., który python-dotenv wczytuje, a SDK pobiera automatycznie, więc nigdy nie przekazujesz klucza w kodzie.

Jeśli zależności projektowe lub pliki .env są dla ciebie nowe, nasze przewodniki o wirtualnym środowisku i zmiennych środowiskowych je wyjaśniają. Potwierdź, że klucz działa, zanim na nim zbudujesz.

Jeśli twój klucz API już działa z Responses API, pomiń następną podsekcję i zacznij od synchronicznej pętli narzędzi. Pierwsze żądanie tylko weryfikuje konfigurację.

Wykonaj pierwsze wywołanie API GPT-6 Astra

Gdy klucz jest gotowy, trzeba go wczytać przez dotenv. Potem możesz utworzyć klienta OpenAI i wysłać pierwsze żądanie funkcją client.responses.create(). Najmniejsze możliwe żądanie wygląda tak:

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI()
response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    input="In one sentence, what is a staging environment used for?",
)
print(response.output_text)

Pole usage w odpowiedzi zawiera liczby tokenów potrzebne do późniejszego obliczenia kosztu.

Zbuduj synchroniczną pętlę narzędzi GPT-6 Astra

Poniższe fragmenty to wycinki; wersje uruchamialne są w dołączonym repozytorium GitHub.

Zanim dotknąłem czegokolwiek async, zbudowałem zwykłą wersję: 

  1. Wywołaj model

  2. Sprawdź, czy jest element function_call

  3. Uruchom pasujące narzędzie

  4. Odeślij wynik z previous_response_id

  5. Powtarzaj, aż model przestanie prosić o narzędzia. 

Ta blokująca pętla to punkt odniesienia dla porównania z async.

for turn in range(max_turns):
    response = client.responses.create(
        model="gpt-6-astra",
        reasoning={"effort": "low"},
        tools=TOOLS,
        input=next_input,
        previous_response_id=previous_response_id,
    )
    calls = [item for item in response.output if item.type == "function_call"]
    if not calls:
        final_text = response.output_text
        break
    outputs = [
        {"type": "function_call_output", "call_id": call.call_id, "output": run_tool(call)}
        for call in calls
    ]
    next_input, previous_response_id = outputs, response.id

Co znalazł przebieg bazowy

W przebiegu bazowym model wywołał każde narzędzie po kolei. Znalazł znaną usterkę walidacji i zwrócił decyzję „no-go”. W trzech przebiegach łączny czas zegarowy wyniósł średnio 23,40 sekundy. Ta średnia obejmuje cały przebieg, nie czasy poszczególnych narzędzi.

Jak działa asynchroniczne wywoływanie narzędzi w GPT-6 Astra?

Oznacz narzędzie jako "async": true w jego schemacie, a twoja aplikacja może odroczyć ten wynik, podczas gdy model albo kontynuuje pracę, albo czeka. Twoja aplikacja wciąż uruchamia narzędzie i zarządza zadaniem w tle.

Jak uruchamiać niezależne sprawdzenia współbieżnie

Oznaczyłem run_test_suite i check_ui_flow jako async i dodałem zdefiniowane w aplikacji narzędzie wait_for_tasks bez argumentów, bo to demo ma w danym momencie tylko jedną partię pracy w toku. To „czekanie” bez argumentów utrzymuje przykład w małej skali. 

W produkcyjnym runnerze identyfikuj zadania za pomocą uchwytów, powiąż każdy uchwyt z oryginalnym call_id i czekaj tylko wtedy, gdy następny krok zależy od oczekującego wyniku.

Zwróć każdy ukończony wynik na jego oryginalnym call_id, a potem zwróć status oczekiwania na własnym call_id narzędzia „wait”.

TOOLS = [
    {"type": "function", "name": "run_test_suite", "async": True, ...},
    {"type": "function", "name": "check_ui_flow", "async": True, ...},
    {"type": "function", "name": "check_staging_health", ...},
    {"type": "function", "name": "wait_for_tasks", ...},
]

W tym przebiegu aplikacja przesłała każde oznaczone wywołanie do puli wątków. Gdy sprawdzenia w tle działały, wykonała szybkie synchroniczne sprawdzenie health. Następnie zablokowała się na wait_for_tasks, aż oczekujące sprawdzenia się zakończyły.

Czy async skraca czas zegarowy?

W trzech przebiegach async zmniejszył średni czas zegarowy o 19,1%, z 23,40 s do 18,94 s. Średnia wyglądała prosto, dopóki nie przyszły wyniki poszczególnych przebiegów; wykres poniżej pokazuje faktyczną zmienność. Trzy przebiegi wystarczą, by pokazać, co tu zaszło, nie by przewidywać latencję produkcyjną.

Wykres liniowy porównujący sekundy czasu zegarowego dla trzech przebiegów sync i trzech async tego samego sprawdzenia wydania

Czasy przebiegów wahały się w obu trybach. Obraz: autor.

Dlaczego współbieżne sprawdzenia wywołały warunek wyścigu?

Równoczesne uruchomienie testu przeglądarkowego i testu masowego importu czasem powodowało niepowodzenie asercji masowego importu, bo oba sprawdzenia modyfikowały tę samą listę zadań w pamięci. To złamało założenie testu o wyłącznym dostępie. Izolacja danych w runnerze lub testach uniknęłaby wyścigu.

Ograniczone użycie komputera GPT-6 Astra do testów UI

W przypadku użycia komputera dokumentacja GPT-6 Astra zaleca wykonywanie kodu, podczas gdy ustrukturyzowane narzędzie computer pozostaje wspierane jako alternatywa. Przy wykonywaniu kodu jedno wywołanie może łączyć kilka akcji, pętle i warunki, natomiast narzędzie computer zwraca jedną ustrukturyzowaną akcję myszy lub klawiatury naraz, którą twoja aplikacja tłumaczy i odtwarza.

Jak ograniczyć runner użycia komputera

Nazwę nadałem BrowserSandbox, ale to określenie przecenia jego ochronę. Daje kodowi pisanym przez model obiekt Playwright page, funkcję log() i helper expect_text() . Python nadal może wstrzyknąć built-ins do exec(), a strona może przejść na inny origin.

sandbox_globals = {"page": self.page, "log": log, "expect_text": expect_text}
exec(code, sandbox_globals)

Traktuj to jako demo runner, nie granicę bezpieczeństwa. Kod pisany przez model potrzebuje odizolowanego procesu lub kontenera z ograniczeniami systemu plików, procesów, sieci i origin.

Co wydarzyło się w sprawdzeniu UI?

Ograniczyłem pętlę do ośmiu tur, bo ograniczone sprawdzenie potrzebuje twardego stopu. Model obejrzał stronę, znalazł pole formularza, utworzył tytuł „UI flow check, cobalt otter 73921”, przesłał zadanie i potwierdził, że tytuł się pojawił, co zajęło 13 sekund. Nasz samouczek użycia komputera GPT-5.4 omawia szczegółowy przykład z poprzednikiem Astry.

Jak działa sterowanie w trakcie tury w GPT-6 Astra?

Sterowanie w trakcie tury jest dostępne tylko dla gpt-6-astra przez połączenie WebSocket.

Otwórz połączenie i utwórz odpowiedź, a następnie wyślij zdarzenie response.steer z nowymi instrukcjami, gdy odpowiedź się generuje. Zdarzenie response.steer.accepted oznacza, że aktualizacja jest zakolejkowana, nie zastosowana. Zanim utworzy automatyczną kontynuację, serwer kończy bieżący element wyjścia i wszelką już uruchomioną hostowaną pracę narzędzia. 

Jeśli nadal potrzebuje wyniku narzędzia klienta lub zgody, response.steer.pending wskaże brakujące dane.

async with client.responses.connect() as connection:
    await connection.response.create(model="gpt-6-astra", input=TASK)
    async for event in connection:
        if event.type == "response.created" and initial_response_id is None:
            initial_response_id = event.response.id
            await asyncio.sleep(1.0)
            await connection.response.steer(
                previous_response_id=initial_response_id,
                input="Also add a rollback plan, but skip mobile.",
            )

Jednosekundowe opóźnienie odpowiada kodowi eksperymentu i daje pierwszej odpowiedzi czas na start. Bez tego opóźnienia testowałbyś inny punkt cyklu życia odpowiedzi.

Czego sterowanie w trakcie tury nie zmienia?

Sterowanie nie przepisuje oryginalnej odpowiedzi. Jeśli aktualizacja ją przerwie, ta odpowiedź kończy się z status: "incomplete" i incomplete_details.reason: "steered". Następca kontynuuje z nową instrukcją. 

Jeśli pierwsza odpowiedź skończy przed wejściem aktualizacji w życie, pozostaje ukończona. Sterowanie nie odwraca ani nie anuluje działań po stronie klienta, które już się rozpoczęły; twoja aplikacja wciąż za to odpowiada. Zakolejkowane sterowanie istnieje tylko na bieżącym połączeniu WebSocket, więc zapisz aktualizację przed próbą ponownego połączenia.

Ścieżka porównawcza pozwala pierwszej odpowiedzi skończyć, a następnie wysyła nowe żądanie ze skombinowanymi instrukcjami. W dwóch przebiegach sterowanie zajęło średnio 26,91 s wobec 50,02 s dla ścieżki „zakończ-potem-wznów”. To porównanie nie obejmuje polityki „anuluj i wznow” ani nie ocenia poprawności finalnego tekstu.

Dwa wykresy słupkowe porównujące średnie sekundy i średni koszt dla sterowania vs wznawiania

Średnie z dwóch przebiegów dla czasu i kosztu. Obraz: autor.

Ścieżka restartu generuje dwie pełne odpowiedzi, które pokrywają część tych samych żądań. To wyjaśnia część różnicy w czasie, więc nie traktowałbym tych dwóch przebiegów jako ogólnego benchmarku sterowania.

Jak zmieniać wysiłek rozumowania GPT-6 Astra w trakcie rozmowy

gpt-6-astra obsługuje wysiłek rozumowania od low do max. Wyższy wysiłek może zwiększyć użycie tokenów rozumowania, ale nie gwarantuje innej odpowiedzi. configuration_update zmienia kolejne odpowiedzi aż do nadpisania, podczas gdy ustawienie na poziomie żądania pozostaje bez zmian. 

W tym pipeline raport kończy rozmowę, więc aktualizacja dotyczy tylko tego finalnego kroku.

response = client.responses.create(
    model="gpt-6-astra",
    previous_response_id=previous_id,
    reasoning={"effort": "low"},  # default remains low
    input=[
        {"type": "configuration_update", "reasoning": {"effort": "high"}},
        {"role": "user", "content": "Diagnose the root cause and recommend a fix."},
    ],
)

Użyłem tego samego śladu błędu na obu poziomach wysiłku i porównałem diagnozę oraz użycie tokenów.

Jedna subtelność: pole reasoning.effort w odpowiedzi wciąż raportuje ustawienie na poziomie żądania, a nie wysiłek wybrany przez configuration_update. Nie używaj tego pola do sprawdzania, czy aktualizacja zadziałała.

Czy wysoki wysiłek rozumowania zmienił diagnozę?

W pełnym połączonym przebiegu eskalowany krok użył 108 tokenów rozumowania. Każdy inny krok na low użył zera. We wcześniejszym odizolowanym teście z dłuższym śladem błędu, niski wysiłek użył zera, a wysoki 318 tokenów. Obie wersje zidentyfikowały błąd walidacji, więc wyższy wysiłek zmienił użycie tokenów, ale nie diagnozę.

Aktualizacje konfiguracji działają tylko w standardowych, jednoagentowych żądaniach. API odrzuca sąsiadujące aktualizacje i nie można ich łączyć z automatyczną kompakcją ani automatycznym ucinaniem.

Jak używać ustrukturyzowanych wyników GPT-6 Astra

Ostatni krok pipeline wywołuje client.responses.parse, by zastąpić wolny tekst zweryfikowanym modelem Pydantic.

class GoNoGoReport(BaseModel):
    decision: str
    summary: str
    checks_completed: list[str]
    failures: list[str]
    risks: list[str]
    follow_up_actions: list[str]
    confidence: float

response = client.responses.parse(
    model="gpt-6-astra",
    previous_response_id=previous_id,
    text_format=GoNoGoReport,
    input=[...],
)

Pydantic sprawdza typy pól zadeklarowane tutaj. Nie dowodzi, że raport zgadza się z dowodami, i ta wersja nie ogranicza decision do dwóch wartości ani confidence do zakresu.

Co wychwycił raport go/no-go?

Raport zwrócił decision: "no_go". Sklasyfikował wspomnianą wcześniej usterkę walidacji pod failures i problem współbieżności pod risks. Dla tego drugiego napisał: „możliwa interferencja z równoczesnych testów UI na współdzielonych danych stagingowych”. Prompt nie nazwał tego ryzyka.

Trzymaj latencję i koszt poza tym schematem i licz je w kodzie. Model wypełnia pola raportu na podstawie dowodów z narzędzi.

Interfejs Streamlit korzysta z tego samego generatora co runner wiersza poleceń. Renderuje każde zdarzenie narzędzia na bieżąco, a potem pokazuje sparsowany raport w kartach Raport i JSON.

Postęp agenta na żywo obok finalnego raportu. Wideo: autor.

Pulpit uruchamia połączony asynchroniczny pipeline wydania ze stałym testem przeglądarkowym, aktualizacją rozumowania, ustrukturyzowanym raportem i wyświetlaniem czasu. Panel kosztów czyta ten sam rejestr co runner CLI. Nie uruchamia osobnych dem użycia komputera pisanych przez model ani sterowania.

Jak śledzić użycie tokenów i koszt API GPT-6 Astra

W części dotyczącej tokenów modelu pole usage zawiera cztery liczby tokenów potrzebne do wyceny każdej odpowiedzi. Zapisy do cache mają własną stawkę, więc nie grupuj ich ze zwykłym wejściem. Narzędzia tutaj działają w twojej aplikacji; jeśli dodasz hostowane narzędzie z osobną opłatą, uwzględnij ją również.

details = usage.input_tokens_details
cached_tokens = details.cached_tokens
cache_write_tokens = details.cache_write_tokens
ordinary_tokens = usage.input_tokens - cached_tokens - cache_write_tokens

cost = (
    ordinary_tokens * PRICE_INPUT
    + cached_tokens * PRICE_CACHED_INPUT
    + cache_write_tokens * PRICE_CACHE_WRITE
    + usage.output_tokens * PRICE_OUTPUT
) / 1_000_000

To wyliczenie obejmuje jedną odpowiedź. Rejestr stosuje je po każdej odpowiedzi, a potem sumuje wartości wywołań.

Loguj cache_write_tokens nawet gdy wartość wynosi zero. W przeciwnym razie przyszły zapis do cache może ukryć się w liczbie zwykłego wejścia, a to irytujący sposób na wykrycie błędu rozliczeń.

Uwagi produkcyjne dla agenta GPT-6 Astra

Demo potrzebuje tych zmian, zanim będzie mogło blokować wdrożenia.

Uprawnienia i izolacja narzędzi

Utrzymaj granicę stagingu i odizoluj BrowserSandbox jak wyżej. Nie dawaj mu poświadczeń do bazy ani dostępu do produkcji.

Cykl życia zadań async

W demo każde oczekujące zadanie się kończy i nic innego go nie dotyka. Runner wdrożony musi przetrwać przypadki, gdy żadne z powyższych nie jest prawdą. Potrzebuje, dla każdego oczekującego wpisu:

  • Terminu i stanu końcowego, by nic nie wisiało w nieskończoność
  • Flagi dostarczenia, by callback i retry nie wysłały dwa razy tego samego wyniku
  • Znaczników czasu startu i zakończenia, by odróżnić timeout od spóźnionego, ale poprawnego ukończenia
  • Odrzucania zduplikowanych wywołań, by to samo zadanie nie zostało uruchomione dwa razy
  • Obsługi błędów w wątkach w tle, by rzucony wyjątek nie zniknął w puli
  • Anulowania, czyli zignorowania spóźnionego wyniku i zatrzymania zewnętrznej pracy już w toku

Sterowanie i działania nieodwracalne

Sterowanie może zmienić przyszłe instrukcje, ale nie cofnie zakończonego efektu ubocznego. Jeśli narzędzie już zmieniło system zewnętrzny, osobne działanie narzędzia musi to skompensować.

Monitorowanie misalignementu

Automatyczne zatrzymywanie dotyczy żądań Responses API, które używają utrwalonego rozumowania, WebSocketów lub kompakcji OpenAI. Inne żądania mogą wyzwalać alerty, ale nie są automatycznie zatrzymywane. 

Przed strumieniowaniem monitorowanie misalignementu może zablokować objęty przebieg kodem HTTP 403 i kodem misalignment_policy_violation. Klient strumieniujący może zamiast tego otrzymać błąd po rozpoczęciu wyjścia. API nie zapewnia ogólnej ścieżki wznowienia zatrzymanej rozmowy.

Lista kontrolna wdrożenia agenta GPT-6 Astra

Zanim przeniesiesz tego agenta z lokalnego demo do wdrożenia, dodaj te mechanizmy. Należą do kodu aplikacji, a nie do instrukcji modelu.

  • Ustaw jawne timeouty dla wywołań HTTP aplikacji stagingowej i połączenia WebSocket

  • Loguj zwykłe wejście, wejście cache, zapisy cache, wyjście, ID odpowiedzi i liczbę tur

  • Alarmuj o niekompletnych przebiegach lub takich, które osiągnęły limit tur. Ustaw osobny alert dla przekroczeń budżetu

  • Przypnij wersję SDK openai i sprawdź ponownie zachowanie async, sterowania i configuration_update przed aktualizacją

Kiedy używać async narzędzi lub sterowania w GPT-6 Astra?

Wybierz najprostsze podejście, które pasuje do zadania.

  • Zacznij od żądania synchronicznego i ustrukturyzowanych wyników, gdy narzędzia zwracają szybko, a wymagania są stałe.
  • Dodaj asynchroniczne wywoływanie narzędzi, gdy model lub inne narzędzie mogą wykonać pożyteczną pracę podczas wolnego wywołania, a oszczędność czasu uzasadnia dodatkową obsługę zadań.
  • Użyj sterowania w trakcie tury, gdy wymagania zmieniają się podczas przebiegu.

Podsumowanie

Synchroniczne sprawdzenie wydania stało się bardziej użyteczne, gdy można było nałożyć wolne narzędzia, choć nie był to czysty wygrany. W trzech przebiegach async zmniejszył średni czas z 23,40 s do 18,94 s, a potem ujawnił wyścig na współdzielonym stanie, który sekwencyjna pętla ukryła. 

Odizolowałbym przeglądarkę i dane testowe, rutynowe tury trzymał na low, a wysiłek rozumowania podnosił tylko wtedy, gdy dowody wymagają bliższego spojrzenia. Jeśli narzędzia kończą szybko, a wymagania są stałe, zatrzymaj się na synchronicznej pętli z ustrukturyzowanymi wynikami. Używaj async, gdy można nałożyć niezależną pracę, i sterowania, gdy instrukcje zmieniają się podczas odpowiedzi.

Jeśli chodzi o podstawy API, polecam nasz kurs Working with the OpenAI API. W przypadku większych systemów agentowych zobacz kurs Building Scalable Agentic Systems.

FAQs

Czy mogę używać Chat Completions z GPT-6 Astra?

Dla czystego tekstu tak. Dla wywoływania narzędzi nie: Astra wymaga Responses API, więc każdy przykład tutaj używa client.responses.create.

Które modele obsługują async wywoływanie narzędzi i sterowanie?

Asynchroniczne wywoływanie narzędzi wprowadzono wraz z GPT-6 Astra. Sterowanie w trakcie tury jest wyłącznie dla Astry i wyłącznie przez WebSocket; GPT-5.6 i wcześniejsze w ogóle go nie obsługują.

Co się psuje, gdy przełączam istniejące żądanie na gpt-6-astra?

Trzy rzeczy. reasoning.effort: "none" zwraca HTTP 400, więc zacznij od low. Ustawienia temperature, top_p i log-probability muszą zniknąć. A wywoływanie narzędzi musi przejść do Responses, jeśli jeszcze tam nie jest.

Czy async wywoływanie narzędzi zastępuje równoległe wywołania narzędzi?

Nie, rozwiązują różne problemy. Równoległe wywołania narzędzi pozwalają modelowi poprosić o kilka narzędzi w jednej turze; async pozwala twojej aplikacji odroczyć wynik jednego narzędzia, podczas gdy model idzie dalej.

Dlaczego moje async wywołanie narzędzia zakończyło się błędem braku function_call_output?

Ten błąd może wystąpić, gdy nieasynchroniczne wywołanie narzędzia w tej samej partii nie zostało rozstrzygnięte. Async odracza tylko oznaczone wywołanie; każde inne wciąż potrzebuje najpierw wyjścia.

Czy async wywoływanie narzędzi wymaga WebSocketów?

Nie. Implementacja async powyżej używa zwykłych wywołań Responses API.

Czy błąd pustego tytułu został kiedykolwiek złapany przez test UI zamiast pakietu testów?

Nie. Tylko pakiet testów sprawdzał walidację pustego tytułu; testy UI i health sprawdzały inne zachowania.

Dlaczego używamy previous_response_id w pętli narzędzi?

Łączy każdy wynik narzędzia z odpowiedzią, która o niego prosiła. Pętla może kontynuować tę samą rozmowę w Responses API bez odsyłania pełnej transkrypcji w każdym wywołaniu.

Tematy
Sztuczna inteligencja
Duże modele językowe
Agenci AI

Ucz się AI z DataCamp!

Track

Inżynier AI Associate dla programistów

26 godz.
Dowiedz się, jak integrować AI z aplikacjami software’owymi za pomocą API i bibliotek open source. Rozpocznij swoją drogę do zostania inżynierem AI już dziś!
Zobacz szczegółyRight Arrow
Rozpocznij Kurs
Zobacz więcejRight Arrow