zuplo 7.9.4 → 7.9.6

package/docs/concepts/ai-gateway.mdx

@@ -2,46 +2,50 @@
 title: AI Gateway Concepts
 sidebar_label: AI Gateway
 description:
-  The mental model behind the Zuplo AI Gateway — providers, teams, apps, and
-  per-app policy chains — and how it relates to the rest of the platform.
+  The mental model behind the Zuplo AI Gateway — providers, pools, apps, User
+  Apps, and policy chains — and how it all relates to the rest of the platform.
 ---
 
-The Zuplo AI Gateway is a proxy that sits between your apps and LLM providers
-like OpenAI, Anthropic, Google, Mistral, and xAI. Instead of each app holding
-provider API keys and calling providers directly, every request flows through
-the gateway, which applies policies, controls, and monitoring. This page
-explains the concepts behind it. For the full feature tour, see the
+The Zuplo AI Gateway is a proxy that sits between your apps, your people, and
+LLM providers like OpenAI, Anthropic, Google, Mistral, and xAI. Instead of each
+app holding provider API keys and calling providers directly, every request
+flows through the gateway, which applies policies, controls, and monitoring.
+This page explains the concepts behind it. For the full feature tour, see the
 [AI Gateway overview](../ai-gateway/overview.mdx).
 
-## Providers, teams, and apps
+## Providers, pools, and apps
 
-Three building blocks organize an AI Gateway:
+Four building blocks organize an AI Gateway:
 
 - **[Providers](../ai-gateway/providers.mdx)** are the LLM vendors your gateway
   can route to. Administrators configure providers once, including any
   [custom OpenAI-compatible providers](../ai-gateway/custom-providers.mdx), and
   consumers never see the underlying credentials.
-- **[Teams](../ai-gateway/teams.mdx)** group users and carry budget limits. Each
-  team totals usage across its sub-teams and apps. A request must remain within
-  the gateway, ancestor team, and app limits. See
+- **[Pools](../ai-gateway/pools.mdx)** group apps and carry budget limits. Each
+  pool totals usage across its sub-pools and apps. A request must remain within
+  the gateway, ancestor pool, and app limits. See
   [Usage Limits](../ai-gateway/usage-limits.mdx).
 - **[Apps](../ai-gateway/apps.mdx)** are the pieces of software that call the
   gateway — a support chatbot is one app, an internal coding agent is another.
   Each app gets its own gateway URL, its own Zuplo-managed API key, and its own
   policy chain.
+- **The [User App](../ai-gateway/user-apps.mdx)** is how people call the gateway
+  from their own tools. Each project has one. People call its URL with their own
+  personal API key, and each person has their own budget.
 
 ## Policy chains
 
-Every app runs its own ordered [policy chain](../ai-gateway/policy-chains.mdx) —
-model filtering, fallback models, budgets, semantic caching, guardrails,
-tracing, and any [custom policies](../ai-gateway/custom-policies.mdx) written in
-TypeScript. Team [policy templates](../ai-gateway/policy-templates.mdx) give new
-apps a consistent starting pipeline, and chain changes apply within about a
-minute with no redeploy.
+Every app, and the User App, runs its own ordered
+[policy chain](../ai-gateway/policy-chains.mdx) — model filtering, fallback
+models, budgets, semantic caching, guardrails, tracing, and any
+[custom policies](../ai-gateway/custom-policies.mdx) written in TypeScript. Pool
+[policy templates](../ai-gateway/policy-templates.mdx) give new apps a
+consistent starting pipeline, and chain changes apply within about a minute with
+no redeploy.
 
 App-level controls are opt-in: an app with an empty policy chain applies no
 model restrictions, budgets, guardrails, or caching of its own — though gateway
-and team usage limits still apply.
+and pool usage limits still apply.
 
 ## The Universal API
 
@@ -58,7 +62,7 @@ code change.
 An AI Gateway is a type of Zuplo project. A new project deploys without a Git
 repository; you can [connect a repository](../ai-gateway/source-control.mdx)
 later so gateway changes go through the same review workflow as the rest of your
-Zuplo configuration. The providers, teams, and apps you configure belong to that
+Zuplo configuration. The providers, pools, and apps you configure belong to that
 project. The platform primitives — deployment model, environments, analytics —
 are the same ones described in [How Zuplo Works](./how-zuplo-works.mdx).
 

package/docs/policies/ai-gateway-akamai-firewall-inbound/doc.md

@@ -36,7 +36,7 @@ object; they do not merge with it.
 
 Do not add this policy to the inbound chain of an app used as a
 [Smart Router](/docs/policies/ai-gateway-smart-router-inbound) classifier
-(`classifierAppID`). The firewall would inspect Smart Router's internal
+(`classifier.app`). The firewall would inspect Smart Router's internal
 classification call as if it were a completion request, and Smart Router fails
 open on a resulting denial — so this combination is rejected with a
 `ConfigurationError` instead of silently degrading classification.

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

@@ -73,6 +73,21 @@
                 "type": "object",
                 "additionalProperties": false,
                 "required": ["budgetBy", "meters"],
+                "if": {
+                  "required": ["budgetBy"],
+                  "properties": {
+                    "budgetBy": {
+                      "const": "app"
+                    }
+                  }
+                },
+                "then": {
+                  "properties": {
+                    "meters": {
+                      "minItems": 1
+                    }
+                  }
+                },
                 "properties": {
                   "budgetBy": {
                     "type": "string",
@@ -86,9 +101,8 @@
                   },
                   "meters": {
                     "type": "array",
-                    "minItems": 1,
                     "maxItems": 24,
-                    "description": "Thresholds this rule enforces. Add one entry per meter, period, and action you want.",
+                    "description": "Thresholds this rule enforces. Add one entry per meter, period, and action you want. An \"app\" rule needs at least one entry. An \"expression\" rule may leave this empty to track usage per value without enforcing a limit.",
                     "items": {
                       "type": "object",
                       "additionalProperties": false,

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

@@ -12,24 +12,125 @@ classifier prompt.
 
 ## Required options
 
-- `classifierAppID` — AI Gateway application id whose chat/completions route
-  runs the classifier.
-- `classifierModel` — `providerName/model` sent on the classifier request.
+- `classifier` — where the prompt is classified. Set exactly one of `app`,
+  `chatCompletions`, or `jev`; see [Choose a classifier](#choose-a-classifier).
 - `modelsByComplexity` — `providerName/model` for each of `low`, `medium`, and
   `high`. Used for routing unless `smartRoutingEnabled` is set to `false`.
 
+Omit `intents` and `classifierPrompt` to use the built-in dictionary (code,
+summarization, translation, qa, conversation, classification, creative_writing,
+agentic, document_qa, other) and the built-in classification prompt.
+
+## Choose a classifier
+
+| 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.                               |
+| `classifier.chatCompletions` | `apiKey`, `model` | You want to call an OpenAI-compatible model directly with its own key, without a second AI Gateway app.                                                   |
+| `classifier.jev`             | `apiKey`          | You want a model built for classification. Jev, from TypeSafe, answers typed questions instead of generating text. TypeSafe and OpenRouter both serve it. |
+
+The three are mutually exclusive. Setting more than one is rejected with a
+`ConfigurationError` rather than guessed at, because routing on a classifier you
+didn't mean to use would look like it was working.
+
+### AI Gateway app
+
+```json
+"classifier": {
+  "app": {
+    "appId": "$env(CLASSIFIER_APP_ID)",
+    "model": "openai/gpt-4o-mini"
+  }
+}
+```
+
+- `appId` — the AI Gateway app whose Chat Completions endpoint runs the
+  classifier.
+- `model` — the `providerName/model` that app routes the classifier request to.
+- `apiKey` — optional. See
+  [Authenticating the classifier app](#authenticating-the-classifier-app).
+
 Give the classifier its own application rather than pointing this at the app the
 policy runs on. The classifier request never leaves the gateway, so that
 application needs no API key checked at all — put the Ensure Gateway Internal
 Invocation Only policy on it in place of API Key Authentication.
 
-`classifierAppApiKey` is only for a classifier app that does check API keys: a
-bearer token for it, typically `$env(CLASSIFIER_APP_API_KEY)`. Omit it, or leave
-it empty, and the classifier request carries no `Authorization` header.
+### Chat Completions API
 
-Omit `intents` and `classifierPrompt` to use the built-in dictionary (code,
-summarization, translation, qa, conversation, classification, creative_writing,
-agentic, document_qa, other) and the built-in classification prompt.
+```json
+"classifier": {
+  "chatCompletions": {
+    "apiKey": "$env(OPENAI_API_KEY)",
+    "model": "gpt-4o-mini"
+  }
+}
+```
+
+- `apiKey` — sent as `Authorization: Bearer`.
+- `model` — the model id the service expects, such as `gpt-4o-mini`, not a
+  `providerName/model` reference. It must support structured outputs: the
+  classifier request asks for a strict JSON schema in `response_format`.
+- `baseUrl` — optional, `https://api.openai.com/v1` by default. Set it to call
+  another OpenAI-compatible service. The request goes to
+  `{baseUrl}/chat/completions`.
+
+To classify with an app in this project, use `classifier.app` rather than
+pointing `baseUrl` at the app's URL. `classifier.app` invokes the app
+in-process, and it rejects a classifier app that would call back into this
+policy.
+
+### Jev
+
+```json
+"classifier": {
+  "jev": {
+    "apiKey": "$env(TYPESAFE_API_KEY)"
+  }
+}
+```
+
+- `apiKey` — your TypeSafe API key, from the
+  [TypeSafe dashboard](https://console.typesafe.ai/keys), sent as
+  `Authorization: Bearer`. Through OpenRouter, your OpenRouter key.
+- `model` — optional, `jev-latest` by default, which follows the newest stable
+  release. After you tune `minConfidenceForRouting`, pin a versioned model so a
+  new release can't move answers under your threshold: `jev-1.13.0` on TypeSafe,
+  or `jev-1.13` on OpenRouter.
+- `baseUrl` — optional, `https://api.typesafe.ai` by default. It's the API root,
+  the same value the TypeSafe SDK's `baseURL` takes, and the request goes to
+  `{baseUrl}/v1/systemone`.
+
+To call Jev through OpenRouter, set `baseUrl` to OpenRouter's API root and use
+an OpenRouter key. OpenRouter serves the same System One API and bills your
+OpenRouter account:
+
+```json
+"classifier": {
+  "jev": {
+    "apiKey": "$env(OPENROUTER_API_KEY)",
+    "baseUrl": "https://openrouter.ai/api"
+  }
+}
+```
+
+The policy sends the prompt and two questions to `{baseUrl}/v1/systemone`:
+
+- **Intent** — a Choice over your intents. Each `id` is an option, and its
+  `description` tells Jev what the option covers.
+- **Complexity** — a Score over three levels, low to high. The policy rounds the
+  score to the nearest level.
+
+`profile.confidence` is the lower of Jev's confidence in the two answers, so
+routing applies only when Jev is sure of both. Jev writes no reasons, so
+`profile.reasons` is empty.
+
+Jev takes no system prompt, so setting `classifierPrompt` with `classifier.jev`
+is rejected with a `ConfigurationError`.
+
+`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
+policy logs the status and its most likely cause but not the response body,
+which can echo the request back, prompt included.
 
 ## Authenticating the classifier app
 
@@ -39,18 +140,21 @@ the
 [Ensure Gateway Internal Invocation Only](/docs/policies/ai-gateway-internal-only-inbound)
 policy instead of AI Gateway Authentication: it accepts requests this gateway
 made itself and rejects everything that arrives over the network. Then omit
-`classifierAppApiKey` — nothing is sent, and there is no key to rotate or leak.
-
-Set `classifierAppApiKey` only when the classifier application authenticates
-callers with API keys. It is sent as `Authorization: Bearer`. If you leave it
-unset while the classifier app still checks keys, that app answers `401` and the
-gateway logs which policy to add.
-
-`classifierAppID` must not be this app's own id, and the classifier application
-must not run this policy itself. Both are rejected with a `ConfigurationError`
-instead of silently skipping or failing open, so a misconfigured routing loop —
-within one app, or between two — is never mistaken for smart routing that is
-simply doing nothing.
+`classifier.app.apiKey` — nothing is sent, and there is no key to rotate or
+leak.
+
+Set `classifier.app.apiKey` only when the classifier application authenticates
+callers with API keys. It is sent as `Authorization: Bearer`, typically from
+`$env(CLASSIFIER_APP_API_KEY)`. Omit it, or leave it empty, and the classifier
+request carries no `Authorization` header. If you leave it unset while the
+classifier app still checks keys, that app answers `401` and the gateway logs
+which policy to add.
+
+`classifier.app.appId` must not be this app's own id, and the classifier
+application must not run this policy itself. Both are rejected with a
+`ConfigurationError` instead of silently skipping or failing open, so a
+misconfigured routing loop — within one app, or between two — is never mistaken
+for smart routing that is simply doing nothing.
 
 The classifier application must not run
 [Akamai AI Firewall](/docs/policies/ai-gateway-akamai-firewall-inbound) either.
@@ -70,8 +174,12 @@ nothing. This is rejected with a `ConfigurationError` for the same reason.
     "export": "AIGatewaySmartRouterInboundPolicy",
     "module": "$import(@zuplo/runtime)",
     "options": {
-      "classifierAppID": "$env(CLASSIFIER_APP_ID)",
-      "classifierModel": "openai/gpt-4o-mini",
+      "classifier": {
+        "app": {
+          "appId": "$env(CLASSIFIER_APP_ID)",
+          "model": "openai/gpt-4o-mini"
+        }
+      },
       "smartRoutingEnabled": true,
       "modelsByComplexity": {
         "low": "openai/gpt-4o-mini",
@@ -83,6 +191,20 @@ nothing. This is rejected with a `ConfigurationError` for the same reason.
 }
 ```
 
+## Migrating from `classifierAppID`
+
+Earlier versions configured the classifier app with three top-level options.
+They're deprecated, and still honored when `classifier` isn't set:
+
+| Deprecated option     | Replacement             |
+| --------------------- | ----------------------- |
+| `classifierAppID`     | `classifier.app.appId`  |
+| `classifierModel`     | `classifier.app.model`  |
+| `classifierAppApiKey` | `classifier.app.apiKey` |
+
+Move all three at once. Setting `classifier` together with any of them is
+rejected with a `ConfigurationError`.
+
 ## Policy order
 
 ```text
@@ -149,14 +271,19 @@ 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`, 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.
+
 If the classifier returns an `id` outside this list, Smart Router keeps it as an
 "unknown intent" and caps its confidence just below `minConfidenceForRouting`,
 so it's never eligible for routing.
 
 ### Custom classifier prompt
 
-`classifierPrompt` replaces the built-in classifier prompt. It accepts either a
-string or an array of lines:
+`classifierPrompt` replaces the built-in classifier prompt for `classifier.app`
+and `classifier.chatCompletions`. Jev takes no prompt, so it can't be combined
+with `classifier.jev`. It accepts either a string or an array of lines:
 
 ```json
 {
@@ -225,6 +352,11 @@ interface AIGatewaySmartRouterResult {
 }
 ```
 
+With `classifier.jev`, `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 `promptTokens` and `completionTokens`.
+
 Read it from any policy placed after Smart Router in the chain. Common uses:
 
 - **Branch on intent or complexity** — apply a stricter rate limit, a different
@@ -300,10 +432,21 @@ complexity. Embeddings, tool messages 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.
+Invalid or incomplete options, classifier errors and 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.
+
+These misconfigurations throw a `ConfigurationError` instead, which fails the
+request with a `500` that names the problem. Failing open on them would look
+like smart routing quietly doing nothing:
+
+- More than one section in `classifier`.
+- A deprecated `classifierAppID`, `classifierModel`, or `classifierAppApiKey`
+  next to `classifier`.
+- `classifierPrompt` with `classifier.jev`.
+- A `classifier.app.appId` that names this app.
+- A classifier app that runs this policy or Akamai AI Firewall.
 
 One shape is refused rather than skipped. A Bedrock Runtime request
 (`/model/{modelId}/{operation}`) carries a model-native body that the gateway

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

@@ -1,3 +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.
+Classifies the last user prompt with an AI Gateway app, an OpenAI-compatible
+Chat Completions API, or Jev from TypeSafe, stores the result on
+`AIGatewaySmartRouter` for later policies, and optionally routes completions by
+classified complexity.

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

@@ -32,17 +32,39 @@
         "options": {
           "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.",
+          "description": "Options for the Smart Router policy: classify the last user prompt with an AI Gateway app, a Chat Completions API, or Jev, then optionally route by complexity.",
           "additionalProperties": false,
-          "required": [
-            "classifierAppID",
-            "classifierModel",
-            "modelsByComplexity"
-          ],
+          "required": ["modelsByComplexity"],
+          "if": {
+            "required": ["classifierAppID"]
+          },
+          "then": {
+            "required": ["classifierModel"]
+          },
+          "else": {
+            "required": ["classifier"]
+          },
           "examples": [
             {
-              "classifierAppID": "$env(CLASSIFIER_APP_ID)",
-              "classifierModel": "openai/gpt-4o-mini",
+              "classifier": {
+                "app": {
+                  "appId": "$env(CLASSIFIER_APP_ID)",
+                  "model": "openai/gpt-4o-mini"
+                }
+              },
+              "smartRoutingEnabled": true,
+              "modelsByComplexity": {
+                "low": "openai/gpt-4o-mini",
+                "medium": "openai/gpt-4o",
+                "high": "openai/gpt-5"
+              }
+            },
+            {
+              "classifier": {
+                "jev": {
+                  "apiKey": "$env(TYPESAFE_API_KEY)"
+                }
+              },
               "smartRoutingEnabled": true,
               "modelsByComplexity": {
                 "low": "openai/gpt-4o-mini",
@@ -52,18 +74,101 @@
             }
           ],
           "properties": {
-            "classifierAppID": {
-              "type": "string",
-              "title": "Classifier App ID",
-              "description": "The AI Gateway application id used to run the classifier prompt and evaluate the user's request.",
-              "examples": ["config_1234"]
-            },
-            "classifierModel": {
-              "type": "string",
-              "title": "Classifier Model",
-              "description": "The model (`providerName/model`) the classifier uses to evaluate the user's request. E.g. `openai/gpt-4o-mini`.",
-              "pattern": "^[^/\\s]+/.+$",
-              "examples": ["openai/gpt-4o-mini"]
+            "classifier": {
+              "type": "object",
+              "title": "Classifier",
+              "description": "Where the user's prompt is classified. Required unless the deprecated `classifierAppID` and `classifierModel` are set. Set exactly one of `app`, `chatCompletions`, or `jev`; setting more than one is a configuration error.",
+              "additionalProperties": false,
+              "minProperties": 1,
+              "maxProperties": 1,
+              "properties": {
+                "app": {
+                  "type": "object",
+                  "title": "Classifier App",
+                  "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"],
+                  "properties": {
+                    "appId": {
+                      "type": "string",
+                      "title": "Classifier App ID",
+                      "description": "The id of the AI Gateway app that runs the classifier. It must not be this app, and that app must not run this policy.",
+                      "examples": ["$env(CLASSIFIER_APP_ID)"]
+                    },
+                    "model": {
+                      "type": "string",
+                      "title": "Classifier Model",
+                      "description": "The model (`providerName/model`) the classifier app uses to evaluate the user's request. E.g. `openai/gpt-4o-mini`.",
+                      "pattern": "^[^/\\s]+/.+$",
+                      "examples": ["openai/gpt-4o-mini"]
+                    },
+                    "apiKey": {
+                      "type": "string",
+                      "title": "Classifier App API Key",
+                      "description": "API key sent as `Authorization: Bearer` when invoking the classifier app. Omit it when the classifier app runs the Ensure Gateway Internal Invocation Only policy: the classifier call never leaves the gateway, so that policy accepts it and rejects everything arriving over the network, and no credential is sent. Set it only when the classifier app authenticates callers with API keys.",
+                      "examples": ["$env(CLASSIFIER_APP_API_KEY)"],
+                      "x-advanced": true
+                    }
+                  }
+                },
+                "chatCompletions": {
+                  "type": "object",
+                  "title": "Chat Completions API",
+                  "description": "Classify by calling an OpenAI-compatible Chat Completions API directly, outside the gateway. The model must support structured outputs (`response_format` with a JSON schema).",
+                  "additionalProperties": false,
+                  "required": ["apiKey", "model"],
+                  "properties": {
+                    "apiKey": {
+                      "type": "string",
+                      "title": "Chat Completions API Key",
+                      "description": "API key for the service at `baseUrl`, sent as `Authorization: Bearer`.",
+                      "examples": ["$env(OPENAI_API_KEY)"]
+                    },
+                    "model": {
+                      "type": "string",
+                      "title": "Chat Completions Model",
+                      "description": "The model id the service expects, such as `gpt-4o-mini`. This is sent to the service as-is, not as a `providerName/model` reference.",
+                      "examples": ["gpt-4o-mini"]
+                    },
+                    "baseUrl": {
+                      "type": "string",
+                      "title": "Chat Completions Base URL",
+                      "description": "Base URL of the OpenAI-compatible API. The classifier request is sent to `{baseUrl}/chat/completions`.",
+                      "default": "https://api.openai.com/v1",
+                      "x-advanced": true
+                    }
+                  }
+                },
+                "jev": {
+                  "type": "object",
+                  "title": "Jev (TypeSafe)",
+                  "description": "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": {
+                    "apiKey": {
+                      "type": "string",
+                      "title": "Jev API Key",
+                      "description": "API key for the service at `baseUrl`, sent as `Authorization: Bearer`: a TypeSafe key by default, or an OpenRouter key when `baseUrl` is OpenRouter.",
+                      "examples": ["$env(TYPESAFE_API_KEY)"]
+                    },
+                    "model": {
+                      "type": "string",
+                      "title": "Jev Model",
+                      "description": "The Jev model to call. `jev-latest` follows the newest stable release on both TypeSafe and OpenRouter. Pin a versioned id to keep answers stable after tuning `minConfidenceForRouting`: `jev-1.13.0` on TypeSafe, or `jev-1.13` on OpenRouter.",
+                      "default": "jev-latest",
+                      "x-advanced": true
+                    },
+                    "baseUrl": {
+                      "type": "string",
+                      "title": "Jev Base URL",
+                      "description": "API root of the System One API that serves Jev, the same value the TypeSafe SDK's `baseURL` takes. The classifier request is sent to `{baseUrl}/v1/systemone`. Set it to `https://openrouter.ai/api` to call Jev through OpenRouter.",
+                      "default": "https://api.typesafe.ai",
+                      "x-advanced": true
+                    }
+                  }
+                }
+              }
             },
             "modelsByComplexity": {
               "type": "object",
@@ -95,13 +200,6 @@
                 }
               }
             },
-            "classifierAppApiKey": {
-              "type": "string",
-              "title": "Classifier App API Key",
-              "description": "API key sent as `Authorization: Bearer` when invoking the classifier app. Omit it when the classifier app runs the Ensure Gateway Internal Invocation Only policy: the classifier call never leaves the gateway, so that policy accepts it and rejects everything arriving over the network, and no credential is sent. Set it only when the classifier app authenticates callers with API keys.",
-              "examples": ["$env(CLASSIFIER_APP_API_KEY)"],
-              "x-advanced": true
-            },
             "smartRoutingEnabled": {
               "type": "boolean",
               "title": "Smart Routing Enabled",
@@ -140,7 +238,7 @@
             },
             "classifierPrompt": {
               "title": "Classifier Prompt",
-              "description": "Prompt used to analyze and classify the user message. Omit to use the built-in classifier prompt.",
+              "description": "Prompt used to analyze and classify the user message with `classifier.app` or `classifier.chatCompletions`. Omit to use the built-in classifier prompt. Jev takes no prompt, so setting this with `classifier.jev` is a configuration error.",
               "oneOf": [
                 {
                   "type": "string",
@@ -181,6 +279,34 @@
               "minimum": 1,
               "default": 8000,
               "x-advanced": true
+            },
+            "classifierAppID": {
+              "type": "string",
+              "title": "Classifier App ID (Deprecated)",
+              "description": "\\*\\*Deprecated\\*\\*: use `classifier.app.appId` instead. Still honored when `classifier` is not set; setting both is a configuration error.",
+              "deprecated": true,
+              "doNotSuggest": true,
+              "x-show-example": false,
+              "x-advanced": true
+            },
+            "classifierModel": {
+              "type": "string",
+              "title": "Classifier Model (Deprecated)",
+              "description": "\\*\\*Deprecated\\*\\*: use `classifier.app.model` instead. Still honored when `classifier` is not set; setting both is a configuration error.",
+              "pattern": "^[^/\\s]+/.+$",
+              "deprecated": true,
+              "doNotSuggest": true,
+              "x-show-example": false,
+              "x-advanced": true
+            },
+            "classifierAppApiKey": {
+              "type": "string",
+              "title": "Classifier App API Key (Deprecated)",
+              "description": "\\*\\*Deprecated\\*\\*: use `classifier.app.apiKey` instead. Still honored when `classifier` is not set; setting both is a configuration error.",
+              "deprecated": true,
+              "doNotSuggest": true,
+              "x-show-example": false,
+              "x-advanced": true
             }
           }
         }
@@ -190,8 +316,29 @@
           "export": "AIGatewaySmartRouterInboundPolicy",
           "module": "$import(@zuplo/runtime)",
           "options": {
-            "classifierAppID": "$env(CLASSIFIER_APP_ID)",
-            "classifierModel": "openai/gpt-4o-mini",
+            "classifier": {
+              "app": {
+                "appId": "$env(CLASSIFIER_APP_ID)",
+                "model": "openai/gpt-4o-mini"
+              }
+            },
+            "smartRoutingEnabled": true,
+            "modelsByComplexity": {
+              "low": "openai/gpt-4o-mini",
+              "medium": "openai/gpt-4o",
+              "high": "openai/gpt-5"
+            }
+          }
+        },
+        {
+          "export": "AIGatewaySmartRouterInboundPolicy",
+          "module": "$import(@zuplo/runtime)",
+          "options": {
+            "classifier": {
+              "jev": {
+                "apiKey": "$env(TYPESAFE_API_KEY)"
+              }
+            },
             "smartRoutingEnabled": true,
             "modelsByComplexity": {
               "low": "openai/gpt-4o-mini",