Source: https://ailoot.ai/models/cs/openai-gpt-5-image/ Canonical: https://ailoot.ai/models/cs/openai-gpt-5-image/ Language: cs # OpenAI: GPT-5 Image [Markdown](https://ailoot.ai/models/cs/openai-gpt-5-image/index.md) · [JSON](https://ailoot.ai/models/cs/openai-gpt-5-image/facts.json) ## [OpenAI: GPT-5 Image](https://ailoot.ai/models/cs/openai-gpt-5-image/) GPT-5 Image spojuje jazykové a uvažovací schopnosti GPT-5 od OpenAI s GPT Image 1 pro generování obrázků a úpravy podle referencí. Přijímá text, obrázky a dokumenty a vrací text i obrázky, čímž propojuje písemné zadání s vizuálním výsledkem. - [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-5-image`](https://ailoot.ai/models/cs/openai-gpt-5-image/#method-0) - [**Ailoot Ultra · Obrázky** `POST /v1/images/generations` `openai/gpt-5-image`](https://ailoot.ai/models/cs/openai-gpt-5-image/#method-1) - [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `openai/gpt-5-image`](https://ailoot.ai/models/cs/openai-gpt-5-image/#method-2) O modelu Tento popis zahrnuje schopnosti modelu. Vstupy, výstupy a možnosti dostupné v Ailoot jsou uvedeny níže pro vybranou metodu. GPT-5 Image je kombinovaný profil, který spojuje jazykový model GPT-5 od OpenAI s GPT Image 1. Jazyková složka interpretuje požadavky a zdrojový materiál; obrazová složka vytváří vizuální výsledek. Zveřejněný popis zdůrazňuje uvažování, dodržování pokynů, vykreslování textu a podrobné úpravy obrázků. Profil se hodí pro úlohy, ve kterých mají vizuální podklad a jeho slovní výklad sledovat stejné zadání. #### Interpretujte zadání a vytvořte podklad Sdělte modelu účel obrázku, cílové publikum a obsah, který se musí objevit. Oddělte fakta, jež je třeba zobrazit přesně, od volby kompozice nebo vizuálního zpracování. Zadání diagramu může určit prvky a vztahy a poté uvést popisky, uspořádání a styl. Zadání plakátu může definovat informace o akci, hierarchii a scénu spolu s přesným zněním textu, který má být ve vizuálu. Například připravte koncept plakátu pro komunitní vědeckou akci. Dodejte fakta o akci, požádejte o krátké vysvětlení rozvržení a o obrázek s jasným titulkem a podpůrnými vizuálními prvky. Určete, která slova mají být v obrázku a která patří pouze do doprovodného popisu. Posuzujte písemné vysvětlení a vygenerovaný plakát společně, abyste smysluplný plán rozvržení porovnali se skutečně viditelným výsledkem. Dokumentace kombinovaného profilu uvádí jako vstupy text, obrázky a soubory, například PDF. Dokument může dodat požadavky na vizuál nebo informace určené ke shrnutí. Referenční obrázky mohou určit hlavní námět, produkt, místo nebo rozvržení. Před popisem cíle pojmenujte každý zdroj a vysvětlete jeho roli, zvláště pokud reference obsahuje jak prvky k zachování, tak prvky ke změně. #### Úpravy podle referencí a vykreslování textu Při revizi určete zdrojový obrázek a přesně popište požadovanou změnu. Úprava produktové scény může změnit prostředí a přitom zachovat tvar výrobku i viditelné označení. Vizuální vysvětlení může nahradit jeden prvek a ponechat okolní vztahy. Uveďte v zadání požadavky na zachování a na skutečném obrázku zkontrolujte důležité detaily. Karta tohoto konkrétního kombinovaného profilu povoluje při úpravách až šestnáct referenčních obrázků. Vybírejte reference související s úlohou a vysvětlete, jaké rysy každá přináší. Pokud několik obrázků ukazuje různé osvětlení, pohledy nebo zpracování, určete cílovou kompozici, místo abyste požadovali, aby každý zdroj výsledku dominoval. Uchovejte zdroje společně s dokončeným obrázkem, aby pozdější oprava mohla odkazovat na stejný materiál. Zveřejněný profil zahrnuje mezi schopnosti vykreslování textu. U důležitého textu dodejte přesné znění, interpunkci a umístění a určete jeho vztah k objektům nebo dalším popiskům. Ve vráceném obrázku zkontrolujte každé požadované slovo a číslo při zamýšlené velikosti zobrazení. U diagramu také ověřte, že čáry, polohy a seskupení vyjadřují vztah popsaný v písemném zdroji. #### Kontext a podoba odpovědi Kombinovaný profil uvádí kontextové okno 400 000 tokenů a až 128 000 tokenů dokončení. Tyto limity popisují vstup a generované dokončení, nikoli konkrétní rozměr v pixelech nebo počet obrázků. Využijte kontext pro relevantní požadavky, reference a stav konverzace a ponechte prostor pro požadovaný výstup. Označte dlouhé zdrojové materiály, aby model mohl přiřadit každý pokyn ke správné pasáži. Dokumentovaný kontrakt textového výstupu podporuje strukturované výsledky prostřednictvím schématu JSON. Písemná odpověď může definovat pole potřebná k popisu konceptu, shrnutí požadavku nebo určení požadované změny. Před použitím v aplikaci ověřte tato pole a jejich hodnoty vůči zdroji. Kombinovaný profil nezpřístupňuje volání aplikačních funkcí, přestože uvedené spojení jazykové a obrazové složky provádí vizuální generování interně. Schéma chatového požadavku umožňuje zvolit textovou i obrazovou výstupní modalitu. Uveďte v zadání skutečně požadované textové a vizuální výstupy a poté zkontrolujte, že dokončená odpověď obsahuje obojí. Konfigurace obrázků je specifická pro konkrétní model a rozhraní. Uchovejte přijatá nastavení s požadavkem a používejte pouze ovládací prvky dokumentované pro daný kombinovaný profil; přímé rozhraní obrazové složky může mít jiné uspořádání polí a schopností. #### Používejte uvedené spojení cíleně Obrazovou složkou uvedenou pro tento profil je GPT Image 1. Jeho přímý profil pro generování obrázků zpracovává obrazově zaměřené úlohy, zatímco GPT-5 Image tuto schopnost spojuje s jazykovým zpracováním GPT-5. GPT-5 Image Mini je samostatné spojení GPT-5 Mini a GPT Image 1 Mini. Uchovejte identitu vybraného profilu se zdrojovým materiálem a nastavením výstupu, místo abyste podobně pojmenovaná spojení považovali za stejný model. V konverzaci s několika revizemi přenášejte relevantní písemné požadavky a odkazy na zdroje. V nejnovějším zadání určete konkrétní opravu, například přesunutí popisku, změnu objektu nebo zjednodušení kompozice. Pokud je už ve vráceném podkladu patrná užitečná změna, vyhněte se neurčitému požadavku, aby se všechno zlepšilo. #### Uchovejte a zkontrolujte dokončený výsledek Uchovejte písemnou odpověď a každý skutečný obrazový soubor dodaný v dokončení. Uložte obrázky v oznámeném formátu spolu s promptem, zdrojovými referencemi a vybraným nastavením. Na samotném obrázku zkontrolujte kompozici, detaily hlavního námětu a text; doprovodný text porovnejte s důkazy, které popisuje. Užitečný dokončený výsledek propojuje písemné požadavky s vizuálem, který lze otevřít, zkontrolovat a vložit do zamýšleného dokumentu, stránky nebo tvůrčího procesu. Praktická úloha ### Praktická úloha Technický příklad v angličtině ``` Simplify a community-event poster Edit the supplied community science poster. Preserve the exact event title, date, venue and central telescope illustration. Remove the small decorative stars around the footer, increase the empty space around the title and keep the original portrait layout and two-color palette. Add no new event facts or text. Return the revised poster image. ``` #### Očekávaný výsledek ``` A revised poster image retaining all event wording and the telescope while simplifying the requested areas. ``` #### Ověření výsledku ``` Check every event word and number against the source and confirm that only the named decorative elements were removed. ``` **Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-5-image` [`openai/gpt-5-image`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5-image&route=Ultra&caller=openai%2Fgpt-5-image&fmt=chat) OpenAI /`openai/gpt-5-image` ### Úvod GPT-5 Image spojuje jazykové a uvažovací schopnosti GPT-5 od OpenAI s GPT Image 1 pro generování obrázků a úpravy podle referencí. Přijímá text, obrázky a dokumenty a vrací text i obrázky, čímž propojuje písemné zadání s vizuálním výsledkem. Přijímané vstupy Text Výsledky Text ### Dostupné v Ailoot · vstupy a metody **Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` Vstup `text` Výstup `text` Výstupní formát json nebo SSE | Pole | Typ | Požadavek | Hodnoty a limity | Výchozí | | --- | --- | --- | --- | --- | | Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity openai/gpt-5-image | Výchozí— | | Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— | | Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— | | Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— | | Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— | | Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— | | Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— | | Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— | | Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— | | Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— | | Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse | | Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity function Závisí na modelu | Výchozí— | | Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— | | Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— | | Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— | | Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— | | Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— | | Pole`modalities` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity text | Výchozí— | | Pole`provider` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Podmínky: provider.options je na této textové trase Ultra odmítáno | Výchozí— | | Pole`cache_control.ttl` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Podmínky: Hodnota 1h je ve skutečných umístěních mezipaměti promptů odmítána | Výchozí— | Kombinace vstupních materiálů **Text** · text UTF8 `messages[].content` Parametry a životní cyklus metody | Parametr | Kontrakt | | --- | --- | | Parametr`content_type` | Kontraktapplication/json | | Parametr`required` | Kontraktmodel, messages | | Parametr`material_types` | Kontrakttext | | Parametr`messages` | Kontraktpole zpráv se strukturou role/content | | Parametr`file_material` | Kontraktskutečný dokument UTF-8 vložený jako doslovný text; ID souboru se neodvozuje | | Parametr`optional_controls` | Kontraktstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice | | Parametr`control_scope` | Kontraktspecifické pro model; nástroje uživatelských funkcí se liší od hostovaných nástrojů | | Parametr`output_modalities` | Kontrakttext | | Parametr`hosted_operations` | Kontraktfalse | | Parametr`multimodal_input_binding` | Kontraktnull | Životní cyklus: `synchronous_or_streamed` Odešlete přesné ID modelu spolu s messages. Délka kontextu není limitem výstupu. Textový soubor může dodat doslovný text; obrazové/zvukové vstupy a vstupy v podobě souborových objektů vyžadují přesnou vazbu. ### Tarify Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody. Rychlý režim Standardní sazba Při výběru rychlého režimu Režim flex Standardní sazba Při výběru režimu flex Maximální intenzita uvažování Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default) #### Sazby Ailoot #### Ceny podle konfigurace Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu. | Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek | | --- | --- | --- | --- | --- | | KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0025** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů Výstup · Tokeny výstupního obrázku **$0.08** / 1K obrazových tokenů | | KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0025** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů | #### Podrobnosti referenčního tarifu Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot. OpenAI: GPT-5 Image #### Ceny podle konfigurace | Konfigurace | Podmínky účtování | Poplatek | | --- | --- | --- | | KonfiguraceOpenAI: GPT-5 Image · Výchozí konfigurace | Podmínky účtováníVýchozí konfigurace | Poplatek Vstup · Vstupní tokeny **0,02 US$** / 1K tokenů Výstup · Výstupní tokeny **0,02 US$** / 1K tokenů Výstup · Výstupní obrázek **0,08 US$** / 1K tokenů Výstup · Vyhledávání na webu **0,02 US$** za vyhledání Vstup · Čtení z mezipaměti **0,0025 US$** / 1K tokenů | Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/) ### Příklady požadavků #### Ailoot Ultra · OpenAI Chat curlPython SDKStreamování v Pythonu ```bash set -eu : "${AILOOT_API_KEY:?Set your Ailoot API key}" python3 - <<'PY_REQUEST' import json,os from pathlib import Path p=json.loads('{"model": "openai/gpt-5-image", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}') Path("request.json").write_text(json.dumps(p,ensure_ascii=False)) PY_REQUEST curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \ -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \ --data-binary @request.json -D response-headers.txt -o result.json python3 - <<'PY_RESULT' import json from pathlib import Path r=json.loads(Path("result.json").read_text()) for x in r.get("choices",[]): if x.get("message",{}).get("content"): print(x["message"]["content"]) PY_RESULT ``` ```python from openai import OpenAI import os if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request") client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0) result=client.chat.completions.create(model='openai/gpt-5-image',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) import base64, json from pathlib import Path def save_result(data, stem="result"): # Keep every field, including usage, IDs, reasoning and tool requests. Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") print(json.dumps(data, ensure_ascii=False, indent=2)) def save_blob(encoded, suffix, label): raw = base64.b64decode(encoded, altchars=b"-_", validate=True) ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix file = Path(stem + "-" + label + "." + ext) file.write_bytes(raw) print("Saved", file) for index, block in enumerate(data.get("content") or []): print("Content", index, json.dumps(block, ensure_ascii=False)) for choice in data.get("choices") or []: print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False)) for index, item in enumerate(data.get("output") or []): print("Output", index, json.dumps(item, ensure_ascii=False)) if item.get("type") == "image_generation_call" and item.get("result"): save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index)) for ci, candidate in enumerate(data.get("candidates") or []): for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []): print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False)) blob = part.get("inlineData") or part.get("inline_data") if blob and blob.get("data"): mime = blob.get("mimeType") or blob.get("mime_type") suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin") save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi)) save_result(result.to_dict(mode="json")) ``` ```python from openai import OpenAI import os from pathlib import Path if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request") client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0) import base64, json from pathlib import Path def save_result(data, stem="result"): # Keep every field, including usage, IDs, reasoning and tool requests. Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") print(json.dumps(data, ensure_ascii=False, indent=2)) def save_blob(encoded, suffix, label): raw = base64.b64decode(encoded, altchars=b"-_", validate=True) ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix file = Path(stem + "-" + label + "." + ext) file.write_bytes(raw) print("Saved", file) for index, block in enumerate(data.get("content") or []): print("Content", index, json.dumps(block, ensure_ascii=False)) for choice in data.get("choices") or []: print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False)) for index, item in enumerate(data.get("output") or []): print("Output", index, json.dumps(item, ensure_ascii=False)) if item.get("type") == "image_generation_call" and item.get("result"): save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index)) for ci, candidate in enumerate(data.get("candidates") or []): for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []): print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False)) blob = part.get("inlineData") or part.get("inline_data") if blob and blob.get("data"): mime = blob.get("mimeType") or blob.get("mime_type") suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin") save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi)) with client.chat.completions.stream(model='openai/gpt-5-image',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream: with Path("stream-events.jsonl").open("w",encoding="utf-8") as log: for event in stream: payload=event.to_dict(mode="json") log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush() print(json.dumps(payload,ensure_ascii=False)) final=stream.get_final_completion() save_result(final.to_dict(mode="json"),"stream-result") ``` ### Přijímání a ukládání výsledků #### Ailoot Ultra · OpenAI Chat json nebo SSE ##### Uchovejte všechny dokončené výsledky Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu. Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití. ##### Pokud je nutné ověřit původní odpověď Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy. Pole odpovědi | Pole | Typ | | --- | --- | | Pole`choices[].index` | Typinteger | | Pole`choices[].message.content` | Typstring\|null | | Pole`choices[].message.tool_calls` | Typtool\_call\[\] | | Pole`choices[].message.reasoning_content` | Typstring | | Pole`choices[].message.reasoning_details` | Typobject\|array | | Pole`choices[].finish_reason` | Typstring\|null | | Pole`usage` | Typobject | Chyby a další kroky | Odpověď | Podmínka | Další krok | | --- | --- | --- | | Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. | ### Aliasy #### Aliasy modelu **Ailoot Ultra** [`openai/gpt-5-image`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5-image&route=Ultra&caller=openai%2Fgpt-5-image&fmt=chat) #### Aliasy cest metod `/v1/images` #### Související ID modelů [`openai/gpt-5-image`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5-image&route=Ultra&caller=openai%2Fgpt-5-image&fmt=chat) **Ailoot Ultra · Obrázky** `POST /v1/images/generations` `openai/gpt-5-image` [`openai/gpt-5-image`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5-image&route=Ultra&caller=openai%2Fgpt-5-image&fmt=images) OpenAI /`openai/gpt-5-image` ### Úvod GPT-5 Image spojuje jazykové a uvažovací schopnosti GPT-5 od OpenAI s GPT Image 1 pro generování obrázků a úpravy podle referencí. Přijímá text, obrázky a dokumenty a vrací text i obrázky, čímž propojuje písemné zadání s vizuálním výsledkem. Přijímané vstupy Text · Obrázky Výsledky Obrázky ### Dostupné v Ailoot · vstupy a metody **Ailoot Ultra · Obrázky** `POST /v1/images/generations` Vstup `text`, `image` Výstup `image` | Pole | Typ | Požadavek | Hodnoty a limity | Výchozí | | --- | --- | --- | --- | --- | | Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity openai/gpt-5-image | Výchozí— | | Pole`prompt` | Typ`string` | PožadavekPovinné | Hodnoty a limity Minimální délka: 1 | Výchozí— | | Pole`aspect_ratio` | Typ`string` | PožadavekVolitelné | Hodnoty a limity 1:1, 3:2, 2:3, auto | Výchozí— | | Pole`quality` | Typ`string` | PožadavekVolitelné | Hodnoty a limity auto, low, medium, high | Výchozí— | | Pole`background` | Typ`string` | PožadavekVolitelné | Hodnoty a limity auto, transparent, opaque | Výchozí— | | Pole`n` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Maximum: 10 | Výchozí— | | Pole`input_references` | Typ`array` | PožadavekVolitelné | Hodnoty a limity Minimální počet položek: 0 Maximální počet položek: 16 | Výchozí— | | Pole`output_compression` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 0 Maximum: 100 | Výchozí— | | Pole`provider` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— | Parametry a životní cyklus metody | Parametr | Kontrakt | | --- | --- | | Parametr`content_type` | Kontraktapplication/json | | Parametr`required` | Kontraktmodel, prompt | | Parametr`material_types` | Kontrakttext, image | Životní cyklus: `synchronous_result_then_owned_library` `GET /v1/media/tasks/{task_id}` · skutečně vrácené task\_id nebo záznam v knihovně médií `GET /v1/media/assets/{asset_id}/content` `GET /v1/media/assets` `GET /v1/media/assets/{asset_id}` ### Tarify ##### Jak se vypočítá konečný poplatek Zobrazené sazby slouží k odhadu ceny před generováním. Konečný poplatek se vypočítá z nákladů zaznamenaných u původního generování. Naměřená délka výstupu ani odhadovaná množství nejsou konečným účtovaným množstvím. Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody. Rychlý režim Neuvedeno Při výběru rychlého režimu Režim flex Neuvedeno Při výběru režimu flex Maximální intenzita uvažování Neuvedeno Když se při maximální intenzitě uvažování použije výchozí úprava (default) #### Odhadované sazby pro srovnání #### Ceny podle konfigurace Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu. | Konfigurace | Tabulka sazeb | Předpokládané množství | Poplatek | | --- | --- | --- | --- | | KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Předpokládané množství— | Poplatek Vstup · Vstupní tokeny · Odhad pouze pro srovnání **—** / 1K tokenů Výstup · Výstupní tokeny · Odhad pouze pro srovnání **—** / 1K tokenů Vstup · Čtení z mezipaměti · Odhad pouze pro srovnání **—** / 1K tokenů Vstup · Zápis do mezipaměti · Odhad pouze pro srovnání **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina · Odhad pouze pro srovnání **—** / 1K tokenů | | KonfiguraceOdhadovaná cena generování | Tabulka sazeb— | Předpokládané množstvíodhad pro jedno generování | Poplatek Výstup · Odhadovaná cena generování · Odhad pouze pro srovnání **$0.32768** odhad před generováním Tento odhad není dodatečným poplatkem ani pevnou sazbou za dokončené generování. | Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/) ### Příklady požadavků #### Ailoot Ultra · Obrázky curl ```bash set -eu : "${AILOOT_API_KEY:?Set your Ailoot API key}" export AILOOT_API_KEY python3 - <<'PY_REQUEST' import json,os from pathlib import Path p={'model': 'openai/gpt-5-image', 'prompt': 'a red panda astronaut floating in space, studio lighting'} Path("request.json").write_text(json.dumps(p,ensure_ascii=False)) PY_REQUEST curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/images/generations \ -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \ --data-binary @request.json -D response-headers.txt -o result.json python3 - <<'PY_RESULT' import base64, json, os, subprocess from pathlib import Path from urllib.parse import urlsplit, urljoin def save_images(items): if not items: raise SystemExit("No completed images; retain the full response") for index, item in enumerate(items): encoded=item.get("b64_json") uri=item.get("url", "") if not encoded and uri.startswith("data:image/"): header, separator, encoded=uri.partition(",") if not separator or ";base64" not in header: raise SystemExit("Unsupported image data URI") if encoded: raw=base64.b64decode(encoded,validate=True) elif uri: uri=urljoin("https://api.ailoot.ai",uri) parsed=urlsplit(uri) if parsed.scheme!="https" or not parsed.netloc or parsed.username or parsed.password: raise SystemExit("Invalid returned image URL") owned=parsed.netloc=="api.ailoot.ai" and parsed.path.startswith("/v1/media/assets/") and parsed.path.endswith("/content") args=["curl","--fail-with-body","--silent","--show-error",uri] if owned: args += ["-H","Authorization: Bearer "+os.environ["AILOOT_API_KEY"]] temporary=Path(f"image-{index}.bin") subprocess.run(args+["-o",str(temporary)],check=True) raw=temporary.read_bytes() temporary.unlink() else: raise SystemExit("Image has neither bytes nor URL") if not raw: raise SystemExit("Empty image result") ext="png" if raw.startswith(b"\x89PNG") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else "svg" if raw.lstrip().startswith((b"