Open Responses: One Agent Client for OpenAI, OpenRouter, Ollama and vLLM

0. Start the local servers (skip the ones you don’t use)

# Ollama (Responses support since v0.13.3) listens on port 11434
ollama pull qwen3:8b

# LM Studio (Responses support since 0.3.29): load openai/gpt-oss-20b in the app, then
lms server start --port 1234

# vLLM: flags from its Responses tool-calling example, plus an API key (needs a GPU)
vllm serve Qwen/Qwen3-1.7B --reasoning-parser qwen3 \
  --enable-auto-tool-choice --tool-call-parser hermes \
  --api-key token-abc123

1. One client, seven providers (Python)

# pip install --upgrade openai   (signatures checked against openai 3.40.0)
import os
import openai
from openai import OpenAI

# Base URLs and model IDs from each provider's docs (Oct 2026).
# The SDK appends /responses, so every base_url stops at /v1.
PROVIDERS = {
    "openai":      {"base_url": "https://api.openai.com/v1", "key_env": "OPENAI_API_KEY",
                    "model": "gpt-6-astra", "extra": {"store": False}},  # OpenAI stores by default
    "openrouter":  {"base_url": "https://openrouter.ai/api/v1", "key_env": "OPENROUTER_API_KEY",
                    "model": "openai/gpt-6.1-terra"},
    "huggingface": {"base_url": "https://router.huggingface.co/v1", "key_env": "HF_TOKEN",
                    "model": "openai/gpt-oss-120b:groq"},
    "vercel":      {"base_url": "https://ai-gateway.vercel.sh/v1", "key_env": "AI_GATEWAY_API_KEY",
                    "model": "anthropic/claude-sonnet-5.5"},
    "ollama":      {"base_url": "http://localhost:11434/v1", "key": "ollama", "model": "qwen3:8b"},
    "lmstudio":    {"base_url": "http://localhost:1234/v1", "key": "lm-studio",
                    "model": "openai/gpt-oss-20b"},
    "vllm":        {"base_url": "http://localhost:8000/v1", "key": "token-abc123",
                    "model": "Qwen/Qwen3-1.7B"},
}

def client_for(name):
    p = PROVIDERS[name]
    # Never pass api_key=None: the SDK falls back to OPENAI_API_KEY
    # and would send your OpenAI key to whatever base_url you set.
    key = p.get("key") or os.environ[p["key_env"]]
    return OpenAI(base_url=p["base_url"], api_key=key), p["model"], p.get("extra", {})

# The same two items the compliance suite's system-prompt test sends
INPUT = [
    {"type": "message", "role": "system", "content": "Answer in one short sentence."},
    {"type": "message", "role": "user", "content": "What does HTTP status 429 mean?"},
]

for name in PROVIDERS:
    try:
        client, model, extra = client_for(name)
        r = client.responses.create(model=model, input=INPUT, **extra)
        print(f"{name:12} {r.status} {r.output_text!r}")
    except (KeyError, openai.APIError) as e:  # missing key, server down, 4xx/5xx
        print(f"{name:12} skipped: {type(e).__name__}: {e}")

The same call in TypeScript

// npm i openai   (types checked against openai 7.45.1)
import OpenAI from "openai";

// One provider per run: set BASE_URL, API_KEY and MODEL
const client = new OpenAI({
  baseURL: process.env.BASE_URL ?? "http://localhost:11434/v1",
  apiKey: process.env.API_KEY ?? "ollama", // never undefined: it falls back to OPENAI_API_KEY
});

const response = await client.responses.create({
  model: process.env.MODEL ?? "qwen3:8b",
  input: [
    { type: "message", role: "system", content: "Answer in one short sentence." },
    { type: "message", role: "user", content: "What does HTTP status 429 mean?" },
  ],
});

console.log(response.status, response.output_text);

2. Stream the text and keep the terminal event

client, model, extra = client_for("ollama")  # any provider from step 1

stream = client.responses.create(
    model=model,
    input="Count from 1 to 5, one number per line.",
    stream=True,
    **extra,
)

final = None
for event in stream:
    t = event.type
    if t == "response.output_text.delta":
        print(event.delta, end="", flush=True)
    elif t in ("response.reasoning_summary_text.delta",  # summaries: same name everywhere
               "response.reasoning.delta",               # raw reasoning, spec name
               "response.reasoning_text.delta"):         # raw reasoning, OpenAI SDK name
        pass                                             # route to a "thinking" panel
    elif t == "response.output_item.added" and event.item.type == "function_call":
        print(f"\n[tool call started: {event.item.name}]")
    elif t in ("response.completed", "response.incomplete", "response.failed"):
        final = event.response                           # terminal event: the full response
    elif t == "error":
        raise RuntimeError(f"stream error: {event}")
    # anything else, including vendor events such as acme:trace_event: ignore it

print("\nstatus:", final.status if final else "no terminal event received")

3. Stateless round trip (the portable version)

import json

client, model, extra = client_for("vllm")  # swap the name to test another provider

tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Current temperature in Celsius for a city.",
    "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
        "additionalProperties": False,
    },
}]

def get_weather(city: str) -> str:
    return json.dumps({"city": city, "celsius": 18})  # stub: call a real API here

question = {"type": "message", "role": "user", "content": "What's the weather in Montevideo?"}
history = [question]

first = client.responses.create(model=model, input=history, tools=tools, **extra)

# Keep EVERY output item (reasoning included), then answer each function_call
history += first.output
for item in first.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)
        history.append({
            "type": "function_call_output",
            "call_id": item.call_id,  # must match the call it answers
            "output": get_weather(args["city"]),
        })

second = client.responses.create(model=model, input=history, tools=tools, **extra)
print(second.output_text)

The stateful shortcut, only where the server keeps state

# Only where the server keeps state: OpenAI (store is on by default), LM Studio,
# or vLLM started with VLLM_ENABLE_RESPONSES_API_STORE=1. Not OpenRouter, not Ollama.
first = client.responses.create(model=model, input=[question], tools=tools)
calls = [i for i in first.output if i.type == "function_call"]

second = client.responses.create(
    model=model,
    previous_response_id=first.id,  # the server replays first's input + output
    input=[{"type": "function_call_output", "call_id": c.call_id,
            "output": get_weather(json.loads(c.arguments)["city"])} for c in calls],
    tools=tools,
)

4. Clone, install, run (commands from the README and the CLI’s --help)

# Requires Bun (the repo pins bun 1.4.2 in .tool-versions)
git clone https://github.com/openresponses/openresponses.git
cd openresponses
bun install

# All 17 tests against a local Ollama. --api-key is mandatory; Ollama ignores it
bun run test:compliance --base-url http://localhost:11434/v1 --api-key ollama --model qwen3:8b

# Only the HTTP basics against your gateway (e.g. a LiteLLM proxy), verbose on failure
bun run test:compliance -u http://localhost:4000/v1 -k "$LITELLM_KEY" -m "$MODEL" \
  --filter basic-response,system-prompt,multi-turn,streaming-response,tool-calling -v

# CI: JSON summary on stdout, exit code 1 if any test fails
bun run test:compliance -u "$API_URL" -k "$API_KEY" -m "$MODEL" --json > results.json