{
  "model": "openai/gpt-5.4-mini",
  "messages": [{ "role": "user", "content": "..." }],
  "reasoning_effort": "medium"
}

curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.4-mini",
    "messages": [
      {
        "role": "system",
        "content": "Classify the support ticket. Reply with exactly one word: billing, technical, shipping, or other."
      },
      { "role": "user", "content": "My order never arrived and the tracking page is blank." }
    ],
    "reasoning_effort": "none",
    "verbosity": "low",
    "max_tokens": 16
  }'

import os
from openai import OpenAI

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

SCHEMA = {
    "type": "json_schema",
    "json_schema": {
        "name": "invoice",
        "strict": True,
        "schema": {
            "type": "object",
            "properties": {
                "invoice_number": {"type": ["string", "null"]},
                "total": {"type": ["number", "null"]},
                "currency": {"type": ["string", "null"]},
                "due_date": {"type": ["string", "null"]},
            },
            "required": ["invoice_number", "total", "currency", "due_date"],
            "additionalProperties": False,
        },
    },
}


def extract(document: str) -> str:
    """Extract typed fields from one document."""
    response = client.chat.completions.create(
        model="openai/gpt-5.4-mini",
        messages=[
            {
                "role": "system",
                "content": "Extract only fields present in the source. Use null for anything absent — never infer.",
            },
            {"role": "user", "content": document},
        ],
        response_format=SCHEMA,
        max_tokens=2048,
        extra_body={"reasoning_effort": "none", "verbosity": "low"},
    )
    return response.choices[0].message.content

def summarise_tool_output(raw: str) -> str:
    """Condense a large tool result before it re-enters an expensive model's context."""
    response = client.chat.completions.create(
        model="openai/gpt-5.4-mini",
        messages=[
            {
                "role": "system",
                "content": (
                    "Condense this tool output to the facts a downstream agent needs. "
                    "Preserve every identifier, number, and error message exactly. "
                    "Drop formatting, repetition, and anything purely decorative."
                ),
            },
            {"role": "user", "content": raw},
        ],
        max_tokens=2048,
        extra_body={"reasoning_effort": "low", "verbosity": "low"},
    )
    return response.choices[0].message.content

VALID_EFFORT = {"none", "low", "medium", "high", "xhigh"}


def ask(prompt: str, *, effort: str, verbosity: str = "medium", max_tokens: int = 8192) -> str:
    """Send a request with an explicit effort level, validated before it is sent."""
    if effort not in VALID_EFFORT:
        raise ValueError(f"reasoning_effort must be one of {sorted(VALID_EFFORT)}, got {effort!r}")

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

import base64

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

response = client.chat.completions.create(
    model="openai/gpt-5.4-mini",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{encoded}"},
                },
                {
                    "type": "text",
                    "text": (
                        "List every interactive element in this interface with its label, type, "
                        "and approximate position. Report nothing you cannot actually see."
                    ),
                },
            ],
        }
    ],
    max_tokens=4096,
    extra_body={"reasoning_effort": "low", "verbosity": "low"},
)

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.4-mini",
  messages: [
    {
      role: "system",
      content: "Classify the support ticket. Reply with exactly one word: billing, technical, shipping, or other.",
    },
    { role: "user", content: ticket },
  ],
  max_tokens: 16,
  reasoning_effort: "none",
  verbosity: "low",
});

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

import json

for _ in range(20):  # bounded loop — always give an agent an iteration ceiling
    response = client.chat.completions.create(
        model="openai/gpt-5.4-mini",
        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.4-mini",
    messages=[{"role": "user", "content": "Summarise this incident log."}],
    max_tokens=8192,
    stream=True,
    extra_body={"reasoning_effort": "low", "verbosity": "low"},
)

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)