claude-sonnet-5

# Fails on this model
client.chat.completions.create(model=..., messages=..., temperature=0.7)

# Works
client.chat.completions.create(model=..., messages=...)

message = reply.choices[0].message

trace = getattr(message, "reasoning_content", None)
if trace:
    logger.debug("reasoning: %d characters", len(trace))

print(message.content)

curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "messages": [
      {
        "role": "user",
        "content": "A delivery webhook sometimes fires twice within the same second. Our handler marks the order shipped both times and sends two SMS notifications. Walk through the fixes in order of how little they change."
      }
    ],
    "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",
)

# Models that reject non-default sampling values.
NO_SAMPLING = {"anthropic/claude-sonnet-5"}


def ask(model: str, prompt: str, *, temperature: float | None = None, max_tokens: int = 16384) -> str:
    """Send a request, omitting sampling parameters where the model refuses them."""
    payload = {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": max_tokens,
    }

    if temperature is not None and model not in NO_SAMPLING:
        payload["temperature"] = temperature

    reply = client.chat.completions.create(**payload)
    return reply.choices[0].message.content

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[
        {
            "role": "system",
            "content": "Classify this ticket. Answer with one word: billing, delivery, technical, or other.",
        },
        {"role": "user", "content": ticket},
    ],
    max_tokens=16,
    extra_body={"output_config": {"effort": "low"}},
)

from pathlib import Path

contracts = "\n\n---\n\n".join(
    f"### {path.name}\n{path.read_text(encoding='utf-8')}"
    for path in sorted(Path("agreements").glob("*.txt"))
)

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[
        {
            "role": "system",
            "content": (
                "You are reviewing a set of supplier agreements. Find every obligation that appears "
                "in one document and contradicts an obligation in another. Quote both clauses and "
                "name both files. Report only conflicts you can quote."
            ),
        },
        {"role": "user", "content": contracts},
    ],
    max_tokens=32768,
)

print(reply.choices[0].message.content)

import json

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "lookup_order",
            "description": "Return order status, line items, and notification history 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}

thread = [{"role": "user", "content": "Order 48213 shows as shipped twice. Find out what happened."}]

LIMIT = 15

for step in range(LIMIT):
    reply = client.chat.completions.create(
        model="anthropic/claude-sonnet-5",
        messages=thread,
        tools=TOOLS,
        max_tokens=16384,
    )

    message = reply.choices[0].message
    thread.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:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                # Send the failure back as data — the model adapts to it.
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        thread.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})
else:
    print(f"Stopped at {LIMIT} steps without a conclusion.")

import base64

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

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encoded}"}},
                {
                    "type": "text",
                    "text": (
                        "Read the tracking number and destination address exactly as printed. "
                        "If any character is ambiguous, say which one rather than choosing."
                    ),
                },
            ],
        }
    ],
    max_tokens=2048,
)

npm install devupai

import DevupAI from "devupai";

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

// No temperature, no top_p — this model refuses them.
const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  messages: [
    {
      role: "system",
      content:
        "Summarise this support thread for a handover. State what was tried, what is still " +
        "unresolved, and what the customer is waiting on.",
    },
    { role: "user", content: thread },
  ],
  max_tokens: 8192,
});

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

stream = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[{"role": "user", "content": "Explain why a shared Redis cart store makes sticky sessions unnecessary — or why it does not."}],
    max_tokens=16384,
    stream=True,
)

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

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