@cherrystudio/provider-registry 0.0.0-stage → 0.1.1

package/dist/model-NFEbqWMs.mjs

@@ -0,0 +1,665 @@
+import * as z from "zod";
+//#region src/schemas/enums.ts
+/**
+* Canonical enum definitions for the registry system.
+*
+* These are the SINGLE SOURCE OF TRUTH for all enum types.
+* Uses `as const` objects with kebab-case string values for debuggability.
+*
+* - registry/schemas/ uses these via z.enum()
+* - shared/data/types/ re-exports these directly
+*/
+const ENDPOINT_TYPE = {
+	ANTHROPIC_MESSAGES: "anthropic-messages",
+	GOOGLE_GENERATE_CONTENT: "google-generate-content",
+	JINA_RERANK: "jina-rerank",
+	OLLAMA_CHAT: "ollama-chat",
+	OLLAMA_GENERATE: "ollama-generate",
+	OPENAI_AUDIO_TRANSCRIPTION: "openai-audio-transcription",
+	OPENAI_AUDIO_TRANSLATION: "openai-audio-translation",
+	OPENAI_CHAT_COMPLETIONS: "openai-chat-completions",
+	OPENAI_EMBEDDINGS: "openai-embeddings",
+	OPENAI_IMAGE_EDIT: "openai-image-edit",
+	OPENAI_IMAGE_GENERATION: "openai-image-generation",
+	OPENAI_RESPONSES: "openai-responses",
+	OPENAI_TEXT_COMPLETIONS: "openai-text-completions",
+	OPENAI_TEXT_TO_SPEECH: "openai-text-to-speech",
+	OPENAI_VIDEO_GENERATION: "openai-video-generation"
+};
+const MODEL_CAPABILITY = {
+	FUNCTION_CALL: "function-call",
+	REASONING: "reasoning",
+	IMAGE_RECOGNITION: "image-recognition",
+	IMAGE_GENERATION: "image-generation",
+	AUDIO_RECOGNITION: "audio-recognition",
+	AUDIO_GENERATION: "audio-generation",
+	EMBEDDING: "embedding",
+	RERANK: "rerank",
+	AUDIO_TRANSCRIPT: "audio-transcript",
+	VIDEO_RECOGNITION: "video-recognition",
+	VIDEO_GENERATION: "video-generation",
+	STRUCTURED_OUTPUT: "structured-output",
+	FILE_INPUT: "file-input",
+	CODE_EXECUTION: "code-execution",
+	FILE_SEARCH: "file-search",
+	COMPUTER_USE: "computer-use"
+};
+const SERVER_TOOL = {
+	WEB_SEARCH: "web-search",
+	URL_CONTEXT: "url-context"
+};
+const SERVER_TOOL_MODEL_SCOPE = {
+	/** The provider supplies the tool for every chat model it serves. */
+	ALL_CHAT_MODELS: "all-chat-models",
+	/** Tool-specific model eligibility must also pass. */
+	MODEL_DEPENDENT: "model-dependent"
+};
+/**
+* The closed vocabulary of image-generation param keys. A model declares a
+* subset of these under `imageGeneration.modes[mode].supports` (see
+* `ImageModeDefSchema`), and they flow end-to-end as `painting.params` keys.
+*
+* Unlike the other enums, the VALUES are camelCase on purpose: they ARE the
+* runtime param-bag keys and must match `painting.params`/registry data
+* verbatim — do NOT kebab-case them (it would break the wire contract).
+*
+* This is the single source of truth that ties together the registry schema,
+* the form's `KEY_LABELS`/`OPTION_LABELS`, and `canonicalGenerate`'s
+* `POSITIONAL_RENAME`. Adding a new canonical param is a deliberate change:
+* add the member here, give it a label in `KEY_LABELS`, and declare it on the
+* relevant models in registry data.
+*/
+const CANONICAL_PARAM_KEY = {
+	ADD_WATERMARK: "addWatermark",
+	ASPECT_RATIO: "aspectRatio",
+	BACKGROUND: "background",
+	BOTTOM_SCALE: "bottomScale",
+	CFG: "cfg",
+	CUSTOM_SIZE: "customSize",
+	DETAIL: "detail",
+	ENABLE_INTERLEAVE: "enableInterleave",
+	FUNCTION: "function",
+	GUIDANCE_SCALE: "guidanceScale",
+	IMAGE_RESOLUTION: "imageResolution",
+	IMAGE_WEIGHT: "imageWeight",
+	IS_SKETCH: "isSketch",
+	LEFT_SCALE: "leftScale",
+	MAGIC_PROMPT_OPTION: "magicPromptOption",
+	MAX_IMAGES: "maxImages",
+	MODERATION: "moderation",
+	NEGATIVE_PROMPT: "negativePrompt",
+	NUM_IMAGES: "numImages",
+	NUM_INFERENCE_STEPS: "numInferenceSteps",
+	OUTPUT_FORMAT: "outputFormat",
+	OUTPUT_COMPRESSION: "outputCompression",
+	PERSON_GENERATION: "personGeneration",
+	PROMPT_ENHANCEMENT: "promptEnhancement",
+	PROMPT_EXTEND: "promptExtend",
+	QUALITY: "quality",
+	RESOLUTION: "resolution",
+	REF_MODE: "refMode",
+	REF_STRENGTH: "refStrength",
+	RENDERING_SPEED: "renderingSpeed",
+	RESEMBLANCE: "resemblance",
+	RIGHT_SCALE: "rightScale",
+	SAFETY_TOLERANCE: "safetyTolerance",
+	SEED: "seed",
+	SEQUENTIAL_IMAGE_GENERATION: "sequentialImageGeneration",
+	SIZE: "size",
+	SOURCE_LANG: "sourceLang",
+	STRENGTH: "strength",
+	STYLE: "style",
+	STYLE_TYPE: "styleType",
+	TARGET_LANG: "targetLang",
+	THINKING_MODE: "thinkingMode",
+	TOP_SCALE: "topScale",
+	UPSCALE_FACTOR: "upscaleFactor"
+};
+const MODALITY = {
+	TEXT: "text",
+	IMAGE: "image",
+	AUDIO: "audio",
+	VIDEO: "video",
+	VECTOR: "vector"
+};
+const CURRENCY = {
+	USD: "USD",
+	CNY: "CNY"
+};
+const REASONING_EFFORT = {
+	NONE: "none",
+	MINIMAL: "minimal",
+	LOW: "low",
+	MEDIUM: "medium",
+	HIGH: "high",
+	XHIGH: "xhigh",
+	MAX: "max",
+	ULTRA: "ultra",
+	AUTO: "auto"
+};
+/**
+* Intensity ladder for nearest-match fallback when a persisted effort is not
+* in a model's vocabulary (model switch / vocabulary shrink). `auto` is
+* deliberately last — it is a mode, not an intensity.
+*/
+const REASONING_EFFORT_ORDER = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"ultra",
+	"auto"
+];
+/** Extract the value tuple from a const object for use with z.enum(). */
+function objectValues(obj) {
+	return Object.values(obj);
+}
+//#endregion
+//#region src/schemas/common.ts
+/**
+* Common type definitions for the registry system
+* Shared across model, provider, and override schemas
+*/
+const EndpointTypeSchema = z.enum(objectValues(ENDPOINT_TYPE));
+const ModelIdSchema = z.string().min(1);
+const ProviderIdSchema = z.string().min(1);
+/**
+* Opaque change-detection token for a generated artifact. The generator stamps it with a hash of the
+* artifact's content, so equal content ⇒ equal version and ANY content change ⇒ new version — that's
+* the contract seeders rely on (`SeedRunner` skips a seeder whose journal version matches). Older
+* artifacts carried a generation date; treat the value as opaque, never parse it.
+*/
+const VersionSchema = z.string().min(1);
+z.iso.datetime();
+const NumericRangeSchema = z.object({
+	min: z.number(),
+	max: z.number()
+}).refine((r) => r.min <= r.max, { message: "min must be less than or equal to max" });
+z.object({
+	min: z.string(),
+	max: z.string()
+});
+const ZodCurrencySchema = z.enum(objectValues(CURRENCY)).optional();
+const PricePerTokenSchema = z.object({
+	perMillionTokens: z.number().nonnegative().nullable(),
+	currency: ZodCurrencySchema
+});
+const MetadataSchema = z.record(z.string(), z.unknown()).optional();
+//#endregion
+//#region src/schemas/forwardCompat.ts
+/**
+* Forward compatibility for the wire contract — a catalog emitted by a NEWER
+* generator must stay readable by THIS client.
+*
+* `z.object` already strips unknown keys, so additive fields were always safe.
+* The remaining break was vocabulary growth: one unknown member of a closed
+* `z.enum` failed its whole document, which is why every new effort/capability
+* used to force a {@link REGISTRY_SCHEMA_VERSION} bump. {@link looseArray}
+* degrades that failure to the smallest unit that can be dropped:
+*
+*  - inside a list of enum values → drop the unknown member, keep the entry
+*  - inside a list of entries (models/providers/overrides) → drop the entry
+*    the client cannot represent, keep the rest of the catalog
+*
+* Values this client cannot *execute* (a new adapter family, endpoint type,
+* wire behavior) are still gated — by `REGISTRY_MIN_APP_VERSION`, not by
+* parse failure.
+*/
+/**
+* Like `z.array(item)`, but silently drops members that fail to parse.
+*
+* @param min Minimum members required AFTER dropping — the entry is rejected
+* (and dropped by its own enclosing `looseArray`) when too few survive.
+*/
+function looseArray(item, { min } = {}) {
+	const array = z.array(z.unknown()).transform((values) => values.reduce((kept, value) => {
+		const parsed = item.safeParse(value);
+		if (parsed.success) kept.push(parsed.data);
+		return kept;
+	}, []));
+	return min === void 0 ? array : array.refine((values) => values.length >= min, { message: `expected at least ${min} recognized value(s)` });
+}
+//#endregion
+//#region src/schemas/model.ts
+/**
+* Model configuration schema definitions
+* Defines the structure for model metadata, capabilities, and configurations
+*/
+const ModalitySchema = z.enum(objectValues(MODALITY));
+const ModelCapabilityTypeSchema = z.enum(objectValues(MODEL_CAPABILITY));
+const CanonicalParamKeySchema = z.enum(objectValues(CANONICAL_PARAM_KEY));
+const ThinkingTokenLimitsSchema = z.object({
+	min: z.number().nonnegative().optional(),
+	max: z.number().positive().optional(),
+	default: z.number().nonnegative().optional()
+}).refine((d) => d.min == null === (d.max == null), { message: "min and max must be both present or both absent" }).refine((d) => d.min == null || d.max == null || d.min <= d.max, { message: "min must be less than or equal to max" });
+/** Reasoning effort levels shared across providers */
+const ReasoningEffortSchema = z.enum(objectValues(REASONING_EFFORT));
+/**
+* Per-model reasoning control declaration — the SOURCE from which the legacy
+* pair (`supportedEfforts` / `thinkingTokenLimits`) is DERIVED at generation
+* time (`deriveLegacyReasoningFields`). Kinds align 1:1 with models.dev
+* `reasoning_options` so upstream ingestion is lossless.
+*/
+const ReasoningControlSchema = z.discriminatedUnion("kind", [
+	z.object({
+		/** Discrete effort knob. `values` is the model's intrinsic vocabulary, in
+		*  UI display order. The active endpoint profile may map those values to a
+		*  narrower wire vocabulary (`'none'` present ⇔ reasoning can be disabled). */
+		kind: z.literal("effort"),
+		values: looseArray(ReasoningEffortSchema, { min: 1 }),
+		default: ReasoningEffortSchema.optional()
+	}),
+	z.object({
+		/** Numeric thinking-token budget knob. */
+		kind: z.literal("budget"),
+		min: z.number().nonnegative(),
+		max: z.number().positive(),
+		default: z.number().nonnegative().optional()
+	}),
+	z.object({
+		/** On/off only — no effort levels, no budget. */
+		kind: z.literal("toggle"),
+		default: z.boolean().optional()
+	})
+]);
+/**
+* Which dialect variant of its endpoint's native protocol a model generation
+* speaks. NOT a wire format — the format still follows the serving endpoint.
+* This only disambiguates when one protocol carries two mutually exclusive
+* parameter shapes across model generations, and the older generation
+* hard-rejects the newer field:
+*  - `google-generate-content`: Gemini 3 `thinkingLevel` vs 2.x `thinkingBudget`
+*  - `anthropic-messages`: Claude 4.6+ `thinking.type=adaptive` vs <=4.5
+*    `thinking.type=enabled` + `budget_tokens`
+*
+* Opus 5.5 always uses adaptive thinking; Sonnet 5.5 also supports `between_tools`.
+* It has effect only where the format profile declares the matching alternative, so open-weight models on openai-compatible endpoints are
+* unaffected (their dialect really does follow the provider — see the rule
+* on {@link ReasoningFamilyRuleSchema}).
+*/
+const ReasoningWireDialectSchema = z.enum([
+	"effort",
+	"budget",
+	"adaptive-always",
+	"adaptive-between-tools"
+]);
+/**
+* A creator-declared reasoning FAMILY rule — ID-pattern knowledge as DATA
+* (#16598). Creators declare these next to their models (`Creator.
+* reasoningFamilies`); generation compiles them into per-model `controls`
+* and the shipped `patterns/reasoning-families.gen.ts` artifact consumed by
+* the zero-knowledge matchers.
+*
+* Every rule is one of two semantic kinds:
+*  - PROFILE (default): "this pattern IS a reasoning SKU (with knobs K)".
+*    Membership is implied — the ingest gate (`inferReasoningMembership`)
+*    accepts any id a profile rule matches. A profile may carry no knobs at
+*    all (a fixed reasoner: reasons, nothing to tune).
+*  - TEMPLATE (`template: true`): "models of this family that DO reason use
+*    knob shape K". Deliberately broader than membership (e.g. the `^qwen`
+*    toggle) — contributes knobs only, never membership; SKUs are admitted
+*    by profile rules, the generic id shapes, or a declared capability.
+*
+* A rule carries MODEL KNOBS ONLY — never a reasoning format/wire field:
+* open-weight models are served by many providers and the serialization
+* dialect follows the serving endpoint, not a runtime model-id match. The one
+* narrow exception is `wireDialect`, which does NOT name a format: it picks
+* between the generation-dialects a single first-party protocol defines
+* for itself (see {@link ReasoningWireDialectSchema}). That fact is the
+* vendor's own API contract and holds across every provider proxying it, so
+* it belongs to the model, not the endpoint.
+*
+* Matching: `pattern` is a case-insensitive regex SOURCE tested against the
+* lowercased, namespace-stripped id (vocabulary part) and the raw id string
+* (budget part — token-limit callers pass `provider::model` unique ids, so
+* budget-only rules should stay unanchored). Patterns must be
+* vendor-specific (same discipline as `idPrefixes`). Within a creator,
+* declaration order is match priority — first rule wins per part.
+*/
+const compilableRegexSource = z.string().refine((source) => {
+	try {
+		new RegExp(source, "i");
+		return true;
+	} catch {
+		return false;
+	}
+}, { message: "pattern must be a valid regular expression" });
+z.object({
+	/** Case-insensitive regex source. Must compile. */
+	pattern: compilableRegexSource,
+	/** Intrinsic effort vocabulary, in UI display order. */
+	effort: looseArray(ReasoningEffortSchema, { min: 1 }).optional(),
+	/**
+	* Thinking on/off switch. `false` is an EXPLICIT "always-on, no switch"
+	* declaration that stops broader family rules below from applying
+	* (e.g. qwen3 `*-thinking` SKUs vs the generic qwen toggle).
+	*/
+	toggle: z.boolean().optional(),
+	/** Thinking-token budget range. */
+	budget: z.object({
+		min: z.number().nonnegative(),
+		max: z.number().positive()
+	}).refine((b) => b.min <= b.max, { message: "budget min must be <= max" }).optional(),
+	/** Knob-shape template for a broad family — contributes NO membership. */
+	template: z.literal(true).optional(),
+	/** Native-protocol dialect for this model generation. */
+	wireDialect: ReasoningWireDialectSchema.optional()
+}).refine((rule) => rule.template !== true || rule.effort !== void 0 || rule.toggle !== void 0 || rule.budget !== void 0 || rule.wireDialect !== void 0, { message: "a template rule with no knobs declares nothing — drop it or make it a profile" });
+const CommonReasoningFieldsSchema = {
+	/** Source of truth for the model's reasoning knobs (at most one per kind).
+	*  The legacy fields below are DERIVED from it when present. */
+	controls: looseArray(ReasoningControlSchema).optional(),
+	thinkingTokenLimits: ThinkingTokenLimitsSchema.optional(),
+	supportedEfforts: looseArray(ReasoningEffortSchema).optional(),
+	/** What the API does when no reasoning param is sent. */
+	defaultEffort: ReasoningEffortSchema.optional(),
+	/** Native-protocol dialect this model generation speaks, when its protocol
+	*  defines more than one. Selects the endpoint profile's wire variant. */
+	wireDialect: ReasoningWireDialectSchema.optional()
+};
+/**
+* Reasoning support schema — describes model-level reasoning capabilities.
+*
+* This only captures WHAT the model supports (effort levels, token limits).
+* HOW to invoke reasoning is defined by the provider's reasoning format
+* (see provider.ts ProviderReasoningFormatSchema).
+*/
+const ReasoningSupportSchema = z.object({ ...CommonReasoningFieldsSchema }).superRefine((r, ctx) => {
+	const kinds = (r.controls ?? []).map((c) => c.kind);
+	if (new Set(kinds).size !== kinds.length) ctx.addIssue({
+		code: "custom",
+		message: "at most one reasoning control per kind"
+	});
+	for (const c of r.controls ?? []) {
+		if (c.kind === "effort" && c.default != null && !c.values.includes(c.default)) ctx.addIssue({
+			code: "custom",
+			message: "effort default must be a member of values"
+		});
+		if (c.kind === "budget" && (c.min > c.max || c.default != null && (c.default < c.min || c.default > c.max))) ctx.addIssue({
+			code: "custom",
+			message: "budget range must satisfy min <= default <= max"
+		});
+	}
+});
+/**
+* Image-generation support describes what controls a model accepts, in a
+* shape uniform across all models so the painting page can render the
+* right controls without per-vendor branching.
+*
+* `supports` is a flat map of canonical param keys to widget specs — the
+* renderer dispatches by `spec.type`. `size` / `numImages` / `customSize`
+* are no longer top-level fields; they're entries inside `supports` like
+* everything else. `modes` is `Record<Mode, ModeDef>` (always an object,
+* never an array) so single-mode models declare `{ generate: { ... } }`
+* uniformly; multi-mode models with different params per mode (Ideogram
+* V_*) declare each mode's complete `ModeDef` explicitly.
+*
+* Vendor wire transforms (snake_case keys, `'ASPECT_X_Y' → 'X:Y'` strings,
+* `Uint8Array → base64`) live in the AI SDK image-model adapters under
+* `aiCore/provider/custom/`; this schema carries canonical names only.
+* Per-mode transport routing (PPIO endpoint URL + sync/async flag) lives
+* on `ModeDef.vendorTransport` so it travels with the registry data.
+*/
+const ImageGenerationModeSchema = z.enum([
+	"generate",
+	"edit",
+	"remix",
+	"upscale",
+	"merge"
+]);
+const SwitchSpecSchema = z.object({
+	type: z.literal("switch"),
+	default: z.boolean().optional()
+});
+const EnumSpecSchema = z.object({
+	type: z.literal("enum"),
+	options: z.array(z.string()).min(1),
+	default: z.string().optional(),
+	/** `'chips'` for compact button rows (size / aspectRatio / imageResolution);
+	*  defaults to `'select'` (dropdown) when omitted. */
+	render: z.enum(["select", "chips"]).optional(),
+	columns: z.number().int().positive().optional()
+});
+const RangeSpecSchema = z.object({
+	type: z.literal("range"),
+	min: z.number(),
+	max: z.number(),
+	default: z.number().optional(),
+	/** Omitted means the numeric input accepts any precision; renderers may
+	*  still choose an interaction step for controls such as sliders. */
+	step: z.number().optional()
+}).refine((r) => r.min <= r.max, { message: "min must be ≤ max" });
+const RangeIntSpecSchema = z.object({
+	type: z.literal("range"),
+	min: z.number().int(),
+	max: z.number().int(),
+	default: z.number().int().optional(),
+	step: z.number().int().positive().default(1)
+}).refine((r) => r.min <= r.max, { message: "min must be ≤ max" });
+const SizeSpecSchema = z.object({
+	type: z.literal("size"),
+	/** Both width and height share this bound. */
+	minSide: z.number(),
+	maxSide: z.number(),
+	/** When set, the size widget only renders when the named enum is at
+	*  `'custom'` (CogView pattern: pick the `'custom'` chip on the size
+	*  enum to reveal width/height inputs). */
+	pairedEnumKey: z.string().optional()
+});
+const TextSpecSchema = z.object({
+	type: z.literal("text"),
+	multiline: z.boolean().optional()
+});
+const SupportSpecSchema = z.discriminatedUnion("type", [
+	SwitchSpecSchema,
+	EnumSpecSchema,
+	RangeSpecSchema,
+	SizeSpecSchema,
+	TextSpecSchema
+]);
+const INTEGER_RANGE_PARAM_KEYS = [
+	CANONICAL_PARAM_KEY.NUM_IMAGES,
+	CANONICAL_PARAM_KEY.MAX_IMAGES,
+	CANONICAL_PARAM_KEY.NUM_INFERENCE_STEPS,
+	CANONICAL_PARAM_KEY.SAFETY_TOLERANCE,
+	CANONICAL_PARAM_KEY.OUTPUT_COMPRESSION
+];
+const ImageSupportsSchema = z.partialRecord(CanonicalParamKeySchema, SupportSpecSchema).transform((supports, ctx) => {
+	const normalized = { ...supports };
+	for (const key of INTEGER_RANGE_PARAM_KEYS) {
+		const spec = supports[key];
+		if (spec === void 0) continue;
+		const result = RangeIntSpecSchema.safeParse(spec);
+		if (result.success) normalized[key] = result.data;
+		else for (const issue of result.error.issues) ctx.addIssue({
+			...issue,
+			path: [key, ...issue.path]
+		});
+	}
+	return normalized;
+});
+/**
+* Per-mode model capability declaration. The renderer iterates `supports`
+* and dispatches `specToField` by `spec.type`; no per-vendor logic. `supports`
+* keys are drawn from the closed `CanonicalParamKey` vocabulary (see
+* `CANONICAL_PARAM_KEY` in `enums.ts`) — an unknown key fails to parse, and
+* the same vocabulary types the form's `KEY_LABELS`/`OPTION_LABELS` and
+* `canonicalGenerate`'s `POSITIONAL_RENAME`, so a typo/rename is a compile or
+* parse error rather than a silent raw-key render. Adding a new canonical
+* param: (1) add the member to `CANONICAL_PARAM_KEY`, (2) add a label to
+* `KEY_LABELS` in `imageGenerationToFields`, (3) declare it on models'
+* `supports`.
+*
+* `vendorTransport` carries PPIO-style per-model endpoint routing — the
+* AI SDK adapter for that vendor reads endpoint + isSync off the registry
+* instead of a hand-maintained routing table.
+*/
+const ImageModeDefSchema = z.object({
+	supports: ImageSupportsSchema,
+	maxInputImages: z.number().int().positive().optional(),
+	vendorTransport: z.object({
+		endpoint: z.string().regex(/^\/(?!\/)/, "vendor transport endpoint must be a root-relative path, not a URL"),
+		isSync: z.boolean().optional()
+	}).optional(),
+	/**
+	* When `false`, the generic painting pipeline does NOT enforce a non-empty
+	* `painting.prompt` before submitting. Set on models like DashScope's
+	* `qwen-mt-image` (image-text translation: no prompt, just source/target
+	* languages) or PPIO's image-upscaler / image-eraser / image-remove-bg
+	* variants. Default is `true` (prompt required).
+	*/
+	requirePrompt: z.boolean().optional()
+});
+const ImageGenerationSupportSchema = z.object({ modes: z.partialRecord(ImageGenerationModeSchema, ImageModeDefSchema) });
+const ParameterSupportSchema = z.object({
+	temperature: z.object({
+		supported: z.boolean(),
+		range: NumericRangeSchema.optional()
+	}).default({ supported: true }),
+	topP: z.object({
+		supported: z.boolean(),
+		range: NumericRangeSchema.optional()
+	}).default({ supported: true }),
+	topK: z.object({
+		supported: z.boolean(),
+		range: NumericRangeSchema.optional()
+	}).default({ supported: false }),
+	frequencyPenalty: z.boolean().default(true),
+	presencePenalty: z.boolean().default(true),
+	maxTokens: z.boolean().default(true),
+	stopSequences: z.boolean().default(true),
+	systemMessage: z.boolean().default(true)
+});
+/**
+* Model pricing configuration.
+*
+* Pricing tiers based on actual provider billing models:
+* - input/output per-token: OpenAI, Anthropic, Google, all major LLM providers
+* - cacheRead/cacheWrite: Anthropic prompt caching, OpenAI cached tokens
+* - perImage: DALL-E (per-image), Midjourney (per-image)
+* - perMinute: Whisper, ElevenLabs (per-minute audio billing)
+*/
+const ModelPricingObjectSchema = z.object({
+	input: PricePerTokenSchema,
+	output: PricePerTokenSchema,
+	cacheRead: PricePerTokenSchema.optional(),
+	cacheWrite: PricePerTokenSchema.optional(),
+	inputTokenTiers: z.array(z.object({
+		minInputTokens: z.number().int().positive().refine(Number.isSafeInteger),
+		input: PricePerTokenSchema,
+		output: PricePerTokenSchema,
+		cacheRead: PricePerTokenSchema.optional(),
+		cacheWrite: PricePerTokenSchema.optional()
+	})).optional(),
+	perImage: z.object({
+		price: z.number(),
+		currency: ZodCurrencySchema,
+		unit: z.enum(["image", "pixel"]).optional()
+	}).optional(),
+	perMinute: z.object({
+		price: z.number(),
+		currency: ZodCurrencySchema
+	}).optional()
+});
+function validateInputTokenPricingTiers(pricing, ctx) {
+	for (let index = 1; index < (pricing.inputTokenTiers?.length ?? 0); index++) if (pricing.inputTokenTiers[index].minInputTokens <= pricing.inputTokenTiers[index - 1].minInputTokens) ctx.addIssue({
+		code: "custom",
+		path: [
+			"inputTokenTiers",
+			index,
+			"minInputTokens"
+		],
+		message: "minInputTokens must be strictly increasing"
+	});
+	if (!pricing.inputTokenTiers?.length) return;
+	const rates = [
+		...pricing.input ? [{
+			rate: pricing.input,
+			path: ["input"]
+		}] : [],
+		...pricing.output ? [{
+			rate: pricing.output,
+			path: ["output"]
+		}] : [],
+		...pricing.cacheRead ? [{
+			rate: pricing.cacheRead,
+			path: ["cacheRead"]
+		}] : [],
+		...pricing.cacheWrite ? [{
+			rate: pricing.cacheWrite,
+			path: ["cacheWrite"]
+		}] : [],
+		...pricing.inputTokenTiers.flatMap((tier, index) => [
+			{
+				rate: tier.input,
+				path: [
+					"inputTokenTiers",
+					index,
+					"input"
+				]
+			},
+			{
+				rate: tier.output,
+				path: [
+					"inputTokenTiers",
+					index,
+					"output"
+				]
+			},
+			...tier.cacheRead ? [{
+				rate: tier.cacheRead,
+				path: [
+					"inputTokenTiers",
+					index,
+					"cacheRead"
+				]
+			}] : [],
+			...tier.cacheWrite ? [{
+				rate: tier.cacheWrite,
+				path: [
+					"inputTokenTiers",
+					index,
+					"cacheWrite"
+				]
+			}] : []
+		])
+	];
+	const currency = rates[0]?.rate.currency ?? CURRENCY.USD;
+	for (const { rate, path } of rates) if ((rate.currency ?? CURRENCY.USD) !== currency) ctx.addIssue({
+		code: "custom",
+		path: [...path, "currency"],
+		message: "pricing currencies must match"
+	});
+}
+const ModelPricingSchema = ModelPricingObjectSchema.superRefine(validateInputTokenPricingTiers);
+const PartialModelPricingSchema = ModelPricingObjectSchema.partial().superRefine(validateInputTokenPricingTiers);
+const ModelConfigSchema = z.object({
+	id: ModelIdSchema,
+	name: z.string(),
+	description: z.string().optional(),
+	capabilities: looseArray(ModelCapabilityTypeSchema).refine((arr) => new Set(arr).size === arr.length, { message: "Capabilities must be unique" }).optional(),
+	inputModalities: looseArray(ModalitySchema).refine((arr) => new Set(arr).size === arr.length, { message: "Input modalities must be unique" }).optional(),
+	outputModalities: looseArray(ModalitySchema).refine((arr) => new Set(arr).size === arr.length, { message: "Output modalities must be unique" }).optional(),
+	endpointTypes: looseArray(EndpointTypeSchema).optional(),
+	contextWindow: z.number().optional(),
+	maxOutputTokens: z.number().optional(),
+	maxInputTokens: z.number().optional(),
+	pricing: ModelPricingSchema.optional(),
+	reasoning: ReasoningSupportSchema.optional(),
+	parameterSupport: ParameterSupportSchema.optional(),
+	imageGeneration: ImageGenerationSupportSchema.optional(),
+	family: z.string().optional(),
+	ownedBy: z.string().optional(),
+	openWeights: z.boolean().optional(),
+	metadata: MetadataSchema
+});
+const ModelListSchema = z.object({
+	version: VersionSchema,
+	models: looseArray(ModelConfigSchema)
+});
+//#endregion
+export { REASONING_EFFORT as C, objectValues as D, SERVER_TOOL_MODEL_SCOPE as E, MODEL_CAPABILITY as S, SERVER_TOOL as T, ZodCurrencySchema as _, ModelConfigSchema as a, ENDPOINT_TYPE as b, PartialModelPricingSchema as c, looseArray as d, EndpointTypeSchema as f, VersionSchema as g, ProviderIdSchema as h, ModelCapabilityTypeSchema as i, ReasoningControlSchema as l, ModelIdSchema as m, ImageGenerationSupportSchema as n, ModelListSchema as o, MetadataSchema as p, ModalitySchema as r, ParameterSupportSchema as s, ImageGenerationModeSchema as t, ReasoningSupportSchema as u, CANONICAL_PARAM_KEY as v, REASONING_EFFORT_ORDER as w, MODALITY as x, CURRENCY as y };