@game-infra/ai-schemas 0.3.0

package/dist/provider.d.ts

@@ -0,0 +1,487 @@
+import { type InferOutput } from "valibot";
+/**
+ * How ai-service names the ways a model can be reached.
+ *
+ * The distinction that matters is not the vendor but who pays and how, because
+ * that is what routing preference is expressed in: a flat-rate coding-plan
+ * subscription is already paid for, a direct API key is metered by the vendor
+ * that trained the model, an umbrella gateway resells other vendors' models at
+ * a markup, and a local server costs whatever the operator's hardware costs.
+ * Preference is declared over these tiers rather than over provider ids, so a
+ * deployment that adds a second gateway does not have to restate its policy.
+ */
+export declare const PROVIDER_TIERS: readonly ["subscription", "direct", "local", "umbrella"];
+export declare const ProviderTierSchema: import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>;
+export type ProviderTier = InferOutput<typeof ProviderTierSchema>;
+/**
+ * The default order tiers are tried in.
+ *
+ * Subscription first because its quota is already bought and spending metered
+ * tokens beside it is waste; then the model's own vendor, which is the cheapest
+ * metered route and the one whose behaviour the model was documented against;
+ * then a local server, which costs nothing per token but is only as available
+ * as the machine it runs on; and finally an umbrella gateway, which can serve
+ * almost anything but at a resale price.
+ *
+ * A preset reorders this list. It never filters: a tier left out of a preset's
+ * preference is appended in this order rather than dropped, so a preference
+ * written before a tier existed cannot silently make that tier unreachable.
+ */
+export declare const DEFAULT_TIER_PREFERENCE: readonly ProviderTier[];
+/**
+ * How a provider is authenticated, which decides what the credential routes
+ * expect and whether a call needs a manual unlock.
+ *
+ * - `api-key` — one key held by the deployment, sealed under `ENCRYPTION_KEY`
+ *   and usable by any call this service serves.
+ * - `subscription` — a personal coding-plan credential (Claude Code, Codex, and
+ *   the Anthropic-compatible plans) that its owner sealed under a password only
+ *   they know. It is unusable until a request carries that password.
+ * - `none` — nothing to store. Either an endpoint that takes no credential at
+ *   all, which is the normal shape of an Ollama or vLLM server on a trusted
+ *   network, or one reached through a Worker binding, where the platform
+ *   authorises the call and there is no key for this service to hold.
+ */
+export declare const CREDENTIAL_KINDS: readonly ["api-key", "subscription", "none"];
+export declare const CredentialKindSchema: import("valibot").PicklistSchema<readonly ["api-key", "subscription", "none"], undefined>;
+export type CredentialKind = InferOutput<typeof CredentialKindSchema>;
+/**
+ * The wire dialect a provider speaks, which is what decides the SDK client
+ * ai-service builds for it.
+ *
+ * Nearly everything is `openai-compatible`: the OpenAI `/chat/completions`
+ * shape is what the gateways, the local runners and most direct vendors expose,
+ * so one client covers them. `openai` and `anthropic` are the two first-party
+ * dialects worth using natively, because their own SDKs carry the structured
+ * output and prompt-caching features the compatible shape flattens away.
+ *
+ * `workers-ai` is the one that is not HTTP at all. It reaches Cloudflare's
+ * hosted models through the Worker's own `AI` binding, so the call never leaves
+ * the runtime: no account id in a URL, no API token to seal, rotate or leak,
+ * and no egress hop. That is why it is a dialect rather than a base URL — what
+ * differs is the transport, not the wire format — and why a provider on it
+ * needs neither `baseUrl` nor a credential.
+ */
+export declare const PROVIDER_DIALECTS: readonly ["openai", "anthropic", "openai-compatible", "workers-ai"];
+export declare const ProviderDialectSchema: import("valibot").PicklistSchema<readonly ["openai", "anthropic", "openai-compatible", "workers-ai"], undefined>;
+export type ProviderDialect = InferOutput<typeof ProviderDialectSchema>;
+/** Lowercase, dash-separated identifier a provider is referred to by. */
+export declare const ProviderIdSchema: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 64, undefined>, import("valibot").RegexAction<string, "must be lowercase words separated by single dashes">]>;
+/**
+ * One model this provider serves, and the id it serves it under.
+ *
+ * The pair is the whole point. A caller asks for a canonical model
+ * (`claude-sonnet-4-5`); OpenRouter serves that same model as
+ * `anthropic/claude-sonnet-4.5` and a self-hosted vLLM serves it under whatever
+ * the operator named the weights. Nothing can derive one from the other, so the
+ * mapping is configuration rather than a guess, and a canonical id no
+ * configured provider maps is simply a model this deployment cannot route.
+ */
+export declare const ProviderModelRouteSchema: import("valibot").ObjectSchema<{
+    /** Canonical model id, the name a caller asks for. */
+    readonly model: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 160, undefined>]>;
+    /** The id this provider serves that model under. */
+    readonly providerModelId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+    /**
+     * Cost per million input tokens, in whatever currency the operator is
+     * budgeting in. Advisory: shown beside a route so the person ordering the
+     * preference can see what the fallback costs, never used to reorder anything
+     * on its own.
+     */
+    readonly inputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** Cost per million output tokens, on the same terms. */
+    readonly outputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /**
+     * Whether this route accepts image parts. Absent means nobody has said, which
+     * is not the same as "no": a request carrying images skips a route declared
+     * `false` and reports `model_no_image_input`, and skips an undeclared one
+     * reporting `unknown_model_image_input`, which is the difference between
+     * "this cannot work" and "declare it and it will".
+     */
+    readonly acceptsImages: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Whether this route supports provider-native structured output. Absent means
+     * undeclared and is treated as capable, because every dialect ai-service
+     * speaks has a structured-output path; set it to `false` for a local server
+     * whose runtime does not implement one, so `/generate/object` routes past it
+     * instead of failing on it.
+     */
+    readonly supportsStructuredOutput: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export type ProviderModelRoute = InferOutput<typeof ProviderModelRouteSchema>;
+/**
+ * A configured way to reach models.
+ *
+ * The record never carries the credential itself. `credentialConfigured` and
+ * `credentialHint` are what the console renders, and they are all the API will
+ * ever say about a stored key: the ciphertext is opened in memory at call time
+ * and nothing reads it back out over HTTP.
+ */
+export declare const ProviderSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    /** Stable key used in preset preferences and in a request's `provider` pin. */
+    readonly providerId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 64, undefined>, import("valibot").RegexAction<string, "must be lowercase words separated by single dashes">]>;
+    /** Display name shown in the console. */
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+    readonly tier: import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>;
+    readonly dialect: import("valibot").PicklistSchema<readonly ["openai", "anthropic", "openai-compatible", "workers-ai"], undefined>;
+    readonly credentialKind: import("valibot").PicklistSchema<readonly ["api-key", "subscription", "none"], undefined>;
+    /**
+     * Where this provider lives. Required for `openai-compatible`, which has no
+     * default host to fall back on; optional for the two first-party dialects,
+     * whose SDKs carry their own and which accept an override so a deployment can
+     * point them at a compatible endpoint; ignored for `workers-ai`, which is not
+     * reached over HTTP and has no URL to point anywhere.
+     */
+    readonly baseUrl: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>, import("valibot").MaxLengthAction<string, 400, undefined>]>, undefined>;
+    /**
+     * Whether routing may pick this provider. A disabled provider keeps its
+     * credential and its routes, so taking a gateway out of rotation during an
+     * outage is one toggle and putting it back does not mean re-entering a key.
+     */
+    readonly enabled: import("valibot").BooleanSchema<undefined>;
+    /** The canonical models this provider serves, and their ids here. */
+    readonly models: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        /** Canonical model id, the name a caller asks for. */
+        readonly model: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 160, undefined>]>;
+        /** The id this provider serves that model under. */
+        readonly providerModelId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+        /**
+         * Cost per million input tokens, in whatever currency the operator is
+         * budgeting in. Advisory: shown beside a route so the person ordering the
+         * preference can see what the fallback costs, never used to reorder anything
+         * on its own.
+         */
+        readonly inputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** Cost per million output tokens, on the same terms. */
+        readonly outputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /**
+         * Whether this route accepts image parts. Absent means nobody has said, which
+         * is not the same as "no": a request carrying images skips a route declared
+         * `false` and reports `model_no_image_input`, and skips an undeclared one
+         * reporting `unknown_model_image_input`, which is the difference between
+         * "this cannot work" and "declare it and it will".
+         */
+        readonly acceptsImages: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        /**
+         * Whether this route supports provider-native structured output. Absent means
+         * undeclared and is treated as capable, because every dialect ai-service
+         * speaks has a structured-output path; set it to `false` for a local server
+         * whose runtime does not implement one, so `/generate/object` routes past it
+         * instead of failing on it.
+         */
+        readonly supportsStructuredOutput: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Extra headers sent with every call. For the gateways that ask for
+     * attribution headers (OpenRouter's `HTTP-Referer` / `X-Title`) and for a
+     * self-hosted gateway behind a proxy that wants a routing header. Never a
+     * place to put a credential: values are stored in the clear.
+     */
+    readonly headers: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly value: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    /** Whether a credential is stored for this provider. */
+    readonly credentialConfigured: import("valibot").BooleanSchema<undefined>;
+    /**
+     * The last four characters of the stored key, which is enough to tell two
+     * keys apart when someone is deciding whether to rotate one, and not enough
+     * to use. Absent for `none` and for a provider with nothing stored yet.
+     */
+    readonly credentialHint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly createdAt: import("valibot").StringSchema<undefined>;
+    readonly updatedAt: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export type Provider = InferOutput<typeof ProviderSchema>;
+/** Fields accepted when registering a provider. */
+export declare const CreateProviderRequestSchema: import("valibot").ObjectSchema<{
+    readonly providerId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 64, undefined>, import("valibot").RegexAction<string, "must be lowercase words separated by single dashes">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+    readonly tier: import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>;
+    readonly dialect: import("valibot").PicklistSchema<readonly ["openai", "anthropic", "openai-compatible", "workers-ai"], undefined>;
+    readonly credentialKind: import("valibot").PicklistSchema<readonly ["api-key", "subscription", "none"], undefined>;
+    readonly baseUrl: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>, import("valibot").MaxLengthAction<string, 400, undefined>]>, undefined>;
+    readonly enabled: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly models: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        /** Canonical model id, the name a caller asks for. */
+        readonly model: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 160, undefined>]>;
+        /** The id this provider serves that model under. */
+        readonly providerModelId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+        /**
+         * Cost per million input tokens, in whatever currency the operator is
+         * budgeting in. Advisory: shown beside a route so the person ordering the
+         * preference can see what the fallback costs, never used to reorder anything
+         * on its own.
+         */
+        readonly inputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** Cost per million output tokens, on the same terms. */
+        readonly outputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /**
+         * Whether this route accepts image parts. Absent means nobody has said, which
+         * is not the same as "no": a request carrying images skips a route declared
+         * `false` and reports `model_no_image_input`, and skips an undeclared one
+         * reporting `unknown_model_image_input`, which is the difference between
+         * "this cannot work" and "declare it and it will".
+         */
+        readonly acceptsImages: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        /**
+         * Whether this route supports provider-native structured output. Absent means
+         * undeclared and is treated as capable, because every dialect ai-service
+         * speaks has a structured-output path; set it to `false` for a local server
+         * whose runtime does not implement one, so `/generate/object` routes past it
+         * instead of failing on it.
+         */
+        readonly supportsStructuredOutput: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly headers: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly value: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    /**
+     * The API key, supplied at creation so registering a provider is one call.
+     * Sealed before it is written and never readable afterwards; replace it
+     * through the credential route.
+     */
+    readonly apiKey: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 4000, undefined>]>, undefined>;
+}, undefined>;
+export type CreateProviderRequest = InferOutput<typeof CreateProviderRequestSchema>;
+/** Fields accepted when updating a provider. Absent means unchanged. */
+export declare const UpdateProviderRequestSchema: import("valibot").ObjectSchema<{
+    readonly name: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>, undefined>;
+    readonly tier: import("valibot").OptionalSchema<import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>, undefined>;
+    readonly dialect: import("valibot").OptionalSchema<import("valibot").PicklistSchema<readonly ["openai", "anthropic", "openai-compatible", "workers-ai"], undefined>, undefined>;
+    readonly baseUrl: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>, import("valibot").MaxLengthAction<string, 400, undefined>]>, undefined>;
+    readonly enabled: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /** Replaces the whole list. The console edits routes as a table, not row by row. */
+    readonly models: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        /** Canonical model id, the name a caller asks for. */
+        readonly model: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 160, undefined>]>;
+        /** The id this provider serves that model under. */
+        readonly providerModelId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+        /**
+         * Cost per million input tokens, in whatever currency the operator is
+         * budgeting in. Advisory: shown beside a route so the person ordering the
+         * preference can see what the fallback costs, never used to reorder anything
+         * on its own.
+         */
+        readonly inputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** Cost per million output tokens, on the same terms. */
+        readonly outputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /**
+         * Whether this route accepts image parts. Absent means nobody has said, which
+         * is not the same as "no": a request carrying images skips a route declared
+         * `false` and reports `model_no_image_input`, and skips an undeclared one
+         * reporting `unknown_model_image_input`, which is the difference between
+         * "this cannot work" and "declare it and it will".
+         */
+        readonly acceptsImages: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        /**
+         * Whether this route supports provider-native structured output. Absent means
+         * undeclared and is treated as capable, because every dialect ai-service
+         * speaks has a structured-output path; set it to `false` for a local server
+         * whose runtime does not implement one, so `/generate/object` routes past it
+         * instead of failing on it.
+         */
+        readonly supportsStructuredOutput: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly headers: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly value: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+export type UpdateProviderRequest = InferOutput<typeof UpdateProviderRequestSchema>;
+/** A key to seal for a provider. */
+export declare const SetProviderCredentialRequestSchema: import("valibot").ObjectSchema<{
+    readonly apiKey: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 4000, undefined>]>;
+}, undefined>;
+export type SetProviderCredentialRequest = InferOutput<typeof SetProviderCredentialRequestSchema>;
+/** One provider. */
+export declare const ProviderResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    provider: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        /** Stable key used in preset preferences and in a request's `provider` pin. */
+        readonly providerId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 64, undefined>, import("valibot").RegexAction<string, "must be lowercase words separated by single dashes">]>;
+        /** Display name shown in the console. */
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+        readonly tier: import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>;
+        readonly dialect: import("valibot").PicklistSchema<readonly ["openai", "anthropic", "openai-compatible", "workers-ai"], undefined>;
+        readonly credentialKind: import("valibot").PicklistSchema<readonly ["api-key", "subscription", "none"], undefined>;
+        /**
+         * Where this provider lives. Required for `openai-compatible`, which has no
+         * default host to fall back on; optional for the two first-party dialects,
+         * whose SDKs carry their own and which accept an override so a deployment can
+         * point them at a compatible endpoint; ignored for `workers-ai`, which is not
+         * reached over HTTP and has no URL to point anywhere.
+         */
+        readonly baseUrl: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>, import("valibot").MaxLengthAction<string, 400, undefined>]>, undefined>;
+        /**
+         * Whether routing may pick this provider. A disabled provider keeps its
+         * credential and its routes, so taking a gateway out of rotation during an
+         * outage is one toggle and putting it back does not mean re-entering a key.
+         */
+        readonly enabled: import("valibot").BooleanSchema<undefined>;
+        /** The canonical models this provider serves, and their ids here. */
+        readonly models: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            /** Canonical model id, the name a caller asks for. */
+            readonly model: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 160, undefined>]>;
+            /** The id this provider serves that model under. */
+            readonly providerModelId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+            /**
+             * Cost per million input tokens, in whatever currency the operator is
+             * budgeting in. Advisory: shown beside a route so the person ordering the
+             * preference can see what the fallback costs, never used to reorder anything
+             * on its own.
+             */
+            readonly inputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            /** Cost per million output tokens, on the same terms. */
+            readonly outputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            /**
+             * Whether this route accepts image parts. Absent means nobody has said, which
+             * is not the same as "no": a request carrying images skips a route declared
+             * `false` and reports `model_no_image_input`, and skips an undeclared one
+             * reporting `unknown_model_image_input`, which is the difference between
+             * "this cannot work" and "declare it and it will".
+             */
+            readonly acceptsImages: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+            /**
+             * Whether this route supports provider-native structured output. Absent means
+             * undeclared and is treated as capable, because every dialect ai-service
+             * speaks has a structured-output path; set it to `false` for a local server
+             * whose runtime does not implement one, so `/generate/object` routes past it
+             * instead of failing on it.
+             */
+            readonly supportsStructuredOutput: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        /**
+         * Extra headers sent with every call. For the gateways that ask for
+         * attribution headers (OpenRouter's `HTTP-Referer` / `X-Title`) and for a
+         * self-hosted gateway behind a proxy that wants a routing header. Never a
+         * place to put a credential: values are stored in the clear.
+         */
+        readonly headers: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly name: import("valibot").StringSchema<undefined>;
+            readonly value: import("valibot").StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
+        /** Whether a credential is stored for this provider. */
+        readonly credentialConfigured: import("valibot").BooleanSchema<undefined>;
+        /**
+         * The last four characters of the stored key, which is enough to tell two
+         * keys apart when someone is deciding whether to rotate one, and not enough
+         * to use. Absent for `none` and for a provider with nothing stored yet.
+         */
+        readonly credentialHint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly createdAt: import("valibot").StringSchema<undefined>;
+        readonly updatedAt: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type ProviderResponse = InferOutput<typeof ProviderResponseSchema>;
+/** Every configured provider. */
+export declare const ProviderListResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    providers: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        /** Stable key used in preset preferences and in a request's `provider` pin. */
+        readonly providerId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 64, undefined>, import("valibot").RegexAction<string, "must be lowercase words separated by single dashes">]>;
+        /** Display name shown in the console. */
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+        readonly tier: import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>;
+        readonly dialect: import("valibot").PicklistSchema<readonly ["openai", "anthropic", "openai-compatible", "workers-ai"], undefined>;
+        readonly credentialKind: import("valibot").PicklistSchema<readonly ["api-key", "subscription", "none"], undefined>;
+        /**
+         * Where this provider lives. Required for `openai-compatible`, which has no
+         * default host to fall back on; optional for the two first-party dialects,
+         * whose SDKs carry their own and which accept an override so a deployment can
+         * point them at a compatible endpoint; ignored for `workers-ai`, which is not
+         * reached over HTTP and has no URL to point anywhere.
+         */
+        readonly baseUrl: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>, import("valibot").MaxLengthAction<string, 400, undefined>]>, undefined>;
+        /**
+         * Whether routing may pick this provider. A disabled provider keeps its
+         * credential and its routes, so taking a gateway out of rotation during an
+         * outage is one toggle and putting it back does not mean re-entering a key.
+         */
+        readonly enabled: import("valibot").BooleanSchema<undefined>;
+        /** The canonical models this provider serves, and their ids here. */
+        readonly models: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            /** Canonical model id, the name a caller asks for. */
+            readonly model: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 160, undefined>]>;
+            /** The id this provider serves that model under. */
+            readonly providerModelId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+            /**
+             * Cost per million input tokens, in whatever currency the operator is
+             * budgeting in. Advisory: shown beside a route so the person ordering the
+             * preference can see what the fallback costs, never used to reorder anything
+             * on its own.
+             */
+            readonly inputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            /** Cost per million output tokens, on the same terms. */
+            readonly outputCostPerMillion: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            /**
+             * Whether this route accepts image parts. Absent means nobody has said, which
+             * is not the same as "no": a request carrying images skips a route declared
+             * `false` and reports `model_no_image_input`, and skips an undeclared one
+             * reporting `unknown_model_image_input`, which is the difference between
+             * "this cannot work" and "declare it and it will".
+             */
+            readonly acceptsImages: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+            /**
+             * Whether this route supports provider-native structured output. Absent means
+             * undeclared and is treated as capable, because every dialect ai-service
+             * speaks has a structured-output path; set it to `false` for a local server
+             * whose runtime does not implement one, so `/generate/object` routes past it
+             * instead of failing on it.
+             */
+            readonly supportsStructuredOutput: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        /**
+         * Extra headers sent with every call. For the gateways that ask for
+         * attribution headers (OpenRouter's `HTTP-Referer` / `X-Title`) and for a
+         * self-hosted gateway behind a proxy that wants a routing header. Never a
+         * place to put a credential: values are stored in the clear.
+         */
+        readonly headers: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly name: import("valibot").StringSchema<undefined>;
+            readonly value: import("valibot").StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
+        /** Whether a credential is stored for this provider. */
+        readonly credentialConfigured: import("valibot").BooleanSchema<undefined>;
+        /**
+         * The last four characters of the stored key, which is enough to tell two
+         * keys apart when someone is deciding whether to rotate one, and not enough
+         * to use. Absent for `none` and for a provider with nothing stored yet.
+         */
+        readonly credentialHint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly createdAt: import("valibot").StringSchema<undefined>;
+        readonly updatedAt: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+export type ProviderListResponse = InferOutput<typeof ProviderListResponseSchema>;
+/**
+ * What a live probe of a provider found.
+ *
+ * Separate fields rather than one boolean, because "the key is wrong" and "the
+ * host did not answer" are fixed in different places, and a caller told only
+ * that the provider is unhealthy has to guess which.
+ */
+export declare const ProviderProbeResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    providerId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** Whether the provider answered a real request. */
+    reachable: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /** The model the probe called, so a failure names something concrete. */
+    model: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** Round-trip time of the probe call, in milliseconds. */
+    latencyMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** Vendor or transport failure, verbatim, when there was one. */
+    failure: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type ProviderProbeResponse = InferOutput<typeof ProviderProbeResponseSchema>;
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"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"}