@8wave/ai-elements 0.110.0 → 0.111.0-beta.11

package/dist-vue/packages/models/src/schema/Agent.d.ts

@@ -28,8 +28,10 @@ export declare enum AgentSearchMode {
  * - Google (Gemini 3/3.1): `thinkingLevel`; Gemini 2.5: `thinkingBudget`
  * - DeepSeek: on/off thinking toggle
  *
- * Everything else in the catalog (Alibaba, Meta, Moonshot AI, xAI, z.ai) is one
- * effort level and shares {@link GenericReasoningSchema}.
+ * Alibaba, Meta, Moonshot AI, xAI, Xiaomi and z.ai are one effort level and
+ * share {@link GenericReasoningSchema}. Mistral has no configuration at all:
+ * of its catalog models only Medium 3.5 reasons, on a `none`/`high` scale, so
+ * it runs on the provider's own default.
  *
  * Only the matching provider's config is used at runtime (based on model prefix).
  * Admins can pre-configure multiple providers for easy model switching.
@@ -110,9 +112,11 @@ export type DeepSeekReasoning = z.infer<typeof DeepSeekReasoningSchema>;
  * Verified against the gateway on 2026-08-25: every catalog model of these
  * families advertises the `reasoning` parameter, a family that only offers
  * `high`/`xhigh` clamps a lower level instead of rejecting the request, and
- * `none` does bring reasoning tokens to zero.
+ * `none` does bring reasoning tokens to zero. Xiaomi joined on 2026-09-22 on
+ * the listing alone: its models advertise `reasoning` and an effort scale that
+ * includes `low`, but the clamp and `none` behaviour were not measured on it.
  */
-export declare const GENERIC_REASONING_PROVIDERS: readonly ["alibaba", "meta", "moonshotai", "spacexai", "zai"];
+export declare const GENERIC_REASONING_PROVIDERS: readonly ["alibaba", "meta", "moonshotai", "spacexai", "xiaomi", "zai"];
 export type GenericReasoningProvider = (typeof GENERIC_REASONING_PROVIDERS)[number];
 export declare function isGenericReasoningProvider(provider: string): provider is GenericReasoningProvider;
 /**
@@ -223,6 +227,16 @@ export declare const AgentReasoningSchema: z.ZodOptional<z.ZodCodec<z.ZodUnknown
             minimal: "minimal";
         }>>;
     }, z.core.$strip>>;
+    xiaomi: z.ZodOptional<z.ZodObject<{
+        reasoningEffort: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            minimal: "minimal";
+        }>>;
+    }, z.core.$strip>>;
     zai: z.ZodOptional<z.ZodObject<{
         reasoningEffort: z.ZodOptional<z.ZodEnum<{
             none: "none";
@@ -507,11 +521,10 @@ export declare const VOICE_RENDER_ACK_PREFIX = "Voice turn note";
  *
  * That note is the secondary lever, not the main one: in the turn shape the
  * voice prompt asks for (spoken sentence and presentation call in the SAME
- * reply) it never runs at all, because the closure gate refuses a closure
- * called in the answering step and the server writes the card itself, so
- * nothing executes. The spoken mention is therefore asked for in `<voice_turn>`
- * as well, where it costs no round trip; this note covers only the turns that
- * call the tool a step later.
+ * reply) the model never reads it, because the turn ends on that very step.
+ * The spoken mention is therefore asked for in `<voice_turn>` as well, where
+ * it costs no round trip; this note covers only the turns that go on after the
+ * tool.
  */
 export declare const voiceRenderAck: (toolName: string) => string;
 /** True when a tool output is our own "it was drawn" note and not a result. */
@@ -884,6 +897,16 @@ export declare const AgentModelSchema: z.ZodObject<{
                 minimal: "minimal";
             }>>;
         }, z.core.$strip>>;
+        xiaomi: z.ZodOptional<z.ZodObject<{
+            reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                minimal: "minimal";
+            }>>;
+        }, z.core.$strip>>;
         zai: z.ZodOptional<z.ZodObject<{
             reasoningEffort: z.ZodOptional<z.ZodEnum<{
                 none: "none";
@@ -1088,6 +1111,13 @@ export type AgentOpenAiApi = z.infer<typeof AgentOpenAiApiSchema>;
 export declare const VOICE_MIN_CASCADE_TIMEOUT_SECONDS = 5;
 /** And the longest they accept: their own ceiling, measured 2026-08-06. */
 export declare const VOICE_MAX_CASCADE_TIMEOUT_SECONDS = 15;
+/**
+ * Name prefix of the API key the voice channel mints for the provider's
+ * callbacks, in the name of the agent's creator. It is how a key list tells
+ * that key apart: revoking it silences the agent's voice until the voice is
+ * turned off and on again, which mints a new one.
+ */
+export declare const VOICE_API_KEY_NAME_PREFIX = "[voice] ";
 /**
  * Voice conversation through ElevenLabs Agents, which provides the voice layer
  * (ASR, turn taking, barge-in, TTS) and calls back into our own turn as a
@@ -1296,6 +1326,16 @@ export declare const AgentSettingsSchema: z.ZodObject<{
                     minimal: "minimal";
                 }>>;
             }, z.core.$strip>>;
+            xiaomi: z.ZodOptional<z.ZodObject<{
+                reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    xhigh: "xhigh";
+                    minimal: "minimal";
+                }>>;
+            }, z.core.$strip>>;
             zai: z.ZodOptional<z.ZodObject<{
                 reasoningEffort: z.ZodOptional<z.ZodEnum<{
                     none: "none";
@@ -1573,7 +1613,7 @@ export declare const AgentDtoSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     prompt: z.ZodOptional<z.ZodString>;
-    model: z.ZodDefault<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
     fallbackModels: z.ZodDefault<z.ZodArray<z.ZodString>>;
     status: z.ZodDefault<z.ZodEnum<typeof AgentStatus>>;
     visibility: z.ZodDefault<z.ZodEnum<typeof AgentVisibility>>;
@@ -1678,6 +1718,16 @@ export declare const AgentDtoSchema: z.ZodObject<{
                         minimal: "minimal";
                     }>>;
                 }, z.core.$strip>>;
+                xiaomi: z.ZodOptional<z.ZodObject<{
+                    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                        none: "none";
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        xhigh: "xhigh";
+                        minimal: "minimal";
+                    }>>;
+                }, z.core.$strip>>;
                 zai: z.ZodOptional<z.ZodObject<{
                     reasoningEffort: z.ZodOptional<z.ZodEnum<{
                         none: "none";
@@ -2061,6 +2111,16 @@ export declare const AgentSchema: z.ZodLazy<z.ZodObject<{
                         minimal: "minimal";
                     }>>;
                 }, z.core.$strip>>;
+                xiaomi: z.ZodOptional<z.ZodObject<{
+                    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                        none: "none";
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        xhigh: "xhigh";
+                        minimal: "minimal";
+                    }>>;
+                }, z.core.$strip>>;
                 zai: z.ZodOptional<z.ZodObject<{
                     reasoningEffort: z.ZodOptional<z.ZodEnum<{
                         none: "none";

package/dist-vue/packages/models/src/schema/Chat.d.ts

@@ -140,6 +140,16 @@ export declare const ChatRequestSchema: z.ZodObject<{
                 minimal: "minimal";
             }>>;
         }, z.core.$strip>>;
+        xiaomi: z.ZodOptional<z.ZodObject<{
+            reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                minimal: "minimal";
+            }>>;
+        }, z.core.$strip>>;
         zai: z.ZodOptional<z.ZodObject<{
             reasoningEffort: z.ZodOptional<z.ZodEnum<{
                 none: "none";
@@ -247,6 +257,27 @@ export declare const ChatRequestSchema: z.ZodObject<{
     smoothStream: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ChatRequest = z.infer<typeof ChatRequestSchema>;
+/**
+ * What the chat route validates on the way in.
+ *
+ * Deliberately not `ChatRequestSchema`: a turn resumed after a client tool or
+ * a tool approval posts the assistant message back, whose parts are tool
+ * calls, and the part union above accepts text and files only. Pinning the
+ * body to it would answer 400 to a legitimate resume. So this validates the
+ * envelope the turn cannot run without and lets the rest through untouched
+ * (`loose`), which is also why the overrides the client sends still reach the
+ * service.
+ *
+ * The id is minted by the client and read back as a row key: without it the
+ * lookup ran with `undefined` and the route answered 500 instead of 400
+ * (found 2026-09-21).
+ */
+export declare const ChatRequestEnvelopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
 export declare enum BlockedReasonCode {
     SevereAbuse = "severe_abuse",
     HighRiskScore = "high_risk_score",

package/dist-vue/packages/models/src/schema/ModelProvider.d.ts

@@ -0,0 +1,316 @@
+import * as z from 'zod';
+/**
+ * Where the price of a model came from.
+ *
+ * `listing` is the public gateway price list matched by id or by name,
+ * `reference` is another catalog model the administrator said this one costs
+ * like, `manual` is a price typed by hand. A model can only be activated with
+ * one of the three: a model with no price would be charged as free, and the
+ * columns that carry the cost of a turn have no way to say "unknown".
+ */
+export declare enum ModelPriceSource {
+    Listing = "listing",
+    Reference = "reference",
+    Manual = "manual"
+}
+/**
+ * Per-token prices, the same unit the gateway listing publishes, so copying
+ * them is literal. The interface multiplies by a million to show them.
+ */
+export declare const ModelPricingSchema: z.ZodObject<{
+    inputUsdPerToken: z.ZodNumber;
+    outputUsdPerToken: z.ZodNumber;
+    cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+    cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ModelPricing = z.infer<typeof ModelPricingSchema>;
+export declare const ModelPriceSchema: z.ZodObject<{
+    source: z.ZodEnum<typeof ModelPriceSource>;
+    reference: z.ZodOptional<z.ZodString>;
+    pricing: z.ZodObject<{
+        inputUsdPerToken: z.ZodNumber;
+        outputUsdPerToken: z.ZodNumber;
+        cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+        cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    resolvedAt: z.ZodString;
+}, z.core.$strip>;
+export type ModelPrice = z.infer<typeof ModelPriceSchema>;
+export declare const ModelProviderModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+    price: z.ZodObject<{
+        source: z.ZodEnum<typeof ModelPriceSource>;
+        reference: z.ZodOptional<z.ZodString>;
+        pricing: z.ZodObject<{
+            inputUsdPerToken: z.ZodNumber;
+            outputUsdPerToken: z.ZodNumber;
+            cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+            cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        resolvedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ModelProviderModel = z.infer<typeof ModelProviderModelSchema>;
+/**
+ * The two embedding families an organization may run on its own endpoint.
+ *
+ * Closed on purpose, and closed in code rather than in the form: both are
+ * natively 3072 dimensions, which is the width of the Qdrant collections and
+ * cannot be changed after creation, and each one carries its own calibrated
+ * relevance floors. Adding a family is a code change that brings its
+ * measurements with it.
+ */
+export declare const BYOK_EMBEDDING_FAMILIES: readonly ["google/gemini-embedding-2", "openai/text-embedding-3-large"];
+export type ByokEmbeddingFamily = (typeof BYOK_EMBEDDING_FAMILIES)[number];
+export declare const ByokEmbeddingFamilySchema: z.ZodEnum<{
+    "google/gemini-embedding-2": "google/gemini-embedding-2";
+    "openai/text-embedding-3-large": "openai/text-embedding-3-large";
+}>;
+/** Vector width of both families, and of the two Qdrant collections. */
+export declare const BYOK_EMBEDDING_DIMENSIONS = 3072;
+/**
+ * How close the endpoint's vector has to be to the gateway's, for the same
+ * sentence, before we believe the endpoint really serves the declared family.
+ *
+ * Measured on 2026-09-21 against the customer's proxy: the same model scores
+ * 0.999999 and a different model of the same width scores -0.0168, so the
+ * check has the whole range as margin and still discriminates.
+ */
+export declare const BYOK_EMBEDDING_IDENTITY_FLOOR = 0.99;
+export declare enum ByokEmbeddingStatus {
+    Reindexing = "reindexing",
+    Ready = "ready"
+}
+export declare const ModelProviderEmbeddingSchema: z.ZodObject<{
+    family: z.ZodEnum<{
+        "google/gemini-embedding-2": "google/gemini-embedding-2";
+        "openai/text-embedding-3-large": "openai/text-embedding-3-large";
+    }>;
+    modelId: z.ZodString;
+    price: z.ZodObject<{
+        source: z.ZodEnum<typeof ModelPriceSource>;
+        reference: z.ZodOptional<z.ZodString>;
+        pricing: z.ZodObject<{
+            inputUsdPerToken: z.ZodNumber;
+            outputUsdPerToken: z.ZodNumber;
+            cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+            cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        resolvedAt: z.ZodString;
+    }, z.core.$strip>;
+    verifiedAt: z.ZodString;
+    status: z.ZodEnum<typeof ByokEmbeddingStatus>;
+}, z.core.$strip>;
+export type ModelProviderEmbedding = z.infer<typeof ModelProviderEmbeddingSchema>;
+/**
+ * `http` is allowed for the same reason `McpServer` allows it: the endpoint
+ * that asked for this feature lives inside a VNet. The form warns that the key
+ * would travel in clear outside a private network, and asks for a
+ * confirmation, not a block: whoever configures this is an administrator of
+ * the organization and the network is theirs.
+ */
+export declare const ModelProviderBaseUrlSchema: z.ZodURL;
+/**
+ * Header names and values are checked for control characters before they are
+ * ever stored. A value with a newline is a header injection, and it is also a
+ * secret leak: `fetch` refuses it with an error whose message quotes the value
+ * verbatim, and that message would reach the logs (measured 2026-09-21).
+ */
+export declare const HttpHeaderNameSchema: z.ZodString;
+export declare const HttpHeaderValueSchema: z.ZodString;
+export declare const ModelProviderHeadersSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export declare const OrganizationModelProviderSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    name: z.ZodString;
+    baseUrl: z.ZodString;
+    hasApiKey: z.ZodBoolean;
+    headerNames: z.ZodArray<z.ZodString>;
+    queryParams: z.ZodRecord<z.ZodString, z.ZodString>;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
+        price: z.ZodObject<{
+            source: z.ZodEnum<typeof ModelPriceSource>;
+            reference: z.ZodOptional<z.ZodString>;
+            pricing: z.ZodObject<{
+                inputUsdPerToken: z.ZodNumber;
+                outputUsdPerToken: z.ZodNumber;
+                cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+                cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            resolvedAt: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    embedding: z.ZodNullable<z.ZodObject<{
+        family: z.ZodEnum<{
+            "google/gemini-embedding-2": "google/gemini-embedding-2";
+            "openai/text-embedding-3-large": "openai/text-embedding-3-large";
+        }>;
+        modelId: z.ZodString;
+        price: z.ZodObject<{
+            source: z.ZodEnum<typeof ModelPriceSource>;
+            reference: z.ZodOptional<z.ZodString>;
+            pricing: z.ZodObject<{
+                inputUsdPerToken: z.ZodNumber;
+                outputUsdPerToken: z.ZodNumber;
+                cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+                cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            resolvedAt: z.ZodString;
+        }, z.core.$strip>;
+        verifiedAt: z.ZodString;
+        status: z.ZodEnum<typeof ByokEmbeddingStatus>;
+    }, z.core.$strip>>;
+    enabled: z.ZodBoolean;
+    createdAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type OrganizationModelProvider = z.infer<typeof OrganizationModelProviderSchema>;
+/**
+ * One model as the form sends it. `source` and `resolvedAt` are written by the
+ * server: `reference` and `pricing` are what the administrator can say, and
+ * either of them wins over the listing match instead of following it, so a
+ * wrong automatic match can be corrected without the listing winning it back
+ * on the next save.
+ */
+export declare const ModelProviderModelDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+    reference: z.ZodOptional<z.ZodString>;
+    pricing: z.ZodOptional<z.ZodObject<{
+        inputUsdPerToken: z.ZodNumber;
+        outputUsdPerToken: z.ZodNumber;
+        cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+        cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ModelProviderModelDto = z.infer<typeof ModelProviderModelDtoSchema>;
+export declare const OrganizationModelProviderDtoSchema: z.ZodObject<{
+    name: z.ZodString;
+    baseUrl: z.ZodURL;
+    apiKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    models: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
+        reference: z.ZodOptional<z.ZodString>;
+        pricing: z.ZodOptional<z.ZodObject<{
+            inputUsdPerToken: z.ZodNumber;
+            outputUsdPerToken: z.ZodNumber;
+            cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+            cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OrganizationModelProviderDto = z.infer<typeof OrganizationModelProviderDtoSchema>;
+export declare const ModelProviderDiscoverDtoSchema: z.ZodObject<{
+    baseUrl: z.ZodURL;
+    apiKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type ModelProviderDiscoverDto = z.infer<typeof ModelProviderDiscoverDtoSchema>;
+/**
+ * What a discovered model is, as far as we can tell.
+ *
+ * The endpoint's own `/models` does not say: neither LiteLLM nor OpenAI types
+ * the entries. The gateway listing does, so the kind is the type of the
+ * listing entry the id matches, and `unknown` when nothing matches. An
+ * unknown id is treated as a chat model until the probe says otherwise.
+ */
+export declare enum DiscoveredModelKind {
+    Chat = "chat",
+    Embedding = "embedding",
+    Unknown = "unknown"
+}
+export declare const DiscoveredModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    listingMatch: z.ZodNullable<z.ZodString>;
+    kind: z.ZodEnum<typeof DiscoveredModelKind>;
+}, z.core.$strip>;
+export type DiscoveredModel = z.infer<typeof DiscoveredModelSchema>;
+export declare const ModelProviderDiscoverResponseSchema: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        listingMatch: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<typeof DiscoveredModelKind>;
+    }, z.core.$strip>>;
+    listingUnavailable: z.ZodBoolean;
+}, z.core.$strip>;
+export type ModelProviderDiscoverResponse = z.infer<typeof ModelProviderDiscoverResponseSchema>;
+/** Where a model in the picker comes from. */
+export declare enum ModelCatalogSource {
+    Gateway = "gateway",
+    Byok = "byok"
+}
+/**
+ * How far a privacy guarantee reaches.
+ *
+ * Three values and not two, and the middle one is the common case: the
+ * gateway serves many models through several upstream providers and the
+ * guarantee holds only on some of them, so it routes accordingly. `unknown`
+ * is an organization's own endpoint, where we have no basis to claim
+ * anything and therefore claim nothing.
+ */
+export declare enum ModelGuarantee {
+    All = "all",
+    Some = "some",
+    None = "none",
+    Unknown = "unknown"
+}
+/**
+ * One entry of the catalog the model picker reads, whichever source served
+ * it. The frontend derives nothing from the id any more: not the label, not
+ * the i18n key, not the brand for the icon.
+ */
+export declare const ModelCatalogEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodEnum<typeof ModelCatalogSource>;
+    label: z.ZodString;
+    brand: z.ZodString;
+    brandIcon: z.ZodString;
+    pricing: z.ZodOptional<z.ZodObject<{
+        inputUsdPerToken: z.ZodNumber;
+        outputUsdPerToken: z.ZodNumber;
+        cachedInputUsdPerToken: z.ZodOptional<z.ZodNumber>;
+        cacheWriteUsdPerToken: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    priceEstimated: z.ZodBoolean;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    inputModalities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        effortLevels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    zdr: z.ZodEnum<typeof ModelGuarantee>;
+    noTraining: z.ZodEnum<typeof ModelGuarantee>;
+    retired: z.ZodBoolean;
+    disabled: z.ZodBoolean;
+    sourceOff: z.ZodBoolean;
+}, z.core.$strip>;
+export type ModelCatalogEntry = z.infer<typeof ModelCatalogEntrySchema>;
+/**
+ * Whether an organization can pick this model: neither switched off (by its
+ * administrator or with its source) nor retired by the gateway. The one
+ * definition the picker, the chip, the defaults and the disconnected banner
+ * share.
+ */
+export declare const isModelAvailable: (entry: ModelCatalogEntry) => boolean;
+/**
+ * Whether the gateway half of a catalog reflects a listing that was read.
+ *
+ * With the listing unreachable AND no last good copy, every gateway model
+ * reads as retired, and membership then proves nothing: whoever validates a
+ * model against the catalog has to let a gateway id through instead of
+ * blaming the administrator for our outage. Judged on the gateway half
+ * alone, because the endpoint's models are never retired.
+ */
+export declare const isGatewayCatalogKnown: (catalog: ModelCatalogEntry[]) => boolean;

package/dist-vue/packages/models/src/schema/Organization.d.ts

@@ -1,3 +1,4 @@
+import { PlatformType } from './Platform';
 import { StoragePolicy } from './Media';
 import * as z from 'zod';
 export declare const OrganizationSchema: z.ZodObject<{
@@ -220,11 +221,142 @@ export declare const OrganizationRetentionPolicySchema: z.ZodObject<{
     anonymousRetentionDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
 export type OrganizationRetentionPolicy = z.infer<typeof OrganizationRetentionPolicySchema>;
+/**
+ * Product features an operator can switch on or off per organization from the
+ * system panel. A feature is listed here when a contract can plausibly exclude
+ * it, or when it ships for a single customer: never before.
+ */
+export declare enum OrganizationFeature {
+    Voice = "voice",
+    /**
+     * One flag per messaging platform and not one for all of them, because
+     * a contract names the channels it includes. See
+     * {@link PLATFORM_CHANNEL_FEATURES}.
+     */
+    WhatsApp = "whatsapp",
+    Teams = "teams",
+    McpServers = "mcpServers",
+    ApiTools = "apiTools",
+    SubAgents = "subAgents",
+    Endpoints = "endpoints",
+    Integrations = "integrations",
+    /**
+     * Files attached to chat messages, on every surface of the agent. Like
+     * the voice it is switched on inside the agent settings, so the gate is
+     * on that transition and not on a route.
+     */
+    FileUpload = "fileUpload",
+    /**
+     * The platform's AI gateway as a source of models. The one flag that
+     * stops the runtime rather than hiding a page: switched off, nothing of
+     * this organization reaches the gateway, not a chat model, not a utility,
+     * not an embedding, not a document conversion. It is read from the
+     * organization metadata and not from the request, because most of what
+     * it stops runs without a session.
+     */
+    Gateway = "gateway",
+    Byok = "byok"
+}
+/**
+ * Value of a feature for an organization that does not mention it in its
+ * metadata. Everything the platform already shipped to everybody defaults to
+ * `true`, so adding the catalog changes nothing for anybody; a feature born for
+ * a single customer defaults to `false`.
+ */
+export declare const ORGANIZATION_FEATURE_DEFAULTS: Record<OrganizationFeature, boolean>;
+/**
+ * The feature flag of each messaging platform an administrator can connect to
+ * an agent. A platform missing here cannot be connected at all: the
+ * connection service refuses it, and the channels page does not offer it.
+ */
+export declare const PLATFORM_CHANNEL_FEATURES: Partial<Record<PlatformType, OrganizationFeature>>;
+/**
+ * Free-form keys AND free-form values on purpose. `z.record(z.enum(...))`
+ * rejects unknown keys in zod 4, so a feature dropped from the catalog would
+ * invalidate the whole metadata; and `z.record(z.string(), z.boolean())`
+ * rejects the whole record over a single non-boolean value, which would turn
+ * one stale key into every flag reverting to its default, switching a paid
+ * feature back on. The per-key filtering lives in
+ * {@link resolveOrganizationFeatures}, which is the only reader, and the
+ * `.catch` covers the case of `features` not being an object at all.
+ */
+export declare const OrganizationFeaturesSchema: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+export type OrganizationFeatures = Record<OrganizationFeature, boolean>;
+/**
+ * The models an organization chose for itself, both optional: an absent one
+ * falls back to `PLATFORM_MODEL_DEFAULTS`. Ids and not an enum, because one
+ * of them may be a model on the organization's own endpoint.
+ */
+export declare const OrganizationModelDefaultsSchema: z.ZodObject<{
+    agentModel: z.ZodOptional<z.ZodString>;
+    utilityModel: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type OrganizationModelDefaults = z.infer<typeof OrganizationModelDefaultsSchema>;
+/**
+ * The `models` section of the organization metadata: the two defaults, plus
+ * the gateway models the administrator switched off.
+ *
+ * Exclusions and not an allowlist. Absent means the whole curated list, so
+ * nobody has anything to migrate and a model we curate tomorrow appears for
+ * everyone; switching one model off writes one id, not sixty. The opposite
+ * shape would turn the first switch into a silent change of mode, from
+ * "follow the platform" to "frozen at today's list". The price is on the
+ * other side: a newly curated model appears switched on even for an
+ * organization that curated its list, which is acceptable because this
+ * switch is curation, not security (an agent left on a switched off model
+ * keeps answering).
+ */
+export declare const OrganizationModelSettingsSchema: z.ZodObject<{
+    agentModel: z.ZodOptional<z.ZodString>;
+    utilityModel: z.ZodOptional<z.ZodString>;
+    disabledGatewayModels: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type OrganizationModelSettings = z.infer<typeof OrganizationModelSettingsSchema>;
+/**
+ * A write to the `models` section, key by key: an absent key is left as it
+ * is, so the two default pickers and the switches of the gateway table write
+ * without erasing each other. `null` clears a default, back to the platform
+ * one; an empty list switches every gateway model back on, and removes the
+ * key so "nothing excluded" and "never touched" stay the same state.
+ */
+export declare const OrganizationModelSettingsPatchSchema: z.ZodObject<{
+    agentModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    utilityModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    disabledGatewayModels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type OrganizationModelSettingsPatch = z.infer<typeof OrganizationModelSettingsPatchSchema>;
+/**
+ * The `models` section as the Models page reads it: the two defaults in
+ * force (the platform ones when the organization chose none or chose one it
+ * can no longer use) and the gateway models switched off.
+ */
+export declare const OrganizationModelSettingsResolvedSchema: z.ZodObject<{
+    agentModel: z.ZodString;
+    utilityModel: z.ZodString;
+    disabledGatewayModels: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type OrganizationModelSettingsResolved = z.infer<typeof OrganizationModelSettingsResolvedSchema>;
+/**
+ * Why a default was refused: the model is unknown to the catalog, retired by
+ * the gateway, switched off by the administrator, or its whole source is off.
+ */
+export declare enum ModelDefaultIssue {
+    Unknown = "unknown",
+    Retired = "retired",
+    Disabled = "disabled",
+    SourceOff = "source-off"
+}
 export declare const OrganizationMetadataSchema: z.ZodObject<{
-    retention: z.ZodOptional<z.ZodObject<{
+    retention: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         chatRetentionDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         anonymousRetentionDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    features: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    models: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        agentModel: z.ZodOptional<z.ZodString>;
+        utilityModel: z.ZodOptional<z.ZodString>;
+        disabledGatewayModels: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
 }, z.core.$loose>;
 export type OrganizationMetadata = z.infer<typeof OrganizationMetadataSchema>;
 /**
@@ -241,6 +373,14 @@ export declare const GDPR_RETENTION_DEFAULTS: Record<keyof OrganizationRetention
  * typed object. Returns `{}` on missing or malformed input.
  */
 export declare function parseOrganizationMetadata(metadata: string | Record<string, unknown> | null | undefined): OrganizationMetadata;
+/**
+ * Resolve the effective feature flags of an organization from its raw
+ * `metadata` value (a JSON string on most reads, an object on the better-auth
+ * create and update responses). Keys outside the catalog are ignored and the
+ * missing ones fall back to `ORGANIZATION_FEATURE_DEFAULTS`, so a missing or
+ * malformed metadata resolves to the platform defaults instead of failing.
+ */
+export declare function resolveOrganizationFeatures(metadata: string | Record<string, unknown> | null | undefined): OrganizationFeatures;
 export declare const OrganizationPublicSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;