@cherrystudio/provider-registry 0.0.0-stage → 0.1.1

package/dist/model-kwW2vWDI.cjs

@@ -0,0 +1,855 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let zod = require("zod");
+zod = __toESM(zod, 1);
+//#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 = zod.enum(objectValues(ENDPOINT_TYPE));
+const ModelIdSchema = zod.string().min(1);
+const ProviderIdSchema = zod.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 = zod.string().min(1);
+zod.iso.datetime();
+const NumericRangeSchema = zod.object({
+	min: zod.number(),
+	max: zod.number()
+}).refine((r) => r.min <= r.max, { message: "min must be less than or equal to max" });
+zod.object({
+	min: zod.string(),
+	max: zod.string()
+});
+const ZodCurrencySchema = zod.enum(objectValues(CURRENCY)).optional();
+const PricePerTokenSchema = zod.object({
+	perMillionTokens: zod.number().nonnegative().nullable(),
+	currency: ZodCurrencySchema
+});
+const MetadataSchema = zod.record(zod.string(), zod.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 = zod.array(zod.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 = zod.enum(objectValues(MODALITY));
+const ModelCapabilityTypeSchema = zod.enum(objectValues(MODEL_CAPABILITY));
+const CanonicalParamKeySchema = zod.enum(objectValues(CANONICAL_PARAM_KEY));
+const ThinkingTokenLimitsSchema = zod.object({
+	min: zod.number().nonnegative().optional(),
+	max: zod.number().positive().optional(),
+	default: zod.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 = zod.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 = zod.discriminatedUnion("kind", [
+	zod.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: zod.literal("effort"),
+		values: looseArray(ReasoningEffortSchema, { min: 1 }),
+		default: ReasoningEffortSchema.optional()
+	}),
+	zod.object({
+		/** Numeric thinking-token budget knob. */
+		kind: zod.literal("budget"),
+		min: zod.number().nonnegative(),
+		max: zod.number().positive(),
+		default: zod.number().nonnegative().optional()
+	}),
+	zod.object({
+		/** On/off only — no effort levels, no budget. */
+		kind: zod.literal("toggle"),
+		default: zod.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 = zod.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 = zod.string().refine((source) => {
+	try {
+		new RegExp(source, "i");
+		return true;
+	} catch {
+		return false;
+	}
+}, { message: "pattern must be a valid regular expression" });
+zod.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: zod.boolean().optional(),
+	/** Thinking-token budget range. */
+	budget: zod.object({
+		min: zod.number().nonnegative(),
+		max: zod.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: zod.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 = zod.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 = zod.enum([
+	"generate",
+	"edit",
+	"remix",
+	"upscale",
+	"merge"
+]);
+const SwitchSpecSchema = zod.object({
+	type: zod.literal("switch"),
+	default: zod.boolean().optional()
+});
+const EnumSpecSchema = zod.object({
+	type: zod.literal("enum"),
+	options: zod.array(zod.string()).min(1),
+	default: zod.string().optional(),
+	/** `'chips'` for compact button rows (size / aspectRatio / imageResolution);
+	*  defaults to `'select'` (dropdown) when omitted. */
+	render: zod.enum(["select", "chips"]).optional(),
+	columns: zod.number().int().positive().optional()
+});
+const RangeSpecSchema = zod.object({
+	type: zod.literal("range"),
+	min: zod.number(),
+	max: zod.number(),
+	default: zod.number().optional(),
+	/** Omitted means the numeric input accepts any precision; renderers may
+	*  still choose an interaction step for controls such as sliders. */
+	step: zod.number().optional()
+}).refine((r) => r.min <= r.max, { message: "min must be ≤ max" });
+const RangeIntSpecSchema = zod.object({
+	type: zod.literal("range"),
+	min: zod.number().int(),
+	max: zod.number().int(),
+	default: zod.number().int().optional(),
+	step: zod.number().int().positive().default(1)
+}).refine((r) => r.min <= r.max, { message: "min must be ≤ max" });
+const SizeSpecSchema = zod.object({
+	type: zod.literal("size"),
+	/** Both width and height share this bound. */
+	minSide: zod.number(),
+	maxSide: zod.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: zod.string().optional()
+});
+const TextSpecSchema = zod.object({
+	type: zod.literal("text"),
+	multiline: zod.boolean().optional()
+});
+const SupportSpecSchema = zod.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 = zod.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 = zod.object({
+	supports: ImageSupportsSchema,
+	maxInputImages: zod.number().int().positive().optional(),
+	vendorTransport: zod.object({
+		endpoint: zod.string().regex(/^\/(?!\/)/, "vendor transport endpoint must be a root-relative path, not a URL"),
+		isSync: zod.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: zod.boolean().optional()
+});
+const ImageGenerationSupportSchema = zod.object({ modes: zod.partialRecord(ImageGenerationModeSchema, ImageModeDefSchema) });
+const ParameterSupportSchema = zod.object({
+	temperature: zod.object({
+		supported: zod.boolean(),
+		range: NumericRangeSchema.optional()
+	}).default({ supported: true }),
+	topP: zod.object({
+		supported: zod.boolean(),
+		range: NumericRangeSchema.optional()
+	}).default({ supported: true }),
+	topK: zod.object({
+		supported: zod.boolean(),
+		range: NumericRangeSchema.optional()
+	}).default({ supported: false }),
+	frequencyPenalty: zod.boolean().default(true),
+	presencePenalty: zod.boolean().default(true),
+	maxTokens: zod.boolean().default(true),
+	stopSequences: zod.boolean().default(true),
+	systemMessage: zod.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 = zod.object({
+	input: PricePerTokenSchema,
+	output: PricePerTokenSchema,
+	cacheRead: PricePerTokenSchema.optional(),
+	cacheWrite: PricePerTokenSchema.optional(),
+	inputTokenTiers: zod.array(zod.object({
+		minInputTokens: zod.number().int().positive().refine(Number.isSafeInteger),
+		input: PricePerTokenSchema,
+		output: PricePerTokenSchema,
+		cacheRead: PricePerTokenSchema.optional(),
+		cacheWrite: PricePerTokenSchema.optional()
+	})).optional(),
+	perImage: zod.object({
+		price: zod.number(),
+		currency: ZodCurrencySchema,
+		unit: zod.enum(["image", "pixel"]).optional()
+	}).optional(),
+	perMinute: zod.object({
+		price: zod.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 = zod.object({
+	id: ModelIdSchema,
+	name: zod.string(),
+	description: zod.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: zod.number().optional(),
+	maxOutputTokens: zod.number().optional(),
+	maxInputTokens: zod.number().optional(),
+	pricing: ModelPricingSchema.optional(),
+	reasoning: ReasoningSupportSchema.optional(),
+	parameterSupport: ParameterSupportSchema.optional(),
+	imageGeneration: ImageGenerationSupportSchema.optional(),
+	family: zod.string().optional(),
+	ownedBy: zod.string().optional(),
+	openWeights: zod.boolean().optional(),
+	metadata: MetadataSchema
+});
+const ModelListSchema = zod.object({
+	version: VersionSchema,
+	models: looseArray(ModelConfigSchema)
+});
+//#endregion
+Object.defineProperty(exports, "CANONICAL_PARAM_KEY", {
+	enumerable: true,
+	get: function() {
+		return CANONICAL_PARAM_KEY;
+	}
+});
+Object.defineProperty(exports, "CURRENCY", {
+	enumerable: true,
+	get: function() {
+		return CURRENCY;
+	}
+});
+Object.defineProperty(exports, "ENDPOINT_TYPE", {
+	enumerable: true,
+	get: function() {
+		return ENDPOINT_TYPE;
+	}
+});
+Object.defineProperty(exports, "EndpointTypeSchema", {
+	enumerable: true,
+	get: function() {
+		return EndpointTypeSchema;
+	}
+});
+Object.defineProperty(exports, "ImageGenerationModeSchema", {
+	enumerable: true,
+	get: function() {
+		return ImageGenerationModeSchema;
+	}
+});
+Object.defineProperty(exports, "ImageGenerationSupportSchema", {
+	enumerable: true,
+	get: function() {
+		return ImageGenerationSupportSchema;
+	}
+});
+Object.defineProperty(exports, "MODALITY", {
+	enumerable: true,
+	get: function() {
+		return MODALITY;
+	}
+});
+Object.defineProperty(exports, "MODEL_CAPABILITY", {
+	enumerable: true,
+	get: function() {
+		return MODEL_CAPABILITY;
+	}
+});
+Object.defineProperty(exports, "MetadataSchema", {
+	enumerable: true,
+	get: function() {
+		return MetadataSchema;
+	}
+});
+Object.defineProperty(exports, "ModalitySchema", {
+	enumerable: true,
+	get: function() {
+		return ModalitySchema;
+	}
+});
+Object.defineProperty(exports, "ModelCapabilityTypeSchema", {
+	enumerable: true,
+	get: function() {
+		return ModelCapabilityTypeSchema;
+	}
+});
+Object.defineProperty(exports, "ModelConfigSchema", {
+	enumerable: true,
+	get: function() {
+		return ModelConfigSchema;
+	}
+});
+Object.defineProperty(exports, "ModelIdSchema", {
+	enumerable: true,
+	get: function() {
+		return ModelIdSchema;
+	}
+});
+Object.defineProperty(exports, "ModelListSchema", {
+	enumerable: true,
+	get: function() {
+		return ModelListSchema;
+	}
+});
+Object.defineProperty(exports, "ParameterSupportSchema", {
+	enumerable: true,
+	get: function() {
+		return ParameterSupportSchema;
+	}
+});
+Object.defineProperty(exports, "PartialModelPricingSchema", {
+	enumerable: true,
+	get: function() {
+		return PartialModelPricingSchema;
+	}
+});
+Object.defineProperty(exports, "ProviderIdSchema", {
+	enumerable: true,
+	get: function() {
+		return ProviderIdSchema;
+	}
+});
+Object.defineProperty(exports, "REASONING_EFFORT", {
+	enumerable: true,
+	get: function() {
+		return REASONING_EFFORT;
+	}
+});
+Object.defineProperty(exports, "REASONING_EFFORT_ORDER", {
+	enumerable: true,
+	get: function() {
+		return REASONING_EFFORT_ORDER;
+	}
+});
+Object.defineProperty(exports, "ReasoningControlSchema", {
+	enumerable: true,
+	get: function() {
+		return ReasoningControlSchema;
+	}
+});
+Object.defineProperty(exports, "ReasoningSupportSchema", {
+	enumerable: true,
+	get: function() {
+		return ReasoningSupportSchema;
+	}
+});
+Object.defineProperty(exports, "SERVER_TOOL", {
+	enumerable: true,
+	get: function() {
+		return SERVER_TOOL;
+	}
+});
+Object.defineProperty(exports, "SERVER_TOOL_MODEL_SCOPE", {
+	enumerable: true,
+	get: function() {
+		return SERVER_TOOL_MODEL_SCOPE;
+	}
+});
+Object.defineProperty(exports, "VersionSchema", {
+	enumerable: true,
+	get: function() {
+		return VersionSchema;
+	}
+});
+Object.defineProperty(exports, "ZodCurrencySchema", {
+	enumerable: true,
+	get: function() {
+		return ZodCurrencySchema;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "looseArray", {
+	enumerable: true,
+	get: function() {
+		return looseArray;
+	}
+});
+Object.defineProperty(exports, "objectValues", {
+	enumerable: true,
+	get: function() {
+		return objectValues;
+	}
+});