One gateway, different protocols: what actually carries over
A practical way to check model and protocol compatibility before a parameter disappears in translation.

Start with the job, not the API name
Two endpoints can both accept a conversation and still behave differently. One application needs plain text; another depends on images, structured output or a tool call. Write down the behavior that must survive the request and response, then choose a model and an endpoint that document those capabilities together. An OpenAI-compatible route describes a request shape, not a promise that every model implements every field.
Similar endpoint names usually mean some request and response structures are related, not that every model understands every parameter. Sampling controls, output limits, structured formats, image input and tool definitions may have different constraints. The provider, gateway and client library may each validate or transform data. Test basic callability separately from the capabilities the product depends on.
Make a small compatibility matrix
For each model and endpoint you plan to use, record accepted inputs, streaming behavior, tools, output format and relevant limits. Send one minimal request for each important feature. Treat unsupported fields as a release blocker if your product depends on them; do not assume that a successful plain-text request proves image or tool support.
A successful text request does not prove that streaming, tool calling or image input works for the same model. Check stream completion markers, tool names and argument shapes, the documented image input method, and the errors returned when something is unsupported. Do not treat fields from one provider as a universal standard; consult the current model and endpoint documentation.
Maintain a small set of ordinary text, boundary parameters, interrupted streams, tool calls and necessary multimodal cases. Run it after changing a model, client library or gateway, and compare response structure as well as status. Remove credentials and customer content from fixtures. Document the affected workflows and a rollback plan before promoting an incompatible change.
A useful record identifies the model version, endpoint, input category, expected result, actual result and test date. Avoid a single “compatible” label: one combination may handle text while rejecting a particular image input. Keep untested fields marked unknown, then test them before a dependent feature is released.
An adapter connects two protocols, but some features may not pass through.Inspect both sides of the exchange
Keep a sanitized sample request and response in your test suite. Check whether optional fields are rejected, ignored or transformed, and whether the response contains the information your application needs. Never put real keys, private prompts or customer content into public fixtures. Model versions and providers change, so repeat these checks when you switch either.
For each important parameter, record whether it is accepted and effective, explicitly rejected, ignored, or transformed with a different meaning. Inspect the request and the response, including the difference between a missing field and an explicit zero or false. A successful status does not prove that a parameter took effect. Use inputs that make the difference observable and keep sanitized results in regression tests.
Decide what happens when a feature is missing
Some differences can be handled in your application: for example, disable a UI control when the selected model does not support it. Other differences require a different model or endpoint. Show a useful error instead of silently dropping an instruction, and keep the provider documentation close to the compatibility record.
If a field has not been tested, mark it as unknown rather than supported. Record the test date, model ID, endpoint, result and limitations. When a capability cannot be converted, disable the relevant control, explain the limitation or offer a different model. If a difference changes the meaning of a request, an explicit error is safer than silently discarding an instruction.
Check what each field actually means
Compatibility involves more than renaming request fields. One API may represent message content as a string while another accepts an array of text, image and other blocks. System instructions, tool definitions and finish reasons can differ too. A converted request can be accepted while losing a meaning your application relies on.
Test an absent field, an empty value and an explicit zero or false separately: they may have different semantics. When a capability cannot be represented, choose a clear response—report it as unsupported, disable it with the user's knowledge or offer a tested alternative. Silently dropping an image or tool instruction is difficult for users to diagnose.
Test streaming and tool calls separately
For streaming, test event boundaries, content deltas, finish events and errors, not just the first visible word. A tool call may arrive in pieces; assemble and validate its arguments according to the actual protocol before execution. An interrupted answer should not be presented as complete.
A model's tool proposal is not permission to execute it. Validate arguments and user permissions, handle tool failures and return results in the chosen protocol's format. Test structured output separately: an endpoint accepting a field and one valid JSON response do not prove that every result will satisfy your schema.
Keep a compatibility record up to date
Record each combination with model ID and version, endpoint, input type, streaming, tools, output format, test date and result. Use “passed,” “failed” and “not tested,” with the conditions needed to reproduce a difference. Keep keys and customer content out of test fixtures.
For an order-support assistant, test a normal answer, valid and missing tool arguments, a redacted order result, denied access and a timeout. Check that the final answer reflects the tool's actual result. Rerun these examples after changing a model, client or gateway configuration, and decide whether to disable the affected feature or switch to a previously verified route.
A concrete comparison
Suppose a support assistant needs text answers and a customer lookup tool. Test the same question with each candidate model, then test a valid lookup and a malformed argument. Record whether the model asks for the tool, whether your server rejects bad input, and whether the final answer uses the returned data. If you later add image input, repeat the checks for that separate capability instead of assuming it follows from text support.