zuplo 6.72.13 → 6.72.15

package/docs/articles/migrate-from-apigee.md

@@ -120,7 +120,7 @@ The following table maps common Apigee policies to Zuplo equivalents:
 | `ExtractVariables`        | [Custom Code Policy](../policies/custom-code-inbound.md)                                         |
 | `XMLToJSON` / `JSONToXML` | [XML to JSON](../policies/xml-to-json-outbound.md) or custom code                                |
 | `RaiseFault`              | Custom code returning an error [Response](../programmable-api/http-problems.md)                  |
-| `AccessControl`           | [IP Restriction](../policies/ip-restriction-inbound.md)                                          |
+| `AccessControl`           | [Custom Code](../policies/custom-code-inbound.md)                                                |
 | `CORS`                    | Built-in [CORS configuration](../programmable-api/custom-cors-policy.md)                         |
 | `JavaScript` callout      | [Custom Code Policy](../policies/custom-code-inbound.md) (TypeScript)                            |
 | `ServiceCallout`          | [Custom Code Policy](../policies/custom-code-inbound.md) using `fetch()`                         |

package/docs/articles/migrate-from-azure-apim.md

@@ -97,7 +97,7 @@ The following table maps common Azure APIM policies to Zuplo equivalents:
 | `quota` / `quota-by-key`           | [Quota](../policies/quota-inbound.md)                                     |
 | `validate-jwt`                     | [Open ID JWT Authentication](../policies/open-id-jwt-auth-inbound.md)     |
 | `authentication-basic`             | [Basic Authentication](../policies/basic-auth-inbound.md)                 |
-| `ip-filter`                        | [IP Restriction](../policies/ip-restriction-inbound.md)                   |
+| `ip-filter`                        | [Custom Code](../policies/custom-code-inbound.md)                         |
 | `cors`                             | Built-in [CORS configuration](../programmable-api/custom-cors-policy.md)  |
 | `json-to-xml` / `xml-to-json`      | [XML to JSON](../policies/xml-to-json-outbound.md) or custom code         |
 | `find-and-replace`                 | [Replace String](../policies/replace-string-outbound.md)                  |

package/docs/articles/migrate-from-kong.md

@@ -145,13 +145,13 @@ The following table maps common Kong plugins to their Zuplo policy equivalents:
 | `basic-auth`             | [Basic Authentication](../policies/basic-auth-inbound.md)                |
 | `rate-limiting`          | [Rate Limiting](../policies/rate-limit-inbound.md)                       |
 | `rate-limiting-advanced` | [Complex Rate Limiting](../policies/complex-rate-limit-inbound.md)       |
-| `request-transformer`    | [Transform Body](../policies/transform-body-inbound.md)                  |
-| `response-transformer`   | [Transform Body Outbound](../policies/transform-body-outbound.md)        |
+| `request-transformer`    | [Custom Code](../policies/custom-code-inbound.md)                        |
+| `response-transformer`   | [Custom Code](../policies/custom-code-outbound.md)                       |
 | `cors`                   | Built-in [CORS configuration](../programmable-api/custom-cors-policy.md) |
-| `ip-restriction`         | [IP Restriction](../policies/ip-restriction-inbound.md)                  |
+| `ip-restriction`         | [Custom Code](../policies/custom-code-inbound.md)                        |
 | `request-size-limiting`  | [Request Size Limit](../policies/request-size-limit-inbound.md)          |
 | `request-validation`     | [Request Validation](../policies/request-validation-inbound.md)          |
-| `acl`                    | [ACL Policy](../policies/acl-policy-inbound.md)                          |
+| `acl`                    | [Custom Code](../policies/custom-code-inbound.md)                        |
 | Custom Lua plugin        | [Custom Code Policy](../policies/custom-code-inbound.md) (TypeScript)    |
 
 ### Step 3: Translate plugin configuration

package/docs/articles/waf-ddos-akamai.md

@@ -24,20 +24,20 @@ your API Gateway. This is a good way to ensure that only Akamai can access your
 API Gateway. However, as Akamai is a multi-tenant service, this method isn't
 sufficient to protect unauthorized traffic from hitting your API Gateway.
 
-In Zuplo, you can use the custom
-[IP Restriction policy](../policies/ip-restriction-inbound.mdx) to limit traffic
-to only the Akamai IP addresses. Copy the policy code from that page into a
-module in your project (for example, `modules/ip-restriction-inbound.ts`), then
+In Zuplo, you can use a
+[custom code policy](../policies/custom-code-inbound.mdx) to limit traffic to
+only the Akamai IP addresses. Add a module in your project (for example,
+`modules/ip-restriction.ts`) that allows only your permitted IP ranges, then
 configure the policy with the IP ranges that Akamai publishes for your account
 in Akamai Control Center.
 
 ```json
 {
   "name": "allow-akamai-only",
-  "policyType": "ip-restriction-inbound",
+  "policyType": "custom-code-inbound",
   "handler": {
     "export": "default",
-    "module": "$import(./modules/ip-restriction-inbound)",
+    "module": "$import(./modules/ip-restriction)",
     "options": {
       "allowedIpAddresses": ["23.32.0.0/11", "104.64.0.0/10"]
     }

package/docs/articles/waf-ddos-aws-waf-shield.mdx

@@ -26,20 +26,20 @@ way to ensure that only CloudFront can access your API Gateway. However, as
 CloudFront is available to any AWS customer, this method isn't sufficient to
 protect unauthorized traffic from hitting your API Gateway.
 
-In Zuplo, you can use the custom
-[IP Restriction policy](../policies/ip-restriction-inbound.mdx) to limit traffic
-to only the CloudFront IP addresses. Copy the policy code from that page into a
-module in your project (for example, `modules/ip-restriction-inbound.ts`), then
+In Zuplo, you can use a
+[custom code policy](../policies/custom-code-inbound.mdx) to limit traffic to
+only the CloudFront IP addresses. Add a module in your project (for example,
+`modules/ip-restriction.ts`) that allows only your permitted IP ranges, then
 configure the policy with the `CLOUDFRONT` ranges from the
 [AWS IP address ranges list](https://ip-ranges.amazonaws.com/ip-ranges.json).
 
 ```json
 {
   "name": "allow-cloudfront-only",
-  "policyType": "ip-restriction-inbound",
+  "policyType": "custom-code-inbound",
   "handler": {
     "export": "default",
-    "module": "$import(./modules/ip-restriction-inbound)",
+    "module": "$import(./modules/ip-restriction)",
     "options": {
       "allowedIpAddresses": ["13.32.0.0/15", "13.35.0.0/16"]
     }

package/docs/articles/waf-ddos-fastly.mdx

@@ -27,20 +27,20 @@ your API Gateway. This is a good way to ensure that only Fastly can access your
 API Gateway. However, as Fastly is a multi-tenant service, this method isn't
 sufficient to protect unauthorized traffic from hitting your API Gateway.
 
-In Zuplo, you can use the custom
-[IP Restriction policy](../policies/ip-restriction-inbound.mdx) to limit traffic
-to only the Fastly IP addresses. Copy the policy code from that page into a
-module in your project (for example, `modules/ip-restriction-inbound.ts`), then
+In Zuplo, you can use a
+[custom code policy](../policies/custom-code-inbound.mdx) to limit traffic to
+only the Fastly IP addresses. Add a module in your project (for example,
+`modules/ip-restriction.ts`) that allows only your permitted IP ranges, then
 configure the policy with the address ranges from
 [Fastly's public IP list](https://api.fastly.com/public-ip-list).
 
 ```json
 {
   "name": "allow-fastly-only",
-  "policyType": "ip-restriction-inbound",
+  "policyType": "custom-code-inbound",
   "handler": {
     "export": "default",
-    "module": "$import(./modules/ip-restriction-inbound)",
+    "module": "$import(./modules/ip-restriction)",
     "options": {
       "allowedIpAddresses": ["151.101.0.0/16", "199.232.0.0/16"]
     }

package/docs/articles/waf-ddos.mdx

@@ -31,7 +31,7 @@ Many common WAF functions can be implemented directly in Zuplo using policies,
 without the need for a separate WAF service:
 
 - **IP Restriction** - Block or allow requests from specific IP addresses using
-  the [IP Restriction policy](../policies/ip-restriction-inbound.mdx)
+  a [custom code policy](../policies/custom-code-inbound.mdx)
 - **Geolocation Blocking** - Route or block requests based on country using
   [custom policies](../guides/geolocation-backend-routing.mdx)
 - **Rate Limiting** - Protect against abuse with built-in

package/docs/concepts/authentication.mdx

@@ -79,7 +79,8 @@ users already authenticate with an identity provider.
 - [mTLS](../articles/securing-the-gateway-with-client-mtls.mdx) - Mutual TLS
   certificate authentication
 - [LDAP](../policies/ldap-auth-inbound.mdx) - LDAP directory authentication
-- [HMAC](../policies/hmac-auth-inbound.mdx) - Hash-based message authentication
+- [HMAC](../policies/custom-code-inbound.mdx) - Hash-based message
+  authentication via a custom code policy
 
 ## Combining authentication methods
 

package/docs/concepts/request-lifecycle.mdx

@@ -50,7 +50,7 @@ security headers, [logging](../articles/logging.mdx), analytics.
 | Validate request bodies       | [Inbound policy](../policies/request-validation-inbound.mdx)   |
 | Forward to a backend          | [URL Forward Handler](../handlers/url-forward.mdx)             |
 | Return custom responses       | [Function Handler](../handlers/custom-handler.mdx)             |
-| Transform response bodies     | [Outbound policy](../policies/transform-body-outbound.mdx)     |
+| Transform response bodies     | [Custom code policy](../policies/custom-code-outbound.mdx)     |
 | Add headers to all responses  | [Response hook](../programmable-api/hooks.mdx)                 |
 | Log every request             | [Response final hook](../programmable-api/hooks.mdx)           |
 | Normalize URLs before routing | [Pre-routing hook](../programmable-api/runtime-extensions.mdx) |

package/docs/policies/_index.md

@@ -2,21 +2,14 @@
 
 | Policy ID | Name | Description | Products |
 | --- | --- | --- | --- |
-| ab-test-inbound | A/B Test Inbound | An A/B test policy is used to handle requests differently based on parameters such as user, ip, etc. | api-gateway |
-| ab-test-outbound | A/B Test Outbound | An A/B test policy is used to handle responses differently based on parameters such as user, ip, etc. | api-gateway |
-| acl-policy-inbound | Access Control List | The access control list inbound policy limits access to resources based on parameters on the authenticated user. | api-gateway |
 | set-query-params-inbound | Add or Set Query Parameters | Adds or sets query parameters on the incoming request. | api-gateway |
 | set-headers-inbound | Add or Set Request Headers | Adds or sets headers on the incoming request. | api-gateway |
+| ai-gateway-model-routing-v2-inbound | AI Gateway Model Routing (v2) | Matches AI Gateway requests against curated allow lists or open block lists, then stores the winning `AIGatewayRouteTarget` for the route handler. | ai-gateway |
 | akamai-ai-firewall | Akamai AI Firewall | Akamai AI Firewall Inbound Policy | ai-gateway |
 | akamai-firewall-for-ai-outbound | Akamai Firewall for AI | Inspects each upstream response with Akamai's Firewall for AI detect API and replaces the response with a `403 Forbidden` if Akamai returns a `deny` rule. Useful behind AI-powered APIs to filter unsafe completions, sensitive data exposure, and toxic content before they reach the client.  The body, headers, URL, and query string sent to Akamai are configurable; by default only the response body is captured. Bodies are read from a clone so the client still receives the original. | api-gateway |
 | akamai-firewall-for-ai-inbound | Akamai Firewall for AI | Inspects each incoming request with Akamai's Firewall for AI detect API and blocks the request if Akamai returns a `deny` rule. Useful in front of AI-powered APIs to filter prompt injection, jailbreaks, and other unsafe inputs before they reach the model.  The body, headers, URL, and query string sent to Akamai are configurable; by default only the request body is captured. Bodies are read from a clone so the upstream handler still sees the original. | api-gateway |
 | amberflo-metering-inbound | Amberflo Metering / Billing | Amberflo is a usage metering and billing service. This policy allows you to send metering calls for each API to their meter ingest endpoint. | api-gateway |
 | api-key-inbound | API Key Authentication | Authenticates requests based on API Keys using Zuplo's built-in API key management. This policy validates API keys against Zuplo's key storage, caches results for performance, and automatically adds user information to authenticated requests. | api-gateway |
-| archive-request-aws-s3-inbound | Archive Request to AWS S3 | Archive the incoming request body to AWS S3 storage | api-gateway |
-| archive-request-azure-storage-inbound | Archive Request to Azure Storage | Archive the incoming request to Azure blob storage. | api-gateway |
-| archive-request-gcp-storage-inbound | Archive Request to GCP Storage | Archive the incoming request to Google Cloud Storage. | api-gateway |
-| archive-response-aws-s3-outbound | Archive Response to AWS S3 | Archive the outgoing response body to AWS S3 storage | api-gateway |
-| archive-response-azure-storage-outbound | Archive Response to Azure Storage | Archive the outgoing response to Azure blob storage. | api-gateway |
 | audit-log-inbound | Audit Logs | Capture detailed logs of requests for auditing purposes. The policy emits one structured CloudEvent per request, and user code can emit additional events via the static `log()` method. | api-gateway |
 | auth0-jwt-auth-inbound | Auth0 JWT Auth | Authenticate users using Auth0 issued JWT tokens. | api-gateway |
 | authzen-inbound | AuthZEN Authorization | Authorize requests using an AuthZEN compatible PDP | api-gateway |
@@ -48,9 +41,7 @@
 | graphql-complexity-limit-inbound | GraphQL Complexity Limit | Policy that limits the complexity and depth of GraphQL queries to prevent abuse. Protects your GraphQL API from expensive queries that could cause performance issues or denial of service attacks. | api-gateway |
 | graphql-disable-introspection-inbound | GraphQL Disable Introspection | Policy that disables GraphQL introspection queries in production. Introspection allows clients to discover the schema, which can be a security risk as it exposes your entire API structure. | api-gateway |
 | graphql-introspection-filter-outbound | GraphQL Introspection Filter | Filters GraphQL introspection responses to exclude specific types and fields.  This policy intercepts GraphQL introspection query responses and removes configured types and fields from the schema. Useful for hiding internal types or sensitive fields from the public schema. | api-gateway |
-| hmac-auth-inbound | HMAC Auth | Authenticate requests using the HMAC-SHA256 authentication scheme. | api-gateway |
 | http-deprecation-outbound | HTTP Deprecation | Sets HTTP deprecation headers on the outgoing response following the IETF HTTP Deprecation Header standard. Supports the Deprecation, Sunset, and Link headers. | api-gateway |
-| ip-restriction-inbound | IP Restriction | Block or allow requests based on their IP address. | api-gateway |
 | validate-json-schema-inbound | JSON Body Validation (deprecated) | Validates the body of an incoming request based on a JSON schema. | api-gateway |
 | open-id-jwt-auth-inbound | JWT Auth | The Open ID JWT Authentication policy allows you to authenticate incoming requests using an Open ID compliant bearer token. | api-gateway |
 | jwt-scopes-inbound | JWT Scope Validation | Validates that the JWT token includes specific scopes | api-gateway |
@@ -82,7 +73,6 @@
 | query-param-to-header-inbound | Query Parameter to Header | Extracts a query parameter and sets it as a header in the request. | api-gateway |
 | quota-inbound | Quota | The Quota policy enables you to set monthly, weekly, daily or hourly quotas on your API. | api-gateway |
 | rate-limit-inbound | Rate Limiting | Rate limiting policy to control the number of requests to your API. Supports multiple identification strategies (by user, IP, header, etc.) and can operate in strict or async mode for different performance characteristics. | api-gateway |
-| rbac-policy-inbound | RBAC Authorization | The RBAC authorization inbound policy limits access to resources based on the roles of the authenticated user. | api-gateway |
 | readme-metrics-inbound | Readme Metrics | Readme is a developer documentation and API metrics company. This policy pushes logs to their API calls dashboard. | api-gateway |
 | remove-query-params-inbound | Remove Query Parameters | Remove query parameters from the incoming request | api-gateway |
 | remove-headers-inbound | Remove Request Headers | Remove headers from the incoming request. | api-gateway |
@@ -102,8 +92,6 @@
 | 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 |
-| transform-body-inbound | Transform Request Body | Transform the body of an incoming request. | api-gateway |
-| transform-body-outbound | Transform Response Body | Transform the body of an outgoing response. | api-gateway |
 | upstream-aws-federated-auth-inbound | Upstream AWS Federated Auth | Resolves AWS credentials with STS AssumeRoleWithWebIdentity using Zuplo's ambient OIDC identity — no AWS keys are stored anywhere. The role's trust policy must trust the Zuplo OIDC identity provider. Resolved credentials are registered on the request context for the AWS Lambda handler and custom code to sign upstream requests with `AwsClient.fromContext`. This policy does not itself sign or forward the request. | api-gateway |
 | upstream-aws-service-auth-inbound | Upstream AWS Service Auth | Resolves AWS credentials from static access keys (optionally exchanged for an IAM role's temporary credentials via STS AssumeRole) and registers them on the request context. The AWS Lambda handler and custom code read them with `AwsClient.fromContext` to sign upstream requests. This policy does not itself sign or forward the request. | api-gateway |
 | upstream-azure-ad-service-auth-inbound | Upstream Azure AD Service Auth | Uses Azure Active Directory to add an Authorization header to the request in order to authenticate requests using Azure identity. | api-gateway |

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

@@ -0,0 +1,162 @@
+# AI Gateway Model Routing (v2) Policy
+
+The AI Gateway Model Routing (v2) policy applies declarative allow or block
+rules to AI requests. Configured targets use `provider/model` form and split on
+the first slash, so provider-specific model IDs can contain additional slashes.
+
+## Configuration
+
+Set a non-empty `models` object containing `completions`, `embeddings`, or both.
+Each capability uses exactly one mode:
+
+- `allowList` is curated mode. Only listed `main` models are accepted, entry 0
+  is the default when the request omits `model`, and entries can include
+  `backup`, `fallbackTimeoutSeconds`, and `quotaFallback`.
+- `blockList` is open-but-filtered mode. Any unblocked target can be requested,
+  but every request must include `model`; this mode has no defaults or
+  fallbacks.
+
+Because Responses management operations such as `GET /v1/responses/{id}` and
+`DELETE /v1/responses/{id}` have no request body, attach curated `allowList`
+rules (or a custom routing policy that supplies an OpenAI selection) to those
+operations. A `blockList` policy cannot select credentials for a bodyless
+request because that mode intentionally has no default.
+
+An allow-list entry can be a string shorthand or a full target object:
+
+```json
+{
+  "name": "ai-gateway-model-routing-v2-inbound",
+  "policyType": "ai-gateway-model-routing-v2",
+  "handler": {
+    "export": "AIGatewayModelRoutingV2InboundPolicy",
+    "module": "$import(@zuplo/runtime)",
+    "options": {
+      "models": {
+        "completions": {
+          "allowList": [
+            "openai/gpt-5",
+            {
+              "main": "anthropic/claude-sonnet-4-6",
+              "backup": "openai/gpt-5-mini",
+              "fallbackTimeoutSeconds": 30,
+              "quotaFallback": "anthropic/claude-haiku-4-5"
+            }
+          ]
+        },
+        "embeddings": {
+          "blockList": ["openai/legacy-embedding-model"]
+        }
+      }
+    }
+  }
+}
+```
+
+The first slash separates the provider from the model. Model IDs may contain
+additional slashes, such as `my-fireworks/accounts/fireworks/models/llama-v3`.
+Provider and model matching is case-insensitive. In curated mode the configured
+casing is preserved when the request is sent upstream.
+
+## Request behavior
+
+Clients can send a bare model name or `provider/model`. In curated mode, a bare
+name selects the one allow-list `main` with that model name; an ambiguous name
+receives a 400 response asking for `provider/model`. In block-list mode, bare
+Chat Completions and Embeddings models use OpenAI, while native Messages and
+Responses models use Anthropic and OpenAI respectively.
+
+`/v1/embeddings` uses the `embeddings` rules; Chat Completions, Responses, and
+Anthropic Messages use `completions` rules. A request containing `/` is treated
+as `provider/model`, so model IDs containing slashes must include their
+provider.
+
+The pass-through routes are provider-native: `/v1/messages` accepts Anthropic
+targets and `/v1/responses` accepts OpenAI targets. A request that explicitly
+selects the wrong provider receives a 400 response. An incompatible entry-0
+default is a policy configuration error.
+
+## Fallback behavior
+
+When `backup` is configured, the gateway fails over after a retryable error or
+after `fallbackTimeoutSeconds` (60 seconds by default). The timeout must be from
+1 through 300 seconds. `quotaFallback` independently selects another model after
+a usage-limit-exceeded signal. Fallbacks do not chain through another allow-list
+entry.
+
+Retry and timeout backups apply to translated Chat Completions and Embeddings
+requests. Native `/v1/messages` and `/v1/responses` requests are passed through
+without retrying a `backup`; `AIGatewayModelRouting.set` still validates every
+configured target and credential eagerly. A same-native-provider `quotaFallback`
+can still serve those routes after a usage-limit-exceeded signal.
+
+## Write your own routing policy
+
+Everything this policy does is built on two public primitives, so a custom
+inbound policy can replace it entirely. The policy's job is to collapse its
+allow list to one winning target and store it; custom code makes the same call
+with whatever logic it wants:
+
+- `AIGatewayModels.load(context)` returns the cached provider catalog, including
+  each model's capability, status, and per-token pricing.
+- `AIGatewayModelRouting.set(context, routing)` validates the routing, resolves
+  provider credentials internally, and stores the selection that the AI Gateway
+  handler consumes.
+
+A per-capability target is the same `AIGatewayRouteTarget` shape used by
+`allowList` entries: a `"provider/model"` string, or an object with `main` and
+optional `backup`, `fallbackTimeoutSeconds`, and `quotaFallback`.
+
+```typescript
+import {
+  AIGatewayModelRouting,
+  AIGatewayModels,
+  type ZuploContext,
+  type ZuploRequest,
+} from "@zuplo/runtime";
+
+export default async function routeModel(
+  request: ZuploRequest,
+  context: ZuploContext
+) {
+  const providers = await AIGatewayModels.load(context);
+  const openAI = providers.find((provider) => provider.name === "openai");
+  const model = openAI?.models.find(
+    (candidate) =>
+      candidate.capability === "completions" && candidate.status === "active"
+  );
+  if (!model) {
+    throw new Error("No active OpenAI completions model is available");
+  }
+  await AIGatewayModelRouting.set(context, {
+    completions: {
+      main: `openai/${model.model}`,
+      backup: "anthropic/claude-sonnet-4-6",
+      fallbackTimeoutSeconds: 30,
+    },
+  });
+  return request;
+}
+```
+
+Attach the module as an ordinary inbound policy on the AI Gateway route instead
+of (or before) the built-in model-routing policy:
+
+```json
+{
+  "name": "my-model-routing-inbound",
+  "policyType": "custom-code-inbound",
+  "handler": {
+    "export": "default",
+    "module": "$import(./modules/my-model-routing)"
+  }
+}
+```
+
+`AIGatewayModelRouting.get(context)` returns the sanitized, normalized routing
+set for the current request; it never returns credentials. The AI Gateway
+handler consumes this selection even when the built-in model-routing policy is
+not attached to the route. Prefer one routing policy per route. If you compose
+policies intentionally, a custom policy before the built-in policy wins because
+the built-in policy preserves an existing selection. A custom policy after it
+can replace an allowed selection, while a built-in rejection stops the chain.

package/docs/policies/ai-gateway-model-routing-v2-inbound/intro.md

@@ -0,0 +1,19 @@
+The AI Gateway Model Routing (v2) policy selects models with either a curated
+`allowList` or an open-but-filtered `blockList`. Allow-list entries accept the
+string shorthand `"provider/model"` or an object with `main`, `backup`,
+`fallbackTimeoutSeconds`, and `quotaFallback`; entry zero is the default when a
+curated request omits `model`, while block-list mode requires every request to
+name a model.
+
+Request model references split on the first slash, match provider and model
+case-insensitively, and preserve configured casing upstream. Clients may send a
+bare model name: curated rules resolve a unique allow-list match, while open
+rules default to OpenAI except on Anthropic-native Messages routes. Bodyless
+Responses management operations need curated or custom routing because
+block-list mode has no default. Retry backups apply to translated Chat
+Completions and Embeddings, not native pass-through routes; quota fallbacks
+remain independent and fallbacks do not chain.
+
+Custom inbound policies can inspect `AIGatewayModels.load(context)` and call
+`AIGatewayModelRouting.set(context, routing)` to select the same target without
+attaching the built-in policy. This policy is in beta.