zuplo 7.11.4 → 7.11.5

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

@@ -177,7 +177,7 @@ const client = new BedrockRuntimeClient({
 // Unchanged from here down.
 const response = await client.send(
   new ConverseCommand({
-    modelId: "bedrockruntime/us.anthropic.claude-haiku-4-5-20251001-v1:0",
+    modelId: "bedrockruntime/us.anthropic.claude-haiku-5-5",
     messages: [{ role: "user", content: [{ text: "Say hi" }] }],
   }),
 );
@@ -198,7 +198,7 @@ Apps reference models as `providerName/modelId`, where `providerName` is the
 name you gave the provider configuration:
 
 ```
-bedrockruntime/us.anthropic.claude-haiku-4-5-20251001-v1:0
+bedrockruntime/us.anthropic.claude-haiku-5-5
 ```
 
 The gateway strips its own prefix and sends AWS the model ID exactly as you

package/docs/ai-gateway/cookbooks/sdk-path-shim.mdx

@@ -25,7 +25,7 @@ runtime feature, and these clients aren't among the supported clients documented
 on the [Azure AI](../azure-ai.mdx) or [Vertex AI](../vertex-ai.mdx) pages. Model
 references don't change—they stay the gateway's usual `providerName/deployment`
 for Azure (`azureai/my-gpt`) and `providerName/publisher/model` for Vertex
-(`vertexai/anthropic/claude-haiku-4-5@20251001`).
+(`vertexai/anthropic/claude-haiku-5-5`).
 
 ## The policy
 

package/docs/ai-gateway/fallback.mdx

@@ -39,7 +39,7 @@ models are referenced like any model, as `providerName/model`.
 
 1. Configure the policy:
    - **Fallback**: the model attempted after a retryable error or timeout, for
-     example `anthropic/claude-haiku-4-5`.
+     example `anthropic/claude-haiku-5-5`.
    - **Quota fallback**: the model used once a usage limit is exceeded, for
      example `openai/gpt-6-luna`.
    - **Fallback timeout (seconds)**: how long the primary call can run before

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

@@ -285,7 +285,7 @@ const anthropic = createAnthropic({
 });
 
 const { text } = await generateText({
-  model: anthropic("vertexai/anthropic/claude-haiku-4-5@20251001"),
+  model: anthropic("vertexai/anthropic/claude-haiku-5-5"),
   prompt: "Write a one-sentence bedtime story about a unicorn.",
 });
 ```

package/docs/ai-gateway/integrations/claude-code.mdx

@@ -79,7 +79,7 @@ use the app's API key and API URL instead.
     "ANTHROPIC_MODEL": "anthropic/claude-sonnet-5-5",
     "ANTHROPIC_DEFAULT_OPUS_MODEL": "anthropic/claude-opus-5-5",
     "ANTHROPIC_DEFAULT_SONNET_MODEL": "anthropic/claude-sonnet-5-5",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "anthropic/claude-haiku-4-5",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "anthropic/claude-haiku-5-5",
     "ANTHROPIC_DEFAULT_FABLE_MODEL": "anthropic/claude-fable-5-1"
   },
   "modelOverrides": {
@@ -166,7 +166,7 @@ In the **JSON** editor:
     "ANTHROPIC_MODEL": "anthropic/claude-sonnet-5-5",
     "ANTHROPIC_DEFAULT_OPUS_MODEL": "anthropic/claude-opus-5-5",
     "ANTHROPIC_DEFAULT_SONNET_MODEL": "anthropic/claude-sonnet-5-5",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "anthropic/claude-haiku-4-5",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "anthropic/claude-haiku-5-5",
     "ANTHROPIC_DEFAULT_FABLE_MODEL": "anthropic/claude-fable-5-1"
   },
   "modelOverrides": {

package/docs/ai-gateway/providers.mdx

@@ -178,7 +178,7 @@ Two things make its setup different from every other provider:
 Every Vertex model ID is publisher-qualified, so a model reference has two
 slashes: a provider named `vertexai` serves `vertexai/google/gemini-3.7-flash`,
 `vertexai/qwen/qwen3-coder-480b-a35b-instruct-maas`, and
-`vertexai/anthropic/claude-haiku-4-5@20251001`. Model availability varies by
+`vertexai/anthropic/claude-haiku-5-5`. Model availability varies by
 location—most Model Garden models are served only from the `global` location,
 and Google's regional endpoints serve Claude Sonnet 4.6 and earlier only, so
 `global` is the location that serves every Claude model. Vertex's Claude models

package/docs/ai-gateway/vertex-ai.mdx

@@ -112,7 +112,7 @@ instead, with the model in the URL:
 
 ```
 https://aiplatform.googleapis.com
-  /v1/projects/my-project-123/locations/global/publishers/anthropic/models/claude-haiku-4-5@20251001:rawPredict
+  /v1/projects/my-project-123/locations/global/publishers/anthropic/models/claude-haiku-5-5:rawPredict
 ```
 
 The **location** lives in the hostname, which is why the provider dialog asks
@@ -403,7 +403,7 @@ const client = new Anthropic({
 });
 
 const message = await client.messages.create({
-  model: "vertexai/anthropic/claude-haiku-4-5@20251001",
+  model: "vertexai/anthropic/claude-haiku-5-5",
   max_tokens: 1024,
   messages: [{ role: "user", content: "Say hi" }],
 });

package/docs/policies/_index.md

@@ -8,7 +8,7 @@
 | ai-gateway-configuration-executor-inbound | AI Gateway Configuration Executor | Loads the app configuration for the request (when auth or the configuration loader has not already), runs the inbound policy chain from that configuration, and enforces limits inherited from parent teams or the gateway root.  Place this policy on AI Gateway routes after optional authentication and optional `ai-gateway-configuration-loader-inbound`. When either of those already populated the app-configuration channel, this policy reuses it. Otherwise it loads the configuration with the route's `app_id` path parameter. Applications select from policies pre-declared by the gateway. Applications without a `inboundPolicyChain`, or with an empty chain, run no application-selected policies. Entry options replace the declaration's options as a complete object; omit them to inherit the declaration, including environment-backed credentials. Each occurrence receives a private deep copy of its entry options, so a policy mutating its options cannot corrupt the cached app configuration. | ai-gateway |
 | ai-gateway-configuration-loader-inbound | AI Gateway Configuration Loader | Loads the AI Gateway app configuration for the request into the request-scoped channel and does nothing else.  Place this policy on AI Gateway routes before `ai-gateway-configuration-executor-inbound` when you want configuration loading separated from chain execution. When `ai-gateway-auth-inbound` already populated the channel, this policy reuses it. Otherwise it loads the configuration with the route's `app_id` path parameter.  If this policy is omitted, the configuration executor still loads configuration itself before running the application chain. | ai-gateway |
 | ai-gateway-fallback-model-inbound | AI Gateway Fallback Model | Adds failure and quota fallbacks to an existing AI Gateway model selection.  Place this policy after AI Gateway Model Filtering. It never creates a model selection, so a misplaced policy cannot bypass filtering. | ai-gateway |
-| ai-gateway-metering-inbound | AI Gateway Metering | Meters AI Gateway usage and enforces limits configured by the application.  The authentication policy must run before this policy so the app configuration id is available for meter storage and analytics. | ai-gateway |
+| ai-gateway-metering-inbound | AI Gateway Metering | Meters AI Gateway usage for the application.  The authentication policy must run before this policy so the app configuration id is available for meter storage and analytics. Budgets are declared with `budgetRules` and enforced by the configuration executor. | ai-gateway |
 | ai-gateway-model-filtering-inbound | AI Gateway Model Filtering | Matches AI Gateway requests against curated allow lists or open block lists, then stores the winning model reference for the route handler. | ai-gateway |
 | ai-gateway-model-override-inbound | AI Gateway Model Override | Forces one model for every request, or supplies a default model when a request omits one, then stores that selection for the AI Gateway handler.  An earlier policy's model selection is never overwritten, so a custom routing policy placed before this one stays authoritative. | ai-gateway |
 | ai-gateway-semantic-cache-inbound | AI Gateway Semantic Cache | AI Gateway Semantic Cache policy. This inbound policy looks up the semantic cache on entry and, on a miss, registers a response-sending hook to write the upstream response back into the cache.  Caching parameters (semanticTolerance, expirationSecondsTtl, namespace, recentMessageCount) come from the policy options, and presence in the route's chain is what enables it. An id from the authenticated app configuration always provides the cache namespace so application-supplied options cannot cross tenant partitions. The cache key covers the system prompt plus the last `recentMessageCount` messages (default 1) — applied when storing and when matching — so multi-turn conversations can hit entries cached from earlier, shorter ones.  Cache outcomes are reported on the response via the RFC 9211 `Cache-Status` header under the cache name `zp-aigw-sem-cache` (hit: `zp-aigw-sem-cache; hit; detail="similarity=0.93"`; miss: `zp-aigw-sem-cache; fwd=miss; stored`). Responses also include the `x-ai-gateway-cache: HIT\|MISS` and `x-ai-gateway-cache-similarity` headers. | ai-gateway |
@@ -46,7 +46,7 @@
 | ai-gateway-galileo-tracing-inbound | Galileo Tracing | Galileo Tracing Inbound Policy | ai-gateway |
 | geo-filter-inbound | Geo-location filtering | Block requests based on geo-location parameters: country, region code, and ASN | api-gateway |
 | graphql-analytics-outbound | GraphQL Analytics | Reports GraphQL errors returned in response bodies to Zuplo's GraphQL analytics. GraphQL servers following the standard Apollo / graphql-yoga pattern return `200 OK` with an `errors[]` array in the body when an operation fails, which HTTP-level analytics alone report as a success — add this policy to a GraphQL route and failed operations show up as failures on the GraphQL dashboard, classified by error type.  Each error in `errors[]` is classified from its `extensions.code` following the Apollo Server conventions (`GRAPHQL_PARSE_FAILED` → `syntax`, `GRAPHQL_VALIDATION_FAILED` → `validation`, `UNAUTHENTICATED` / `FORBIDDEN` → `auth`, timeout codes → `timeout`); custom codes can be mapped with `errorCodeClassification`, and anything unrecognized falls back to `defaultErrorClass` (`resolver`). Optionally set `logErrors` to also write a structured warning per errored response. The policy reads up to `maxScanBytes` of the body (128 KiB by default, 5 MiB maximum), scanning it for the `errors` token; a response larger than that is treated as error-free. When the token is found and the body fits, it is parsed and its errors reported.  The response always passes through unchanged — the body is read from a clone, and any internal failure is swallowed so reporting can never break the request. The route must be marked `x-graphql: true` in `routes.oas.json` (which enables GraphQL analytics for the route); without the marker the policy logs a warning and does nothing. | api-gateway |
-| graphql-cache-inbound | GraphQL Cache | Caches GraphQL query responses at the edge so identical queries are served without a round-trip to the origin.  Unlike CDN caching that keys on the raw request body, this policy parses the GraphQL document and normalizes it before hashing: insignificant whitespace, field formatting, and fragment layout are collapsed, and variable object keys are sorted. Two requests that are semantically identical therefore share a cache entry even when their bodies differ byte-for-byte. There is no query size or nesting-depth limit.  Only `query` operations are cached. Mutations, subscriptions, malformed documents, and non-JSON bodies are forwarded to the origin untouched. Cache hits and misses are reported on the `x-cache` response header, with a short key fingerprint on `x-cache-key`.  To avoid serving one user's data to another, requests carrying an `authorization` or `cookie` header are not cached by default. Use `cacheKeyHeaders` to opt into caching them: each listed header's value is included in the cache key, so distinct credentials get distinct cache entries. | api-gateway |
+| graphql-cache-inbound | GraphQL Cache | Caches GraphQL query responses at the edge so identical queries are served without a round-trip to the origin.  Unlike CDN caching that keys on the raw request body, this policy parses the GraphQL document and normalizes it before hashing: insignificant whitespace, field formatting, and fragment layout are collapsed, and variable object keys are sorted. Two requests that are semantically identical therefore share a cache entry even when their bodies differ byte-for-byte. There is no query size or nesting-depth limit.  Only `query` operations are cached. Mutations, subscriptions, malformed documents, and non-JSON bodies are forwarded to the origin untouched. Cache hits and misses are reported on the `x-cache` response header, with a short key fingerprint on `x-cache-key`, and in the Cache analytics alongside the Caching policy's lookups.  To avoid serving one user's data to another, requests carrying an `authorization` or `cookie` header are not cached by default. Use `cacheKeyHeaders` to opt into caching them: each listed header's value is included in the cache key, so distinct credentials get distinct cache entries. | api-gateway |
 | 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 |

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

@@ -255,9 +255,9 @@ An application can inherit the options from `policies.json`. Include
 ```
 
 Place authentication first when the app requires a key, then model filtering,
-fallback-model, and metering so metering can activate the resolved quota
-fallback. Put policies that may short-circuit, such as semantic cache, after
-metering so those requests still count toward request limits.
+fallback-model, and metering. Put policies that may short-circuit, such as
+semantic cache, after metering so those requests still count toward request
+limits.
 
 An application can also provide a complete options object for an entry:
 

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

@@ -73,7 +73,8 @@ Embeddings requests. Native create requests at `/v1/messages` and
 exhausts its upstream 429 retries; they do not inherit `fallbackTimeoutSeconds`
 or transport/5xx fallback. Responses management operations do not retry a backup
 because stored response IDs belong to the provider that created them. Quota
-fallback remains a separate, metering-driven path.
+fallback is a separate path that the configuration executor activates when a
+budget is exceeded.
 
 ## Write your own fallback policy
 

package/docs/policies/ai-gateway-load-balancing-inbound/doc.md

@@ -408,7 +408,7 @@ declared in `config/policies.json`. See
 | [Model Filtering](/docs/policies/ai-gateway-model-filtering-inbound) | Not needed for request types this policy has a list for, because the list already limits the models clients can reach. If Model Filtering runs first, it routes or refuses each request by the model the client asked for, and this policy does nothing. Placed after, it doesn't check this policy's choices.                     |
 | [Fallback Model](/docs/policies/ai-gateway-fallback-model-inbound)   | Place it after, where it changes the retry model, the timeout, and where over-quota requests go. Placed before, it does nothing. See [With Fallback Model](#with-fallback-model).                                                                                                                                                  |
 | [Smart Router](/docs/policies/ai-gateway-smart-router-inbound)       | When it routes a request, its model wins, whichever runs first. The request loses this policy's retry model, and Smart Router doesn't apply this policy's endpoint or stored-response rules. Fallback Model placed after Smart Router still adds its `fallback` and `quotaFallback`. Placed before Smart Router, they're lost too. |
-| [Metering](/docs/policies/ai-gateway-metering-inbound)               | Place it after this policy and Fallback Model, so a request over its quota can switch to Fallback Model's `quotaFallback`. Costs and usage use the model that served the request.                                                                                                                                                  |
+| [Metering](/docs/policies/ai-gateway-metering-inbound)               | Either order works. Costs and usage use the model that served the request.                                                                                                                                                                                                                                                         |
 | [Semantic Cache](/docs/policies/ai-gateway-semantic-cache-inbound)   | Place it after. Its cache key uses the request's own `model`, not this policy's choice, so with a list of different models a cached answer can come from any of them. Placed before, it serves a cache hit without this policy when the request's `model` is a valid model, and skips the hit otherwise.                           |
 
 ### With Fallback Model

package/docs/policies/ai-gateway-metering-inbound/doc.md

@@ -14,8 +14,8 @@ fallback model or returns `429 Too Many Requests`. Cached responses are also
 subject to budgets: a blocked cache hit returns `429 Too Many Requests` without
 using a fallback model.
 
-Place Metering after Model Filtering and Fallback Model. Place it before
-Semantic Cache so cache hits count toward request limits.
+Place Metering after Model Filtering. Place it before Semantic Cache so cache
+hits count toward request limits.
 
 ## Example
 
@@ -242,6 +242,6 @@ so concurrent requests can exceed a budget before further requests are blocked.
 
 If a budget check is unavailable, requests can proceed unless a budget has
 already been determined to block them. The `throwOnFailure` option controls
-whether this policy rejects requests when its metering operations fail; it does
-not change how application, team, or gateway `budgetRules` handle unavailable
+whether this policy fails the request when recording usage fails; it does not
+change how application, team, or gateway `budgetRules` handle unavailable
 checks.

package/docs/policies/ai-gateway-metering-inbound/intro.md

@@ -1,13 +1,14 @@
 The AI Gateway Metering policy records each application's spend, tokens, and
-requests and enforces spend, token, and request budgets. When a limit is
-exceeded, it uses the model selection's quota fallback when one is configured or
-returns `429 Too Many Requests`.
+requests, and declares the application's spend, token, and request budgets. The
+configuration executor enforces those budgets: when a budget is exceeded, it
+uses the model selection's quota fallback when one is configured or returns
+`429 Too Many Requests`.
 
 A budget rule covers the whole application, or gives every distinct value of an
 expression its own budget, such as one budget per user with
 `request.headers.get("x-user-id")`.
 
-Place it after Model Filtering and Fallback Model, and before policies such as
-Semantic Cache that may answer without calling a provider. Metering fails open
-by default when its service is unavailable; set `throwOnFailure` to `true` to
-reject requests instead.
+Place it after Model Filtering and before policies such as Semantic Cache that
+may answer without calling a provider. Metering fails open by default when
+recording usage fails; set `throwOnFailure` to `true` to fail the request
+instead.

package/docs/policies/ai-gateway-metering-inbound/schema.json

@@ -12,7 +12,7 @@
   "requiresAI": true,
   "policyType": "ai-gateway-metering",
   "products": ["ai-gateway"],
-  "description": "Meters AI Gateway usage and enforces limits configured by the application.\n\nThe authentication policy must run before this policy so the app configuration id is available for meter storage and analytics.",
+  "description": "Meters AI Gateway usage for the application.\n\nThe authentication policy must run before this policy so the app configuration id is available for meter storage and analytics. Budgets are declared with `budgetRules` and enforced by the configuration executor.",
   "deprecatedMessage": "",
   "required": ["handler"],
   "properties": {
@@ -32,7 +32,7 @@
         "options": {
           "title": "AIGatewayMeteringInboundPolicyOptions",
           "type": "object",
-          "description": "Options for metering AI Gateway usage and enforcing request-time limits.",
+          "description": "Options for metering AI Gateway usage and declaring budget rules.",
           "additionalProperties": false,
           "required": [],
           "examples": [
@@ -63,7 +63,7 @@
             "throwOnFailure": {
               "type": "boolean",
               "default": false,
-              "description": "Throw when the metering service is unavailable instead of failing open."
+              "description": "Fail the request instead of logging the error when recording usage with the metering service fails."
             },
             "budgetRules": {
               "type": "array",
@@ -140,7 +140,7 @@
               "doNotSuggest": true,
               "x-show-example": false,
               "x-advanced": true,
-              "description": "Usage limits grouped by meter.",
+              "description": "Deprecated and not enforced. Declare budgets with budgetRules.",
               "additionalProperties": false,
               "properties": {
                 "costs": {

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

@@ -25,7 +25,7 @@ agentic, document_qa, other) and the built-in classification prompt.
 
 | Classifier                                | Set               | Use it when                                                                                                                                                                                                                              |
 | ----------------------------------------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `classifier.app`                          | `appId`, `model`  | You want the classifier to use one of your providers, through an AI Gateway app in this project. The call stays in-process. Set `adapter: "messages"` for Claude models, or `adapter: "system-one"` for Jev and other System One models. |
+| `classifier.app`                          | `appId`, `model`  | You want the classifier to use one of your providers, through an AI Gateway app in this project. The call stays in-process. Set `dialect: "messages"` for Claude models, or `dialect: "system-one"` for Jev and other System One models. |
 | `classifier.chatCompletions` (deprecated) | `apiKey`, `model` | You need to call an OpenAI-compatible endpoint directly with its own key, without a second AI Gateway app.                                                                                                                               |
 | `classifier.jev` (deprecated)             | `apiKey`          | You need to call Jev, from TypeSafe, directly with its own key. TypeSafe and OpenRouter both serve it.                                                                                                                                   |
 
@@ -50,7 +50,7 @@ budgets, and analytics, and new classifier features are added only to
 ```
 
 - `appId` — the AI Gateway app that runs the classifier.
-- `adapter` — optional: `chat-completions` (default), `messages`, or
+- `dialect` — optional: `chat-completions` (default), `messages`, or
   `system-one`. Selects `/v1/chat/completions`, `/v1/messages`, or
   `/v1/systemone` on that app.
 - `model` — the `providerName/model` that app routes the classifier request to.
@@ -69,7 +69,7 @@ Anthropic Messages API:
 "classifier": {
   "app": {
     "appId": "$env(CLASSIFIER_APP_ID)",
-    "adapter": "messages",
+    "dialect": "messages",
     "model": "anthropic/claude-haiku-4-5"
   }
 }
@@ -107,7 +107,7 @@ schema is built from your `intents`, so the first classification after you
 change them, or after the cache expires, can be slower than usual. If it runs
 past `classifierTimeoutMs`, that one request continues unclassified.
 
-The `messages` adapter does not translate between providers: pick a model the
+The `messages` dialect does not translate between providers: pick a model the
 classifier app serves on `/v1/messages`.
 
 For Jev registered with your gateway, use the same app path with System One:
@@ -116,7 +116,7 @@ For Jev registered with your gateway, use the same app path with System One:
 "classifier": {
   "app": {
     "appId": "$env(CLASSIFIER_APP_ID)",
-    "adapter": "system-one",
+    "dialect": "system-one",
     "model": "jev/jev-latest"
   }
 }
@@ -125,12 +125,12 @@ For Jev registered with your gateway, use the same app path with System One:
 Replace `jev` with your configured provider name. The classifier app resolves
 the provider assignment and owns upstream credentials, routing, DB pricing,
 budget checks, token metering, and analytics. No direct provider key, base URL,
-or pricing configuration is needed in Smart Router. Its result still includes
-the classifier's usage and cost; it does not emit duplicate analytics under the
-calling app.
+or pricing configuration is needed in Smart Router. Its result includes the
+classifier's token usage; it does not emit duplicate analytics under the calling
+app.
 
 Smart Router sends its intent and complexity questions to the app and interprets
-the returned System One answers. Omit `classifierPrompt` for this adapter. Keep
+the returned System One answers. Omit `classifierPrompt` for this dialect. Keep
 Smart Router off the classifier app's own chain. System One is not a chat-shaped
 request, so choose policies compatible with that endpoint; existing guardrails
 that cannot inspect its shape still reject it according to their configuration.
@@ -209,7 +209,7 @@ routing applies only when Jev is sure of both. Jev writes no reasons, so
 
 Jev takes no system prompt, so setting `classifierPrompt` with `classifier.jev`
 is rejected with a `ConfigurationError`. The same restriction applies to
-`classifier.app.adapter: "system-one"`.
+`classifier.app.dialect: "system-one"`.
 
 `chatCompletions` and `jev` call a service outside the gateway with the key you
 configure, and send it the prompt. When that service answers with an error, the
@@ -218,9 +218,9 @@ which can echo the request back, prompt included.
 
 To migrate a direct section, register the provider with the gateway, create a
 classifier app for it, and replace the section with `classifier.app`. Use
-`adapter: "system-one"` to replace `classifier.jev`, and `adapter: "messages"`
+`dialect: "system-one"` to replace `classifier.jev`, and `dialect: "messages"`
 for a Claude model. Existing `classifier.app` configurations continue to default
-to Chat Completions when `adapter` is omitted. `system-one` uses the existing
+to Chat Completions when `dialect` is omitted. `system-one` uses the existing
 Jev request and response contract; it does not add support for arbitrary
 decision APIs.
 
@@ -295,6 +295,12 @@ They're deprecated, and still honored when `classifier` isn't set:
 Move all three at once. Setting `classifier` together with any of them is
 rejected with a `ConfigurationError`.
 
+## Migrating from `classifier.app.adapter`
+
+`classifier.app.adapter` is the earlier name of `classifier.app.dialect`. It
+takes the same values, and is still honored when `dialect` isn't set. Rename the
+field to `dialect`. Setting both is rejected with a `ConfigurationError`.
+
 ## Policy order
 
 ```text
@@ -361,7 +367,7 @@ classifier calls a strict JSON-schema chat completion, so it can only return one
 of your configured ids. The `description` values are only shown to the
 classifier if your prompt includes `{{intents}}` (see below).
 
-With `classifier.jev` or `classifier.app.adapter: "system-one"`, the `id` values
+With `classifier.jev` or `classifier.app.dialect: "system-one"`, the `id` values
 are the options of Jev's intent question, and every `description` is shown to
 Jev with its option. There is no prompt, so `{{intents}}` doesn't apply.
 
@@ -372,9 +378,9 @@ so it's never eligible for routing.
 ### Custom classifier prompt
 
 `classifierPrompt` replaces the built-in classifier prompt for `classifier.app`
-(its default `chat-completions` adapter, or `messages`, which sends it as
+(its default `chat-completions` dialect, or `messages`, which sends it as
 `system`) and `classifier.chatCompletions`.
-`classifier.app.adapter: "system-one"` and `classifier.jev` take no prompt, so
+`classifier.app.dialect: "system-one"` and `classifier.jev` take no prompt, so
 combining `classifierPrompt` with either is a configuration error. It accepts
 either a string or an array of lines:
 
@@ -422,20 +428,8 @@ interface AIGatewaySmartRouterResult {
     inputTokens: number;
     outputTokens: number;
     totalTokens: number;
-    breakdown?: {
-      uncachedInputTokens: number;
-      cacheReadInputTokens?: number;
-      cacheWriteInput?: Array<{ tokens: number; cacheTtl?: "5m" | "1h" }>;
-      visibleOutputTokens: number;
-      reasoningOutputTokens?: number;
-    };
   };
   classifierModel: string;
-  cost?: {
-    costUsd: number;
-    source: "provider" | "catalog" | "unpriced";
-    accuracy: "exact" | "estimated" | "unpriced";
-  };
   routing: { model?: string };
   durationMs: number;
   promptSource: "user" | "prior-user";
@@ -457,7 +451,7 @@ interface AIGatewaySmartRouterResult {
 }
 ```
 
-With `classifier.jev` or `classifier.app.adapter: "system-one"`,
+With `classifier.jev` or `classifier.app.dialect: "system-one"`,
 `classifierModel` is the versioned model that answered, in the host's naming:
 `jev-1.13.0` on TypeSafe, or `typesafe/jev-1.13-20260917` on OpenRouter. `usage`
 reports the input and output tokens that the Jev API returns as `inputTokens`
@@ -550,7 +544,8 @@ like smart routing quietly doing nothing:
 - More than one section in `classifier` (`app`, `chatCompletions`, and `jev`).
 - A deprecated `classifierAppID`, `classifierModel`, or `classifierAppApiKey`
   next to `classifier`.
-- `classifierPrompt` with `classifier.app.adapter: "system-one"` or
+- Both `classifier.app.dialect` and the deprecated `classifier.app.adapter`.
+- `classifierPrompt` with `classifier.app.dialect: "system-one"` or
   `classifier.jev`.
 - A `classifier.app.appId` that names this app.
 - A classifier app that runs this policy or Akamai AI Firewall.
@@ -564,27 +559,11 @@ the policy from that route to use Bedrock Runtime through it.
 
 ### Classifier cost reporting
 
-Use `classifier.app` for DB-backed pricing, metering, analytics and budgets.
-After classification, `AIGatewaySmartRouter.get(context)` exposes token usage
-and cost from the invoked gateway's accounting headers, including its accounted
-input, output, and total tokens and cost accuracy. Smart Router does not
-recompute usage from the provider response for app classifiers. Missing or
-invalid token headers produce zero counts; missing cost headers produce
-`source: "unpriced"`. Responses from older gateways without cost accuracy retain
-a conservative estimate for catalog costs.
-
-Deprecated direct classifiers retain token usage and any validated
-provider-reported cost in the Smart Router result, but do not look up DB prices,
-send gateway analytics, or increment budget meters. If the provider does not
-report a valid cost, the result is `unpriced`; its numeric zero does not mean
-the call was free. No additional pricing configuration is supported for direct
-calls.
+Use `classifier.app` for DB-backed pricing, metering, analytics and budgets. The
+classifier app records the classifier call's cost under its own app.
+`AIGatewaySmartRouter.get(context)` exposes only the token usage that the
+classifier response body reports, not its cost.
 
-App classifier results also include `usage.breakdown` when the gateway has
-canonical accounting detail. It exposes uncached input, cache-read input,
-cache-write input (with TTL when known), visible output, and reasoning output.
-These disjoint categories are already included in `inputTokens` and
-`outputTokens`; do not add them to the totals again. Unreported detail remains
-absent, while an explicitly reported zero is preserved. Missing or malformed
-breakdown headers do not discard aggregate token counts or cost. Smart Router
-does not derive these categories from the provider body or infer cache TTLs.
+Deprecated direct classifiers do not look up DB prices, send gateway analytics,
+or increment budget meters. No pricing configuration is supported for direct
+calls.

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

@@ -63,7 +63,7 @@
               "classifier": {
                 "app": {
                   "appId": "$env(CLASSIFIER_APP_ID)",
-                  "adapter": "system-one",
+                  "dialect": "system-one",
                   "model": "jev/jev-latest"
                 }
               },
@@ -77,7 +77,7 @@
               "classifier": {
                 "app": {
                   "appId": "$env(CLASSIFIER_APP_ID)",
-                  "adapter": "messages",
+                  "dialect": "messages",
                   "model": "anthropic/claude-haiku-4-5"
                 }
               },
@@ -92,7 +92,7 @@
               "classifier": {
                 "app": {
                   "appId": "$env(CLASSIFIER_APP_ID)",
-                  "adapter": "chat-completions",
+                  "dialect": "chat-completions",
                   "model": "openai/gpt-4o-mini"
                 }
               },
@@ -107,7 +107,7 @@
             "classifier": {
               "type": "object",
               "title": "Classifier",
-              "description": "Where the prompt is classified. Set `app.adapter` to select the API that classifier app exposes.",
+              "description": "Where the prompt is classified. Set `app.dialect` to select the API that classifier app exposes.",
               "additionalProperties": false,
               "minProperties": 1,
               "maxProperties": 1,
@@ -118,6 +118,9 @@
                   "description": "Classify with another AI Gateway app in this project. The call runs in-process and never leaves the gateway, so the classifier uses that app's providers, routing, and quotas.",
                   "additionalProperties": false,
                   "required": ["appId", "model"],
+                  "not": {
+                    "required": ["dialect", "adapter"]
+                  },
                   "properties": {
                     "appId": {
                       "type": "string",
@@ -128,7 +131,7 @@
                     "model": {
                       "type": "string",
                       "title": "Classifier Model",
-                      "description": "The model (`providerName/model`) the classifier app uses to evaluate the user's request. `providerName` is the name of the provider as configured on the classifier app, not a fixed vendor id. E.g. `openai/gpt-4o-mini`, `anthropic/claude-haiku-4-5` with the `messages` adapter, or `jev/jev-latest` when the Jev provider is named `jev`.",
+                      "description": "The model (`providerName/model`) the classifier app uses to evaluate the user's request. `providerName` is the name of the provider as configured on the classifier app, not a fixed vendor id. E.g. `openai/gpt-4o-mini`, `anthropic/claude-haiku-4-5` with the `messages` dialect, or `jev/jev-latest` when the Jev provider is named `jev`.",
                       "pattern": "^[^/\\s]+/.+$",
                       "examples": ["openai/gpt-4o-mini"]
                     },
@@ -139,12 +142,22 @@
                       "examples": ["$env(CLASSIFIER_APP_API_KEY)"],
                       "x-advanced": true
                     },
-                    "adapter": {
+                    "dialect": {
                       "type": "string",
                       "enum": ["chat-completions", "messages", "system-one"],
                       "default": "chat-completions",
-                      "title": "Classifier App Adapter",
+                      "title": "Classifier App Dialect",
                       "description": "API contract exposed by the classifier app. `chat-completions` calls /v1/chat/completions; `messages` calls /v1/messages for Claude models that support structured outputs (`output_config.format`), such as `claude-haiku-4-5`, on a provider whose Messages endpoint accepts them (not Amazon Bedrock Mantle); `system-one` calls /v1/systemone for models such as Jev. The app owns provider credentials, pricing, metering and analytics."
+                    },
+                    "adapter": {
+                      "type": "string",
+                      "enum": ["chat-completions", "messages", "system-one"],
+                      "title": "Classifier App Adapter (Deprecated)",
+                      "description": "\\*\\*Deprecated\\*\\*: use `classifier.app.dialect` instead. Still honored when `dialect` is not set; setting both is a configuration error.",
+                      "deprecated": true,
+                      "doNotSuggest": true,
+                      "x-show-example": false,
+                      "x-advanced": true
                     }
                   }
                 },
@@ -181,7 +194,7 @@
                 "jev": {
                   "type": "object",
                   "title": "Jev (TypeSafe)",
-                  "description": "Deprecated: use `classifier.app` with `adapter` `system-one` instead. Classify with Jev, TypeSafe's classification model, by calling a System One API directly: TypeSafe's by default, or another host such as OpenRouter through `baseUrl`. Jev answers typed questions instead of generating text, so it takes no `classifierPrompt`.",
+                  "description": "Deprecated: use `classifier.app` with `dialect` `system-one` instead. Classify with Jev, TypeSafe's classification model, by calling a System One API directly: TypeSafe's by default, or another host such as OpenRouter through `baseUrl`. Jev answers typed questions instead of generating text, so it takes no `classifierPrompt`.",
                   "additionalProperties": false,
                   "required": ["apiKey"],
                   "properties": {
@@ -279,7 +292,7 @@
             },
             "classifierPrompt": {
               "title": "Classifier Prompt",
-              "description": "Prompt for classifier.app (its default `chat-completions` adapter or the `messages` adapter, where it is sent as the system prompt) and classifier.chatCompletions. Omit to use the built-in prompt. classifier.app.adapter `system-one` and classifier.jev take no prompt; combining them with classifierPrompt is a configuration error.",
+              "description": "Prompt for classifier.app (its default `chat-completions` dialect or the `messages` dialect, where it is sent as the system prompt) and classifier.chatCompletions. Omit to use the built-in prompt. classifier.app.dialect `system-one` and classifier.jev take no prompt; combining them with classifierPrompt is a configuration error.",
               "oneOf": [
                 {
                   "type": "string",
@@ -357,12 +370,27 @@
                 "required": ["app"],
                 "properties": {
                   "app": {
-                    "required": ["adapter"],
-                    "properties": {
-                      "adapter": {
-                        "const": "system-one"
+                    "anyOf": [
+                      {
+                        "required": ["dialect"],
+                        "properties": {
+                          "dialect": {
+                            "const": "system-one"
+                          }
+                        }
+                      },
+                      {
+                        "not": {
+                          "required": ["dialect"]
+                        },
+                        "required": ["adapter"],
+                        "properties": {
+                          "adapter": {
+                            "const": "system-one"
+                          }
+                        }
                       }
-                    }
+                    ]
                   }
                 }
               }
@@ -396,7 +424,7 @@
             "classifier": {
               "app": {
                 "appId": "$env(CLASSIFIER_APP_ID)",
-                "adapter": "system-one",
+                "dialect": "system-one",
                 "model": "jev/jev-latest"
               }
             },
@@ -414,7 +442,7 @@
             "classifier": {
               "app": {
                 "appId": "$env(CLASSIFIER_APP_ID)",
-                "adapter": "messages",
+                "dialect": "messages",
                 "model": "anthropic/claude-haiku-4-5"
               }
             },
@@ -433,7 +461,7 @@
             "classifier": {
               "app": {
                 "appId": "$env(CLASSIFIER_APP_ID)",
-                "adapter": "chat-completions",
+                "dialect": "chat-completions",
                 "model": "openai/gpt-4o-mini"
               }
             },

package/docs/policies/graphql-cache-inbound/doc.md

@@ -30,6 +30,15 @@ Every response served or stored by the policy carries two headers:
 Both headers are added to `access-control-expose-headers` so browsers can read
 them, without overwriting any value an upstream CORS policy already set.
 
+### Analytics
+
+Every lookup is reported in your project's **Cache** analytics, under the `HTTP`
+cache type with the policy's name: hits, misses, stored responses, and cache
+latency. The latency covers both reading entries and storing new ones. Requests
+the policy forwards without a lookup, such as mutations and credentialed
+requests, don't count toward the hit rate. On routes that also run GraphQL
+analytics, the **GraphQL** analytics show the hit rate per operation.
+
 ### What is and isn't cached
 
 - Only `query` operations are cached. **Mutations** and **subscriptions** are

package/docs/policies/graphql-cache-inbound/schema.json

@@ -12,7 +12,7 @@
   "requiresAI": false,
   "policyType": "graphql-cache-inbound",
   "products": ["api-gateway"],
-  "description": "Caches GraphQL query responses at the edge so identical queries are served without a round-trip to the origin.\n\nUnlike CDN caching that keys on the raw request body, this policy parses the GraphQL document and normalizes it before hashing: insignificant whitespace, field formatting, and fragment layout are collapsed, and variable object keys are sorted. Two requests that are semantically identical therefore share a cache entry even when their bodies differ byte-for-byte. There is no query size or nesting-depth limit.\n\nOnly `query` operations are cached. Mutations, subscriptions, malformed documents, and non-JSON bodies are forwarded to the origin untouched. Cache hits and misses are reported on the `x-cache` response header, with a short key fingerprint on `x-cache-key`.\n\nTo avoid serving one user's data to another, requests carrying an `authorization` or `cookie` header are not cached by default. Use `cacheKeyHeaders` to opt into caching them: each listed header's value is included in the cache key, so distinct credentials get distinct cache entries.",
+  "description": "Caches GraphQL query responses at the edge so identical queries are served without a round-trip to the origin.\n\nUnlike CDN caching that keys on the raw request body, this policy parses the GraphQL document and normalizes it before hashing: insignificant whitespace, field formatting, and fragment layout are collapsed, and variable object keys are sorted. Two requests that are semantically identical therefore share a cache entry even when their bodies differ byte-for-byte. There is no query size or nesting-depth limit.\n\nOnly `query` operations are cached. Mutations, subscriptions, malformed documents, and non-JSON bodies are forwarded to the origin untouched. Cache hits and misses are reported on the `x-cache` response header, with a short key fingerprint on `x-cache-key`, and in the Cache analytics alongside the Caching policy's lookups.\n\nTo avoid serving one user's data to another, requests carrying an `authorization` or `cookie` header are not cached by default. Use `cacheKeyHeaders` to opt into caching them: each listed header's value is included in the cache key, so distinct credentials get distinct cache entries.",
   "deprecatedMessage": "",
   "required": ["handler"],
   "properties": {

package/docs/programmable-api/jwt-service-plugin.mdx

@@ -16,13 +16,14 @@ issued by your API.
 
 ## JWT Token
 
-By default, this service issues JWTs using the EdDSA algorithm. This is the
-recommended algorithm for new applications due to its strong security properties
-and performance characteristics. However, not every library supports EdDSA, so
-you should ensure that your [client library](https://jwt.io/libraries) can
-handle this algorithm. If you need a different algorithm (for example, for
-compatibility with an existing key pair or client library), use the `algorithm`
-configuration option.
+This service signs JWTs with the EdDSA algorithm, using the Ed25519 signing key
+that Zuplo provisions for each environment. EdDSA is the only supported signing
+algorithm. The plugin can't sign tokens with RS256 or any other RSA or ECDSA
+algorithm, and you can't supply your own key pair.
+
+EdDSA has strong security properties and good performance, but not every JWT
+library supports it. Make sure the [client library](https://jwt.io/libraries)
+that validates your tokens can handle EdDSA.
 
 ## Use Cases
 
@@ -86,13 +87,11 @@ export function runtimeInit(runtime: RuntimeExtensions) {
   is `"/__zuplo/issuer"`. This affects the issuer URL and OIDC configuration
   endpoints.
 
-- **`algorithm`** (optional): The asymmetric signing algorithm used for issued
-  JWTs. Default is `"EdDSA"`. Supported values are `EdDSA`, `RS256`, `RS384`,
-  `RS512`, `PS256`, `PS384`, `PS512`, `ES256`, `ES384`, and `ES512`. The
-  algorithm must match the configured key pair — for example, an RSA key
-  requires an `RS*` or `PS*` value and an Ed25519 key requires `EdDSA`.
-  Symmetric algorithms (like `HS256`) aren't supported because the plugin
-  publishes a JWKS endpoint.
+- **`algorithm`** (optional): The signing algorithm for issued JWTs. Leave this
+  option unset or set it to `"EdDSA"`, which is the default. EdDSA is the only
+  algorithm the environment's Ed25519 key can sign with. See
+  [Unsupported algorithms](#unsupported-algorithms) for what happens with other
+  values.
 
 - **`expiresIn`** (optional): Sets the default expiration time for JWTs. Default
   is `"1h"`. Can be either:
@@ -121,6 +120,36 @@ export function runtimeInit(runtime: RuntimeExtensions) {
   Note: Individual JWT creation can override this default by specifying
   `expiresIn` in the `signJwt` method.
 
+### Unsupported algorithms
+
+The plugin only signs with EdDSA. Other `algorithm` values fail as follows:
+
+- **A symmetric or unknown algorithm**, such as `"HS256"`, fails when the plugin
+  is created, so the gateway doesn't start. The error lists the values the
+  option accepts:
+
+  ```txt
+  JwtServicePlugin - Unsupported signing algorithm "HS256". Supported algorithms: EdDSA, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384, ES512.
+  ```
+
+  Not all of these values work. The environment's key is an Ed25519 key, so only
+  `EdDSA` can sign tokens.
+
+- **An RSA or ECDSA algorithm**, such as `"RS256"`, `"PS256"`, or `"ES256"`,
+  doesn't match the environment's Ed25519 key. The gateway starts, but
+  `JwtServicePlugin.signJwt()` fails when it imports the key:
+
+  ```txt
+  JwtServicePlugin - Failed to import private key. Ensure it is a valid JWK format and matches the configured algorithm "RS256".
+  ```
+
+  The OpenID configuration endpoint also advertises the configured algorithm
+  while the JWKS endpoint serves the Ed25519 public key, so clients can't verify
+  tokens against it.
+
+To fix either error, remove the `algorithm` option or set it to `"EdDSA"`, and
+validate tokens with EdDSA in your upstream services.
+
 ## Usage
 
 Once the plugin is registered, you can use it to issue JWTs in custom handlers
@@ -190,9 +219,8 @@ export default async function (request: ZuploRequest, context: ZuploContext) {
 ## Validating JWTs in Upstream Services
 
 Upstream services can validate the JWTs issued by your Zuplo API by verifying
-the signature and claims. The examples below use `EdDSA`, the plugin's default
-signing algorithm. If you configured a different algorithm using the `algorithm`
-option, use that value in the `algorithms` list instead.
+the signature and claims. The examples below use `EdDSA`, the algorithm the
+plugin signs with.
 
 ### Node.js/Express Example
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuplo",
-  "version": "7.11.4",
+  "version": "7.11.5",
   "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.11.4",
-    "@zuplo/core": "7.11.4",
-    "@zuplo/runtime": "7.11.4",
-    "@zuplo/test": "7.11.4"
+    "@zuplo/cli": "7.11.5",
+    "@zuplo/core": "7.11.5",
+    "@zuplo/runtime": "7.11.5",
+    "@zuplo/test": "7.11.5"
   }
 }