Source: https://ailoot.ai/models/cs/gpt-6-1-sol/
Canonical: https://ailoot.ai/models/cs/gpt-6-1-sol/
Language: cs
# OpenAI: GPT-6.1 Sol
[Markdown](https://ailoot.ai/models/cs/gpt-6-1-sol/index.md) · [JSON](https://ailoot.ai/models/cs/gpt-6-1-sol/facts.json)
## [OpenAI: GPT-6.1 Sol](https://ailoot.ai/models/cs/gpt-6-1-sol/)
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `gpt-6.1-sol`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-0)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `gpt-6.1-sol`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-1)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `gpt-6.1-sol`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-2)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `gpt-6.1-sol`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-3)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `gpt-6.1-sol`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-4)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-5)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-6)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-7)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/gpt-6-1-sol/#method-8)
O modelu
Tento popis zahrnuje schopnosti modelu. Vstupy, výstupy a možnosti dostupné v Ailoot jsou uvedeny níže pro vybranou metodu.
#### Složitý kód a odborné materiály
GPT-6.1 Sol je model OpenAI pro složité programování, interakci s počítačovým rozhraním a odbornou práci. Přijímá text a obrázky a vrací text. Jeho účel zahrnuje úlohy, v nichž je potřeba propojovat uvažování s postupnými akcemi a zohledňovat získané výsledky.
Model podporuje streamovaný a strukturovaný výstup. Odpověď lze získávat průběžně a pro následné zpracování zadat určité položky a datové typy. Schopnost vizuálního vstupu slouží analýze obrázků; přímý výsledek zůstává textový.
#### Uvažování je zapnuté
Dostupné jsou `low`, `medium`, `high`, `xhigh` a `max`. Standardní úrovní je `medium`. Hodnoty `none` a `minimal` nejsou podporovány, proto pro tento model nelze volit vypnuté ani minimální uvažování.
Vedle úsilí uvažování OpenAI nabízí běžný a rozšířený režim provádění. Běžný se používá ve výchozím nastavení. Rozšířený je určen pro obtížné úlohy, u nichž je přípustné delší čekání i větší využití tokenů. Režim volí způsob zpracování a hloubka uvažování působí uvnitř něj; jde o nezávislá nastavení. Volba je k dispozici pro `Responses` a vyžaduje podporu aplikace, proto dostupnost u výrobce nepotvrzuje její zapnutí v aktuální metodě Ailoot.
Úroveň úsilí řídí práci na řešení. Délka výsledného textu je samostatným požadavkem: pro složitou úlohu lze požadovat stručný výsledek. Při vytváření odpovědi vnitřní uvažování rovněž zabírá výstupní rozpočet; maximální výstup neznamená garantovanou délku viditelné odpovědi.
#### Nástroje a omezení formátu
Pro volání nástrojů je vyžadován `Responses`. Formát `Chat Completions` podporuje textovou výměnu bez volání nástrojů. Toto omezení se vztahuje na samotný model a je důležité při volbě způsobu provedení úlohy.
Oficiální karta uvádí vyhledávání v souborech a na internetu, provádění kódu a příkazů, změny souborů, počítačové akce a hledání připojeného nástroje. Při uživatelském volání model zadává funkci a argumenty a aplikace provede akci a předá výsledek. Skutečná nabídka závisí na metodě a poskytnutých připojeních.
Při odpovídajícím připojení výrobce nabízí také samostatný nástroj pro generování obrázků, práci s dovednostmi a vnější prostředky přes MCP. Přímá odpověď modelu zůstává textová; výsledek generování obrázku vytváří samostatný nástroj. Jeho dostupnost u výrobce neznamená připojení těchto schopností v libovolné metodě Ailoot.
#### Pokračování úlohy a opakovaný vstup
GPT-6.1 Sol podporuje využití dostupného stavu uvažování předchozích kroků. Pomáhá pokračovat ve vícekrokovém zadání, pokud jsou předány potřebné prvky historie. Opakující se vstupní prefix lze ukládat do mezipaměti; uchovávání uvažování a ukládání do mezipaměti jsou určeny pro různé části procesu.
Strukturovaný výstup omezuje podobu výsledku schématem JSON. Lze tak předem určit položky, soulad s podobou však nenahrazuje kontrolu faktů a hodnot.
#### Rozměry kontextu
Výrobce uvádí kontextové okno 1 050 000 tokenů, maximální vstup 922 000 a maximální výstup 128 000 tokenů. Hranicí znalostí je 30. duben 2026. V aktuálním katalogu Ailoot je pro tento model uveden vstupní limit 272 000 tokenů. Charakteristiky výrobce a limit zvolené metody je třeba zohledňovat samostatně.
Praktická úloha
### Praktická úloha
Technický příklad v angličtině
```
Prevent a duplicate callback transition
Review this text-only callback handler: if (status==='paid') { ship(orderId); markPaid(orderId); }. Requirements: repeated callbacks must not create another shipment, and shipping may fail. Propose a state-transition design using a unique order ID and explain how the handler should recover from a shipping failure. Return pseudocode and scenario checks, without claiming deployment.
```
#### Očekávaný výsledek
```
A proposed state-transition table, handler pseudocode and duplicate/failure scenario checks.
```
#### Ověření výsledku
```
Check the design addresses the failure between shipping and state persistence rather than just reordering the two calls.
```
**Ailoot · Anthropic Messages** `POST /v1/messages` `gpt-6.1-sol`
[`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages)
OpenAI /`gpt-6.1-sol`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · Anthropic Messages** `POST /v1/messages`
Vstup
`text`, `image`
Výstup
`text`
Kontext
272 000 tokens
Maximální výstup
128 000 tokens
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 gpt-6.1-sol | 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 user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_block[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`system` | Typ`string\|content_block[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity Minimum: 1 Limit platí pro: přesný limit vybraného modelu/karty | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| 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_sequences` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: nástroj je dodán | Výchozí— |
| Pole`tools[].description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].input_schema` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.budget_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`output_config.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`metadata` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`cache_control` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content nebo blok type=text`
**Text + obrázek**
`{type:image,source:{type:base64,media_type,data}} nebo zdroj type=url`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,002 US$ */ 1K*
Výstup
0,01 US$ */ 1K*
Čtení z mezipaměti
0,0001 US$ */ 1K*
Zápis do mezipaměti
0,0025 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0025 US$ */ 1K tokens*
Násobitel fast
×2
Násobitel flex
×0.5
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/)
#### 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.
Referenční tabulky modelu
#### 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 |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Zá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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Zá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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · Anthropic Messages
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-6.1-sol", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-6.1-sol", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
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/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="gpt-6.1-sol",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "gpt-6.1-sol",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='gpt-6.1-sol',max_tokens=1024,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_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · Anthropic Messages
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### 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`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `gpt-6.1-sol`
[`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=responses)
OpenAI /`gpt-6.1-sol`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Responses** `POST /v1/responses`
Vstup
`text`, `image`
Výstup
`text`
Kontext
272 000 tokens
Maximální výstup
128 000 tokens
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 gpt-6.1-sol | Výchozí— |
| Pole`input` | Typ`string\|input_item[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity message, reasoning, function\_call, function\_call\_output | Výchozí— |
| Pole`input[].content` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output; zachovejte skutečně vrácené call\_id | Výchozí— |
| Pole`input[].output` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output | Výchozí— |
| Pole`max_output_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`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`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | 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`reasoning.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.summary` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.verbosity` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`include` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`store` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`previous_response_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Požadavek na ID: Pouze skutečné ID odpovědi z podporovaného pokračování Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_key` | Typ`string` | 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í— |
Kombinace vstupních materiálů
**Text** · text UTF8
`vstupní text nebo část input_text`
**Text + obrázek**
`{type:input_image,image_url}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, input |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,002 US$ */ 1K*
Výstup
0,01 US$ */ 1K*
Čtení z mezipaměti
0,0001 US$ */ 1K*
Zápis do mezipaměti
0,0025 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0025 US$ */ 1K tokens*
Násobitel fast
×2
Násobitel flex
×0.5
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/)
#### 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.
Referenční tabulky modelu
#### 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 |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Zá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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Zá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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Responses
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-6.1-sol", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
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/responses \
-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
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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-6.1-sol", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
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/responses \
-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
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(json.loads(Path("result.json").read_text(encoding="utf-8")))
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)
resp = client.responses.create(model="gpt-6.1-sol", input="Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "gpt-6.1-sol", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
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))
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)
with client.responses.stream(model="gpt-6.1-sol", input="Explain the difference between an observation and a hypothesis 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_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Responses
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou výstupní položku a část obsahu, skutečné call\_id funkce, šifrované uvažování a údaje o využití. Při streamování uchovejte úplnou identitu události/položky.
##### 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`id` | Typstring |
| Pole`status` | Typstring |
| Pole`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Pole`output[].content[]` | Typcontent part |
| 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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=responses)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=responses), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `gpt-6.1-sol`
[`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat)
OpenAI /`gpt-6.1-sol`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`, `image`
Výstup
`text`
Kontext
272 000 tokens
Maximální výstup
128 000 tokens
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 gpt-6.1-sol | 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 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í— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
**Text + obrázek**
`{type:image_url,image_url:{url,detail}}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,002 US$ */ 1K*
Výstup
0,01 US$ */ 1K*
Čtení z mezipaměti
0,0001 US$ */ 1K*
Zápis do mezipaměti
0,0025 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0025 US$ */ 1K tokens*
Násobitel fast
×2
Násobitel flex
×0.5
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/)
#### 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.
Referenční tabulky modelu
#### 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 |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Zá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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Zá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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Chat
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-6.1-sol", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-6.1-sol", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
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)
resp = client.chat.completions.create(
model="gpt-6.1-sol",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "gpt-6.1-sol",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```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='gpt-6.1-sol',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 · 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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `gpt-6.1-sol`
[`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat)
OpenAI /`gpt-6.1-sol`
ID modelu
- `gpt-6.1-sol`
- `openai/gpt-6.1-sol`
- `~openai/gpt-sol-latest`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
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 gpt-6.1-sol | 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 Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Textová konverzace | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
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 |
| Parametr`control_scope` | KontraktTextová konverzace; stream je booleovská hodnota a ve výchozím nastavení je false. |
| Parametr`output_modalities` | Kontrakttext |
| Parametr`hosted_operations` | Kontraktfalse |
| Parametr`multimodal_input_binding` | Kontraktnull |
Aliasy metody: `/chat/completions`
Ž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)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · max
Standardní sazba Při intenzitě uvažování max
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### 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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 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 SDK
```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":"gpt-6.1-sol","messages":[{"role":"user","content":"hello"}],"stream":false}')
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="gpt-6.1-sol", messages=[{"role":"user","content":"hello"}], stream=False)
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"))
```
### 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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `gpt-6.1-sol`
[`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages)
OpenAI /`gpt-6.1-sol`
ID modelu
- `gpt-6.1-sol`
- `openai/gpt-6.1-sol`
- `~openai/gpt-sol-latest`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
Přijímané vstupy
Text
Výsledky
json · sse
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Vstup
`text`
Výstup
`json`, `sse`
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 gpt-6.1-sol | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF-8
`řetězec messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`material_types` | Kontrakttext |
| Parametr`text_file_material` | KontraktPřečtěte skutečný dokument UTF-8 a vložte jeho text do uvedeného pole input nebo do řetězce obsahu zprávy. |
Životní cyklus: `synchronous_or_streamed`
### 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)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · max
Standardní sazba Při intenzitě uvažování max
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### 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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 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 · Anthropic Messages
Úplné minimální tělo požadavku JSONcurl · použijte svůj dokument UTF-8Python · uložte úplný výsledek
```json
{
"model": "gpt-6.1-sol",
"max_tokens": 128,
"messages": [
{
"role": "user",
"content": "Summarize the incident report."
}
],
"stream": false
}
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'gpt-6.1-sol', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```
```python
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'gpt-6.1-sol', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError
api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
with urlopen(request, timeout=120) as response:
raw = response.read()
Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
Path('result.json').write_bytes(error.read())
Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · Anthropic Messages
JSON nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### 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`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-6.1-sol`
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat)
OpenAI /`openai/gpt-6.1-sol`
ID modelu
- `gpt-6.1-sol`
- `openai/gpt-6.1-sol`
- `~openai/gpt-sol-latest`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
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-6.1-sol | 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)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · max
Standardní sazba Při intenzitě uvažování max
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### 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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 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-6.1-sol", "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-6.1-sol',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-6.1-sol',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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `openai/gpt-6.1-sol`
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages)
OpenAI /`openai/gpt-6.1-sol`
ID modelu
- `gpt-6.1-sol`
- `openai/gpt-6.1-sol`
- `~openai/gpt-sol-latest`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
Přijímané vstupy
Text
Výsledky
json · sse
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Vstup
`text`
Výstup
`json`, `sse`
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-6.1-sol | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF-8
`řetězec messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`material_types` | Kontrakttext |
| Parametr`text_file_material` | KontraktPřečtěte skutečný dokument UTF-8 a vložte jeho text do uvedeného pole input nebo do řetězce obsahu zprávy. |
Životní cyklus: `synchronous_or_streamed`
### 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)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · max
Standardní sazba Při intenzitě uvažování max
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### 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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 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 · Anthropic Messages
Úplné minimální tělo požadavku JSONcurl · použijte svůj dokument UTF-8Python · uložte úplný výsledek
```json
{
"model": "openai/gpt-6.1-sol",
"max_tokens": 128,
"messages": [
{
"role": "user",
"content": "Summarize the incident report."
}
],
"stream": false
}
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'openai/gpt-6.1-sol', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```
```python
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'openai/gpt-6.1-sol', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError
api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
with urlopen(request, timeout=120) as response:
raw = response.read()
Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
Path('result.json').write_bytes(error.read())
Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · Anthropic Messages
JSON nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### 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`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `~openai/gpt-sol-latest`
[`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat)
OpenAI /`~openai/gpt-sol-latest`
ID modelu
- `gpt-6.1-sol`
- `openai/gpt-6.1-sol`
- `~openai/gpt-sol-latest`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
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-sol-latest | 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)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · max
Standardní sazba Při intenzitě uvažování max
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### 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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 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-sol-latest", "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-sol-latest',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-sol-latest',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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=chat), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=chat), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=chat), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `~openai/gpt-sol-latest`
[`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages)
OpenAI /`~openai/gpt-sol-latest`
ID modelu
- `gpt-6.1-sol`
- `openai/gpt-6.1-sol`
- `~openai/gpt-sol-latest`
### Úvod
GPT-6.1 Sol je určen pro složitou práci s kódem, počítačovým rozhraním a odbornými materiály. Přijímá text a obrázky a pracuje s několika úrovněmi uvažování.
Přijímané vstupy
Text
Výsledky
json · sse
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Vstup
`text`
Výstup
`json`, `sse`
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-sol-latest | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF-8
`řetězec messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`material_types` | Kontrakttext |
| Parametr`text_file_material` | KontraktPřečtěte skutečný dokument UTF-8 a vložte jeho text do uvedeného pole input nebo do řetězce obsahu zprávy. |
Životní cyklus: `synchronous_or_streamed`
### 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)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · max
Standardní sazba Při intenzitě uvažování max
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### 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.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.004** / 1K tokenů Výstup · Výstupní tokeny **$0.02** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0002** / 1K tokenů Vstup · Zápis do mezipaměti **$0.005** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.008** / 1K tokenů Výstup · Výstupní tokeny **$0.03** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0004** / 1K tokenů Vstup · Zápis do mezipaměti **$0.01** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 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 · Anthropic Messages
Úplné minimální tělo požadavku JSONcurl · použijte svůj dokument UTF-8Python · uložte úplný výsledek
```json
{
"model": "~openai/gpt-sol-latest",
"max_tokens": 128,
"messages": [
{
"role": "user",
"content": "Summarize the incident report."
}
],
"stream": false
}
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': '~openai/gpt-sol-latest', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```
```python
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': '~openai/gpt-sol-latest', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError
api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
with urlopen(request, timeout=120) as response:
raw = response.read()
Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
Path('result.json').write_bytes(error.read())
Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · Anthropic Messages
JSON nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### 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`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_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 [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages)
**Ailoot Ultra** [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages), [`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=openai%2Fgpt-6.1-sol&fmt=messages), [`~openai/gpt-sol-latest`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=~openai%2Fgpt-sol-latest&fmt=messages), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Core&caller=gpt-6.1-sol&fmt=messages), [`gpt-6.1-sol`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-6.1-sol&route=Ultra&caller=gpt-6.1-sol&fmt=messages)
FAQ · OpenAI: GPT-6.1 Sol
Jaké vstupy a výsledky jsou dostupné?
`POST /v1/messages` · `gpt-6.1-sol`: `text`, `image` → `text` `POST /v1/responses` · `gpt-6.1-sol`: `text`, `image` → `text` `POST /v1/chat/completions` · `gpt-6.1-sol`: `text`, `image` → `text` `POST /v1/chat/completions` · `gpt-6.1-sol`: `text` → `text` `POST /v1/messages` · `gpt-6.1-sol`: `text` → `json`, `sse` `POST /v1/chat/completions` · `openai/gpt-6.1-sol`: `text` → `text` `POST /v1/messages` · `openai/gpt-6.1-sol`: `text` → `json`, `sse` `POST /v1/chat/completions` · `~openai/gpt-sol-latest`: `text` → `text` `POST /v1/messages` · `~openai/gpt-sol-latest`: `text` → `json`, `sse`
Jaká pole požadavek používá?
`POST /v1/messages` · `gpt-6.1-sol`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `gpt-6.1-sol`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `gpt-6.1-sol`: `model`, `messages`, `stream` `POST /v1/chat/completions` · `gpt-6.1-sol`: `model`, `messages`, `stream` `POST /v1/messages` · `gpt-6.1-sol`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/chat/completions` · `openai/gpt-6.1-sol`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `openai/gpt-6.1-sol`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/chat/completions` · `~openai/gpt-sol-latest`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `~openai/gpt-sol-latest`: `model`, `messages`, `max_tokens`, `stream`
Jaké limity platí?
`POST /v1/messages` · `gpt-6.1-sol`: `ctx`: `272000`; `max_out`: `128000`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `gpt-6.1-sol`: `ctx`: `272000`; `max_out`: `128000` `POST /v1/chat/completions` · `gpt-6.1-sol`: `ctx`: `272000`; `max_out`: `128000`; `messages.min_items`: `1` `POST /v1/chat/completions` · `gpt-6.1-sol`: `messages.min_items`: `1` `POST /v1/chat/completions` · `openai/gpt-6.1-sol`: `messages.min_items`: `1` `POST /v1/chat/completions` · `~openai/gpt-sol-latest`: `messages.min_items`: `1`
Připojte Ailoot k Claude Code, OpenCode, Hermes nebo vlastní aplikaci.
## Společnost a její portfolio projektů
Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.
## Nakupujte tokeny se slevou.
Sleva předplatného pro pravidelnou práci. Promo kódy až 50% na nákup tokenů.
Předplatné
Pro pravidelné požadavky vyberte tarif se slevou.
Promo kód až 50%
Při nákupu zadejte kód. Cena se přepočítá podle probíhající akce.
Výdaje v historii
U každého požadavku se uloží model, tokeny a částka.
[Vybrat předplatné](https://ailoot.ai/docs/cs/billing/subscriptions/) · [Zobrazit ceny modelů](https://ailoot.ai/models/cs/)
## Připojte API k produktu, který prodáváte.
SaaS, aplikace a boti podle nabídky a licenční smlouvy Ailoot. Pro přeprodej požádejte o licenci přeprodejce.
Komerční aplikace
Začleňte generování textu, obrázků, videa a zvuku do placených funkcí své služby.
Licence pro přeprodejce
Pošlete popis projektu a způsob poskytování přístupu. Vyžádejte písemné podmínky použití a přeprodeje.
Dokumenty na webu
Nabídka, licenční smlouva a zásady zpracování dat jsou dostupné před připojením.
[Požádat o licenci přeprodejce](mailto:support@ailoot.ai) · [Nabídka a licenční smlouva](https://ailoot.ai/legal/offer?lang=cs)
## Ailoot · Společnost a její portfolio projektů
Ailoot staví na dlouhodobých provozních zkušenostech, široké klientské základně, stabilních službách a průběžném sledování KPI.
Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.
Ailoot využívá tyto provozní zkušenosti k poskytování přístupu přes API k funkcím AI v produktech zákazníků, agentech, aplikacích a automatizacích.