Capability matrix

modelux exposes two proxy surfaces — OpenAI shape and Anthropic shape — and routes requests across many upstream providers. The matrices below show which features work on which combination, and why the empty cells are empty.

Proxy surfaces

What you can send to each endpoint:

The semantic cache index is shared across surfaces: an entry stored from /openai/v1/chat/completions with model gpt-4o-mini and a given prompt serves a hit for the same model + prompt arriving on /anthropic/v1/messages. The cached response is re-serialized into whichever wire shape the calling endpoint expects.

Upstream providers

What each upstream supports through the proxy. Cells marked drop mean the proxy silently skips that part of the request rather than fail — so a multi-modal request with an image can still reach a provider that doesn’t accept images, just without the image.

Cross-provider translation notes

When you send a request on one surface and modelux routes it to a provider whose native API is shaped differently, these are the translations modelux performs and the edges where fidelity is lost:

Tools

• OpenAI ↔ Anthropic: tools ↔ tools (input_schema rename), tool_choice shapes mapped, assistant tool_calls[] ↔ assistant tool_use blocks, role: "tool" reply ↔ tool_result block.
• ↔ Google: tools become functionDeclarations; tool_choice becomes toolConfig.functionCallingConfig mode. Tool call IDs are synthesized on the proxy side because Gemini doesn’t issue them.
• ↔ Cohere: tool reply content is wrapped in a document array (Cohere v2 requirement); finish reasons are uppercase upstream and normalized to the OpenAI vocabulary.

Tool result content

Text only on the cross-provider path. OpenAI’s role: "tool" reply shape only carries text content, so image-typed tool_result blocks (which Anthropic supports natively) get dropped during translation. The text portion is preserved.

Extended thinking

Round-tripped verbatim when the upstream is Anthropic or Bedrock-Claude (signature included so multi-turn reasoning resumes correctly). Silently ignored by all other providers.

Vision

Anthropic image source formats (base64, url) translate to OpenAI’s image_url data URI / HTTPS form on the OpenAI cross-provider path. On Google’s path, only base64 sources work — URL-only images get dropped because Gemini requires inline data.

Stop reasons / finish reasons

Each provider’s native stop reasons normalize into the OpenAI vocabulary internally (stop, length, tool_calls, content_filter), then translate back into Anthropic’s vocabulary (end_turn, max_tokens, tool_use) on the response side. SDK consumers see exactly the values their SDK expects.

Streaming event taxonomy

The OpenAI surface emits OpenAI-format SSE chunks (chat.completion.chunk). The Anthropic surface emits Anthropic’s full event taxonomy (message_start → content_block_start → content_block_delta → content_block_stop → message_delta → message_stop), with thinking_delta/signature_delta for extended-thinking and input_json_delta for tool argument streaming. Both shapes are rebuilt from the same internal stream regardless of which provider served the chunks.

Native prompt caching (Anthropic)

Anthropic’s cache_control field on a content block — typically {"type":"ephemeral"} on a long system prompt or tool definition you expect to reuse — passes through the proxy verbatim. Set it on the caller side and you get Anthropic’s native prompt-cache discount on the next matching request, additive to modelux’s semantic cache:

{
  "model": "claude-sonnet-4-5",
  "messages": [{
    "role": "user",
    "content": [
      {"type": "text", "text": "long context to cache", "cache_control": {"type": "ephemeral"}},
      {"type": "text", "text": "Question about that context."}
    ]
  }]
}

Honored when the upstream is Anthropic or Bedrock-Claude. Other providers ignore it.

Cache hit / priming token counts land in the request log row (cache_read_tokens, cache_creation_tokens) so dashboards can answer “did my cache_control tag actually hit?”.

Message batches (async)

Both providers’ batch surfaces are proxied as authenticated thin passthroughs — auth + rate-limit + entitlements via the customer’s modelux key, forwarded to the upstream with the org’s stored credential (or BYOK via X-Modelux-Provider-Key), and logged to ClickHouse so batch traffic shows up in the dashboard alongside synchronous traffic. Per-sub-request analytics inside a batch is deferred — query the results file for those. Each provider’s async discount (Anthropic 50%, OpenAI 50%) applies on the upstream side untouched.

Anthropic (/anthropic/v1/messages/batches/*):

OpenAI (/openai/v1/batches/* + /openai/v1/files/*):

OpenAI batches reference uploaded files by id, so /v1/files is also proxied (same auth/BYOK/observability story).

Responses API (OpenAI)

The full /v1/responses surface is proxied:

Same auth + BYOK + observability story as batches. Streaming requests relay SSE events (response.created → deltas → response.completed) through to the caller without buffering. The proxy snaps usage (input_tokens, output_tokens, cached_tokens) out of the terminal response.completed event for analytics. The Responses request shape isn’t translated cross-provider — see footnote on the matrix for why.

On create, @config in the model field resolves through the standard router: single-model, fallback_chain, and ab_test policies all work (they yield one or more OpenAI targets that the proxy tries in order on 5xx / 429 / transport failures). Non-OpenAI targets and ensemble policies are rejected before any upstream call. See the Responses page for examples.

Files (Anthropic)

The Anthropic Files API beta is proxied alongside batches. Use it to upload large documents/images once and reference them by id from /v1/messages content blocks (instead of inlining base64 every turn).

The proxy forwards the caller’s anthropic-beta header(s) verbatim so the SDK’s beta-tag declaration reaches the upstream — meaning the proxy doesn’t need to track which beta tag is current.

What’s not in the matrix

The matrix is currently complete for both proxy surfaces. If you spot a gap, file an issue.