@game-infra/ai-schemas 0.3.0

package/dist/index.js

@@ -0,0 +1,39 @@
+/**
+ * @game-infra/ai-schemas
+ *
+ * The ai-service API contract: how a provider, a coding-plan subscription and a
+ * routing preset are described, what an inference request and its answer look
+ * like, and the endpoint definitions that carry them.
+ */
+// Providers
+export { CREDENTIAL_KINDS, CreateProviderRequestSchema, CredentialKindSchema, DEFAULT_TIER_PREFERENCE, PROVIDER_DIALECTS, PROVIDER_TIERS, ProviderDialectSchema, ProviderIdSchema, ProviderListResponseSchema, ProviderModelRouteSchema, ProviderProbeResponseSchema, ProviderResponseSchema, ProviderSchema, ProviderTierSchema, SetProviderCredentialRequestSchema, UpdateProviderRequestSchema, } from "./provider.js";
+// Subscriptions
+export { CreateSubscriptionRequestSchema, SUBSCRIPTION_AUTH_SCHEMES, SUBSCRIPTION_VENDOR_PROFILES, SUBSCRIPTION_VENDORS, SubscriptionListResponseSchema, SubscriptionResponseSchema, SubscriptionAuthSchemeSchema, SubscriptionSchema, SubscriptionVendorSchema, UnlockSubscriptionRequestSchema, UnlockSubscriptionResponseSchema, UpdateSubscriptionRequestSchema, } from "./subscription.js";
+// Presets and routing
+export { CreatePresetRequestSchema, LOCKED_SUBSCRIPTION_POLICIES, LockedSubscriptionPolicySchema, PresetListResponseSchema, PresetModelEntrySchema, PresetResponseSchema, PresetSchema, PresetSlugSchema, ROUTE_EXCLUSION_REASONS, RouteCandidateSchema, RouteExclusionReasonSchema, RouteExclusionSchema, RoutePlanResponseSchema, UpdatePresetRequestSchema, } from "./preset.js";
+// Inference
+export { AttemptFailureSchema, GenerateObjectRequestSchema, GenerateObjectResponseSchema, GenerateTextRequestSchema, GenerateTextResponseSchema, ImagePartSchema, MESSAGE_ROLES, MessageRoleSchema, MessageSchema, RouteOutcomeSchema, STREAM_EVENTS, StreamEventSchema, TextPartSchema, UsageSchema, } from "./inference.js";
+// The named request-schema registry, as published
+export { RegisteredSchemaSchema, SchemaListResponseSchema, SchemaResponseSchema, } from "./schemaRegistry.js";
+// Provider blueprints and model discovery
+export { CatalogResponseSchema, DiscoveredModelsResponseSchema, PROVIDER_BLUEPRINTS, ProviderBlueprintSchema, SubscriptionVendorOptionSchema, } from "./catalog.js";
+// The models this deployment surfaces by name, and how they become routable
+export { FEATURED_MODEL_PURPOSES, FEATURED_MODELS, FeaturedModelPurposeSchema, FeaturedModelSchema, featuredModelRoutes, featuredModelsFor, } from "./featuredModels.js";
+// Service
+export { AiReadinessResponseSchema, CALL_LIST_SCOPES, CallListQuerySchema, CallListResponseSchema, CallListScopeSchema, CallRecordSchema, DeleteResponseSchema, } from "./service.js";
+// Typed endpoint contracts (toad-contracts). Each contract carries its own
+// `pathResolver`; wire them into a client via @toad-contracts/frontend-http-client.
+export { aiCallListContract, aiCatalogContract, aiGenerateObjectContract, aiGenerateStreamContract, aiGenerateTextContract, aiPresetCreateContract, aiPresetDeleteContract, aiPresetGetContract, aiPresetListContract, aiPresetRoutePlanContract, aiPresetUpdateContract, aiProviderCreateContract, aiProviderCredentialDeleteContract, aiProviderCredentialSetContract, aiProviderDeleteContract, aiProviderGetContract, aiProviderListContract, aiProviderModelsContract, aiProviderProbeContract, aiProviderUpdateContract, aiReadinessContract, aiSchemaGetContract, aiSchemaListContract, aiSubscriptionCreateContract, aiSubscriptionDeleteContract, aiSubscriptionListContract, aiSubscriptionUnlockContract, aiSubscriptionUpdateContract, } from "./contracts.js";
+// Routing rules the service and the console must agree about, stated once here
+// rather than restated on each side.
+export { orderedProviderPreference, orderedTierPreference } from "./preference.js";
+/**
+ * The header a request carries the subscription unlock password in.
+ *
+ * A header rather than a body field, for the same reason the bearer token is
+ * one: it is a credential rather than an argument, it must not vary between the
+ * text and the streaming forms of the same call, and a body field would end up
+ * copied into request logs by every client that logs what it posted.
+ */
+export const SUBSCRIPTION_PASSWORD_HEADER = "X-AI-Subscription-Password";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY;AACZ,OAAO,EACL,gBAAgB,EAChB,2BAA2B,EAC3B,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,0BAA0B,EAC1B,wBAAwB,EACxB,2BAA2B,EAC3B,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,kCAAkC,EAClC,2BAA2B,GAC5B,MAAM,eAAe,CAAC;AAevB,gBAAgB;AAChB,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,EACzB,4BAA4B,EAC5B,oBAAoB,EACpB,8BAA8B,EAC9B,0BAA0B,EAC1B,4BAA4B,EAC5B,kBAAkB,EAClB,wBAAwB,EACxB,+BAA+B,EAC/B,gCAAgC,EAChC,+BAA+B,GAChC,MAAM,mBAAmB,CAAC;AAc3B,sBAAsB;AACtB,OAAO,EACL,yBAAyB,EACzB,4BAA4B,EAC5B,8BAA8B,EAC9B,wBAAwB,EACxB,sBAAsB,EACtB,oBAAoB,EACpB,YAAY,EACZ,gBAAgB,EAChB,uBAAuB,EACvB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,aAAa,CAAC;AAerB,YAAY;AACZ,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,4BAA4B,EAC5B,yBAAyB,EACzB,0BAA0B,EAC1B,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,WAAW,GACZ,MAAM,gBAAgB,CAAC;AAcxB,kDAAkD;AAClD,OAAO,EACL,sBAAsB,EACtB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAG7B,0CAA0C;AAC1C,OAAO,EACL,qBAAqB,EACrB,8BAA8B,EAC9B,mBAAmB,EACnB,uBAAuB,EACvB,8BAA8B,GAC/B,MAAM,cAAc,CAAC;AAGtB,4EAA4E;AAC5E,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,0BAA0B,EAC1B,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAG7B,UAAU;AACV,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAUtB,2EAA2E;AAC3E,oFAAoF;AACpF,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,kCAAkC,EAClC,+BAA+B,EAC/B,wBAAwB,EACxB,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,4BAA4B,EAC5B,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,EAC5B,4BAA4B,GAC7B,MAAM,gBAAgB,CAAC;AAExB,+EAA+E;AAC/E,qCAAqC;AACrC,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAEnF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,4BAA4B,CAAC"}

package/dist/inference.d.ts

@@ -0,0 +1,323 @@
+import { type InferOutput } from "valibot";
+/**
+ * The inference surface.
+ *
+ * ai-service defines no prompts. Every word a model sees comes from the caller,
+ * which is what keeps this a routing and credential service rather than a
+ * second place where a game's voice is decided. What it does own is the part no
+ * caller should have to: which provider serves the request, what to do when
+ * that provider is down, and what a structured response is allowed to look
+ * like.
+ */
+/** Who a message is from. */
+export declare const MESSAGE_ROLES: readonly ["system", "user", "assistant"];
+export declare const MessageRoleSchema: import("valibot").PicklistSchema<readonly ["system", "user", "assistant"], undefined>;
+export type MessageRole = InferOutput<typeof MessageRoleSchema>;
+/** A piece of an image, given as a URL or as base64 bytes with their media type. */
+export declare const ImagePartSchema: import("valibot").ObjectSchema<{
+    readonly type: import("valibot").PicklistSchema<["image"], undefined>;
+    /** `https:` or `data:` URL, or bare base64 when {@link mediaType} is set. */
+    readonly image: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 20000000, undefined>]>;
+    /** `image/png`, `image/jpeg`, … Required when `image` is bare base64. */
+    readonly mediaType: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>, undefined>;
+}, undefined>;
+/** A piece of text. */
+export declare const TextPartSchema: import("valibot").ObjectSchema<{
+    readonly type: import("valibot").PicklistSchema<["text"], undefined>;
+    readonly text: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000000, undefined>]>;
+}, undefined>;
+/**
+ * One message.
+ *
+ * `content` is a plain string or a list of parts. The string form is what
+ * almost every caller wants and is not sugar over the other: a text-only
+ * request must be able to route to a model nobody has declared image support
+ * for, and that is decidable only if "no parts" and "parts that happen to be
+ * text" stay distinguishable.
+ */
+export declare const MessageSchema: import("valibot").ObjectSchema<{
+    readonly role: import("valibot").PicklistSchema<readonly ["system", "user", "assistant"], undefined>;
+    readonly content: import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000000, undefined>]>, import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly type: import("valibot").PicklistSchema<["text"], undefined>;
+        readonly text: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000000, undefined>]>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly type: import("valibot").PicklistSchema<["image"], undefined>;
+        /** `https:` or `data:` URL, or bare base64 when {@link mediaType} is set. */
+        readonly image: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 20000000, undefined>]>;
+        /** `image/png`, `image/jpeg`, … Required when `image` is bare base64. */
+        readonly mediaType: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>, undefined>;
+    }, undefined>], undefined>, undefined>], undefined>;
+}, undefined>;
+export type Message = InferOutput<typeof MessageSchema>;
+/** A free-text completion. */
+export declare const GenerateTextRequestSchema: import("valibot").ObjectSchema<{
+    /** Preset slug. Unknown or disabled slugs are refused rather than defaulted. */
+    readonly preset: import("valibot").OptionalSchema<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">]>, undefined>;
+    /** Canonical model id, when the caller is naming one directly. */
+    readonly model: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 160, undefined>]>, undefined>;
+    /** Force one provider. Same meaning as a preset entry's pin: no fallback. */
+    readonly provider: import("valibot").OptionalSchema<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">]>, undefined>;
+    /** The conversation. At least one message; the service adds none of its own. */
+    readonly messages: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly role: import("valibot").PicklistSchema<readonly ["system", "user", "assistant"], undefined>;
+        readonly content: import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000000, undefined>]>, import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly type: import("valibot").PicklistSchema<["text"], undefined>;
+            readonly text: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000000, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly type: import("valibot").PicklistSchema<["image"], undefined>;
+            /** `https:` or `data:` URL, or bare base64 when {@link mediaType} is set. */
+            readonly image: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 20000000, undefined>]>;
+            /** `image/png`, `image/jpeg`, … Required when `image` is bare base64. */
+            readonly mediaType: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>, undefined>;
+        }, undefined>], undefined>, undefined>], undefined>;
+    }, undefined>, undefined>, import("valibot").MinLengthAction<{
+        role: "assistant" | "system" | "user";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            image: string;
+            mediaType?: string | undefined;
+        })[];
+    }[], 1, undefined>]>;
+    /** Overrides the preset's temperature. */
+    readonly temperature: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 2, undefined>]>, undefined>;
+    /** Overrides the preset's output-token cap. */
+    readonly maxOutputTokens: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, 200000, undefined>]>, undefined>;
+    /**
+     * Opaque label recorded with the call, so spend can be read back per caller.
+     * A service name or a job kind, never anything derived from a player.
+     */
+    readonly callLabel: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>, undefined>;
+}, undefined>;
+export type GenerateTextRequest = InferOutput<typeof GenerateTextRequestSchema>;
+/**
+ * A completion shaped by one of this service's registered schemas.
+ *
+ * The schema is named, never sent. A caller that could post its own schema
+ * would be deciding, per call, what this deployment is willing to ask a model
+ * for, and the shapes would drift between the callers that share them. So the
+ * schemas live here, `schemaId` selects one, and an id this service does not
+ * know is an error rather than a fall back to free text.
+ */
+export declare const GenerateObjectRequestSchema: import("valibot").ObjectSchema<{
+    /** Preset slug. Unknown or disabled slugs are refused rather than defaulted. */
+    readonly preset: import("valibot").OptionalSchema<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">]>, undefined>;
+    /** Canonical model id, when the caller is naming one directly. */
+    readonly model: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 160, undefined>]>, undefined>;
+    /** Force one provider. Same meaning as a preset entry's pin: no fallback. */
+    readonly provider: import("valibot").OptionalSchema<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">]>, undefined>;
+    /** The conversation. At least one message; the service adds none of its own. */
+    readonly messages: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly role: import("valibot").PicklistSchema<readonly ["system", "user", "assistant"], undefined>;
+        readonly content: import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000000, undefined>]>, import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly type: import("valibot").PicklistSchema<["text"], undefined>;
+            readonly text: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000000, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly type: import("valibot").PicklistSchema<["image"], undefined>;
+            /** `https:` or `data:` URL, or bare base64 when {@link mediaType} is set. */
+            readonly image: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 20000000, undefined>]>;
+            /** `image/png`, `image/jpeg`, … Required when `image` is bare base64. */
+            readonly mediaType: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>, undefined>;
+        }, undefined>], undefined>, undefined>], undefined>;
+    }, undefined>, undefined>, import("valibot").MinLengthAction<{
+        role: "assistant" | "system" | "user";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            image: string;
+            mediaType?: string | undefined;
+        })[];
+    }[], 1, undefined>]>;
+    /** Overrides the preset's temperature. */
+    readonly temperature: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 2, undefined>]>, undefined>;
+    /** Overrides the preset's output-token cap. */
+    readonly maxOutputTokens: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, 200000, undefined>]>, undefined>;
+    /**
+     * Opaque label recorded with the call, so spend can be read back per caller.
+     * A service name or a job kind, never anything derived from a player.
+     */
+    readonly callLabel: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>, undefined>;
+    readonly schemaId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+}, undefined>;
+export type GenerateObjectRequest = InferOutput<typeof GenerateObjectRequestSchema>;
+/** Tokens spent on one call, as the provider reported them. */
+export declare const UsageSchema: import("valibot").ObjectSchema<{
+    /** Fresh input tokens, exclusive of anything served from a prompt cache. */
+    readonly inputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly outputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** Cached input tokens read, where the provider reports them separately. */
+    readonly cachedInputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly totalTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type Usage = InferOutput<typeof UsageSchema>;
+/** Why one attempted route did not produce the answer. */
+export declare const AttemptFailureSchema: import("valibot").ObjectSchema<{
+    readonly providerId: import("valibot").StringSchema<undefined>;
+    readonly model: import("valibot").StringSchema<undefined>;
+    /** The vendor or transport failure, verbatim. Secrets are stripped first. */
+    readonly failure: import("valibot").StringSchema<undefined>;
+    /** Whether the failure was one the next route could plausibly do better on. */
+    readonly retryable: import("valibot").BooleanSchema<undefined>;
+}, undefined>;
+export type AttemptFailure = InferOutput<typeof AttemptFailureSchema>;
+/**
+ * What actually happened, reported on every answer.
+ *
+ * A response that said only what the model produced would hide the two facts a
+ * caller most needs when a preset is not behaving: which route served it, and
+ * which routes were skipped or failed on the way there. Both are here on
+ * success as well as on failure, because a preset degrading quietly to its last
+ * fallback looks exactly like one working.
+ */
+export declare const RouteOutcomeSchema: import("valibot").ObjectSchema<{
+    /** The route that answered. */
+    readonly served: import("valibot").ObjectSchema<{
+        readonly order: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+        readonly model: import("valibot").StringSchema<undefined>;
+        readonly providerModelId: import("valibot").StringSchema<undefined>;
+        readonly providerId: import("valibot").StringSchema<undefined>;
+        readonly providerName: import("valibot").StringSchema<undefined>;
+        readonly tier: import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>;
+        readonly unlockable: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+    /** Routes tried and failed before it, oldest first. */
+    readonly attempts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly providerId: import("valibot").StringSchema<undefined>;
+        readonly model: import("valibot").StringSchema<undefined>;
+        /** The vendor or transport failure, verbatim. Secrets are stripped first. */
+        readonly failure: import("valibot").StringSchema<undefined>;
+        /** Whether the failure was one the next route could plausibly do better on. */
+        readonly retryable: import("valibot").BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+    /** Routes never tried, and why. */
+    readonly excluded: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly model: import("valibot").StringSchema<undefined>;
+        readonly providerId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly tier: import("valibot").OptionalSchema<import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>, undefined>;
+        readonly reason: import("valibot").PicklistSchema<readonly ["model_not_served", "provider_disabled", "credential_missing", "subscription_locked", "subscription_not_owned", "subscription_required", "pinned_provider_unavailable", "model_no_image_input", "unknown_model_image_input", "structured_output_unsupported", "attempt_budget_exhausted"], undefined>;
+        readonly detail: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type RouteOutcome = InferOutput<typeof RouteOutcomeSchema>;
+/** A free-text answer. */
+export declare const GenerateTextResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    text: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** `stop`, `length`, `content-filter`, … as the provider reported it. */
+    finishReason: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    usage: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        /** Fresh input tokens, exclusive of anything served from a prompt cache. */
+        readonly inputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly outputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** Cached input tokens read, where the provider reports them separately. */
+        readonly cachedInputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly totalTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    route: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        /** The route that answered. */
+        readonly served: import("valibot").ObjectSchema<{
+            readonly order: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+            readonly model: import("valibot").StringSchema<undefined>;
+            readonly providerModelId: import("valibot").StringSchema<undefined>;
+            readonly providerId: import("valibot").StringSchema<undefined>;
+            readonly providerName: import("valibot").StringSchema<undefined>;
+            readonly tier: import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>;
+            readonly unlockable: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        }, undefined>;
+        /** Routes tried and failed before it, oldest first. */
+        readonly attempts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly providerId: import("valibot").StringSchema<undefined>;
+            readonly model: import("valibot").StringSchema<undefined>;
+            /** The vendor or transport failure, verbatim. Secrets are stripped first. */
+            readonly failure: import("valibot").StringSchema<undefined>;
+            /** Whether the failure was one the next route could plausibly do better on. */
+            readonly retryable: import("valibot").BooleanSchema<undefined>;
+        }, undefined>, undefined>;
+        /** Routes never tried, and why. */
+        readonly excluded: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly model: import("valibot").StringSchema<undefined>;
+            readonly providerId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly tier: import("valibot").OptionalSchema<import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>, undefined>;
+            readonly reason: import("valibot").PicklistSchema<readonly ["model_not_served", "provider_disabled", "credential_missing", "subscription_locked", "subscription_not_owned", "subscription_required", "pinned_provider_unavailable", "model_no_image_input", "unknown_model_image_input", "structured_output_unsupported", "attempt_budget_exhausted"], undefined>;
+            readonly detail: import("valibot").StringSchema<undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** Wall-clock time of the call that answered, in milliseconds. */
+    latencyMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type GenerateTextResponse = InferOutput<typeof GenerateTextResponseSchema>;
+/**
+ * A structured answer.
+ *
+ * `object` is typed `any` on the wire because its real shape is whichever
+ * registered schema the request named, and a contract cannot know that at
+ * definition time. Callers narrow it by parsing against the same `schemaId`
+ * they asked for, whose JSON Schema this service publishes.
+ */
+export declare const GenerateObjectResponseSchema: import("valibot").ObjectSchema<{
+    readonly success: import("valibot").BooleanSchema<undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+} & {
+    object: import("valibot").OptionalSchema<import("valibot").AnySchema, undefined>;
+    schemaId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    finishReason: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    usage: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        /** Fresh input tokens, exclusive of anything served from a prompt cache. */
+        readonly inputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly outputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** Cached input tokens read, where the provider reports them separately. */
+        readonly cachedInputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly totalTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    route: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        /** The route that answered. */
+        readonly served: import("valibot").ObjectSchema<{
+            readonly order: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+            readonly model: import("valibot").StringSchema<undefined>;
+            readonly providerModelId: import("valibot").StringSchema<undefined>;
+            readonly providerId: import("valibot").StringSchema<undefined>;
+            readonly providerName: import("valibot").StringSchema<undefined>;
+            readonly tier: import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>;
+            readonly unlockable: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        }, undefined>;
+        /** Routes tried and failed before it, oldest first. */
+        readonly attempts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly providerId: import("valibot").StringSchema<undefined>;
+            readonly model: import("valibot").StringSchema<undefined>;
+            /** The vendor or transport failure, verbatim. Secrets are stripped first. */
+            readonly failure: import("valibot").StringSchema<undefined>;
+            /** Whether the failure was one the next route could plausibly do better on. */
+            readonly retryable: import("valibot").BooleanSchema<undefined>;
+        }, undefined>, undefined>;
+        /** Routes never tried, and why. */
+        readonly excluded: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly model: import("valibot").StringSchema<undefined>;
+            readonly providerId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly tier: import("valibot").OptionalSchema<import("valibot").PicklistSchema<readonly ["subscription", "direct", "local", "umbrella"], undefined>, undefined>;
+            readonly reason: import("valibot").PicklistSchema<readonly ["model_not_served", "provider_disabled", "credential_missing", "subscription_locked", "subscription_not_owned", "subscription_required", "pinned_provider_unavailable", "model_no_image_input", "unknown_model_image_input", "structured_output_unsupported", "attempt_budget_exhausted"], undefined>;
+            readonly detail: import("valibot").StringSchema<undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    latencyMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type GenerateObjectResponse = InferOutput<typeof GenerateObjectResponseSchema>;
+/**
+ * The events a streamed completion emits, as SSE `event:` names.
+ *
+ * `route` arrives first and only once, naming the provider that got the
+ * request. It is sent before the first token because that is the last moment at
+ * which the answer is still honest: fallback is possible only until bytes have
+ * been written, so a stream that failed over would have to retract a route it
+ * had already claimed. After the first `delta`, a failure ends the stream with
+ * `error` and nothing is retried.
+ */
+export declare const STREAM_EVENTS: readonly ["route", "delta", "done", "error"];
+export declare const StreamEventSchema: import("valibot").PicklistSchema<readonly ["route", "delta", "done", "error"], undefined>;
+export type StreamEvent = InferOutput<typeof StreamEventSchema>;
+//# sourceMappingURL=inference.d.ts.map

package/dist/inference.d.ts.map

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

package/dist/inference.js

@@ -0,0 +1,162 @@
+import { createSuccessResponseSchema } from "@game-infra/api-schemas-core";
+import { any, array, boolean, integer, maxLength, maxValue, minLength, minValue, number, object, optional, picklist, pipe, string, union, } from "valibot";
+import { PresetSlugSchema, RouteCandidateSchema, RouteExclusionSchema } from "./preset.js";
+import { ProviderIdSchema } from "./provider.js";
+/**
+ * The inference surface.
+ *
+ * ai-service defines no prompts. Every word a model sees comes from the caller,
+ * which is what keeps this a routing and credential service rather than a
+ * second place where a game's voice is decided. What it does own is the part no
+ * caller should have to: which provider serves the request, what to do when
+ * that provider is down, and what a structured response is allowed to look
+ * like.
+ */
+/** Who a message is from. */
+export const MESSAGE_ROLES = ["system", "user", "assistant"];
+export const MessageRoleSchema = picklist(MESSAGE_ROLES);
+/** A piece of an image, given as a URL or as base64 bytes with their media type. */
+export const ImagePartSchema = object({
+    type: picklist(["image"]),
+    /** `https:` or `data:` URL, or bare base64 when {@link mediaType} is set. */
+    image: pipe(string(), minLength(1), maxLength(20_000_000)),
+    /** `image/png`, `image/jpeg`, … Required when `image` is bare base64. */
+    mediaType: optional(pipe(string(), maxLength(120))),
+});
+/** A piece of text. */
+export const TextPartSchema = object({
+    type: picklist(["text"]),
+    text: pipe(string(), maxLength(2_000_000)),
+});
+/**
+ * One message.
+ *
+ * `content` is a plain string or a list of parts. The string form is what
+ * almost every caller wants and is not sugar over the other: a text-only
+ * request must be able to route to a model nobody has declared image support
+ * for, and that is decidable only if "no parts" and "parts that happen to be
+ * text" stay distinguishable.
+ */
+export const MessageSchema = object({
+    role: MessageRoleSchema,
+    content: union([
+        pipe(string(), maxLength(2_000_000)),
+        array(union([TextPartSchema, ImagePartSchema])),
+    ]),
+});
+/**
+ * What every inference request carries, whatever it asks the model to produce.
+ *
+ * Exactly one of `preset` or `model` names the work's destination. A preset is
+ * the normal form and is what gives a caller fallback; a bare model is the
+ * escape hatch for a caller that knows precisely what it wants, and it routes
+ * through the same tier preference with no model-level fallback.
+ */
+const InferenceRequestFieldsSchema = object({
+    /** Preset slug. Unknown or disabled slugs are refused rather than defaulted. */
+    preset: optional(PresetSlugSchema),
+    /** Canonical model id, when the caller is naming one directly. */
+    model: optional(pipe(string(), minLength(1), maxLength(160))),
+    /** Force one provider. Same meaning as a preset entry's pin: no fallback. */
+    provider: optional(ProviderIdSchema),
+    /** The conversation. At least one message; the service adds none of its own. */
+    messages: pipe(array(MessageSchema), minLength(1)),
+    /** Overrides the preset's temperature. */
+    temperature: optional(pipe(number(), minValue(0), maxValue(2))),
+    /** Overrides the preset's output-token cap. */
+    maxOutputTokens: optional(pipe(number(), integer(), minValue(1), maxValue(200_000))),
+    /**
+     * Opaque label recorded with the call, so spend can be read back per caller.
+     * A service name or a job kind, never anything derived from a player.
+     */
+    callLabel: optional(pipe(string(), maxLength(120))),
+});
+/** A free-text completion. */
+export const GenerateTextRequestSchema = object({ ...InferenceRequestFieldsSchema.entries });
+/**
+ * A completion shaped by one of this service's registered schemas.
+ *
+ * The schema is named, never sent. A caller that could post its own schema
+ * would be deciding, per call, what this deployment is willing to ask a model
+ * for, and the shapes would drift between the callers that share them. So the
+ * schemas live here, `schemaId` selects one, and an id this service does not
+ * know is an error rather than a fall back to free text.
+ */
+export const GenerateObjectRequestSchema = object({
+    ...InferenceRequestFieldsSchema.entries,
+    schemaId: pipe(string(), minLength(1), maxLength(120)),
+});
+/** Tokens spent on one call, as the provider reported them. */
+export const UsageSchema = object({
+    /** Fresh input tokens, exclusive of anything served from a prompt cache. */
+    inputTokens: optional(number()),
+    outputTokens: optional(number()),
+    /** Cached input tokens read, where the provider reports them separately. */
+    cachedInputTokens: optional(number()),
+    totalTokens: optional(number()),
+});
+/** Why one attempted route did not produce the answer. */
+export const AttemptFailureSchema = object({
+    providerId: string(),
+    model: string(),
+    /** The vendor or transport failure, verbatim. Secrets are stripped first. */
+    failure: string(),
+    /** Whether the failure was one the next route could plausibly do better on. */
+    retryable: boolean(),
+});
+/**
+ * What actually happened, reported on every answer.
+ *
+ * A response that said only what the model produced would hide the two facts a
+ * caller most needs when a preset is not behaving: which route served it, and
+ * which routes were skipped or failed on the way there. Both are here on
+ * success as well as on failure, because a preset degrading quietly to its last
+ * fallback looks exactly like one working.
+ */
+export const RouteOutcomeSchema = object({
+    /** The route that answered. */
+    served: RouteCandidateSchema,
+    /** Routes tried and failed before it, oldest first. */
+    attempts: array(AttemptFailureSchema),
+    /** Routes never tried, and why. */
+    excluded: array(RouteExclusionSchema),
+});
+/** A free-text answer. */
+export const GenerateTextResponseSchema = createSuccessResponseSchema({
+    text: optional(string()),
+    /** `stop`, `length`, `content-filter`, … as the provider reported it. */
+    finishReason: optional(string()),
+    usage: optional(UsageSchema),
+    route: optional(RouteOutcomeSchema),
+    /** Wall-clock time of the call that answered, in milliseconds. */
+    latencyMs: optional(number()),
+});
+/**
+ * A structured answer.
+ *
+ * `object` is typed `any` on the wire because its real shape is whichever
+ * registered schema the request named, and a contract cannot know that at
+ * definition time. Callers narrow it by parsing against the same `schemaId`
+ * they asked for, whose JSON Schema this service publishes.
+ */
+export const GenerateObjectResponseSchema = createSuccessResponseSchema({
+    object: optional(any()),
+    schemaId: optional(string()),
+    finishReason: optional(string()),
+    usage: optional(UsageSchema),
+    route: optional(RouteOutcomeSchema),
+    latencyMs: optional(number()),
+});
+/**
+ * The events a streamed completion emits, as SSE `event:` names.
+ *
+ * `route` arrives first and only once, naming the provider that got the
+ * request. It is sent before the first token because that is the last moment at
+ * which the answer is still honest: fallback is possible only until bytes have
+ * been written, so a stream that failed over would have to retract a route it
+ * had already claimed. After the first `delta`, a failure ends the stream with
+ * `error` and nothing is retried.
+ */
+export const STREAM_EVENTS = ["route", "delta", "done", "error"];
+export const StreamEventSchema = picklist(STREAM_EVENTS);
+//# sourceMappingURL=inference.js.map

package/dist/inference.js.map

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

package/dist/preference.d.ts

@@ -0,0 +1,49 @@
+import { type ProviderTier } from "./provider.js";
+/**
+ * The two folds that turn a stored preference into the order a request is
+ * actually tried in.
+ *
+ * They live in this package rather than in the service because the console
+ * renders the same fold: the preset editor shows the resulting order as the
+ * operator drags rows, and a second copy of the rule in Vue is a copy that
+ * eventually disagrees with the one the request takes. Getting an order the
+ * editor never showed is the worst way to learn a preference was misread.
+ */
+/**
+ * A preference REORDERS the tiers; it never filters them.
+ *
+ * The tiers named come first, in the order given; every other tier follows in
+ * the built-in order. That total is deliberate. A preference is a stored
+ * document, so one written before a tier existed would otherwise make that tier
+ * permanently unreachable for the preset that holds it, with nothing on screen
+ * saying so; and an operator dragging a tier off a list means "last", not
+ * "never" (a tier they actually want off is switched off at the provider,
+ * where the effect is visible).
+ *
+ * @example
+ * ```ts
+ * import { orderedTierPreference } from '@game-infra/ai-schemas'
+ *
+ * orderedTierPreference(['umbrella'])
+ * // ['umbrella', 'subscription', 'direct', 'local']
+ * ```
+ */
+export declare function orderedTierPreference(preference: readonly ProviderTier[] | undefined): ProviderTier[];
+/**
+ * Rank providers inside one tier.
+ *
+ * Named providers come first in the order given. The rest follow sorted by
+ * their own id, which matters more than it looks: the alternative is database
+ * order, so two deployments configured with the same providers in a different
+ * sequence would route differently while both presets read identically.
+ *
+ * @example
+ * ```ts
+ * import { orderedProviderPreference } from '@game-infra/ai-schemas'
+ *
+ * orderedProviderPreference(['openrouter'], ['workers-ai', 'bifrost', 'openrouter'])
+ * // ['openrouter', 'bifrost', 'workers-ai']
+ * ```
+ */
+export declare function orderedProviderPreference(preference: readonly string[] | undefined, available: readonly string[]): string[];
+//# sourceMappingURL=preference.d.ts.map

package/dist/preference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preference.d.ts","sourceRoot":"","sources":["../src/preference.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAE3F;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,GAC9C,YAAY,EAAE,CAehB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACzC,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,MAAM,EAAE,CAOV"}