zuplo 7.5.2 → 7.5.4

package/docs/ai-gateway/apps.mdx

@@ -20,10 +20,10 @@ Each app has three things of its own:
 - **An API URL**—the endpoint the app's code calls, shown in full at the top of
   the app page. Expand it to see the ready-to-paste URL for each service the
   gateway mounts under the app—**Chat Completions** (`v1/chat/completions`),
-  **Responses** (`v1/responses`, OpenAI only), and **Messages** (`v1/messages`,
-  Anthropic only)—and copy the one your client needs. The gateway attributes
-  requests made to this URL to the app, tracking usage independently per app.
-  See the [Universal API](./universal-api.mdx).
+  **Responses** (`v1/responses`), and **Messages** (`v1/messages`)—and copy the
+  one your client needs. The [Universal API](./universal-api.mdx) lists which
+  providers serve each endpoint. The gateway attributes requests made to this
+  URL to the app, tracking usage independently per app.
 - **An API key**—authenticates the app's requests when the gateway runs the
   [authentication policy](./policy-chains.mdx#authentication).
 - **A [policy chain](./policy-chains.mdx)**—the ordered policies that run on the

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

@@ -0,0 +1,343 @@
+---
+title: Using Bedrock Mantle
+sidebar_label: Bedrock Mantle
+description:
+  Serve Claude and models from many other vendors on Amazon Bedrock through one
+  provider configuration—one regional endpoint and one long-term Bedrock API
+  key. The gateway routes each model to the right Bedrock API.
+---
+
+**Bedrock Mantle** is
+[Amazon Bedrock's compatible-APIs endpoint](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html).
+One regional endpoint (`https://bedrock-mantle.<region>.api.aws`) and one
+long-term Bedrock API key serve models from many vendors—the Claude family,
+OpenAI's GPT-5.x and GPT-OSS families, Gemma, Qwen, DeepSeek, Mistral, Grok,
+Kimi, GLM, and more. Adding Bedrock Mantle as a provider gives your
+[apps](./apps.mdx) all of them through the [Universal API](./universal-api.mdx)
+with a single credential, on your AWS account and AWS billing.
+
+Mantle is the part of Amazon Bedrock's catalog that AWS exposes over these
+compatible APIs. A model that Bedrock offers only through its native
+`InvokeModel` or `Converse` APIs isn't served by Mantle, so the gateway can't
+route to it.
+
+Apps reference the models as `providerName/model`, where `providerName` is the
+name you give the provider configuration. A provider named `bedrockmantle`
+serves `bedrockmantle/anthropic.claude-sonnet-5` and
+`bedrockmantle/openai.gpt-oss-120b`.
+
+## How the gateway routes Mantle models
+
+Mantle serves two API formats on the same host with the same API key:
+
+- An **OpenAI-compatible API**, serving every non-Claude model with OpenAI-style
+  chat completions and—for the models that support it—the OpenAI Responses API.
+- The **native Anthropic Messages API**, serving the Claude models.
+
+<Diagram height="h-64">
+  <DiagramNode id="app">Your app</DiagramNode>
+  <DiagramNode id="gateway" variant="zuplo">
+    AI Gateway
+  </DiagramNode>
+  <DiagramGroup id="mantle" label="Bedrock Mantle (your region)">
+    <DiagramNode id="openai-surface" variant="blue">
+      OpenAI-compatible API
+    </DiagramNode>
+    <DiagramNode id="messages-surface" variant="green">
+      Anthropic Messages API
+    </DiagramNode>
+  </DiagramGroup>
+  <DiagramEdge from="app" to="gateway" label="Universal API" />
+  <DiagramEdge
+    from="gateway"
+    to="openai-surface"
+    label="OpenAI-compatible models"
+  />
+  <DiagramEdge from="gateway" to="messages-surface" label="Claude models" />
+</Diagram>
+
+The gateway's model catalog records which API serves each model, and the gateway
+routes every request accordingly—your clients always call your app's URL and
+never see the Mantle endpoint. This also covers a Mantle quirk: AWS serves some
+models (the Gemma 4 and GPT-5.x families among them) on a different base path
+(`/openai/v1` instead of `/v1`), documented per
+[AWS model card](https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards.html)—the
+per-model reference pages in the AWS Bedrock docs. The gateway sends each model
+to its documented path, so the model reference and your app's URL stay the same
+either way.
+
+## Supported endpoints by model family
+
+| Endpoint               | OpenAI-compatible models     | Claude models |
+| ---------------------- | ---------------------------- | ------------- |
+| `/v1/chat/completions` | ✅ Forwarded                 | ✅ Translated |
+| `/v1/responses`        | ✅ Models that serve it      | ❌            |
+| `/v1/messages`         | ❌                           | ✅ Native     |
+| `/v1/embeddings`       | ❌ Mantle has no such models | ❌            |
+
+Streaming (`stream: true`) works on all three serving endpoints.
+
+On the OpenAI-compatible side, endpoint support is per model, decided by AWS:
+
+- The GPT-5.x models (`openai.gpt-5.6-sol`, `openai.gpt-5.5`, and family) serve
+  the Responses API only. Sending one to `/v1/chat/completions` returns Mantle's
+  own error that the model doesn't support that API.
+- The GPT-OSS models (`openai.gpt-oss-120b`, `openai.gpt-oss-20b`) serve both
+  chat completions and the Responses API.
+- Most of the other models serve chat completions only, and answer
+  `/v1/responses` with an error.
+
+The **APIs supported** row of a model's AWS model card is the reference. When a
+model doesn't serve the requested API, the gateway forwards Mantle's error to
+your client.
+
+Claude models work on `/v1/chat/completions` through the gateway's translation
+to the Messages API, which supports the core chat parameters: `messages`,
+`max_tokens` (defaults to 1024 when omitted), `temperature`, `top_p`, `stop`,
+and `stream`. Other OpenAI parameters—`tools`, `response_format`, penalties, and
+the rest—are dropped before forwarding, and `n > 1` is rejected. For tool use or
+other Anthropic-specific features with Claude models, call
+[`/v1/messages`](#call-claude-models-on-the-messages-api) instead.
+
+## Before you begin
+
+You need:
+
+- An AWS account with access to Amazon Bedrock in the region you plan to use.
+  Model availability varies by region, and some models—the Claude Mythos models,
+  for example—require an access grant from AWS. Check each model's AWS model
+  card.
+- A long-term Bedrock API key. In the AWS console, open **Bedrock → API keys**
+  and generate a long-term key—it starts with `ABSK`.
+- An AI Gateway project in the Zuplo Portal.
+- An AI Gateway [app](./apps.mdx) to call the models from. The app page shows
+  the app's API URL, and its API key lives on the app's **API Key** tab.
+
+:::caution{title="Long-term API keys only"}
+
+Bedrock issues both long-term and short-term API keys, and the gateway accepts
+only long-term ones, which start with `ABSK`. A short-term key (prefixed
+`bedrock-api-key-`) expires within 12 hours and is locked to the session that
+minted it, so the provider dialog rejects it rather than letting the connection
+break the same day.
+
+:::
+
+## 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.
+
+1. Click the **Add Provider** button.
+
+1. In the **AI Provider** list, select **Bedrock Mantle** from the Default
+   Providers group.
+
+1. Review the **Provider Name**, which fills in as `bedrockmantle` (a second
+   configuration becomes `bedrockmantle-2`). You can replace it with your own
+   name, but only now—the name is permanent after creation, and it's the prefix
+   in every model reference: a provider named `bedrockmantle` serves
+   `bedrockmantle/anthropic.claude-sonnet-5`.
+
+1. In **AWS Region**, enter the lowercase code of the AWS region you use Bedrock
+   in, such as `us-east-1`. The gateway sends this provider's requests to
+   `https://bedrock-mantle.<region>.api.aws`—there's no endpoint URL to enter.
+
+1. In **API Key**, paste your long-term Bedrock API key. The dialog rejects
+   short-term keys and any value that doesn't start with `ABSK`.
+
+1. Select the models to enable, or click **Select All**. The picker shows AWS's
+   per-token prices, which the gateway uses to track cost per app. You can
+   change the selection later.
+
+1. Click **Create**.
+
+</Stepper>
+
+:::note
+
+Saving provider settings triggers an automatic production deployment of your
+gateway, because provider credentials are part of the deployed gateway. The
+change is live once the deployment completes.
+
+:::
+
+When you edit the provider later—see
+[Managing Providers](./managing-providers.mdx)—the **AWS Region** field shows
+the saved region and stays editable, and you can replace the API key. The
+**Provider Name** doesn't change.
+
+## Verify the provider
+
+Once the deployment completes, send a chat completions request to your app's
+[Universal API](./universal-api.mdx) URL—shown at the top of the
+[app page](./apps.mdx)—with the app's API key as the bearer token and one of the
+models you enabled:
+
+```bash
+curl https://my-gateway-main-2e18f50.zuplo.app/config_fe0a04972d2848e0a94ae4b8bcd1497e/v1/chat/completions \
+  -H "Authorization: Bearer $ZUPLO_APP_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "bedrockmantle/openai.gpt-oss-120b",
+    "messages": [{ "role": "user", "content": "Say hi" }]
+  }'
+```
+
+The URL is a sample—replace it with your app's API URL plus
+`/v1/chat/completions`, set `ZUPLO_APP_API_KEY` to the app's API key, and
+substitute any model you enabled for `bedrockmantle/openai.gpt-oss-120b`.
+
+A `200` response confirms the provider works; the body carries
+`"provider": "bedrock-mantle"`—the provider type, not the name you chose. If the
+request fails immediately after you save the provider, the deployment may not
+have finished—retry before debugging further.
+
+## Call OpenAI-compatible models
+
+Use any OpenAI client with your app's URL plus `/v1` as the base URL and the
+app's API key:
+
+```ts
+import OpenAI from "openai";
+
+const client = new OpenAI({
+  apiKey: process.env.ZUPLO_APP_API_KEY,
+  baseURL:
+    "https://my-gateway-main-2e18f50.zuplo.app/config_fe0a04972d2848e0a94ae4b8bcd1497e/v1",
+});
+
+const response = await client.chat.completions.create({
+  model: "bedrockmantle/openai.gpt-oss-120b",
+  messages: [{ role: "user", content: "Summarize this ticket." }],
+});
+```
+
+The same call works with a Claude model string—the gateway translates it to the
+Messages API—within the
+[translation's parameter subset](#supported-endpoints-by-model-family).
+
+### Use the Responses API
+
+Models that serve the Responses API (the GPT-OSS and GPT-5.x families) work
+through `/v1/responses`, including streaming:
+
+```ts
+const response = await client.responses.create({
+  model: "bedrockmantle/openai.gpt-oss-20b",
+  input: "Write a haiku about container ships.",
+  max_output_tokens: 512,
+});
+```
+
+The GPT-OSS models reason before they answer, so give Responses calls a generous
+`max_output_tokens`—a small cap can complete the response with an empty
+`output`.
+
+Setting `store: true` persists the response into Bedrock's session storage,
+which is what makes the management operations—`GET /v1/responses/{id}`,
+`DELETE /v1/responses/{id}`, and `GET /v1/responses/{id}/input_items`—useful.
+Two Mantle-specific notes on them:
+
+- The management operations carry no request body, so the gateway can't read a
+  model from the request. They work on apps whose
+  [policy chain](./policy-chains.mdx) includes a
+  [Model Filtering](../policies/ai-gateway-model-filtering-v2-inbound.mdx)
+  policy with an allow list (the gateway routes them with the first listed
+  model); without one they fail with a `400` error.
+- Whether `DELETE` succeeds is a permission of your Bedrock API key (the
+  `bedrock-mantle:DeleteInference` action in AWS IAM—see
+  [AWS's Bedrock Mantle documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html)).
+  When the key lacks it, the gateway forwards Mantle's `401` response.
+
+## Call Claude models on the Messages API
+
+Claude models serve the native
+[Anthropic Messages API](./universal-api.mdx#supported-endpoints) at
+`/v1/messages`. With the Anthropic SDK, set `baseURL` to the app's URL _without_
+`/v1`—the SDK appends `/v1/messages` itself—and pass the app's API key as
+`authToken`, not `apiKey`:
+
+```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, // apiKey would send x-api-key, which the gateway ignores
+});
+
+const message = await client.messages.create({
+  model: "bedrockmantle/anthropic.claude-sonnet-5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Say hi" }],
+});
+```
+
+The gateway forwards the request body to Mantle verbatim, so everything the
+Messages API supports—tool use, system prompts, streaming—works as it does
+against Anthropic directly. Client headers such as `anthropic-beta` pass
+through, and `anthropic-version` defaults to `2023-06-01` when your client
+doesn't send one.
+
+## Streaming details
+
+Most clients never notice these, but if you parse the SSE stream yourself:
+
+- Claude models on `/v1/chat/completions` stream gateway-translated
+  `chat.completion.chunk` events ending with `data: [DONE]`.
+- OpenAI-compatible models stream exactly what Mantle sends. The GPT-OSS stream
+  ends on a usage chunk with no `[DONE]` sentinel, so don't wait for one.
+- `/v1/messages` streams Anthropic's standard SSE events (`message_start`
+  through `message_stop`).
+
+The gateway meters usage and cost on all of them, streamed or not.
+
+## Troubleshooting
+
+**The dialog rejects your API key.** Only long-term Bedrock API keys work. A key
+starting with `bedrock-api-key-` is short-term—it expires within 12 hours.
+Generate a long-term key (starting with `ABSK`) in the AWS console under
+**Bedrock → API keys**, and paste it without surrounding whitespace.
+
+**A model returns `400` naming `/v1/messages` or `/v1/responses`.** The model's
+family doesn't serve that endpoint: the gateway rejects an OpenAI-compatible
+model on `/v1/messages`, or a Claude model on `/v1/responses`, before any
+upstream call. The error names the provider type (`bedrock-mantle`), which
+serves both APIs, so it can be confusing—support is per model family, per the
+[endpoint table](#supported-endpoints-by-model-family).
+
+**Mantle answers that the model doesn't support the API.** Endpoint support is
+per model on the OpenAI-compatible side—the GPT-5.x models serve only
+`/v1/responses`, and most other models serve only `/v1/chat/completions`. Check
+the **APIs supported** row on the model's AWS model card.
+
+**A model in the picker fails at request time.** The model picker lists Mantle's
+full catalog, but availability is per region and some models are access-gated by
+AWS. If a request fails upstream with a model-not-found or access error, check
+the model's AWS model card for regional availability, and your AWS account's
+model access for gated models such as the Claude Mythos family.
+
+**Embeddings requests fail.** Mantle serves no embeddings models, so the model
+picker lists none and `/v1/embeddings` has no Bedrock Mantle models to route to.
+Use another provider for embeddings.
+
+## Next steps
+
+- [AI Providers](./providers.mdx)—the capability matrix across every supported
+  provider.
+- [Universal API](./universal-api.mdx)—the endpoints every app serves and how
+  model references work.
+- [Managing Providers](./managing-providers.mdx)—edit models, keys, and the
+  region, and understand when changes deploy.
+- [AI Gateway Apps](./apps.mdx)—create the apps that call your Mantle-backed
+  models.
+- [Model Filtering policy](../policies/ai-gateway-model-filtering-v2-inbound.mdx)—control
+  which models each app can call.

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

@@ -34,7 +34,7 @@ example—won't work as a custom provider.
 Custom providers serve chat completions and embeddings only. The gateway's
 `/v1/responses` and `/v1/messages` endpoints don't accept custom-provider
 models: a `/v1/responses` request fails with a `400` error and the message
-`The /v1/responses endpoint is only supported by OpenAI provider. Current provider: <name>`.
+`The /v1/responses endpoint is not supported by provider '<name>'`.
 
 :::
 

package/docs/ai-gateway/introduction.mdx

@@ -75,11 +75,12 @@ usage limits still apply.
 ### Multi-Provider Support
 
 Configure multiple LLM providers within a single AI Gateway project. Supported
-providers include OpenAI, Anthropic, Google, Mistral, xAI, 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.
+providers include OpenAI, Anthropic, Google, Mistral, xAI, Amazon Bedrock
+(through [Bedrock Mantle](./bedrock-mantle.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/managing-providers.mdx

@@ -51,7 +51,9 @@ To add a new AI provider to your Zuplo AI Gateway, follow these steps:
    create an API key for each provider see the
    [provider documentation](./providers.mdx). The
    [Zuplo Demo provider](./providers.mdx#zuplo-demo) asks for no API key—your
-   gateway authenticates to the demo service itself.
+   gateway authenticates to the demo service itself, and
+   [Bedrock Mantle](./bedrock-mantle.mdx) additionally asks for an **AWS
+   Region** and accepts only long-term Bedrock API keys.
 
 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.
@@ -80,8 +82,9 @@ To modify an existing provider, open
 [**Settings → AI Providers**](https://portal.zuplo.com/+/account/project/ai/settings/data-models)
 and click the **Edit** button next to the provider you want to modify.
 
-You can modify the API key and selected models for the provider. The **Provider
-Name** isn't editable: it's the routing address in every `providerName/model`
+You can modify the API key and selected models for the provider—and, for
+[Bedrock Mantle](./bedrock-mantle.mdx), the AWS Region. The **Provider Name**
+isn't editable: it's the routing address in every `providerName/model`
 reference, so renaming it would orphan each stored reference to this provider.
 After making your changes, click **Save** to apply them.
 

package/docs/ai-gateway/providers.mdx

@@ -19,8 +19,8 @@ Zuplo currently supports the following AI providers:
 - Google
 - Mistral
 - xAI (Grok)
-- [Bedrock Mantle](#bedrock-mantle)—Amazon Bedrock's compatible-APIs endpoint,
-  serving both OpenAI-compatible and Claude models
+- [Bedrock Mantle](./bedrock-mantle.mdx)—Amazon Bedrock's compatible-APIs
+  endpoint, serving Claude models and models from many other vendors
 - [Zuplo Demo](#zuplo-demo)—a free, keyless provider for trying the gateway
 - OpenAI-compatible [Custom Providers](./custom-providers.mdx) (such as Qwen,
   Kimi, etc)
@@ -34,7 +34,7 @@ The following capabilities are supported across providers:
 | Google                     | ✅               | ✅         | ❌        | ❌       |
 | Mistral                    | ✅               | ✅         | ❌        | ❌       |
 | xAI                        | ✅               | ✅         | ❌        | ❌       |
-| Bedrock Mantle             | ✅               | ✅         | ❌        | ✅       |
+| Bedrock Mantle             | ✅               | ❌         | ✅        | ✅       |
 | Zuplo Demo                 | ✅               | ❌         | ❌        | ❌       |
 | OpenAI-compatible (Custom) | ✅               | ✅         | ❌        | ❌       |
 
@@ -43,6 +43,11 @@ the native Anthropic Messages API (`/v1/messages`). See the
 [Universal API](./universal-api.mdx#supported-endpoints) for the endpoint each
 capability maps to.
 
+Bedrock Mantle's capabilities depend on the model family: Claude models serve
+Messages (plus chat completions through translation), while its other models
+serve chat completions and—per model—Responses. See
+[Using Bedrock Mantle](./bedrock-mantle.mdx#supported-endpoints-by-model-family).
+
 A custom provider must serve chat completions and embeddings under a `/v1` path
 segment on its API URL, and you enter that URL as an origin root—without the
 `/v1` suffix vendors usually publish. See
@@ -55,28 +60,22 @@ name you give the provider configuration. See the
 
 ## Bedrock Mantle
 
-**Bedrock Mantle** is Amazon Bedrock's compatible-APIs endpoint. It serves two
-model families from one host and one credential, so which capabilities apply
-depends on the model you call:
+**Bedrock Mantle** is Amazon Bedrock's compatible-APIs endpoint. One regional
+endpoint and one long-term Bedrock API key serve two model families, and which
+capabilities apply depends on the model you call:
 
-- **OpenAI-compatible models** (for example `openai.gpt-oss-120b`) serve chat
-  completions and embeddings.
-- **Claude models** serve the native Anthropic Messages API, and chat
-  completions through the gateway's translation.
+- **Claude models** (for example `anthropic.claude-sonnet-5`) serve the native
+  Anthropic Messages API, and chat completions through the gateway's
+  translation.
+- **OpenAI-compatible models**—everything else Mantle serves, from open-weight
+  models such as `openai.gpt-oss-120b` to frontier models such as
+  `openai.gpt-5.6-sol`—serve chat completions and, per model, the OpenAI
+  Responses API.
 
 Mantle endpoints are regional, so the provider dialog asks for an **AWS Region**
-instead of an endpoint URL and builds `https://bedrock-mantle.<region>.api.aws`
-from it. Enter a standard region code such as `us-east-1`.
-
-:::caution{title="Long-term API keys only"}
-
-Bedrock issues both long-term and short-term API keys, and the gateway accepts
-only long-term ones, which start with `ABSK`. Generate one in the AWS console
-under **Bedrock → API keys**. A short-term key (prefixed `bedrock-api-key-`)
-expires within 12 hours and is locked to the session that minted it, so the
-dialog rejects it rather than letting the connection break the same day.
-
-:::
+instead of an endpoint URL, and it accepts only long-term Bedrock API keys,
+which start with `ABSK`. For prerequisites, setup steps, code examples, and
+troubleshooting, see [Using Bedrock Mantle](./bedrock-mantle.mdx).
 
 ## Zuplo Demo
 

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

@@ -63,9 +63,9 @@ 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 every provider except Anthropic         |
-| `/v1/responses`        | OpenAI Responses API, for OpenAI-backed providers      |
-| `/v1/messages`         | Anthropic Messages API, for Anthropic-backed providers |
+| Endpoint               | Notes                                                                                                           |
+| ---------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `/v1/chat/completions` | Chat completions for every provider                                                                             |
+| `/v1/embeddings`       | Embeddings for every provider except Anthropic                                                                  |
+| `/v1/responses`        | OpenAI Responses API: OpenAI, and [Bedrock Mantle](./bedrock-mantle.mdx) OpenAI-compatible models that serve it |
+| `/v1/messages`         | Anthropic Messages API: Anthropic, and [Bedrock Mantle](./bedrock-mantle.mdx) Claude models                     |

package/docs/dev-portal/zudoku/configuration/api-reference.md

@@ -207,6 +207,7 @@ const config = {
       disablePlayground: false, // Disable the interactive API playground
       disableSidecar: false, // Disable the sidecar completely
       disableSecurity: true, // Disable security scheme display and playground auth (default)
+      disableMcpAuthInstructions: false, // Hide auth steps in the MCP server card
       showVersionSelect: "if-available", // Control version selector visibility
       expandAllTags: true, // Control initial expanded state of tag categories
       showInfoPage: true, // Always show the info page (unset = show only if a description is set)
@@ -229,6 +230,11 @@ Available options:
 - `disableSecurity`: Disable OpenAPI security scheme display (auth badges on operations, security
   schemes section on the info page, and the Authorize dialog in the playground). Disabled by default
   (`true`). Set to `false` to enable security scheme support
+- `disableMcpAuthInstructions`: Hide the authentication instructions on
+  [MCP server](../guides/mcp-servers.md) endpoints. The MCP card normally derives a credential
+  header from the operation's security scheme and shows it in every install snippet. Set to `true`
+  to render the server as unauthenticated instead — no header snippets and no "replace
+  `YOUR_API_KEY`" steps
 - `showVersionSelect`: Control version selector visibility
   - `"if-available"`: Show version selector only when multiple versions exist (default)
   - `"always"`: Always show version selector (disabled if only one version)
@@ -260,6 +266,7 @@ const config = {
       disablePlayground: false, // Disable the interactive API playground
       disableSidecar: false, // Disable the sidecar completely
       disableSecurity: true, // Disable security scheme display and playground auth (default)
+      disableMcpAuthInstructions: false, // Hide auth steps in the MCP server card
       showVersionSelect: "if-available", // Control version selector visibility
       expandAllTags: false, // Control initial expanded state of tag categories
       showInfoPage: true, // Always show the info page (unset = show only if a description is set)

package/docs/dev-portal/zudoku/openapi-extensions/x-mcp-server.md

@@ -130,5 +130,14 @@ When detected, the operation page shows:
 The standard method badge, request body, parameters, and sidecar panels are hidden for MCP
 endpoints.
 
+When the extension carries `security` and `securitySchemes`, the card also documents the credential
+header and adds it to every install snippet. Set the
+[`disableMcpAuthInstructions`](/dev-portal/zudoku/configuration/api-reference#options) API option to render the
+server as unauthenticated instead.
+
 For a full walkthrough including Dev Portal configuration, see the
 [Documenting MCP Servers guide](/docs/dev-portal/documenting-mcp-servers).
+
+If a document describes several MCP servers, mark it with
+[`x-zudoku-type: mcp-catalog`](./x-zudoku-type) to render them as a searchable catalog instead of
+individual operation pages.

package/docs/dev-portal/zudoku/openapi-extensions/x-zudoku-type.md

@@ -0,0 +1,80 @@
+---
+title: x-zudoku-type
+sidebar_icon: layout-grid
+---
+
+Use `x-zudoku-type` to change how Dev Portal renders an entire OpenAPI document, instead of the default
+REST API view.
+
+## Location
+
+The extension is added at the **Root Object** level — the outermost level of the OpenAPI
+description.
+
+| Option          | Type     | Description                            |
+| --------------- | -------- | -------------------------------------- |
+| `x-zudoku-type` | `string` | The renderer to use for this document. |
+
+| Value           | Renders as                                                      |
+| --------------- | --------------------------------------------------------------- |
+| `"mcp-catalog"` | A searchable, filterable catalog of the document's MCP servers. |
+
+Values Dev Portal does not recognise are ignored with a build warning, and the document falls back to
+the default API view. This keeps a description written for a newer version of Dev Portal building
+against an older one.
+
+## `mcp-catalog`
+
+A catalog document renders as a **single page** listing every operation marked with
+[`x-mcp-server`](./x-mcp-server) as a card, in one grid that can be searched and filtered by tag.
+Selecting a card opens the server's install instructions and its tool list.
+
+Because the whole document becomes a catalog, a few things change:
+
+- **Only MCP servers are rendered.** Operations without `x-mcp-server` are not shown, and the
+  document contributes no sidebar entries, tag pages, or schema page. If you also want to document
+  plain REST endpoints, put them in a separate OpenAPI document with its own `apis` entry.
+- **Tags become filters** rather than pages or headings. Each tag appears as a filter chip and as a
+  badge on its servers' cards; the grid itself stays flat. Servers without a tag are filed under
+  "Other". The active filter is kept in the URL as `?tag=`, so a filtered view can be linked.
+- **Only the latest version is rendered.** Catalog documents do not support version switching; a
+  versioned API marked as a catalog warns at build time.
+
+The extension is read while your schema is processed, so it applies to `type: "file"` and
+`type: "raw"` APIs. `type: "url"` schemas are fetched in the browser after routing is decided, so
+the flag has no effect on them.
+
+## Example
+
+```yaml
+openapi: 3.1.0
+x-zudoku-type: mcp-catalog
+info:
+  title: Employee MCP Servers
+  version: 1.0.0
+servers:
+  - url: https://mcp.example.com
+tags:
+  - name: CRM & Customer Operations
+paths:
+  /v1/salesforce/sales-cloud/mcp:
+    post:
+      summary: Salesforce Sales Cloud
+      description: Read-only access to accounts, opportunities and contacts.
+      tags:
+        - CRM & Customer Operations
+      x-mcp-server:
+        name: salesforce-sales-cloud
+        version: 1.0.0
+        tools:
+          - name: searchAccounts
+            description: Find accounts by name, domain or owner.
+```
+
+This renders one catalog page with a single `Salesforce Sales Cloud` card, reachable via a
+`CRM & Customer Operations` filter chip. The card opens install snippets for Claude, ChatGPT,
+Cursor, VS Code and Codex, alongside the server's tools.
+
+## Related
+
+- [`x-mcp-server`](./x-mcp-server) — mark an individual operation as an MCP server

package/docs/policies/_index.md

@@ -98,6 +98,7 @@
 | set-status-outbound | Set Status Code | Sets the status code on the on the outgoing response. | api-gateway |
 | set-upstream-api-key-inbound | Set Upstream API Key | Sets a single header on the incoming request, typically used to attach an API key for the upstream service. A more directed version of the `SetHeadersInboundPolicy` that defaults the header name to `Authorization` and is intended to be used with an `$env()` reference for the value. | api-gateway |
 | sleep-inbound | Sleep / Delay | Add a delay to the incoming request. Useful for testing. | api-gateway |
+| ai-gateway-smart-router-inbound | Smart Router | Smart Router Inbound Policy for the AI Gateway | ai-gateway |
 | stripe-webhook-verification-inbound | Stripe Webhook Auth | The Stripe Webhook policy validates the authenticity of an incoming Stripe webhook. | api-gateway |
 | supabase-jwt-auth-inbound | Supabase JWT Auth | The Supabase JWT Authentication policy supports user JWT tokens created by Supabase. | api-gateway |
 | traffic-splitting-inbound | Traffic Splitting | Splits traffic randomly across a set of weighted base paths. On each request one base path is selected (weighted by `weight`) and written to the request custom context at `customOutputProperty`. Reference it from a later URL Rewrite `rewritePattern` or URL Forward `baseUrl`, e.g. `${context.custom.trafficSplitting.basePath}`. | api-gateway |

package/docs/policies/ai-gateway-configuration-executor-v2-inbound/doc.md

@@ -283,6 +283,178 @@ under `permissions` fail closed:
 Omit `permissions`, or either flag, when the portal does not need to record that
 constraint on the stored chain.
 
+## Configure expression budget rules
+
+`budgetRules` in the application configuration can apply a budget to a value
+selected from the request. Each expression rule requires one or more meter rows:
+
+```json
+{
+  "budgetRules": [
+    {
+      "budgetBy": "expression",
+      "expression": "request.user.data[\"team-id\"]",
+      "meters": [
+        {
+          "meter": "requests",
+          "period": "daily",
+          "value": 10000,
+          "action": "warn"
+        },
+        {
+          "meter": "requests",
+          "period": "daily",
+          "value": 12000,
+          "action": "block"
+        }
+      ]
+    }
+  ]
+}
+```
+
+| Field      | Supported values                                     |
+| ---------- | ---------------------------------------------------- |
+| `budgetBy` | `expression`                                         |
+| `meter`    | `cost`, `requests`, `tokens`                         |
+| `period`   | `hourly`, `daily`, `weekly`, `monthly`               |
+| `action`   | `warn` records a warning; `block` returns HTTP `429` |
+| `value`    | A finite number greater than or equal to zero        |
+
+A rule cannot repeat the same meter, period, and action. When a meter and period
+have both actions, the `warn` value must be less than the `block` value. The
+policy does not treat entries whose `budgetBy` is `app` as expression budget
+rules.
+
+### Supported expressions
+
+Expressions read one string or safe integer from request-time data. Use these
+canonical forms when writing application configuration:
+
+| Source                      | Canonical expression example                |
+| --------------------------- | ------------------------------------------- |
+| Request URL or method       | `request.url`, `request.method`             |
+| One request header          | `request.headers.get("x-customer-id")`      |
+| Authenticated subject       | `request.user.sub`                          |
+| User data                   | `request.user.data.profile.organizationId`  |
+| Query parameter             | `request.query.customerId`                  |
+| Query parameter (map form)  | `request.searchParams.customerId`           |
+| Route parameter             | `request.params.productId`                  |
+| Custom context data         | `context.custom.account.id`                 |
+| Route data                  | `context.route.path`                        |
+| Incoming request data       | `context.incomingRequestProperties.country` |
+| Request or context identity | `request.user.sub`, `context.requestId`     |
+| A key requiring brackets    | `request.user.data["team-id"]`              |
+
+The `expression` field contains the complete expression. Do not wrap it in an
+interpolation marker such as `${...}`. The runtime resolves it for every request
+after the application's inbound policy chain finishes. Updating an application's
+configuration changes which value later requests select without rebuilding or
+redeploying the gateway.
+
+JSON encoding and expression syntax are separate. When writing raw JSON, escape
+the double quotes required by a bracket segment:
+
+```json
+{
+  "expression": "request.user.data[\"team-id\"]"
+}
+```
+
+After a JSON parser decodes this value, the expression is
+`request.user.data["team-id"]`; the backslashes are not part of its identity.
+Code that creates application configuration should build an ordinary string and
+let its JSON serializer handle the transport escaping:
+
+```ts
+const expression = 'request.user.data["team-id"]';
+const body = JSON.stringify({ expression });
+```
+
+Header expressions are terminal. Header names are case-insensitive; use
+lowercase in stored expressions. The parser accepts the canonical
+`request.headers.get("content-type")` form and the equivalent
+`request.headers.content-type` and `request.headers["content-type"]` forms. The
+canonical form keeps header access visually distinct from an ordinary object
+property.
+
+A dot property starts with an ASCII letter, `_`, or `$`, followed by those
+characters, ASCII digits, or hyphens. Canonical rendering uses quoted brackets
+for keys containing `$` or `-`, or any other non-identifier character. For
+example, `context.custom.team-id` is accepted and its canonical form is
+`context.custom["team-id"]`. Single- and double-quoted bracket properties are
+accepted. Whitespace immediately inside brackets is accepted but is not
+canonical.
+
+The selectable data model is:
+
+| Root      | Selectable properties                                                                                                                                                                                                                                           |
+| --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `request` | `url`, `method`, `headers`, `user.sub`, `user.data`, `query`, `searchParams`, `params`, and the scalar Fetch request metadata `bodyUsed`, `cache`, `credentials`, `destination`, `integrity`, `keepalive`, `mode`, `redirect`, `referrer`, and `referrerPolicy` |
+| `context` | `contextId`, `requestId`, `custom`, `route`, and `incomingRequestProperties`                                                                                                                                                                                    |
+
+`request.body`, `context.log`, policy invocation methods, and every other host
+object are outside the selectable data model. The evaluator receives a
+plain-data snapshot of the selected root. It never receives the live request or
+context object.
+
+Expressions have these limits:
+
+- The expression is at most 1,024 UTF-8 bytes and contains well-formed Unicode.
+- Quoted keys are non-empty and do not contain double quotes, backslashes,
+  control characters, U+2028, or U+2029. String escapes are not supported.
+- Canonical expressions contain no syntax whitespace. Spaces inside a quoted key
+  are part of the key.
+- Wildcards, recursive descent, filters, numeric bracket indexes, calls other
+  than the terminal header `.get("name")`, function arguments, and roots other
+  than `request` and `context` are not supported. For example,
+  `request.url.substring(5, 1)` is not a supported expression.
+- Traversal reads own properties from plain objects and keys from declared Maps.
+  It does not traverse arrays, class instances, inherited properties, or the
+  property names `__proto__`, `constructor`, and `prototype`.
+
+Expressions observe values after the application's inbound policy chain
+finishes. An authentication policy can populate `request.user`. A custom policy
+earlier in the chain can derive a value and place it in a request header:
+
+```ts
+import { ZuploContext, ZuploRequest } from "@zuplo/runtime";
+
+export default function setBudgetDimension(
+  request: ZuploRequest,
+  context: ZuploContext
+): ZuploRequest {
+  const headers = new Headers(request.headers);
+  headers.set(
+    "x-budget-customer",
+    `${context.route.path}:${request.user?.sub ?? "anonymous"}`
+  );
+  return new ZuploRequest(request, { headers });
+}
+```
+
+The corresponding expression is `request.headers.get("x-budget-customer")`.
+Configuration code should create that ordinary string and pass the enclosing
+object to `JSON.stringify`; the serializer adds the JSON transport escaping.
+
+The expression chooses one value; it does not concatenate values, run
+JavaScript, or evaluate conditions. Compute composite values in an earlier
+policy and store the result in a supported request or context property.
+
+The selected value must be a string or a safe integer. The runtime converts the
+value to well-formed NFC Unicode and ignores it when it exceeds 256 UTF-8 bytes
+or contains control characters, U+2028, or U+2029. A missing or invalid value
+does not contribute to the rule for that request.
+
+The exact stored expression is the rule identity and analytics dimension name.
+Store its authored bytes unchanged. Different accepted spellings, such as single
+quotes and double quotes, identify different rules even when they select the
+same value.
+
+Malformed budget rules are logged and ignored individually. An unsupported
+expression is also logged and omitted from dimension capture and quota tokens;
+other valid rules continue to run.
+
 ## Write a custom policy for the chain
 
 A chain entry can run any declared custom policy. The policy uses the standard

package/docs/policies/ai-gateway-model-filtering-v2-inbound/doc.md

@@ -155,10 +155,14 @@ reported as warnings because they cannot match a request.
 | Policy has no rules for the route capability        | 403 response explaining which capability to configure. |
 | Another inbound policy already selected routing     | Model Filtering leaves that selection unchanged.       |
 
-Native routes also enforce provider type. `/v1/responses` requires a Provider
-Name backed by OpenAI, and `/v1/messages` requires a Provider Name backed by
-Anthropic. Provider Names may be custom labels; validation uses the provider
-type configured for that Provider Assignment.
+Native routes also enforce the wire format. `/v1/responses` requires a selection
+served on the OpenAI API, and `/v1/messages` one served on the Anthropic API. A
+selection qualifies when its Provider Assignment is backed by that provider
+type, or when the provider catalog declares the selected model's dialect as that
+format — Bedrock Mantle serves its `openai`-dialect models on `/v1/responses`
+and its `anthropic`-dialect models on `/v1/messages`. Provider Names may be
+custom labels; validation never infers anything from the label or the model
+name, and a model the catalog does not declare is rejected.
 
 For example, this embedding request is evaluated against `models.embeddings`:
 

package/docs/policies/ai-gateway-smart-router-inbound/doc.md

@@ -0,0 +1,99 @@
+# AI Gateway Smart Router
+
+Use this policy to classify the last user prompt on Chat Completions, Responses,
+and Anthropic Messages requests. It calls a dedicated AI Gateway application
+(`/{classifierAppID}/v1/chat/completions`) and stores the result on
+`AIGatewaySmartRouter` for later policies in the same request.
+
+When `smartRoutingEnabled` is true, it overwrites completions routing from
+`modelsByComplexity`. Place it **after** Model Filtering so an invalid client
+model is still rejected before classification runs. The classified model then
+replaces that selection.
+
+Classification is optional. Timeouts, classifier errors, unreadable bodies, and
+invalid options fail open: the original request is forwarded.
+
+> **Loop prevention.** The classifier hop is an `invokeRoute` sub-request. The
+> policy no-ops when `context.parentContext` is set, so the classifier app can
+> share the same route chain without classifying its own request.
+
+## Required options
+
+- `classifierAppID` — AI Gateway application id whose chat/completions route
+  runs the classifier.
+- `classifierAppApiKey` — bearer token for that app. Use
+  `$env(CLASSIFIER_APP_API_KEY)`.
+- `classifierModel` — `providerName/model` sent on the classifier request.
+
+Omit `intents` and `classifierPrompt` to use the built-in taxonomy (code,
+summarization, translation, qa, conversation, classification, creative_writing,
+agentic, document_qa, other) and the built-in system prompt. Include
+`{{intents}}` in a custom prompt to inject the configured intent list.
+
+## Example
+
+```json
+{
+  "name": "ai-gateway-smart-router-inbound",
+  "policyType": "ai-gateway-smart-router",
+  "handler": {
+    "export": "AIGatewaySmartRouterInboundPolicy",
+    "module": "$import(@zuplo/runtime)",
+    "options": {
+      "classifierAppID": "$env(CLASSIFIER_APP_ID)",
+      "classifierAppApiKey": "$env(CLASSIFIER_APP_API_KEY)",
+      "classifierModel": "openai/gpt-4o-mini",
+      "smartRoutingEnabled": true,
+      "modelsByComplexity": {
+        "low": "openai/gpt-4o-mini",
+        "medium": "openai/gpt-4o",
+        "high": "openai/gpt-5"
+      }
+    }
+  }
+}
+```
+
+## Policy order
+
+```text
+Model Filtering -> Smart Router -> Fallback Model -> AI Gateway handler
+```
+
+Smart Router always `set()`s routing when smart routing applies, even if
+filtering already selected a model. Filtering skips when routing is already set,
+so putting this policy first would also skip allow-list checks on the client's
+original model.
+
+## Read the result from custom code
+
+```typescript
+import { AIGatewaySmartRouter } from "@zuplo/runtime";
+
+const result = AIGatewaySmartRouter.get(context);
+if (result?.profile.intent === "code") {
+  // ...
+}
+```
+
+## How prompt text is chosen
+
+The policy reads the typed body from the route (`getFormat` / `getRequestBody`),
+then takes the last real user text:
+
+- `/v1/chat/completions` — OpenAI chat `messages[]`, even when the downstream
+  provider is Anthropic or Google (Zuplo translates below the policy chain).
+- `/v1/responses` — OpenAI Responses `input`.
+- `/v1/messages` — native Anthropic `messages[]`.
+
+Tool follow-up turns (`tool` / `function` roles, `tool_result` blocks,
+`function_call_output` items) are skipped so a prior user message is classified
+instead. Embeddings and other non-AI paths are skipped.
+
+## Fail-open behavior
+
+The policy never 500s the user request for an internal classifier problem.
+Invalid options, classifier timeouts, empty classifier responses, and smart
+routing catalog errors are logged and the original request continues. Chat
+Completions, Responses, and Anthropic Messages are classified automatically.
+Embeddings and other non-AI paths are skipped.

package/docs/policies/ai-gateway-smart-router-inbound/intro.md

@@ -0,0 +1,4 @@
+Classifies the last user prompt by calling a dedicated classifier AI Gateway
+app, stores the result on `AIGatewaySmartRouter` for later policies, and
+optionally routes completions by classified complexity. Classifier failures fail
+open so the original request still reaches the model.

package/docs/policies/ai-gateway-smart-router-inbound/schema.json

@@ -0,0 +1,204 @@
+{
+  "$schema": "https://json-schema.org/draft-07/schema",
+  "$id": "https://cdn.zuplo.com/policies/runtime/schemas/ai-gateway-smart-router-inbound.json",
+  "type": "object",
+  "title": "Smart Router",
+  "isDeprecated": false,
+  "isPaidAddOn": false,
+  "isEnterprise": false,
+  "isInternal": false,
+  "isBeta": false,
+  "isHidden": false,
+  "requiresAI": true,
+  "policyType": "ai-gateway-smart-router",
+  "products": ["ai-gateway"],
+  "description": "Smart Router Inbound Policy for the AI Gateway",
+  "deprecatedMessage": "",
+  "required": ["handler"],
+  "properties": {
+    "handler": {
+      "type": "object",
+      "default": {},
+      "required": ["export", "module", "options"],
+      "properties": {
+        "export": {
+          "const": "AIGatewaySmartRouterInboundPolicy",
+          "description": "The name of the exported type"
+        },
+        "module": {
+          "const": "$import(@zuplo/runtime)",
+          "description": "The module containing the policy"
+        },
+        "options": {
+          "x-zuplo-policy-type": "ai-gateway-smart-router",
+          "type": "object",
+          "title": "AIGatewaySmartRouterInboundPolicyOptions",
+          "description": "Options for the Smart Router policy: classify the last user prompt with a dedicated classifier AI Gateway app, then optionally route by complexity.",
+          "additionalProperties": false,
+          "required": [
+            "classifierAppID",
+            "classifierAppApiKey",
+            "classifierModel"
+          ],
+          "examples": [
+            {
+              "classifierAppID": "$env(CLASSIFIER_APP_ID)",
+              "classifierAppApiKey": "$env(CLASSIFIER_APP_API_KEY)",
+              "classifierModel": "openai/gpt-4o-mini",
+              "smartRoutingEnabled": true,
+              "modelsByComplexity": {
+                "low": "openai/gpt-4o-mini",
+                "medium": "openai/gpt-4o",
+                "high": "openai/gpt-5"
+              }
+            }
+          ],
+          "properties": {
+            "classifierAppID": {
+              "type": "string",
+              "title": "Classifier App ID",
+              "description": "The AI Gateway application id whose `/v1/chat/completions` route runs the classifier. The policy calls `/{classifierAppID}/v1/chat/completions` via `context.invokeRoute`.",
+              "examples": ["config_1234"]
+            },
+            "classifierAppApiKey": {
+              "type": "string",
+              "title": "Classifier App API Key",
+              "description": "API key sent as `Authorization: Bearer` when invoking the classifier app.",
+              "examples": ["$env(CLASSIFIER_APP_API_KEY)"]
+            },
+            "classifierModel": {
+              "type": "string",
+              "title": "Classifier Model",
+              "description": "The `providerName/model` reference the classifier chat/completions request should use.",
+              "pattern": "^[^/\\s]+/.+$",
+              "examples": ["openai/gpt-4o-mini"]
+            },
+            "smartRoutingEnabled": {
+              "type": "boolean",
+              "title": "Smart Routing Enabled",
+              "description": "When true, apply model routing from `modelsByComplexity` when confidence is high enough and the intent is known. Classification still runs when false.",
+              "default": false
+            },
+            "modelsByComplexity": {
+              "type": "object",
+              "title": "Models By Complexity",
+              "description": "Optional `providerName/model` routing by classified complexity. Used only when `smartRoutingEnabled` is true.",
+              "additionalProperties": false,
+              "properties": {
+                "low": {
+                  "type": "string",
+                  "title": "Low Complexity Model",
+                  "description": "Model used for prompts classified as low complexity.",
+                  "pattern": "^[^/\\s]+/.+$",
+                  "examples": ["openai/gpt-4o-mini"]
+                },
+                "medium": {
+                  "type": "string",
+                  "title": "Medium Complexity Model",
+                  "description": "Model used for prompts classified as medium complexity.",
+                  "pattern": "^[^/\\s]+/.+$",
+                  "examples": ["openai/gpt-4o"]
+                },
+                "high": {
+                  "type": "string",
+                  "title": "High Complexity Model",
+                  "description": "Model used for prompts classified as high complexity.",
+                  "pattern": "^[^/\\s]+/.+$",
+                  "examples": ["openai/gpt-5"]
+                }
+              }
+            },
+            "intents": {
+              "type": "array",
+              "title": "Intents",
+              "description": "Labels the classifier may assign. Used to build the JSON schema enum and injected into `classifierPrompt` at `{{intents}}`. Omit to use the built-in taxonomy (code, summarization, translation, qa, conversation, classification, creative\\_writing, agentic, document\\_qa, other).",
+              "minItems": 1,
+              "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": ["id", "description"],
+                "properties": {
+                  "id": {
+                    "type": "string",
+                    "title": "Intent ID",
+                    "description": "Stable intent identifier written into the classifier JSON schema enum.",
+                    "minLength": 1,
+                    "examples": ["code"]
+                  },
+                  "description": {
+                    "type": "string",
+                    "title": "Intent Description",
+                    "description": "Short description shown to the classifier for this intent.",
+                    "examples": [
+                      "Write, edit, refactor, debug, or review source code."
+                    ]
+                  }
+                }
+              }
+            },
+            "classifierPrompt": {
+              "title": "Classifier Prompt",
+              "description": "System prompt for the classifier. If it includes `{{intents}}`, that placeholder is replaced with the configured intent id/description list. A string or an array of lines (joined with newlines). Omit to use the built-in classifier prompt.",
+              "oneOf": [
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              ]
+            },
+            "minConfidenceForRouting": {
+              "type": "number",
+              "title": "Minimum Confidence For Routing",
+              "description": "Minimum confidence (0–1) required before applying model routing. Unknown intents are capped strictly below this threshold.",
+              "minimum": 0,
+              "maximum": 1,
+              "default": 0.5,
+              "x-advanced": true
+            },
+            "classifierTimeoutMs": {
+              "type": "integer",
+              "title": "Classifier Timeout (ms)",
+              "description": "How long to wait for the classifier `invokeRoute` call before skipping classification and forwarding the original request.",
+              "minimum": 1,
+              "maximum": 120000,
+              "default": 8000,
+              "x-advanced": true
+            },
+            "maxPromptChars": {
+              "type": "integer",
+              "title": "Max Prompt Characters",
+              "description": "Maximum characters of user prompt sent to the classifier. Longer prompts are truncated.",
+              "minimum": 1,
+              "default": 8000,
+              "x-advanced": true
+            }
+          }
+        }
+      },
+      "examples": [
+        {
+          "export": "AIGatewaySmartRouterInboundPolicy",
+          "module": "$import(@zuplo/runtime)",
+          "options": {
+            "classifierAppID": "$env(CLASSIFIER_APP_ID)",
+            "classifierAppApiKey": "$env(CLASSIFIER_APP_API_KEY)",
+            "classifierModel": "openai/gpt-4o-mini",
+            "smartRoutingEnabled": true,
+            "modelsByComplexity": {
+              "low": "openai/gpt-4o-mini",
+              "medium": "openai/gpt-4o",
+              "high": "openai/gpt-5"
+            }
+          }
+        }
+      ]
+    }
+  }
+}

package/docs/policies/data-loss-prevention-inbound/doc.md

@@ -54,8 +54,8 @@ The threshold is configurable via `minConfidence` (default `0.5`). Lowering it
 surfaces context-dependent entities without their context words. Raising it is
 not a precision filter: any recognizer whose base confidence falls below the
 threshold stops matching except near its context words, and most
-checksum-validated recognizers run at `0.85`, so high thresholds disable most
-of the catalog. To narrow detection, scope the `entities` list instead.
+checksum-validated recognizers run at `0.85`, so high thresholds disable most of
+the catalog. To narrow detection, scope the `entities` list instead.
 
 ## Custom patterns
 
@@ -68,20 +68,20 @@ JSON (for example `\\d` to match a digit).
 ## Allowed values
 
 Use `allowValues` to exempt specific values that would otherwise match — for
-example the Stripe test card number `4242 4242 4242 4242` in a payments
-sandbox, or a public support email address. Entries are compared against the
-exact matched text (case-sensitive, separators included), so list every
-written form you want to allow.
+example the Stripe test card number `4242 4242 4242 4242` in a payments sandbox,
+or a public support email address. Entries are compared against the exact
+matched text (case-sensitive, separators included), so list every written form
+you want to allow.
 
 ## Content types
 
 Only text-based bodies (JSON, XML, form-encoded, and `text/*`) are scanned;
 binary bodies pass through untouched. Server-sent event streams
-(`text/event-stream`) are excluded from the default allow-list: scanning
-buffers the whole body, which would hold back every event until the stream
-ends. Override the allow-list with the `contentTypes` option if you need to
-scan a different set of content types (including `text/event-stream`, if you
-accept the buffering).
+(`text/event-stream`) are excluded from the default allow-list: scanning buffers
+the whole body, which would hold back every event until the stream ends.
+Override the allow-list with the `contentTypes` option if you need to scan a
+different set of content types (including `text/event-stream`, if you accept the
+buffering).
 
 ## Configuration
 

package/docs/policies/data-loss-prevention-outbound/doc.md

@@ -54,8 +54,8 @@ The threshold is configurable via `minConfidence` (default `0.5`). Lowering it
 surfaces context-dependent entities without their context words. Raising it is
 not a precision filter: any recognizer whose base confidence falls below the
 threshold stops matching except near its context words, and most
-checksum-validated recognizers run at `0.85`, so high thresholds disable most
-of the catalog. To narrow detection, scope the `entities` list instead.
+checksum-validated recognizers run at `0.85`, so high thresholds disable most of
+the catalog. To narrow detection, scope the `entities` list instead.
 
 ## Custom patterns
 
@@ -68,21 +68,21 @@ JSON (for example `\\d` to match a digit).
 ## Allowed values
 
 Use `allowValues` to exempt specific values that would otherwise match — for
-example the Stripe test card number `4242 4242 4242 4242` in a payments
-sandbox, or a public support email address. Entries are compared against the
-exact matched text (case-sensitive, separators included), so list every
-written form you want to allow.
+example the Stripe test card number `4242 4242 4242 4242` in a payments sandbox,
+or a public support email address. Entries are compared against the exact
+matched text (case-sensitive, separators included), so list every written form
+you want to allow.
 
 ## Content types
 
 Only text-based bodies (JSON, XML, form-encoded, and `text/*`) are scanned;
 binary bodies pass through untouched. Server-sent event streams
-(`text/event-stream`) are excluded from the default allow-list: scanning
-buffers the whole response, which would hold back every event until the
-stream ends — for an upstream SSE response, time-to-first-byte becomes the
-full stream duration. Override the allow-list with the `contentTypes` option
-if you need to scan a different set of content types (including
-`text/event-stream`, if you accept the buffering).
+(`text/event-stream`) are excluded from the default allow-list: scanning buffers
+the whole response, which would hold back every event until the stream ends —
+for an upstream SSE response, time-to-first-byte becomes the full stream
+duration. Override the allow-list with the `contentTypes` option if you need to
+scan a different set of content types (including `text/event-stream`, if you
+accept the buffering).
 
 ## Configuration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuplo",
-  "version": "7.5.2",
+  "version": "7.5.4",
   "type": "module",
   "description": "The programmable API Gateway",
   "author": "Zuplo, Inc.",
@@ -19,9 +19,9 @@
     "zuplo": "zuplo.js"
   },
   "dependencies": {
-    "@zuplo/cli": "7.5.2",
-    "@zuplo/core": "7.5.2",
-    "@zuplo/runtime": "7.5.2",
-    "@zuplo/test": "7.5.2"
+    "@zuplo/cli": "7.5.4",
+    "@zuplo/core": "7.5.4",
+    "@zuplo/runtime": "7.5.4",
+    "@zuplo/test": "7.5.4"
   }
 }