zuplo 7.8.15 → 7.8.16

package/docs/ai-gateway/bedrock-runtime.mdx

@@ -202,8 +202,12 @@ bedrockruntime/us.anthropic.claude-haiku-4-5-20251001-v1:0
 ```
 
 The gateway strips its own prefix and sends AWS the model ID exactly as you
-wrote it, so **anything Bedrock accepts works**—published model IDs,
-cross-region inference profiles, and provisioned-throughput ARNs alike.
+wrote it. As with every other provider, the model must be one you enabled for
+the provider. Cross-region inference profile IDs appear in the model list as
+models of their own. A foundation-model or inference-profile ARN counts as the
+model ID it contains, so it works when that model is enabled. The gateway
+refuses any other model before it calls AWS, including a provisioned-throughput
+ARN and an application inference profile, which don't name a model in the list.
 
 :::tip{title="Many models need an inference profile ID"}
 
@@ -231,12 +235,9 @@ priced too: the `us.`, `eu.`, `apac.`, `au.`, `jp.`, `us-gov.`, and `global.`
 IDs are catalog rows in their own right, each at its own rate. A
 foundation-model or inference-profile ARN, such as
 `arn:aws:bedrock:eu-central-1:123456789012:inference-profile/eu.anthropic.claude-opus-4-8`,
-is priced as the ID it contains. A model with no catalog row, such as a
-provisioned-throughput ARN, an application inference profile, or an inference
-profile AWS added after the catalog, is still served and still counts toward
-token and request [budgets](./usage-limits.mdx), but is priced at zero. It
-doesn't count toward spending budgets, and its response carries no `X-Cost-USD`
-header.
+is priced as the ID it contains. Every model you can call has a catalog price,
+so each request counts toward token, request, and spending
+[budgets](./usage-limits.mdx).
 
 When a budget is exhausted, these routes answer
 `400 ServiceQuotaExceededException`—not the `429` the Universal API returns. AWS
@@ -296,6 +297,12 @@ baked into the deployed gateway. The dialog also rejects an access key ID that
 isn't 16 to 128 uppercase letters and digits, a secret containing spaces or line
 breaks, and either field filled in without the other.
 
+**An error saying the model `is not included in model selections`.** The model
+isn't enabled for the provider. Open the provider in
+[**Settings → AI Providers**](https://portal.zuplo.com/+/account/project/ai/settings/data-models),
+enable the model, and save. If the model is missing from the list, the gateway
+can't serve it through this provider yet.
+
 **A `400` naming the supported operations.** You called `CountTokens` or
 `InvokeModelWithBidirectionalStream`, which the gateway doesn't serve.
 
@@ -305,8 +312,9 @@ these routes with that exception—check the app's usage limits before you open
 quota ticket with AWS.
 
 **Your app's model list is empty of Bedrock models.** Expected—Bedrock Runtime
-models don't appear in `GET /v1/models`, because model IDs here are open-ended
-(inference profiles and ARNs are valid and aren't catalog entries).
+models don't appear in `GET /v1/models`, because that listing describes the
+[Universal API](./universal-api.mdx), and this provider serves only Bedrock's
+native paths.
 
 ## Next steps
 

package/docs/ai-gateway/custom-providers.mdx

@@ -57,8 +57,10 @@ To add a custom AI provider to your Zuplo AI Gateway, follow these steps:
    provider named `acme-llm` serves models as `acme-llm/<model>`. Names are
    lowercase (letters, numbers, dots, dashes, and underscores), and Zuplo
    reserves the built-in provider names (`openai`, `anthropic`, `google`,
-   `mistral`, `xai`, `moonshot`, `zuplo`, `zuplodemo`, `zuplo-demo`). The name
-   is permanent after creation.
+   `mistral`, `xai`, `moonshot`, `zuplo`, `zuplodemo`, `zuplo-demo`,
+   `bedrockmantle`, `bedrock-mantle`, `azureai`, `azure-ai`, `vertexai`,
+   `vertex-ai`, `openrouter`, `open-router`). The name is permanent after
+   creation.
 
 1. Enter the provider's **API URL** as its origin root—for example
    `https://api.together.xyz`. The gateway appends `/v1/chat/completions` (and
@@ -80,6 +82,15 @@ To add a custom AI provider to your Zuplo AI Gateway, follow these steps:
    | Groq       | `https://api.groq.com/openai/v1`        | `https://api.groq.com/openai`        |
    | Fireworks  | `https://api.fireworks.ai/inference/v1` | `https://api.fireworks.ai/inference` |
 
+   :::tip{title="OpenRouter is built in"}
+
+   OpenRouter is now a built-in provider—pick it from the provider list instead
+   of configuring it here, and you get model discovery and per-model cost
+   tracking. See [Using OpenRouter](./openrouter.mdx). The OpenRouter row above
+   still applies to any OpenRouter provider you added before it became built-in.
+
+   :::
+
 1. Enter the API Key for the selected provider (if there is no API key required,
    you can leave this blank).
 

package/docs/ai-gateway/integrations/ai-sdk.mdx

@@ -53,9 +53,10 @@ configure.
 Each provider package appends its own operation path to `baseURL`, so pick the
 model factory that targets an endpoint the gateway serves:
 `/v1/chat/completions` for OpenAI-compatible requests, `/v1/messages` for
-Anthropic, `/v1/embeddings` for every provider with embedding models, and
-`/v1/responses` for OpenAI and Azure OpenAI-compatible deployments. The examples
-below use the right factory for each provider.
+Anthropic and other providers' Claude models, `/v1/embeddings` for every
+provider with embedding models, and `/v1/responses` for OpenAI and the other
+providers whose models serve it (see [AI Providers](../providers.mdx) for the
+matrix). The examples below use the right factory for each provider.
 
 ### OpenAI
 
@@ -143,8 +144,10 @@ const { text } = await generateText({
 ### xAI
 
 Call `xai.chat(...)` rather than `xai(...)`. The bare callable targets xAI's
-Responses API, and the gateway serves `/v1/responses` for the OpenAI provider
-only—an xAI model sent there returns a `400`.
+Responses API, and xAI's models do not serve `/v1/responses` through the
+gateway—an xAI model sent there returns a `400`. The endpoint is
+capability-gated per model rather than restricted to one provider, so which
+models reach it is the matrix in [AI Providers](../providers.mdx).
 
 ```typescript
 import { createXai } from "@ai-sdk/xai";
@@ -287,6 +290,35 @@ const { text } = await generateText({
 });
 ```
 
+### OpenRouter
+
+Use `@ai-sdk/openai`. OpenRouter model references have two slashes,
+`providerName/vendor/model`—see
+[Model references include the vendor prefix](../openrouter.mdx#model-references-include-the-vendor-prefix).
+
+Which factory works depends on the model. The bare `openai(id)` callable targets
+the Responses API, which OpenRouter's Claude models don't serve through the
+gateway, so a Claude model sent that way returns a `400`. Call `openai.chat(id)`
+for Claude—the gateway translates the chat completion to the Messages API—or use
+`@ai-sdk/anthropic` with `authToken` for the native Messages API. Every other
+chat model works with either form.
+
+```typescript
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText } from "ai";
+
+const openai = createOpenAI({
+  apiKey: process.env.ZUPLO_AI_GATEWAY_API_KEY,
+  baseURL:
+    "https://my-gateway-main-2e18f50.zuplo.app/config_fe0a04972d2848e0a94ae4b8bcd1497e/v1",
+});
+
+const { text } = await generateText({
+  model: openai.chat("openrouter/anthropic/claude-sonnet-4.5"),
+  prompt: "Write a one-sentence bedtime story about a unicorn.",
+});
+```
+
 ## Provider options the gateway doesn't forward
 
 On the OpenAI-shaped endpoints (`/v1/chat/completions`, `/v1/embeddings`, and
@@ -298,6 +330,11 @@ forwarded. Options outside that list are dropped without a warning. For example,
 `seed` and `providerOptions.mistral.safePrompt` don't reach Mistral, and
 `temperature` is capped at Mistral's maximum of `1`.
 
+OpenRouter's model-fallback options are the exception: the gateway rejects
+`models` and `route` on chat completions, and `fallbacks` on `/v1/messages`,
+with a `400` rather than dropping them. See
+[Using OpenRouter](../openrouter.mdx#provider-routing-preferences).
+
 Anthropic is different: `/v1/messages` is a native passthrough, so
 `@ai-sdk/anthropic` requests reach Anthropic unchanged apart from the model and
 credential, which the gateway sets from your app configuration.

package/docs/ai-gateway/managing-providers.mdx

@@ -58,7 +58,9 @@ To add a new AI provider to your Zuplo AI Gateway, follow these steps:
    Project ID** and takes a service account JSON key file instead of an API key,
    and [Azure AI](./azure-ai.mdx) asks for an **Azure Resource Name** and a host
    family, plus a mapping for any deployment named differently from the model it
-   serves.
+   serves. [OpenRouter](./openrouter.mdx) is the opposite case: it asks for
+   nothing beyond the key, being a single global host with no endpoint, region
+   or project to enter.
 
 1. Select the model or models you want to use with this provider. The available
    models will depend on the selected provider. This can be changed later.

package/docs/ai-gateway/openrouter.mdx

@@ -0,0 +1,265 @@
+---
+title: Using OpenRouter
+sidebar_label: OpenRouter
+description:
+  Reach hundreds of models from every major vendor through one OpenRouter API
+  key. Model references carry the vendor prefix, Claude models serve the native
+  Messages API, and reported spend matches your OpenRouter invoice.
+---
+
+Reach hundreds of models from every major vendor through one OpenRouter API key,
+with gateway spend that matches your OpenRouter invoice.
+
+**OpenRouter** is a marketplace rather than a single vendor: one key reaches
+models from OpenAI, Anthropic, Google, Meta, DeepSeek, Qwen, xAI and many more,
+and OpenRouter chooses an upstream host for each request. Adding it as a
+provider serves those models to your [apps](./apps.mdx) through the
+[Universal API](./universal-api.mdx), on your OpenRouter account and your
+OpenRouter billing.
+
+Three things set this provider apart, and each one changes something you'll
+type:
+
+- **Model references carry the vendor prefix**, so they have two slashes.
+- **Claude models serve the Messages API**, not the Responses API.
+- **Reported spend matches your OpenRouter invoice**, because OpenRouter prices
+  each request and the gateway bills from that figure.
+
+## Model references include the vendor prefix
+
+Every OpenRouter model ID is vendor-qualified — `anthropic/claude-sonnet-4.5`,
+`openai/gpt-5`, `meta-llama/llama-3.3-70b-instruct`. A gateway model reference
+prefixes your provider name onto that, so it has **two** slashes:
+
+```text
+openrouter/anthropic/claude-sonnet-4.5
+openrouter/openai/gpt-5
+openrouter/meta-llama/llama-3.3-70b-instruct
+```
+
+The first segment is your provider name, and everything after the first slash is
+the model ID exactly as OpenRouter publishes it. This is the same shape
+[Vertex AI](./vertex-ai.mdx) uses.
+
+## Supported endpoints
+
+Which endpoints a model serves depends on what kind of model it is. Claude is
+served on a different API from every other chat model, and embedding models
+serve only embeddings:
+
+| Endpoint                    | Claude models (`anthropic/…`) | Other chat models | Embedding models |
+| --------------------------- | ----------------------------- | ----------------- | ---------------- |
+| `/v1/chat/completions`      | ✅ (translated)               | ✅                | ❌               |
+| `/v1/messages`              | ✅                            | ❌                | ❌               |
+| `/v1/messages/count_tokens` | ❌                            | ❌                | ❌               |
+| `/v1/responses`             | ❌                            | ✅                | ❌               |
+| `/v1/embeddings`            | ❌                            | ❌                | ✅               |
+
+:::note{title="The Responses API is stateless on OpenRouter"}
+
+OpenRouter doesn't store responses. You can create one, but you can't retrieve
+or delete it or list its input items, and OpenRouter rejects requests that set
+`store: true` or `previous_response_id`. Send the full conversation with each
+request instead.
+
+OpenRouter doesn't offer token counting either, so `/v1/messages/count_tokens`
+returns a `400` for every OpenRouter model.
+
+:::
+
+:::note{title="Claude models don't serve the Responses API here"}
+
+OpenRouter's own Responses endpoint will accept a Claude model. The gateway
+doesn't allow it, so that every provider follows the same rule: `/v1/messages`
+means Claude, and `/v1/responses` means everything else. To call a Claude model
+from an OpenAI-compatible client, use `/v1/chat/completions`: the gateway
+translates the request onto the Messages API for you.
+
+:::
+
+## Before you begin
+
+You need an OpenRouter API key. Create one at
+[openrouter.ai/keys](https://openrouter.ai/keys); it starts with `sk-or-v1-`.
+
+You also need credit on the OpenRouter account the key belongs to, or requests
+come back with OpenRouter's own insufficient-credit error.
+
+## Add the provider
+
+Adding or editing providers requires the **Edit** permission, granted to Zuplo
+account and project **Admins**—see
+[Managing Providers](./managing-providers.mdx).
+
+<Stepper>
+
+1. Open
+   [**Settings → AI Providers**](https://portal.zuplo.com/+/account/project/ai/settings/data-models)
+   in your AI Gateway project in the Zuplo Portal.
+
+2. Select **Add Provider**, then choose **OpenRouter**.
+
+3. Give the provider a **Provider Name**. This is the first segment of every
+   model reference, so a provider named `openrouter` serves
+   `openrouter/openai/gpt-5`. The name is permanent after creation.
+
+4. Paste your **API Key**. There is no endpoint or region to enter — OpenRouter
+   is a single global host.
+
+5. Select the models this provider should serve, then **Save**.
+
+</Stepper>
+
+## Routing shortcuts
+
+OpenRouter lets you append a routing preference to any model ID:
+
+| Suffix    | Effect                                       |
+| --------- | -------------------------------------------- |
+| `:nitro`  | Prefer the fastest upstream host             |
+| `:floor`  | Prefer the cheapest upstream host            |
+| `:online` | Add web search to the request                |
+| `:exacto` | Prefer hosts that call tools most accurately |
+
+These work through the gateway and are forwarded to OpenRouter unchanged. They
+don't appear in the model picker, because they aren't separate models — the
+gateway resolves `openrouter/openai/gpt-5:nitro` against the `openai/gpt-5`
+catalog entry and sends the suffix upstream.
+
+Two consequences worth knowing:
+
+- **A model-filtering allow list matches literally.** Allowing
+  `openrouter/openai/gpt-5` does not allow `openrouter/openai/gpt-5:nitro`. Add
+  the suffixed reference explicitly if you want it.
+- **Other suffixes aren't supported.** OpenRouter's `:free` variants are
+  separate models, and the gateway's OpenRouter catalog doesn't include them, so
+  a request for one is rejected like any model outside your selections.
+
+## Call the models
+
+Point any OpenAI-compatible client at your app URL with `/v1` appended:
+
+```ts
+import OpenAI from "openai";
+
+const client = new OpenAI({
+  baseURL:
+    "https://my-gateway-main-2e18f50.zuplo.app/config_fe0a04972d2848e0a94ae4b8bcd1497e/v1",
+  apiKey: process.env.ZUPLO_APP_API_KEY,
+});
+
+const completion = await client.chat.completions.create({
+  model: "openrouter/openai/gpt-5",
+  messages: [{ role: "user", content: "Hello!" }],
+});
+```
+
+### Provider routing preferences
+
+OpenRouter's `provider` option is forwarded, so you can express upstream
+preferences per request:
+
+```ts
+const completion = await client.chat.completions.create({
+  model: "openrouter/openai/gpt-5",
+  messages: [{ role: "user", content: "Hello!" }],
+  // @ts-expect-error -- an OpenRouter extension, not part of the OpenAI types
+  provider: { sort: "throughput" },
+});
+```
+
+`provider` is forwarded on embeddings and the Responses API too. On chat
+completions, `transforms`, `reasoning` and `plugins` are forwarded the same way.
+The Responses API forwards `plugins`, and `reasoning` is a standard Responses
+parameter.
+
+:::caution{title="The models fallback array is never forwarded"}
+
+OpenRouter's `models` array (and `route: "fallback"`) asks OpenRouter to
+substitute a different model when the first one is unavailable. On the Messages
+API the same array is called `fallbacks`. On chat completions and the Messages
+API, the gateway **rejects** these parameters with a `400` rather than dropping
+them silently. On embeddings and the Responses API, it drops them before the
+request reaches OpenRouter.
+
+They would route around the gateway itself: your model filtering wouldn't see
+the substitute, your budgets and per-model costs would be attributed to a model
+that never ran, and it would collide with the gateway's own fallback handling.
+Configure a backup model on the route instead.
+
+:::
+
+## Call Claude models on the Messages API
+
+Claude models on OpenRouter serve Anthropic's native Messages API, so the
+Anthropic SDK works against them directly. Set `baseURL` **without** `/v1` — the
+Anthropic SDK appends that itself — and pass your key as `authToken`:
+
+```ts
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic({
+  baseURL:
+    "https://my-gateway-main-2e18f50.zuplo.app/config_fe0a04972d2848e0a94ae4b8bcd1497e",
+  authToken: process.env.ZUPLO_APP_API_KEY,
+});
+
+const message = await client.messages.create({
+  model: "openrouter/anthropic/claude-sonnet-4.5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Hello!" }],
+});
+```
+
+`authToken`, not `apiKey`: the SDK's `apiKey` sends an `x-api-key` header, which
+the gateway doesn't read.
+
+For the Vercel AI SDK, see
+[the OpenRouter section of the AI SDK guide](./integrations/ai-sdk.mdx#openrouter).
+
+## Costs
+
+OpenRouter prices every request itself and reports the figure in the response,
+and the gateway records **that** figure rather than computing one from a stored
+rate card. Your reported spend therefore reconciles with your OpenRouter
+invoice.
+
+This matters more here than for a single-vendor provider. A `:floor` request and
+a `:nitro` request for the same model can run on different upstream hosts at
+different prices, so there is no single per-model rate that would be correct for
+both.
+
+Responses carry an `X-Cost-USD` header alongside `X-Cost-Source: provider`,
+which tells you the figure came from OpenRouter rather than from a rate card.
+
+## Troubleshooting
+
+**`400` saying `/v1/responses` is not supported** — you sent a Claude model to
+`/v1/responses`. Use `/v1/messages`, or `/v1/chat/completions`, which the
+gateway translates onto the Messages API; see
+[the table above](#supported-endpoints).
+
+**`400` naming `/v1/messages`** — you sent a model other than Claude to
+`/v1/messages`, which serves only Claude models here.
+
+**An error saying the model is not included in your model selections** — the
+model isn't selected on this provider. Open the provider on the **AI Providers**
+page and enable it.
+
+**`400` rejecting `models`, `route` or `fallbacks`** — see the caution above;
+use a route backup model instead.
+
+**`400` from `/v1/messages/count_tokens`** — OpenRouter doesn't offer token
+counting.
+
+**`404` from OpenRouter** — usually a model ID typo. The ID after your provider
+name must match OpenRouter's exactly, vendor prefix and all.
+
+**A key that won't save** — OpenRouter keys start with `sk-or-v1-` and contain
+no whitespace. Re-copy it from [openrouter.ai/keys](https://openrouter.ai/keys).
+
+## Next steps
+
+- [Universal API](./universal-api.mdx) — the endpoints every provider shares
+- [Managing providers](./managing-providers.mdx) — editing models and keys
+- [AI Providers](./providers.mdx) — the full provider and capability matrix

package/docs/ai-gateway/overview.mdx

@@ -78,10 +78,11 @@ Configure multiple LLM providers within a single AI Gateway project. Supported
 providers include OpenAI, Anthropic, Google, Mistral, xAI, Microsoft Azure
 (through [Azure AI](./azure-ai.mdx)), Amazon Bedrock (through
 [Bedrock Mantle](./bedrock-mantle.mdx)), Google Cloud
-([Vertex AI](./vertex-ai.mdx)), and OpenAI-compatible custom providers. See
-[AI Providers](./providers.mdx) for the full list of providers and supported
-capabilities. Apps reference models as `providerName/model`—for example
-`openai/gpt-5-mini`—so a single app can use models from several providers.
+([Vertex AI](./vertex-ai.mdx)), [OpenRouter](./openrouter.mdx), and
+OpenAI-compatible custom providers. See [AI Providers](./providers.mdx) for the
+full list of providers and supported capabilities. Apps reference models as
+`providerName/model`—for example `openai/gpt-5-mini`—so a single app can use
+models from several providers.
 
 ### Source-Controlled Gateway
 

package/docs/ai-gateway/providers.mdx

@@ -3,8 +3,8 @@ title: AI Providers
 sidebar_label: Overview
 description:
   The AI providers and capabilities the Zuplo AI Gateway supports, including
-  OpenAI, Anthropic, Google, Vertex AI, Mistral, xAI, and OpenAI-compatible
-  custom providers.
+  OpenAI, Anthropic, Google, Vertex AI, Mistral, xAI, OpenRouter, and
+  OpenAI-compatible custom providers.
 ---
 
 Zuplo's AI Gateway supports integration with various AI providers, allowing you
@@ -27,6 +27,8 @@ Zuplo currently supports the following AI providers:
   that already calls Bedrock with an AWS SDK
 - [Vertex AI](./vertex-ai.mdx)—Google Cloud's managed model platform, serving
   Gemini and Model Garden models on your own Google Cloud project
+- [OpenRouter](./openrouter.mdx)—hundreds of models from every major vendor
+  behind a single API key
 - [Zuplo Demo](#zuplo-demo)—a free, keyless provider for trying the gateway
 - OpenAI-compatible [Custom Providers](./custom-providers.mdx) (such as Qwen,
   Kimi, etc)
@@ -44,6 +46,7 @@ The following capabilities are supported across providers:
 | Bedrock Mantle             | ✅               | ❌         | ✅        | ✅       |
 | Bedrock Runtime            | ❌               | ❌         | ❌        | ❌       |
 | Vertex AI                  | ✅               | ✅         | ❌        | ✅       |
+| OpenRouter                 | ✅               | ✅         | ✅        | ✅       |
 | Zuplo Demo                 | ✅               | ❌         | ❌        | ❌       |
 | OpenAI-compatible (Custom) | ✅               | ✅         | ❌        | ❌       |
 
@@ -179,6 +182,32 @@ Model Garden for your Google Cloud project before it answers.
 For prerequisites, Google Cloud setup, provider steps, code examples, and
 troubleshooting, see [Using Vertex AI](./vertex-ai.mdx).
 
+## OpenRouter
+
+**OpenRouter** is a marketplace, not a single vendor: one API key reaches
+hundreds of models from OpenAI, Anthropic, Google, Meta, DeepSeek, Qwen, xAI and
+many more, and OpenRouter picks an upstream host for each request.
+
+Three things are specific to it:
+
+- **Model references have two slashes.** Every OpenRouter model ID is
+  vendor-qualified, so a provider named `openrouter` serves
+  `openrouter/anthropic/claude-sonnet-4.5` and `openrouter/openai/gpt-5`. This
+  is the same shape Vertex AI uses.
+- **Claude models are on the Messages API.** Models whose ID begins `anthropic/`
+  serve the native Anthropic Messages API (`/v1/messages`) and a translated
+  `/v1/chat/completions`, but not `/v1/responses`, even though OpenRouter's own
+  Responses endpoint would accept them. Other chat models serve chat completions
+  and the Responses API, and embedding models serve embeddings.
+- **Reported spend matches your OpenRouter invoice.** OpenRouter prices each
+  request itself and reports the figure inline, and the gateway bills from that
+  rather than from a stored rate card. That matters because OpenRouter's routing
+  shortcuts can send the same model to different hosts at different prices from
+  one request to the next.
+
+For prerequisites, provider steps, code examples, the routing shortcuts, and
+troubleshooting, see [Using OpenRouter](./openrouter.mdx).
+
 ## Zuplo Demo
 
 **Zuplo Demo** is a free provider that Zuplo operates so you can try the AI

package/docs/ai-gateway/universal-api.mdx

@@ -63,12 +63,12 @@ list—so clients that can't set a model still work.
 
 ## Supported endpoints
 
-| Endpoint               | Notes                                                                                                                                                           |
-| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `/v1/chat/completions` | Chat completions for every provider                                                                                                                             |
-| `/v1/embeddings`       | Embeddings for the providers marked in the [capability matrix](./providers.mdx#supported-providers)                                                             |
-| `/v1/responses`        | OpenAI Responses API: OpenAI, and the OpenAI-compatible models that serve it on [Azure AI](./azure-ai.mdx) and [Bedrock Mantle](./bedrock-mantle.mdx)           |
-| `/v1/messages`         | Anthropic Messages API: Anthropic, and the Claude models of [Azure AI](./azure-ai.mdx), [Bedrock Mantle](./bedrock-mantle.mdx) and [Vertex AI](./vertex-ai.mdx) |
+| Endpoint               | Notes                                                                                                                                                                                           |
+| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `/v1/chat/completions` | Chat completions for every provider                                                                                                                                                             |
+| `/v1/embeddings`       | Embeddings for the providers marked in the [capability matrix](./providers.mdx#supported-providers)                                                                                             |
+| `/v1/responses`        | OpenAI Responses API: OpenAI, and the OpenAI-compatible models that serve it on [Azure AI](./azure-ai.mdx), [Bedrock Mantle](./bedrock-mantle.mdx) and [OpenRouter](./openrouter.mdx)           |
+| `/v1/messages`         | Anthropic Messages API: Anthropic, and the Claude models of [Azure AI](./azure-ai.mdx), [Bedrock Mantle](./bedrock-mantle.mdx), [Vertex AI](./vertex-ai.mdx) and [OpenRouter](./openrouter.mdx) |
 
 ## Request headers
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuplo",
-  "version": "7.8.15",
+  "version": "7.8.16",
   "type": "module",
   "description": "The official Zuplo CLI for local development and platform management",
   "homepage": "https://zuplo.com/docs/cli/overview",
@@ -32,9 +32,9 @@
     "zuplo": "zuplo.js"
   },
   "dependencies": {
-    "@zuplo/cli": "7.8.15",
-    "@zuplo/core": "7.8.15",
-    "@zuplo/runtime": "7.8.15",
-    "@zuplo/test": "7.8.15"
+    "@zuplo/cli": "7.8.16",
+    "@zuplo/core": "7.8.16",
+    "@zuplo/runtime": "7.8.16",
+    "@zuplo/test": "7.8.16"
   }
 }