@game-infra/ai-schemas 0.3.0

package/dist/provider.js

@@ -0,0 +1,224 @@
+import { createSuccessResponseSchema } from "@game-infra/api-schemas-core";
+import { array, boolean, maxLength, minLength, number, object, optional, picklist, pipe, regex, string, url, } 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 const PROVIDER_TIERS = ["subscription", "direct", "local", "umbrella"];
+export const ProviderTierSchema = picklist(PROVIDER_TIERS);
+/**
+ * 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 const DEFAULT_TIER_PREFERENCE = PROVIDER_TIERS;
+/**
+ * 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 const CREDENTIAL_KINDS = ["api-key", "subscription", "none"];
+export const CredentialKindSchema = picklist(CREDENTIAL_KINDS);
+/**
+ * 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 const PROVIDER_DIALECTS = [
+    "openai",
+    "anthropic",
+    "openai-compatible",
+    "workers-ai",
+];
+export const ProviderDialectSchema = picklist(PROVIDER_DIALECTS);
+/** Lowercase, dash-separated identifier a provider is referred to by. */
+export const ProviderIdSchema = pipe(string(), minLength(1), maxLength(64), regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "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 const ProviderModelRouteSchema = object({
+    /** Canonical model id, the name a caller asks for. */
+    model: pipe(string(), minLength(1), maxLength(160)),
+    /** The id this provider serves that model under. */
+    providerModelId: pipe(string(), minLength(1), maxLength(200)),
+    /**
+     * 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.
+     */
+    inputCostPerMillion: optional(number()),
+    /** Cost per million output tokens, on the same terms. */
+    outputCostPerMillion: optional(number()),
+    /**
+     * 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".
+     */
+    acceptsImages: optional(boolean()),
+    /**
+     * 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.
+     */
+    supportsStructuredOutput: optional(boolean()),
+});
+/**
+ * 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 const ProviderSchema = object({
+    id: string(),
+    /** Stable key used in preset preferences and in a request's `provider` pin. */
+    providerId: ProviderIdSchema,
+    /** Display name shown in the console. */
+    name: pipe(string(), minLength(1), maxLength(120)),
+    tier: ProviderTierSchema,
+    dialect: ProviderDialectSchema,
+    credentialKind: CredentialKindSchema,
+    /**
+     * 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.
+     */
+    baseUrl: optional(pipe(string(), url(), maxLength(400))),
+    /**
+     * 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.
+     */
+    enabled: boolean(),
+    /** The canonical models this provider serves, and their ids here. */
+    models: array(ProviderModelRouteSchema),
+    /**
+     * 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.
+     */
+    headers: optional(array(object({ name: string(), value: string() }))),
+    /** Whether a credential is stored for this provider. */
+    credentialConfigured: boolean(),
+    /**
+     * 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.
+     */
+    credentialHint: optional(string()),
+    createdAt: string(),
+    updatedAt: string(),
+});
+/** Fields accepted when registering a provider. */
+export const CreateProviderRequestSchema = object({
+    providerId: ProviderIdSchema,
+    name: pipe(string(), minLength(1), maxLength(120)),
+    tier: ProviderTierSchema,
+    dialect: ProviderDialectSchema,
+    credentialKind: CredentialKindSchema,
+    baseUrl: optional(pipe(string(), url(), maxLength(400))),
+    enabled: optional(boolean()),
+    models: optional(array(ProviderModelRouteSchema)),
+    headers: optional(array(object({ name: string(), value: string() }))),
+    /**
+     * 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.
+     */
+    apiKey: optional(pipe(string(), minLength(1), maxLength(4000))),
+});
+/** Fields accepted when updating a provider. Absent means unchanged. */
+export const UpdateProviderRequestSchema = object({
+    name: optional(pipe(string(), minLength(1), maxLength(120))),
+    tier: optional(ProviderTierSchema),
+    dialect: optional(ProviderDialectSchema),
+    baseUrl: optional(pipe(string(), url(), maxLength(400))),
+    enabled: optional(boolean()),
+    /** Replaces the whole list. The console edits routes as a table, not row by row. */
+    models: optional(array(ProviderModelRouteSchema)),
+    headers: optional(array(object({ name: string(), value: string() }))),
+});
+/** A key to seal for a provider. */
+export const SetProviderCredentialRequestSchema = object({
+    apiKey: pipe(string(), minLength(1), maxLength(4000)),
+});
+/** One provider. */
+export const ProviderResponseSchema = createSuccessResponseSchema({
+    provider: optional(ProviderSchema),
+});
+/** Every configured provider. */
+export const ProviderListResponseSchema = createSuccessResponseSchema({
+    providers: optional(array(ProviderSchema)),
+});
+/**
+ * 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 const ProviderProbeResponseSchema = createSuccessResponseSchema({
+    providerId: optional(string()),
+    /** Whether the provider answered a real request. */
+    reachable: optional(boolean()),
+    /** The model the probe called, so a failure names something concrete. */
+    model: optional(string()),
+    /** Round-trip time of the probe call, in milliseconds. */
+    latencyMs: optional(number()),
+    /** Vendor or transport failure, verbatim, when there was one. */
+    failure: optional(string()),
+});
+//# sourceMappingURL=provider.js.map

package/dist/provider.js.map

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

package/dist/schemaRegistry.d.ts

@@ -0,0 +1,71 @@
+import { type InferOutput } from "valibot";
+/**
+ * The published description of one registered request schema.
+ *
+ * A caller that names a `schemaId` has to be able to write code against what
+ * comes back, and the only honest way to give it that is the schema itself.
+ * `jsonSchema` is the same document handed to the provider's structured-output
+ * API, not a summary of it, so a caller generating types from this endpoint and
+ * the model filling in the response are working from one description.
+ */
+export declare const RegisteredSchemaSchema: import("valibot").ObjectSchema<{
+    /** The id a request names. */
+    readonly id: import("valibot").StringSchema<undefined>;
+    /** What this shape is for, in a sentence. */
+    readonly description: import("valibot").StringSchema<undefined>;
+    /**
+     * Whether the provider is asked to enforce the shape exactly (no extra keys,
+     * every declared field present). True for everything shipped here; a schema
+     * whose union or recursion a provider's strict mode cannot express is
+     * registered non-strict rather than silently rewritten.
+     */
+    readonly strict: import("valibot").BooleanSchema<undefined>;
+    /** The JSON Schema document sent to the provider. */
+    readonly jsonSchema: import("valibot").AnySchema;
+}, undefined>;
+export type RegisteredSchema = InferOutput<typeof RegisteredSchemaSchema>;
+/** Every schema this deployment will accept a `schemaId` for. */
+export declare const SchemaListResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    schemas: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        /** The id a request names. */
+        readonly id: import("valibot").StringSchema<undefined>;
+        /** What this shape is for, in a sentence. */
+        readonly description: import("valibot").StringSchema<undefined>;
+        /**
+         * Whether the provider is asked to enforce the shape exactly (no extra keys,
+         * every declared field present). True for everything shipped here; a schema
+         * whose union or recursion a provider's strict mode cannot express is
+         * registered non-strict rather than silently rewritten.
+         */
+        readonly strict: import("valibot").BooleanSchema<undefined>;
+        /** The JSON Schema document sent to the provider. */
+        readonly jsonSchema: import("valibot").AnySchema;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+export type SchemaListResponse = InferOutput<typeof SchemaListResponseSchema>;
+/** One registered schema. */
+export declare const SchemaResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    schema: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        /** The id a request names. */
+        readonly id: import("valibot").StringSchema<undefined>;
+        /** What this shape is for, in a sentence. */
+        readonly description: import("valibot").StringSchema<undefined>;
+        /**
+         * Whether the provider is asked to enforce the shape exactly (no extra keys,
+         * every declared field present). True for everything shipped here; a schema
+         * whose union or recursion a provider's strict mode cannot express is
+         * registered non-strict rather than silently rewritten.
+         */
+        readonly strict: import("valibot").BooleanSchema<undefined>;
+        /** The JSON Schema document sent to the provider. */
+        readonly jsonSchema: import("valibot").AnySchema;
+    }, undefined>, undefined>;
+}, undefined>;
+export type SchemaResponse = InferOutput<typeof SchemaResponseSchema>;
+//# sourceMappingURL=schemaRegistry.d.ts.map

package/dist/schemaRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaRegistry.d.ts","sourceRoot":"","sources":["../src/schemaRegistry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAiD,MAAM,SAAS,CAAC;AAE1F;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;IACjC,8BAA8B;;IAE9B,6CAA6C;;IAE7C;;;;;OAKG;;IAEH,qDAAqD;;aAErD,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE1E,iEAAiE;AACjE,eAAO,MAAM,wBAAwB;;;;;QAlBnC,8BAA8B;;QAE9B,6CAA6C;;QAE7C;;;;;WAKG;;QAEH,qDAAqD;;;aASrD,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE9E,6BAA6B;AAC7B,eAAO,MAAM,oBAAoB;;;;;QAxB/B,8BAA8B;;QAE9B,6CAA6C;;QAE7C;;;;;WAKG;;QAEH,qDAAqD;;;aAerD,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemaRegistry.js

@@ -0,0 +1,35 @@
+import { createSuccessResponseSchema } from "@game-infra/api-schemas-core";
+import { any, array, boolean, object, optional, string } from "valibot";
+/**
+ * The published description of one registered request schema.
+ *
+ * A caller that names a `schemaId` has to be able to write code against what
+ * comes back, and the only honest way to give it that is the schema itself.
+ * `jsonSchema` is the same document handed to the provider's structured-output
+ * API, not a summary of it, so a caller generating types from this endpoint and
+ * the model filling in the response are working from one description.
+ */
+export const RegisteredSchemaSchema = object({
+    /** The id a request names. */
+    id: string(),
+    /** What this shape is for, in a sentence. */
+    description: string(),
+    /**
+     * Whether the provider is asked to enforce the shape exactly (no extra keys,
+     * every declared field present). True for everything shipped here; a schema
+     * whose union or recursion a provider's strict mode cannot express is
+     * registered non-strict rather than silently rewritten.
+     */
+    strict: boolean(),
+    /** The JSON Schema document sent to the provider. */
+    jsonSchema: any(),
+});
+/** Every schema this deployment will accept a `schemaId` for. */
+export const SchemaListResponseSchema = createSuccessResponseSchema({
+    schemas: optional(array(RegisteredSchemaSchema)),
+});
+/** One registered schema. */
+export const SchemaResponseSchema = createSuccessResponseSchema({
+    schema: optional(RegisteredSchemaSchema),
+});
+//# sourceMappingURL=schemaRegistry.js.map

package/dist/schemaRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaRegistry.js","sourceRoot":"","sources":["../src/schemaRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAoB,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE1F;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC;IAC3C,8BAA8B;IAC9B,EAAE,EAAE,MAAM,EAAE;IACZ,6CAA6C;IAC7C,WAAW,EAAE,MAAM,EAAE;IACrB;;;;;OAKG;IACH,MAAM,EAAE,OAAO,EAAE;IACjB,qDAAqD;IACrD,UAAU,EAAE,GAAG,EAAE;CAClB,CAAC,CAAC;AAIH,iEAAiE;AACjE,MAAM,CAAC,MAAM,wBAAwB,GAAG,2BAA2B,CAAC;IAClE,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;CACjD,CAAC,CAAC;AAGH,6BAA6B;AAC7B,MAAM,CAAC,MAAM,oBAAoB,GAAG,2BAA2B,CAAC;IAC9D,MAAM,EAAE,QAAQ,CAAC,sBAAsB,CAAC;CACzC,CAAC,CAAC"}

package/dist/service.d.ts

@@ -0,0 +1,143 @@
+import { type InferOutput } from "valibot";
+/**
+ * Whether ai-service is configured and migrated, without reading any
+ * configuration. Named checks rather than one boolean: a deployment missing
+ * `ENCRYPTION_KEY` and one missing its migrations need different fixes, and a
+ * bare `ready: false` names neither.
+ */
+export declare const AiReadinessResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    checks: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").BooleanSchema<undefined>, undefined>, undefined>;
+    failedChecks: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * How many providers are enabled and hold whatever credential their kind
+     * needs. Reported beside the checks rather than counted as one: a freshly
+     * migrated deployment with nothing configured is correctly deployed, and
+     * saying so is different from saying it can serve a request.
+     */
+    usableProviders: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** How many presets a caller could name right now. */
+    enabledPresets: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type AiReadinessResponse = InferOutput<typeof AiReadinessResponseSchema>;
+/** Acknowledgement of a delete. */
+export declare const DeleteResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    deleted: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type DeleteResponse = InferOutput<typeof DeleteResponseSchema>;
+/**
+ * One call, as the usage log recorded it.
+ *
+ * The log exists because routing is the whole product here, and a deployment
+ * whose subscription-first preset has been silently answering from OpenRouter
+ * for a fortnight has no other way to find out. It records which route answered
+ * and how many were tried, never a prompt or a completion: this service does
+ * not author the text it carries and has no business retaining it.
+ */
+export declare const CallRecordSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    /** `text`, `object` or `stream`. */
+    readonly kind: import("valibot").StringSchema<undefined>;
+    /** The account whose token authorised the call. */
+    readonly userId: import("valibot").StringSchema<undefined>;
+    /** The preset named, when one was. */
+    readonly preset: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** The schema requested, for an object call. */
+    readonly schemaId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** The label the caller attached, when it attached one. */
+    readonly callLabel: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** The route that answered, or the last one tried when none did. */
+    readonly providerId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly model: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly succeeded: import("valibot").BooleanSchema<undefined>;
+    /** How many routes were tried, the successful one included. */
+    readonly attempts: import("valibot").NumberSchema<undefined>;
+    readonly inputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly outputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly latencyMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** The failure that ended the call, when it failed. */
+    readonly failure: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly createdAt: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export type CallRecord = InferOutput<typeof CallRecordSchema>;
+/**
+ * How much of the log this answer covers.
+ *
+ * `account` is every ordinary caller's answer: the log names which provider
+ * served each call, so an unscoped read would hand any signed-in account both
+ * every other account's activity and the id of every provider this deployment
+ * has configured — the inventory the admin claim exists to withhold. `all` is
+ * what a caller holding that claim gets.
+ *
+ * Reported rather than inferred, because the two are the same shape and a
+ * reader cannot otherwise tell a quiet deployment from a narrowed view of a
+ * busy one.
+ */
+export declare const CALL_LIST_SCOPES: readonly ["account", "all"];
+export declare const CallListScopeSchema: import("valibot").PicklistSchema<readonly ["account", "all"], undefined>;
+export type CallListScope = InferOutput<typeof CallListScopeSchema>;
+/** Recent calls, newest first. */
+export declare const CallListResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    /** Which calls this answer covers. */
+    scope: import("valibot").OptionalSchema<import("valibot").PicklistSchema<readonly ["account", "all"], undefined>, undefined>;
+    calls: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        /** `text`, `object` or `stream`. */
+        readonly kind: import("valibot").StringSchema<undefined>;
+        /** The account whose token authorised the call. */
+        readonly userId: import("valibot").StringSchema<undefined>;
+        /** The preset named, when one was. */
+        readonly preset: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** The schema requested, for an object call. */
+        readonly schemaId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** The label the caller attached, when it attached one. */
+        readonly callLabel: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** The route that answered, or the last one tried when none did. */
+        readonly providerId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly model: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly succeeded: import("valibot").BooleanSchema<undefined>;
+        /** How many routes were tried, the successful one included. */
+        readonly attempts: import("valibot").NumberSchema<undefined>;
+        readonly inputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly outputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly latencyMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** The failure that ended the call, when it failed. */
+        readonly failure: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly createdAt: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    /**
+     * Volume and tokens folded per provider over every retained call within
+     * {@link CallListResponseSchema} `scope` — not over the page above, which is
+     * only the most recent few.
+     */
+    byProvider: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly providerId: import("valibot").StringSchema<undefined>;
+        readonly calls: import("valibot").NumberSchema<undefined>;
+        readonly failures: import("valibot").NumberSchema<undefined>;
+        readonly inputTokens: import("valibot").NumberSchema<undefined>;
+        readonly outputTokens: import("valibot").NumberSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+export type CallListResponse = InferOutput<typeof CallListResponseSchema>;
+/**
+ * How many calls to return.
+ *
+ * Query parameters arrive as strings, so the bound is applied after the
+ * conversion rather than to the text: `limit=abc` becomes `NaN` and is refused
+ * by the range check with the parameter named, which is what a caller can act
+ * on, where a string-shaped rule would have complained about the format of
+ * something it never converted.
+ */
+export declare const CallListQuerySchema: import("valibot").ObjectSchema<{
+    readonly limit: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, number>, import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, 200, undefined>]>, undefined>;
+}, undefined>;
+export type CallListQuery = InferOutput<typeof CallListQuerySchema>;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,WAAW,EAcjB,MAAM,SAAS,CAAC;AAEjB;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;;;;IAGpC;;;;;OAKG;;IAEH,sDAAsD;;aAEtD,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEhF,mCAAmC;AACnC,eAAO,MAAM,oBAAoB;;;;;aAA+D,CAAC;AACjG,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEtE;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;IAE3B,oCAAoC;;IAEpC,mDAAmD;;IAEnD,sCAAsC;;IAEtC,gDAAgD;;IAEhD,2DAA2D;;IAE3D,oEAAoE;;;;IAIpE,+DAA+D;;;;;IAK/D,uDAAuD;;;aAGvD,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,YAAI,SAAS,EAAE,KAAK,CAAU,CAAC;AAC5D,eAAO,MAAM,mBAAmB,0EAA6B,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEpE,kCAAkC;AAClC,eAAO,MAAM,sBAAsB;;;;IACjC,sCAAsC;;;;QA7CtC,oCAAoC;;QAEpC,mDAAmD;;QAEnD,sCAAsC;;QAEtC,gDAAgD;;QAEhD,2DAA2D;;QAE3D,oEAAoE;;;;QAIpE,+DAA+D;;;;;QAK/D,uDAAuD;;;;IA6BvD;;;;OAIG;;;;;;;;aAYH,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE1E;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;aAW9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/service.js

@@ -0,0 +1,103 @@
+import { createSuccessResponseSchema } from "@game-infra/api-schemas-core";
+import { array, boolean, integer, maxValue, minValue, number, object, optional, picklist, pipe, record, string, transform, } from "valibot";
+/**
+ * Whether ai-service is configured and migrated, without reading any
+ * configuration. Named checks rather than one boolean: a deployment missing
+ * `ENCRYPTION_KEY` and one missing its migrations need different fixes, and a
+ * bare `ready: false` names neither.
+ */
+export const AiReadinessResponseSchema = createSuccessResponseSchema({
+    checks: optional(record(string(), boolean())),
+    failedChecks: optional(array(string())),
+    /**
+     * How many providers are enabled and hold whatever credential their kind
+     * needs. Reported beside the checks rather than counted as one: a freshly
+     * migrated deployment with nothing configured is correctly deployed, and
+     * saying so is different from saying it can serve a request.
+     */
+    usableProviders: optional(number()),
+    /** How many presets a caller could name right now. */
+    enabledPresets: optional(number()),
+});
+/** Acknowledgement of a delete. */
+export const DeleteResponseSchema = createSuccessResponseSchema({ deleted: optional(string()) });
+/**
+ * One call, as the usage log recorded it.
+ *
+ * The log exists because routing is the whole product here, and a deployment
+ * whose subscription-first preset has been silently answering from OpenRouter
+ * for a fortnight has no other way to find out. It records which route answered
+ * and how many were tried, never a prompt or a completion: this service does
+ * not author the text it carries and has no business retaining it.
+ */
+export const CallRecordSchema = object({
+    id: string(),
+    /** `text`, `object` or `stream`. */
+    kind: string(),
+    /** The account whose token authorised the call. */
+    userId: string(),
+    /** The preset named, when one was. */
+    preset: optional(string()),
+    /** The schema requested, for an object call. */
+    schemaId: optional(string()),
+    /** The label the caller attached, when it attached one. */
+    callLabel: optional(string()),
+    /** The route that answered, or the last one tried when none did. */
+    providerId: optional(string()),
+    model: optional(string()),
+    succeeded: boolean(),
+    /** How many routes were tried, the successful one included. */
+    attempts: number(),
+    inputTokens: optional(number()),
+    outputTokens: optional(number()),
+    latencyMs: optional(number()),
+    /** The failure that ended the call, when it failed. */
+    failure: optional(string()),
+    createdAt: string(),
+});
+/**
+ * How much of the log this answer covers.
+ *
+ * `account` is every ordinary caller's answer: the log names which provider
+ * served each call, so an unscoped read would hand any signed-in account both
+ * every other account's activity and the id of every provider this deployment
+ * has configured — the inventory the admin claim exists to withhold. `all` is
+ * what a caller holding that claim gets.
+ *
+ * Reported rather than inferred, because the two are the same shape and a
+ * reader cannot otherwise tell a quiet deployment from a narrowed view of a
+ * busy one.
+ */
+export const CALL_LIST_SCOPES = ["account", "all"];
+export const CallListScopeSchema = picklist(CALL_LIST_SCOPES);
+/** Recent calls, newest first. */
+export const CallListResponseSchema = createSuccessResponseSchema({
+    /** Which calls this answer covers. */
+    scope: optional(CallListScopeSchema),
+    calls: optional(array(CallRecordSchema)),
+    /**
+     * Volume and tokens folded per provider over every retained call within
+     * {@link CallListResponseSchema} `scope` — not over the page above, which is
+     * only the most recent few.
+     */
+    byProvider: optional(array(object({
+        providerId: string(),
+        calls: number(),
+        failures: number(),
+        inputTokens: number(),
+        outputTokens: number(),
+    }))),
+});
+/**
+ * How many calls to return.
+ *
+ * Query parameters arrive as strings, so the bound is applied after the
+ * conversion rather than to the text: `limit=abc` becomes `NaN` and is refused
+ * by the range check with the parameter named, which is what a caller can act
+ * on, where a string-shaped rule would have complained about the format of
+ * something it never converted.
+ */
+export const CallListQuerySchema = object({
+    limit: optional(pipe(string(), transform((raw) => Number(raw)), number(), integer(), minValue(1), maxValue(200))),
+});
+//# sourceMappingURL=service.js.map

package/dist/service.js.map

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