Responses (OpenAI)

POST https://api.staik.se/v1/responses

Endpoint compatible with OpenAI's Responses API. The OpenAI SDKs' responses.create, Codex CLI and other clients that speak the Responses protocol work directly. Authenticate with Authorization: Bearer (same key).

Requests run on the same path as chat completions: same models, quotas, queues, failover and billing. Usage is recorded under the endpoint responses.

from openai import OpenAI

client = OpenAI(api_key="sk-st-your-key", base_url="https://api.staik.se/v1")

response = client.responses.create(
    model="qwen3.6:35b-a3b",
    instructions="Answer briefly.",
    input="Explain how a transformer works.",
)
print(response.output_text)

Stateless: send the full history

staik never stores responses. Every request must contain the full conversation in input, including earlier model output, tool calls and tool results. store is ignored and the response always has "store": false.

Function tools

Tools use the Responses format (type: "function" with name and parameters directly on the tool). The model answers with function_call items, you run the tool and send the result back as function_call_output with the same call_id:

import json

tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get the current weather for a city.",
    "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
    },
}]

history = [{"role": "user", "content": "What's the weather in Gothenburg?"}]
response = client.responses.create(model="qwen3.6:35b-a3b", input=history, tools=tools)

# Stateless: add the model's output to the history before the tool results.
history += response.output
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)
        result = {"city": args["city"], "temp_c": 11}  # your own tool
        history.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps(result),
        })

response = client.responses.create(model="qwen3.6:35b-a3b", input=history, tools=tools)
print(response.output_text)

Supported:

• function tools, including several parallel calls in the same turn (parallel_tool_calls)
• namespace tools: grouped functions. The response carries both name and namespace
• custom tools (freeform input): the response is a custom_tool_call with input as a string, and the result is sent as custom_tool_call_output
• tool_choice: auto, none, required or a specific function. Unknown values are treated as auto
• Images in tool results: input_image with a data URL in output

More on how the models handle tools in Tool calling.

Streaming

Set stream: true and the response arrives as server-sent events in Responses format:

stream = client.responses.create(
    model="qwen3.6:35b-a3b",
    input="Write a haiku about Stockholm.",
    stream=True,
)
for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Every event carries an increasing sequence_number.

Other parameters

reasoning items you send back in input are dropped: earlier reasoning is never sent to the model again. Images are sent as input_image with a data URL, with the same models and rules as chat completions.

Usage

usage in response.completed (and in non-streamed responses) uses the Responses format: input_tokens, input_tokens_details.cached_tokens (prompt cache hits), output_tokens, output_tokens_details.reasoning_tokens and total_tokens. Billing is the same as for chat completions.

Errors

Errors are returned in OpenAI format: {"error": {"message", "type", "param", "code"}}.

If the error happens mid-stream it arrives as response.failed with code context_length_exceeded, invalid_prompt or server_error (transient, retry). See Errors for the full list.