Providers
Five wire dialects, five adapters, fourteen bundled host profiles. The list is the easy part. What you actually need on your screen is which request features survive a cross-dialect leg unchanged, which are coerced into range, which are discarded (with or without a trace in the report), and which skip the leg before a single byte leaves your process.
The five dialects
Every upstream declares exactly one dialect. It is a full round trip: request
translation, response parsing, and stream normalization back into the OpenAI shape your
client already speaks. These five values are the complete set, and anything else is a hard
config load error.
| dialect | Upstream wire surface | Credential placement | Request shape |
|---|---|---|---|
| openai-compat | /v1/chat/completions |
authorization header |
passthrough |
| anthropic-messages | /v1/messages |
x-api-key header |
translated |
| gemini-generate | Gemini generateContent |
x-goog-api-key header |
translated |
| bedrock-converse | Bedrock Converse | SigV4 signature (no header injected) | translated |
| cohere-chat | Cohere chat | authorization header |
translated |
openai-compat is the passthrough dialect: the body relays with the model id
swapped, plus the fidelity pass described below. That is why any OpenAI-compatible host
works without translation: OpenAI itself, Azure, Groq, Together, Fireworks, OpenRouter, or
Ollama's /v1 surface. The other four are real translations, and a report that
says "translated": true is telling you exactly one thing: this leg was not
openai-compat.
Declaring an upstream
An upstream is an entry in route.upstreams, keyed by the name you will use in
route.models and in a route's chain. Three fields matter for
this page; the rest of the schema lives in Configuration.
One of the five values above. It selects the adapter: the translation, the parser, and the capability rules in the matrix below.
A bundled host profile id. It carries the per-host quirks (error envelope grammar, retry-after header formats, stream envelope shape, rejected params) and it supplies the provider attribution label. An unknown id is a hard load error.
Exactly { "env": "VAR_NAME" }, or
{ "file": "/path/to/key" }, or null for a keyless
upstream. Nothing else: a bare string is refused, an extra key is refused, and a
value that looks like a credential is refused without echoing it. Every example on
this page names an environment variable, never a key. See
Security for file modes, caller keys, and header forwarding.
unlistedModels is also an upstream-level field ("verbatim",
"strip-author", or "none") and it affects which legs a request
can expand into; Routing covers that expansion.
What can happen to a request feature
This is the distinction the rest of the page hangs on, and it is worth learning once because each outcome is visible in a different place, and one of them is visible nowhere at all. Read every table cell below against these five words.
-
Forwarded. The value reaches the upstream unchanged. On
openai-compatthat is the whole body verbatim; on a translated dialect it means the adapter mapped the param onto the equivalent wire field under a different name, with the same value. -
Clamped. The value reaches the upstream coerced to the nearest legal
bound for that dialect, and the coercion is annotated in
clamped_params. Never rescaled; see the warning under the clamp table. -
Dropped and annotated. The dialect cannot express it, or the host
profile rejects it. The request still goes out without it, and the drop is written into
the report as
dropped_params. This is the fidelity engine's bucket, and it is the well-behaved case. - Dropped silently. The param never reaches the upstream and appears in no report field. This happens when the fidelity engine keeps a param (it is not on that dialect's unexpressible list) but the adapter's wire body is an explicit allowlist that never mentions it. Every such cell is called out below, because it is the one outcome you cannot detect after the fact. These are open defects, not design.
-
Injected. A value the caller never supplied is added to the outbound
request, or a value the caller did supply is raised. There is one family of these:
Anthropic's required
max_tokens, described under that adapter. It is not annotated either.
Separately from all five, request content has a sixth outcome:
rejected pre-flight, and the leg is skipped. Multimodal content that
cannot be expressed on the target dialect stops the leg before the request is built, at
zero cost and with no network call. The leg is classified
retryable(translated_bad_request), marked as not dispatched, and annotated
unsupported_content. A model answering about an image it was never sent would
be a correctness bug, so the content is never quietly discarded instead.
Two mechanisms produce those outcomes, and knowing which one owns a param tells you whether a drop will be annotated. The fidelity engine owns the sampling knobs: it drops what a dialect cannot express, clamps what is out of range, and returns the annotations. It runs in a fixed order, and later steps see the earlier ones' results:
- the host profile's
rejectedParams; - sampling params the dialect cannot express;
- platform extras the dialect cannot express;
- the
tool_choicedrop; - the Anthropic extended-thinking special case;
- range clamps.
Each adapter owns the structural params (max_tokens,
stop, top_k, top_p, tools,
response_format) by explicit name mapping, and the engine neither drops nor
clamps those. That split is the source of every silent drop on this page: a param the
engine keeps and the adapter does not map vanishes with nothing recorded. It is not that
structural params are safe; it is that nothing is watching them.
Warning
dropped_params and clamped_params are per-leg fields on the
routing report, and the routing report reaches you through exactly one surface: the
onRequestComplete observer hook, plus the bundled journal observer that
persists what the hook carries. They are not response headers. The
x-switchback-* set is upstream, dialect, attempts, budget-overflow and
budget-remaining, and nothing else. So an HTTP client calling switchback cannot see that
its sampling params were edited; only an operator reading the journal, or code wired
into the hook, can. See Observability.
Capability matrix
Read the rows as dialects and the columns as things your client might send. Every cell is the adapter's actual behavior, verified against the wire body the adapter builds. Where a cell says annotated, the report will also tell you after the fact; where it says silently, the report will not, and the cell is the only warning you get.
Request features
| dialect | tool_choice | reasoning | image, base64 data URI | image, data URI without base64 | image, https URL | input_audio | file / document | transforms / route |
|---|---|---|---|---|---|---|---|---|
| openai-compat | Yes | Yes, kept | Yes | Yes | Yes | Yes | Yes | Only on the openrouter profile |
| anthropic-messages | Yes | Translated to thinking | Yes | Leg skipped | Yes, fetched upstream | Leg skipped | Leg skipped | Dropped |
| gemini-generate | Yes | Dropped | Yes | Leg skipped | Leg skipped | Leg skipped | Leg skipped | Dropped |
| bedrock-converse | Yes | Dropped | Four formats only | Leg skipped | Leg skipped | Leg skipped | Leg skipped | Dropped |
| cohere-chat | Dropped | Dropped | Yes | Leg skipped | Leg skipped | Leg skipped | Leg skipped | Dropped |
Where each of those columns maps to, when it is expressible:
-
tool_choicepasses through onopenai-compat, maps to Anthropic's owntool_choice, to Gemini'stoolConfig.functionCallingConfig, and to Bedrock'stoolConfig.toolChoice.cohere-chatcannot express it at all, so it is dropped with adropped_paramsannotation, and your tool-forcing request becomes a suggestion on that leg. -
transformsandrouteare OpenRouter platform keys. They are forwarded verbatim only when the upstream's profile is exactlyopenrouter. On every otheropenai-compathost, and on all four translated dialects, they are dropped and annotated.
Sampling parameters
Three outcomes, not two. Forwarded means the value reaches the upstream,
under that dialect's own field name where it differs.
Dropped, annotated means the fidelity engine removed it and listed it in
dropped_params. Dropped, silently means the engine kept it,
the adapter's wire body never mentions it, and no report field records it: the value you
sent reached nothing, and nothing told you.
| Param | openai-compat | anthropic-messages | gemini-generate | bedrock-converse | cohere-chat |
|---|---|---|---|---|---|
| logprobs | Forwarded | Dropped, annotated | Dropped, annotated | Dropped, annotated | Dropped, annotated |
| top_logprobs | Forwarded | Dropped, annotated | Dropped, annotated | Dropped, annotated | Dropped, annotated |
| logit_bias | Forwarded | Dropped, annotated | Dropped, annotated | Dropped, annotated | Dropped, annotated |
| n | Forwarded | Dropped, annotated | Dropped, annotated | Dropped, annotated | Dropped, annotated |
| frequency_penalty | Forwarded | Dropped, annotated | defect Dropped, silently | Dropped, annotated | Forwarded, unclamped |
| presence_penalty | Forwarded | Dropped, annotated | defect Dropped, silently | Dropped, annotated | Forwarded, unclamped |
| seed | Forwarded | Dropped, annotated | defect Dropped, silently | Dropped, annotated | Forwarded |
Known defect
The three gemini-generate cells above are the page's own correction. Gemini
can express all three (frequencyPenalty,
presencePenalty and seed are real
generationConfig fields), and the fidelity engine keeps them because they
are not on Gemini's unexpressible list. But the adapter's
generationConfig mapper writes only temperature,
topP, topK, maxOutputTokens and
stopSequences, and the request body is a closed set, so all three vanish
with no dropped_params entry. An earlier version of this page listed them
as kept, and for the penalties as carrying "no clamp", which reads as forwarded
unclamped. They are not forwarded at all. Until the mapper is fixed, do not send
penalties or a seed to a Gemini leg and expect either effect or a warning.
Structural parameters
These are name-mapped by each adapter rather than handled by the fidelity engine, so the engine never drops or clamps them and never annotates anything about them. That is exactly why the silent cells below are silent.
| Param | openai-compat | anthropic-messages | gemini-generate | bedrock-converse | cohere-chat |
|---|---|---|---|---|---|
| max_tokens | Forwarded |
injected max_tokens, defaulted to
4096 when you omit it
|
maxOutputTokens |
inferenceConfig.maxTokens |
max_tokens |
| stop | Forwarded | stop_sequences |
stopSequences |
stopSequences, non-strings filtered |
stop_sequences |
| top_p | Forwarded | top_p |
topP |
inferenceConfig.topP |
p |
| top_k | Forwarded | defect Dropped, silently | topK |
defect Dropped, silently | k |
| tools | Forwarded | Translated | functionDeclarations |
toolConfig.tools, suppressed when
tool_choice: "none"
|
Translated |
| response_format | Forwarded | defect Dropped, silently | defect Dropped, silently | defect Dropped, silently | Forwarded |
Known defect
top_k and response_format are the two structural params with
silent cells, and both matter more than a merely unexpressible param would.
top_k is supported by Anthropic's Messages API and expressible on Bedrock
through additional model fields, so this is capability lost to an incomplete mapping
rather than a dialect limitation. response_format is worse in effect: a
request that asks for JSON gets prose back from an Anthropic, Gemini or Bedrock leg
while the same request gets JSON from an openai-compat or Cohere leg, and
nothing in the report distinguishes the two. If your chain mixes dialects and your
caller parses the response, constrain the chain rather than relying on
response_format.
Clamp ranges
A value outside the dialect's legal range is clamped to the nearest legal value and
annotated in clamped_params. A range in a cell means the param is
forwarded, clamped to those bounds if it falls outside them. Only
temperature and top_p have declared bounds on any dialect;
top_k has none anywhere, so where it is mapped at all it rides verbatim.
| dialect | temperature | top_p | frequency_penalty | presence_penalty |
|---|---|---|---|---|
| openai-compat | 0 – 2 | 0 – 1 | -2 – 2 | -2 – 2 |
| anthropic-messages | 0 – 1 | 0 – 1 | Dropped, annotated | Dropped, annotated |
| gemini-generate | 0 – 2 | 0 – 1 | defect Never reaches the wire: dropped silently, so there is nothing to clamp | defect Never reaches the wire: dropped silently, so there is nothing to clamp |
| bedrock-converse | 0 – 1 | 0 – 1 | Dropped, annotated | Dropped, annotated |
| cohere-chat | 0 – 1 | 0 – 1 | Forwarded, no clamp | Forwarded, no clamp |
Note
"Forwarded, no clamp" on the Cohere row is a real exposure rather than a neutral choice. The canonical scale for both penalties is OpenAI's -2 to 2, so a value that is legal for your client is forwarded untouched and Cohere decides whether to accept it. A servable leg can therefore become an upstream 400 that a declared range would have prevented. Note the asymmetry with the Gemini row directly above it: same "no clamp" wording in the old table, two completely different behaviors.
Warning
Clamping is not rescaling. temperature: 0.7 against a dialect whose ceiling
is 1 stays 0.7. It is not remapped to 0.35 to preserve its
position on the 0–2 scale. A chain that crosses from a 0–2 dialect to a 0–1 dialect
therefore changes the effective sampling behavior of the same request, and only a value
actually outside the range shows up in clamped_params: an in-range value is
byte-identical on every leg and is recorded nowhere, correctly.
Reasoning and extended thinking
The reasoning control is OpenRouter's unified reasoning knob. On
openai-compat it is kept. On anthropic-messages it is translated
into an Anthropic thinking block, enabled whenever reasoning is
a non-null object that does not set enabled: false. On
gemini-generate, bedrock-converse and
cohere-chat it is dropped and annotated.
Note
Anthropic forbids a non-default temperature or top_p while
thinking is on, so when the router turns thinking on it drops both and annotates them.
If you send reasoning and temperature together and then wonder
why your temperature had no effect on the Anthropic leg, that pair of
dropped_params entries is the answer.
Reasoning output is normalized in the other direction regardless of whether you could ask
for it: Anthropic thinking blocks, Gemini thought parts and
Cohere thinking blocks all come back to your client as
message.reasoning_content.
Content forms and the pre-flight skip
Expressibility is decided by the form of the content part, not by its size or its media type alone. The check runs before the request is built and it never fetches a URL, so it costs nothing and it cannot be fooled by a host that would have 404ed anyway.
| Form | What it looks like | Notes |
|---|---|---|
| data | data:<mediatype>;base64,<payload> |
A genuine base64 data URI. Expressible on all five dialects for images. |
| data-raw | a data: URI with no ;base64, |
No extractable bytes, so only openai-compat can relay it. Everything
else skips the leg.
|
| url | https:// or http:// |
openai-compat relays it; Anthropic accepts it and fetches it itself.
Gemini, Bedrock and Cohere cannot take a URL.
|
| other | relative, protocol-relative, or malformed | Inexpressible on every dialect, including openai-compat. |
When a form is inexpressible the report names it, so you can tell the four cases apart
without guessing: image_url(https), image_url(data),
image_url(format), image_url(unsupported),
input_audio, file, file(url), and
file(unsupported).
Audio and files are the blunt cases. input_audio is carried by
openai-compat and by nothing else; file and document parts likewise, in all
three URI forms. The four translated dialects declare both unsupported on purpose. Some of
those providers can carry audio, but these adapters do not emit it, and declaring it
expressible would make the content vanish instead of skipping the leg.
Warning
A pre-flight skip only helps you if the chain is allowed to move on. Put
translated_bad_request in a route's policy.advanceOn whenever
any non-openai-compat upstream is in that chain. Otherwise the skip
surfaces to your client as an error instead of advancing to the next leg. See
Routing.
Host profiles
A profile is declarative per-host quirk data, one JSON file per host, selected by id. No provider grammar is hard-coded in the classifier, which is why a new host's error shape is a data change rather than a code change. Fourteen profiles ship in the box:
openai, anthropic, gemini, bedrock,
cohere, openrouter, groq, mistral,
perplexity, cerebras, sambanova,
alibaba, zai, moonshot. openai is the
default and the fallback.
| Profile field | What it carries |
|---|---|
| id | The value you write in profile, and the attribution label. |
| errorShape | Where the message, code and metadata live in this host's error envelope, plus status-to-reason hints and the moderation-flag path. |
| rateLimitHeaders |
Which headers carry retry-after, and in which format:
seconds, http-date, milliseconds,
duration-string, epoch-seconds,
epoch-millis.
|
| streamEnvelope | Stream quirks: where final usage arrives, whether a done sentinel is sent. |
| toolCallIdFormat |
openai-call, mistral-9char, or synthesized.
|
| rejectedParams | Params this host refuses, pre-dropped with an annotation. |
| extraResponseFields | Non-standard response fields to carry through instead of discarding. |
| usageExtensions | Where this host reports cost, cost details, and a bring-your-own-key flag. |
The openrouter profile is the fullest worked example: it reads the message
from error.message and the code from error.code, treats 402 and
403 as auth_budget, walks a three-step retry-after chain from
retry-after through x-ratelimit-reset-requests to
x-ratelimit-reset-tokens, expects final usage in the last stream chunk plus a
done sentinel, carries reasoning_details through, and reads cost out of
usage.cost.
The cerebras profile is the fullest rejectedParams example. It
rejects logprobs, top_logprobs, logit_bias,
frequency_penalty, presence_penalty and n. Those
are dropped and annotated before the dialect pass even runs, which is how an
openai-compat leg can still report a drop.
Note
The profile also supplies the provider attribution you see in the report and in the
response's provider field: it is the profile id if the upstream has one,
otherwise the upstream's own name. An upstream you named stub with
"profile": "openai" reports "provider": "openai".
Per-adapter notes
openai-compat
The passthrough path, and the only dialect with no capability gaps. Point
baseURL at any OpenAI-shaped host and pick the profile that matches it. The
dialect governs translation, the profile governs quirks, and they are independent choices.
It is also the only dialect that carries audio parts, file parts and
data: URIs without base64.
"openai-direct": {
"baseURL": "https://api.openai.com/v1",
"dialect": "openai-compat",
"profile": "openai",
"auth": { "env": "OPENAI_API_KEY" }
},
"cerebras-fast": {
"baseURL": "https://api.cerebras.ai/v1",
"dialect": "openai-compat",
"profile": "cerebras", // pre-drops logprobs, penalties, n
"auth": { "env": "CEREBRAS_API_KEY" }
}
anthropic-messages
Credential goes in x-api-key, resolved from this upstream's own
auth reference. The Anthropic API is versioned by header, so set
anthropic-version in the upstream's static headers.
"anthropic-direct": {
"baseURL": "https://api.anthropic.com",
"dialect": "anthropic-messages",
"profile": "anthropic",
"auth": { "env": "ANTHROPIC_API_KEY" },
"headers": { "anthropic-version": "2023-06-01" }
}
Gotchas specific to this leg:
-
tool_choicemaps faithfully;logprobs,top_logprobs,logit_bias,n,frequency_penalty,presence_penaltyandseedare all dropped and annotated. -
An
httpsimage URL is accepted, but Anthropic fetches it and the router never does. If the image lives somewhere only your network can reach, that leg fails at the provider, not pre-flight. -
Turning on thinking costs you
temperatureandtop_p, as above. -
injected Anthropic requires
max_tokens, so a request that omits it goes out with4096. You are not told. The same request is uncapped on anopenai-compatleg and capped at 4096 completion tokens here, which is a real cross-leg behavior difference in a chain that spans both. -
injected On a thinking leg your own
max_tokenscan be raised: Anthropic requires the thinking budget to be strictly belowmax_tokensand floors the budget at 1024, somax_tokens: 100withreasoningenabled leaves asmax_tokens: 2048with a 1024-token budget. Also unannotated. -
defect
top_kis dropped silently. The fidelity engine keeps it (Anthropic's Messages API supports it), but the adapter's body never mentions it, so it reaches neither the wire nordropped_params. -
defect
response_formatis dropped silently. A JSON-mode request served on this leg comes back as prose. -
known limit On a content-bearing response that arrives
with no finish reason, this adapter still fabricates
"stop".
gemini-generate
Credential goes in x-goog-api-key. tool_choice maps to
toolConfig.functionCallingConfig. baseURL is yours to supply,
since the router does not hard-code any provider endpoint.
"gemini-main": {
"baseURL": "<your Gemini API base URL>",
"dialect": "gemini-generate",
"profile": "gemini",
"auth": { "env": "GEMINI_API_KEY" }
}
Gotchas specific to this leg:
-
Images must be base64 data URIs. A plain
httpsimage URL is a pre-flight skip here, which surprises people migrating a working OpenAI-shaped request. -
logprobs,top_logprobs,logit_biasandnare dropped and annotated.temperature,top_p,top_k,max_tokensandstopare forwarded asgenerationConfigfields. -
defect
frequency_penalty,presence_penaltyandseeddo not survive, and this is the one to read twice if you are migrating a working OpenAI-shaped request. The engine keeps them, thegenerationConfigmapper never writes them, and nodropped_paramsentry appears. Gemini itself would accept all three. An earlier version of this page said they survive. -
defect
response_formatis dropped silently too; Gemini's own structured-output fields are not mapped. -
known limit A parameterized base64 data URI
(one carrying extra parameters, such as
;name=x;base64,) passes the expressibility check and then throws while the request is being built, so it does not degrade into a clean leg skip.
bedrock-converse
The odd one out on credentials: nothing is injected as a header. The material behind this
upstream's auth reference is handed to the SigV4 signer, which signs the
Converse request itself. tool_choice maps to
toolConfig.toolChoice.
"bedrock-usw2": {
"baseURL": "<your Bedrock runtime endpoint>",
"dialect": "bedrock-converse",
"profile": "bedrock",
"auth": { "env": "BEDROCK_SIGNING_CREDENTIAL" }
}
Note
There is additional region and credential fallback behavior on this path that these docs
do not describe, because we have not verified it end to end. Declare the upstream's
auth reference explicitly rather than relying on ambient discovery, and
confirm against a real request before you put a Bedrock leg in a production chain.
Gotchas specific to this leg:
-
Images are restricted to
png,jpeg,gifandwebp(jpgnormalizes tojpeg). Anything else,svg+xmlfor instance, is a pre-flight skip annotatedimage_url(format). This is the one image case where the media type, not the URI form, decides. -
The same seven sampling params Anthropic drops are dropped and annotated here too, and
the clamp ceiling for
temperatureis 1. -
defect
top_kandresponse_formatare dropped silently. The ConverseinferenceConfigthis adapter builds carries onlymaxTokens,temperature,topPandstopSequences;top_kwould need Converse's additional model-request fields, which are not wired. -
known limit This adapter ignores the host profile's
rejectedParams, so for a Bedrock leg the report can disagree with what actually went on the wire. -
known limit This is also the one adapter that clamps
with its own local implementation instead of the shared fidelity engine, while the
report's
clamped_paramsstill comes from the engine. Both say 0 to 1 today, so they agree; change one without the other and the report would state a clamp that never happened. -
known limit
tool_choice: "none"combined with tool history in the conversation is rejected by Converse with a 400. -
known limit Like Anthropic, a content-bearing response
with no finish reason still gets a fabricated
"stop".
cohere-chat
Credential goes in the authorization header. Base64 image data URIs work;
everything else multimodal does not.
"cohere-main": {
"baseURL": "<your Cohere API base URL>",
"dialect": "cohere-chat",
"profile": "cohere",
"auth": { "env": "COHERE_API_KEY" }
}
Gotchas specific to this leg:
-
This is the only dialect that cannot express
tool_choiceat all. The tools themselves are mapped; the choice constraint is dropped and annotated. If your application depends on forcing a specific tool, a Cohere leg will behave differently from the rest of the chain. The caller gets no signal, though the drop is in the report. -
frequency_penalty,presence_penaltyandseedare genuinely forwarded here, and this is the one translated dialect where that is true. The two penalties ride unclamped, on your client's -2 to 2 scale, and Cohere decides whether to accept them.top_kmaps tok,top_ptop, andresponse_formatis forwarded.logprobs,top_logprobs,logit_biasandnare dropped and annotated. -
Cohere
thinkingblocks in the response are normalized tomessage.reasoning_content, even though you cannot request them withreasoningon this dialect.
A chain that crosses dialects
Nothing above requires you to think about dialects per request, which is the point. You declare the upstreams, map slugs onto them, and let one chain span vendors.
{
"route": {
"listen": { "host": "127.0.0.1", "port": 4011 },
"upstreams": {
"openai-direct": {
"baseURL": "https://api.openai.com/v1",
"dialect": "openai-compat",
"profile": "openai",
"auth": { "env": "OPENAI_API_KEY" }
},
"anthropic-direct": {
"baseURL": "https://api.anthropic.com",
"dialect": "anthropic-messages",
"profile": "anthropic",
"auth": { "env": "ANTHROPIC_API_KEY" },
"headers": { "anthropic-version": "2023-06-01" }
},
"groq-fast": {
"baseURL": "https://api.groq.com/openai/v1",
"dialect": "openai-compat",
"profile": "groq",
"auth": { "env": "GROQ_API_KEY" }
},
"cerebras-fast": {
"baseURL": "https://api.cerebras.ai/v1",
"dialect": "openai-compat",
"profile": "cerebras",
"auth": { "env": "CEREBRAS_API_KEY" }
}
},
"models": {
"gpt-4o": { "openai-direct": "gpt-4o" },
"claude-sonnet-4-5": { "anthropic-direct": "claude-sonnet-4-5" },
"llama-3.3-70b": {
"groq-fast": "llama-3.3-70b-versatile",
"cerebras-fast": "llama-3.3-70b"
}
},
"routes": {
"chat-default": {
"match": {},
"chain": ["gpt-4o", "claude-sonnet-4-5"],
"policy": {
"advanceOn": ["rate_limited", "server_error", "translated_bad_request"]
}
}
}
}
}
How that config behaves, feature by feature:
- A request carrying a base64 image works on either leg: the OpenAI one by passthrough, the Anthropic one by translation.
-
The same request carrying an
input_audiopart skips the Anthropic leg (unsupported_content: "input_audio") and, becausetranslated_bad_requestis inadvanceOn, falls through instead of failing the caller. -
A request with
logprobsreports"dropped_params": ["logprobs"]on the Anthropic leg, and reports the same drop on thecerebras-fastleg, sourced from that profile'srejectedParamsrather than from the dialect. -
A request with
top_korresponse_formatis served two different ways with no way to tell which you got: honored on thegpt-4oleg, discarded on theclaude-sonnet-4-5leg, and reported nowhere either way. That is the silent-drop family above, and it is why a chain that mixes dialects should not depend on those two params.
Known limits
Adding a provider does not add everything you might assume comes with it. These are the honest edges as of today.
-
Pricing does not arrive with the adapter. The bundled price catalog
prices exactly two rows,
openai/gpt-4oandanthropic/claude-sonnet-4-5. A new upstream is unpriced until you give it apriceMapentry, and under a dollar cap an unpriced leg is refused rather than guessed at. See Budgets for the details, including the key format, which uses the upstream's model id and not your client-facing slug. -
Embeddings are
openai-compatonly. An embeddings request that lands on any other dialect is skipped asno_route. That is a stated limitation, not a bug. Put anopenai-compatupstream in any chain that serves/v1/embeddings. -
Six params are dropped silently, and that is the worst class here.
frequency_penalty,presence_penaltyandseedon Gemini;top_kon Anthropic and Bedrock;response_formaton Anthropic, Gemini and Bedrock. Each is kept by the fidelity engine, never written by the adapter, and never annotated, so no report field and no response header records the loss. Several are supported by the provider, so this is an incomplete mapping rather than a dialect limitation. Known and unfixed. -
Two
max_tokensvalues are injected on Anthropic legs. The 4096 default when you send none, and the raise-above-your-value when thinking is on. Both change the completion ceiling depending on which leg wins, and neither is recorded. -
The report is an operator surface, not a caller surface.
dropped_params,clamped_paramsandunsupported_contentreach you only through theonRequestCompletehook and the journal. An HTTP client sees none of them. -
The deferred adapter defects listed per adapter above are real. The
fabricated
"stop"on Anthropic and Bedrock, Gemini's parameterized-data-URI build throw, Bedrock ignoring profilerejectedParams, Bedrock's second clamp implementation, and Bedrock'stool_choice: "none"400 are known and unfixed. Treat them as current behavior.
Warning
The router is pre-launch and under active development. The dialect list, the capability rules and the config shape can all change, and the CLI says the same thing every time it starts.
Where to go next
- Routing How a dialect skip becomes a leg advance, and which verdicts move a chain.
- Configuration The full upstream schema: timeouts, headers, forwarding, caller keys.
- Observability Where dropped_params, clamped_params and unsupported_content show up.
- OpenRouter migration What a base-URL swap keeps, and where the openrouter profile matters.