Python

pip install codai-sdk

import os
from codai import Codai

client = Codai(api_key=os.environ["CODAI_API_KEY"], session_id="my-project")

result = client.chat([{"role": "user", "content": "Explică asyncio.gather într-o linie."}])
print(result.content)
print(result.routed_to)  # modelul upstream care a servit efectiv

for delta in client.chat_stream([{"role": "user", "content": "salut"}]):
    print(delta, end="", flush=True)

run = client.agents_run("Găsește și rezumă TODO-urile din acest codebase")
print(run.result)

if result.request_id:
    client.feedback(result.request_id, 1)

client = Codai(
    api_key=os.environ["CODAI_API_KEY"],  # obligatoriu — ridică ValueError dacă e gol
    base_url="https://ai.codai.ro",        # implicit
    session_id="my-project",               # opțional — memorie de sesiune + sticky routing
    timeout=120.0,                         # secunde, implicit
    max_retries=2,                         # reîncercări pe 429 / 5xx cu backoff exponențial
)

client = Codai(api_key=os.environ["CODAI_API_KEY"], device="5dc0de00-0000-4000-8000-00000000c0da")

r = client.chat.completions.create(
    {"messages": messages, "model": "codai"},
    ext={"effort": "high", "thinking": True, "thinking_budget": 8192},
)

stream = client.chat.completions.stream({"messages": messages})
for delta in stream:                 # delte de text; stream.chunks() dă chunk-urile brute
    print(delta, end="")
print(stream.final.usage, stream.final.tool_calls)

# fluxurile SSE native codai sunt generatoare de cadre {"event", "data"}
run = client.agents.runs.create({"task": "Rezumă README-ul repo-ului."})
for ev in client.agents.runs.stream(run["id"]):
    if ev["event"] == "done":
        print(ev["data"]["status"], ev["data"]["result"])

# sesiunile partajate au nevoie de un id de dispozitiv pe client
s = client.sessions.create({"title": "pairing"})
for ev in client.sessions.stream(s["id"], after=0):
    print(ev["event"], ev["data"].get("seq"))

result = client.chat(
    messages=[{"role": "user", "content": "salut"}],
    model="codai",          # implicit
    temperature=None,
    max_tokens=None,
    tools=None,             # tool-uri OpenAI de tip funcție — tu deții bucla de tool-uri
    agent_mode=False,       # X-Codai-Mode: agent (Pro+)
    compact=None,           # "auto" → X-Codai-Compact: auto
    best_of=None,           # 3 forțează best-of-N, 0 dezactivează
    session_id=None,        # suprascriere per apel
)

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    },
}]

first = client.chat([{"role": "user", "content": "Vremea la Cluj?"}], tools=tools)
message = first.raw["choices"][0]["message"]
for call in message.get("tool_calls") or []:
    args = json.loads(call["function"]["arguments"])
    output = get_weather(args["city"])
    final = client.chat([
        {"role": "user", "content": "Vremea la Cluj?"},
        message,
        {"role": "tool", "tool_call_id": call["id"], "content": json.dumps(output)},
    ], tools=tools)
    print(final.content)

for delta in client.chat_stream(
    [{"role": "user", "content": "Scrie un haiku despre Python."}],
    model="codai",
    temperature=None,
    max_tokens=None,
    agent_mode=False,
    session_id=None,
):
    print(delta, end="", flush=True)

run = client.agents_run(
    task="Rezumă punctele cheie ale textului furnizat.",  # obligatoriu, ≤ 64 000 caractere
    context="…input-ul tău…",                              # opțional, ≤ 256 000 caractere
    system="Răspunde în română.",                          # opțional, ≤ 32 000 caractere
    model=None,                                            # opțional, implicit codai
)
run.result    # str
run.model     # upstream-ul care a servit
run.event_id  # id-ul rândului de usage — îl trimiți la feedback()
run.usage     # dict | None

client.feedback(request_id, 1)                    # 👍
client.feedback(request_id, -1, comment="greșit") # 👎, comment ≤ 500 caractere

vectors = client.embeddings(["salut", "lume"], model="codai-embed", dimensions=None)
vectors[0]  # list[float]

# Speech-to-text — încărcare multipart, maximum 25 MB. Returnează transcrierea.
with open("clip.webm", "rb") as f:
    text = client.transcribe(f.read(), filename="clip.webm", model="codai-transcribe")

# Text-to-speech — returnează byte-i audio (mp3 implicit).
audio = client.speech("Salut de la codai.", model="codai-tts", voice="alloy")
with open("salut.mp3", "wb") as f:
    f.write(audio)

minted = client.mint_token("realtime", ttl_seconds=600)
minted["token"]       # "codai_eph_v1.…" — îl dai unui client din browser
minted["expires_at"]  # timestamp ISO
minted["scope"]       # "realtime"

for m in client.models():
    print(m["id"], m["codai"]["kind"])  # de ex. "codai alias"

from codai import Codai, CodaiError

try:
    client.chat([{"role": "user", "content": "salut"}])
except CodaiError as e:
    print(e.status, e)          # status HTTP (0 pentru eșecuri de rețea după reîncercări)
    code = (e.body or {}).get("error", {}).get("code") if isinstance(e.body, dict) else None
    if code == "quota_exceeded":
        ...  # alocarea de task-uri a planului consumată — aștepți

result = await asyncio.to_thread(client.chat, [{"role": "user", "content": "salut"}])