gpt-5.6-terra

Unsupported value: 'reasoning_effort' does not support 'max' with this model.
Supported values are: 'none', 'low', 'medium', 'high', and 'xhigh'.

curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-terra",
    "messages": [
      {
        "role": "user",
        "content": "Two services write to the same row without a transaction. Walk through the failure modes in order of likelihood and propose the smallest fix for each."
      }
    ],
    "reasoning_effort": "medium",
    "max_tokens": 16384
  }'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

# Measured against the live API. `max` is rejected on every model in this family.
EFFORT_LEVELS = {
    "openai/gpt-5.6-luna": {"none", "low", "medium", "high", "xhigh"},
    "openai/gpt-5.6-terra": {"none", "low", "medium", "high", "xhigh"},
    "openai/gpt-5.6-sol": {"none", "low", "medium", "high", "xhigh"},
    "openai/gpt-6-astra": {"low", "medium", "high", "xhigh"},  # no `none`
}


def ask(model: str, prompt: str, *, effort: str, max_tokens: int = 16384) -> str:
    """Send a request, refusing an effort level the target model does not accept."""
    allowed = EFFORT_LEVELS.get(model)
    if allowed is not None and effort not in allowed:
        raise ValueError(
            f"{model} does not accept reasoning_effort={effort!r}. Allowed: {sorted(allowed)}"
        )

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,
        extra_body={"reasoning_effort": effort},
    )
    return response.choices[0].message.content


# Routine classification — cheapest tier, no deliberation.
ask("openai/gpt-5.6-luna", ticket, effort="none", max_tokens=16)

# Everyday production work.
ask("openai/gpt-5.6-terra", question, effort="medium")

# The hard case that failed elsewhere.
ask("openai/gpt-5.6-sol", question, effort="high")

response = client.chat.completions.create(
    model="openai/gpt-5.6-terra",
    messages=[{"role": "user", "content": ticket}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "support_ticket",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "order_id": {"type": ["string", "null"]},
                    "issue_type": {
                        "type": "string",
                        "enum": ["missing_items", "damaged", "late", "other"],
                    },
                    "missing_items": {"type": "array", "items": {"type": "string"}},
                    "contact": {"type": ["string", "null"]},
                },
                "required": ["order_id", "issue_type", "missing_items", "contact"],
                "additionalProperties": False,
            },
        },
    },
    max_tokens=2048,
    extra_body={"reasoning_effort": "none"},
)

import base64

with open("invoice.png", "rb") as handle:
    encoded = base64.b64encode(handle.read()).decode("utf-8")

response = client.chat.completions.create(
    model="openai/gpt-5.6-terra",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{encoded}"},
                },
                {
                    "type": "text",
                    "text": (
                        "Extract every line item as JSON with fields: description, quantity, "
                        "unit_price, line_total. Report the currency exactly as printed. "
                        "Use null for any illegible field — do not infer."
                    ),
                },
            ],
        }
    ],
    max_tokens=8192,
    extra_body={"reasoning_effort": "medium"},
)

npm install devupai

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

const response = await client.chat.completions.create({
  model: "openai/gpt-5.6-terra",
  messages: [
    {
      role: "system",
      content:
        "You are a staff engineer reviewing a migration. Report only defects that would " +
        "cause data loss or downtime, each with a severity and the smallest safe fix.",
    },
    { role: "user", content: migrationPlan },
  ],
  max_tokens: 16384,
  reasoning_effort: "high",
});

console.log(response.choices[0]?.message?.content);

import json

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "lookup_order",
            "description": "Return order status and line items for an order id.",
            "parameters": {
                "type": "object",
                "properties": {"order_id": {"type": "string"}},
                "required": ["order_id"],
            },
        },
    },
]


def lookup_order(order_id: str) -> dict:
    """Replace with your real data access layer."""
    raise NotImplementedError


HANDLERS = {"lookup_order": lookup_order}

messages = [{"role": "user", "content": "Why is order 48213 incomplete?"}]

for _ in range(15):  # bounded loop — never let an agent iterate without a ceiling
    response = client.chat.completions.create(
        model="openai/gpt-5.6-terra",
        messages=messages,
        tools=TOOLS,
        max_tokens=16384,
        extra_body={"reasoning_effort": "medium"},
    )

    message = response.choices[0].message
    messages.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            result = {"error": "unknown_tool", "name": call.function.name}
        else:
            try:
                result = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:  # describe the failure — do not crash the loop
                result = {"error": type(exc).__name__, "detail": str(exc)}

        messages.append(
            {
                "role": "tool",
                "tool_call_id": call.id,
                "content": json.dumps(result),
            }
        )
else:
    print("Agent loop exceeded its iteration limit.")

stream = client.chat.completions.create(
    model="openai/gpt-5.6-terra",
    messages=[{"role": "user", "content": "Design a retry policy for a webhook delivery system."}],
    max_tokens=16384,
    stream=True,
    extra_body={"reasoning_effort": "high"},
)

for chunk in stream:
    if not chunk.choices:
        if getattr(chunk, "usage", None):
            print(f"\n\nTokens — in: {chunk.usage.prompt_tokens}, out: {chunk.usage.completion_tokens}")
        continue

    delta = chunk.choices[0].delta
    if getattr(delta, "content", None):
        print(delta.content, end="", flush=True)