@cherrystudio/provider-registry 0.0.0-stage → 0.1.1

package/dist/provider-DkSIaann.cjs

@@ -0,0 +1,527 @@
+const require_model = require("./model-kwW2vWDI.cjs");
+let zod = require("zod");
+zod = require_model.__toESM(zod, 1);
+//#region src/patterns/vendor-patterns.ts
+/**
+* Vendor identity regex patterns — the single source of truth for
+* "which vendor does this raw model ID belong to".
+*
+* Shared across three call sites:
+*  - `@shared/utils/model` — vendor check functions (`isAnthropicModel`
+*    etc.) and capability inference (e.g. deciding which IDs to mark
+*    `REASONING` in the schema).
+*  - `@cherrystudio/ui` icon registry — vendor-level icon routing for
+*    models whose ID doesn't have a dedicated SKU icon.
+*  - Future callers doing vendor dispatch.
+*
+* Keeping these regex in the registry layer means both capability
+* inference and icon lookup stay in lockstep when a new vendor /
+* naming convention lands.
+*
+* Scope: **vendor identity only**. SKU-level patterns (`gpt-5.1-codex-mini`,
+* `claude-sonnet-4-6`, etc.) stay in their specific consumer modules —
+* those are dispatch details rather than shared vendor taxonomy.
+*
+* Normalization note: patterns assume the id has already been lowercased
+* and had the leading namespace stripped (e.g. `deepseek/deepseek-r1` →
+* `deepseek-r1`). Pair with `getLowerBaseModelName` (in `@shared`) or
+* `normalizeModelId` (in this package).
+*/
+/**
+* Match raw model IDs to their vendor. Keys are vendor slugs; order is
+* not significant because every pattern is anchored to the start of the
+* (namespace-stripped) id, so they stay mutually exclusive — a model
+* belongs to at most one vendor. Keep new patterns anchored (`^…`) so a
+* cross-vendor id like `deepseek-grok` resolves by its leading token, not
+* by insertion order.
+*/
+const VENDOR_PATTERNS = {
+	/** Anthropic / Claude family. Also matches the AWS Bedrock `anthropic.claude-*` prefix. */
+	anthropic: /^(?:anthropic\.)?claude/i,
+	/** Google Gemini family. */
+	gemini: /^(?:gemini|palm|veo|imagen|learnlm|lyria)/i,
+	/** Google Gemma family (gemma-*, gemma2/3/4, and the Ollama-style `gemma:2b` tag). */
+	gemma: /^gemma(?:[-:\d]|$)/i,
+	/** xAI Grok family. */
+	grok: /^grok/i,
+	/**
+	* OpenAI (chat + reasoning + legacy + media + embeddings). GPT-n, ChatGPT, the bare o<digit> series,
+	* codex/davinci/babbage, DALL·E, moderation, and OpenAI's `text-embedding-3*` / `-ada` embeddings.
+	* `text-embedding` is scoped to the `-3`/`-ada` SKUs on purpose — bare `text-embedding-0xx` is Google's,
+	* and `VENDOR_PATTERNS` is a flat set with no per-creator disambiguation.
+	*/
+	openai: /\bgpt\b|^o[134]|^chatgpt|^codex|^davinci|^babbage|^dall-e|^text-moderation|^text-embedding-(?:3|ada)/i,
+	/** Alibaba Qwen family (qwen, qwq, qvq). */
+	qwen: /^qwen|^qwq|^qvq|^tongyi/i,
+	/** ByteDance Doubao family. */
+	doubao: /^(?:doubao|skylark|seed|seedance|seedream|ep-)/i,
+	/** Tencent Hunyuan family — `hunyuan-*`, the `hy-*` SKUs, and the versioned `hyN` namespace (`hy3-preview`). */
+	hunyuan: /^(?:hunyuan|hy-|hy\d)/i,
+	/** Moonshot / Kimi family, including Kimi Code's bare K3 model IDs. */
+	kimi: /^(?:kimi|moonshot|k3(?:[-_.]|$))/i,
+	/** DeepSeek family. */
+	deepseek: /^deepseek/i,
+	/** Perplexity (sonar family). */
+	perplexity: /^sonar/i,
+	/** Baichuan family. */
+	baichuan: /^baichuan/i,
+	/** Xiaomi MiMo family. */
+	mimo: /^mimo-/i,
+	/** Ant Group Ling / Ring family. */
+	ling: /^(?:ling|ring)-/i,
+	/** MiniMax family — current `minimax-*` plus the legacy `abab-*` SKUs the creator still claims. */
+	minimax: /^(?:minimax|abab)/i,
+	/** StepFun family. */
+	step: /^step-/i,
+	/** Zhipu / GLM family. */
+	zhipu: /^(?:glm|chatglm|cogview|cogvideo|codegeex)/i,
+	/** Mistral family — incl. the `open-*` open-weight line (`open-mistral-7b`, `open-mixtral-8x22b`) and `labs-*`. */
+	mistral: /^(?:open-|labs-)?(?:mistral|pixtral|codestral|ministral|voxtral|devstral|mixtral|magistral)/i
+};
+/**
+* Return the vendor slug for a normalized model ID, or `undefined` if
+* no vendor pattern matches. Iteration order is stable (key insertion
+* order) but not semantically important — patterns don't overlap.
+*/
+function matchVendor(normalizedId) {
+	for (const [vendor, pattern] of Object.entries(VENDOR_PATTERNS)) if (pattern.test(normalizedId)) return vendor;
+}
+/**
+* Lightweight vendor predicate factory. Exported primarily so consumers
+* can spell the check as `isVendor('anthropic')(id)` when composing
+* higher-level logic.
+*/
+function isVendor(vendor) {
+	const pattern = VENDOR_PATTERNS[vendor];
+	return (id) => pattern.test(id);
+}
+//#endregion
+//#region src/schemas/reasoningWire.ts
+/** Closed set of leaves the main-process reasoning interpreter may write. */
+const REASONING_WIRE_TARGETS = [
+	"reasoningEffort",
+	"reasoningSummary",
+	"reasoning_effort",
+	"reasoning.effort",
+	"reasoning.enabled",
+	"reasoning.exclude",
+	"reasoning.max_tokens",
+	"thinking.type",
+	"thinking.budget_tokens",
+	"thinking.budgetTokens",
+	"thinking.display",
+	"effort",
+	"sendReasoning",
+	"enable_thinking",
+	"thinking_budget",
+	"incremental_output",
+	"disable_reasoning",
+	"reasoning_budget",
+	"chat_template_kwargs.enable_thinking",
+	"chat_template_kwargs.thinking",
+	"chat_template_kwargs.thinking_mode",
+	"chat_template_kwargs.thinking_budget",
+	"extra_body.google.thinking_config.thinking_budget",
+	"extra_body.google.thinking_config.include_thoughts",
+	"extra_body.thinking.type",
+	"extra_body.thinking_budget",
+	"extra_body.reasoning_effort",
+	"thinkingConfig.includeThoughts",
+	"thinkingConfig.thinkingBudget",
+	"thinkingConfig.thinkingLevel",
+	"reasoningConfig.type",
+	"reasoningConfig.budgetTokens",
+	"reasoningConfig.maxReasoningEffort",
+	"think"
+];
+const ReasoningWireTargetSchema = zod.enum(REASONING_WIRE_TARGETS);
+const ReasoningEffortSchema = zod.enum(require_model.objectValues(require_model.REASONING_EFFORT));
+const ReasoningWireValueSchema = zod.discriminatedUnion("source", [
+	zod.object({
+		source: zod.literal("literal"),
+		value: zod.union([
+			zod.string(),
+			zod.number(),
+			zod.boolean()
+		])
+	}),
+	zod.object({ source: zod.literal("effort") }),
+	zod.object({ source: zod.literal("budget") }),
+	zod.object({ source: zod.literal("assistant-summary") })
+]);
+const ReasoningWireOperationSchema = zod.object({
+	target: ReasoningWireTargetSchema,
+	value: ReasoningWireValueSchema
+});
+const NonBudgetReasoningWireValueSchema = zod.discriminatedUnion("source", [
+	zod.object({
+		source: zod.literal("literal"),
+		value: zod.union([
+			zod.string(),
+			zod.number(),
+			zod.boolean()
+		])
+	}),
+	zod.object({ source: zod.literal("effort") }),
+	zod.object({ source: zod.literal("assistant-summary") })
+]);
+const NonBudgetReasoningWireOperationSchema = zod.object({
+	target: ReasoningWireTargetSchema,
+	value: NonBudgetReasoningWireValueSchema
+});
+const ReasoningBudgetPolicySchema = zod.object({
+	min: zod.number().nonnegative().optional(),
+	autoValue: zod.number().optional(),
+	clampToMaxTokens: zod.boolean().optional(),
+	missing: zod.discriminatedUnion("type", [
+		zod.object({ type: zod.literal("omit-value") }),
+		zod.object({ type: zod.literal("omit-mode") }),
+		zod.object({
+			type: zod.literal("fallback"),
+			value: zod.number()
+		})
+	])
+});
+const ReasoningEffortMapSchema = zod.partialRecord(ReasoningEffortSchema, ReasoningEffortSchema).optional();
+const ReasoningWireModeSchema = zod.union([zod.object({
+	operations: zod.array(NonBudgetReasoningWireOperationSchema).min(1),
+	effortMap: ReasoningEffortMapSchema
+}), zod.object({
+	operations: zod.array(ReasoningWireOperationSchema).min(1).refine((operations) => operations.some((operation) => operation.value.source === "budget"), { message: "reasoning budget mode must contain a budget operation" }),
+	effortMap: ReasoningEffortMapSchema,
+	budget: ReasoningBudgetPolicySchema
+})]);
+const ReasoningWireProfileSchema = zod.object({
+	/** Endpoint deliberately emits no reasoning parameters. */
+	disabled: zod.literal(true).optional(),
+	default: ReasoningWireModeSchema.optional(),
+	off: ReasoningWireModeSchema.optional(),
+	auto: ReasoningWireModeSchema.optional(),
+	effort: ReasoningWireModeSchema.optional()
+}).refine((profile) => profile.disabled === true || profile.default || profile.off || profile.auto || profile.effort, { message: "reasoning wire profile must declare a mode or be disabled" });
+const ReasoningFormatWireProfileSchema = zod.object({
+	wire: ReasoningWireProfileSchema,
+	budgetWire: ReasoningWireProfileSchema.optional(),
+	alwaysOnWire: ReasoningWireProfileSchema.optional(),
+	betweenToolsWire: ReasoningWireProfileSchema.optional()
+});
+//#endregion
+//#region src/schemas/provider.ts
+/**
+* Provider configuration schema definitions
+* Defines the structure for provider connections and API configurations
+*/
+const endpointTypeValues = require_model.objectValues(require_model.ENDPOINT_TYPE);
+const ProviderEditionSchema = zod.enum(["global", "cn"]);
+/**
+* Provider-owned transport used to request faster processing.
+*
+* Model availability remains a provider-model concern; this only describes
+* how the provider carries an enabled Fast request. `openai-priority` means the
+* `serviceTier` provider option on the OpenAI namespace — the tier *value* is
+* vendor-specific and travels in `fastMode.serviceTier` (OpenAI's `priority`,
+* Ark's `fast`), so a new vendor never has to expand this enum: enum expansion
+* is a breaking wire change, an optional field is not.
+*/
+const FastModeTransportSchema = zod.enum(["openai-priority", "claude-code"]);
+const ServiceTierSelectionSchema = zod.enum([
+	"standard",
+	"auto",
+	"fast",
+	"flex"
+]);
+const ServiceTierOptionsSchema = zod.array(ServiceTierSelectionSchema).min(1).refine((options) => new Set(options).size === options.length, { message: "service tier options must be unique" }).refine((options) => options.includes("standard"), { message: "service tier options must include standard" });
+const ServiceTierDeliverySchema = zod.discriminatedUnion("type", [zod.object({
+	type: zod.literal("provider-option"),
+	key: zod.string().min(1)
+}), zod.object({
+	type: zod.literal("request-body"),
+	key: zod.string().min(1)
+})]);
+const ServiceTierRequestControlSchema = zod.object({
+	default: ServiceTierSelectionSchema,
+	options: ServiceTierOptionsSchema,
+	wire: zod.object({
+		delivery: ServiceTierDeliverySchema,
+		values: zod.partialRecord(ServiceTierSelectionSchema, zod.string().min(1))
+	})
+}).superRefine((control, context) => {
+	if (!control.options.includes(control.default)) context.addIssue({
+		code: "custom",
+		message: "service tier default must be one of its options",
+		path: ["default"]
+	});
+	for (const option of control.options) if (!control.wire.values[option]) context.addIssue({
+		code: "custom",
+		message: `service tier option '${option}' must have a wire value`,
+		path: [
+			"wire",
+			"values",
+			option
+		]
+	});
+});
+/** A provider-native tool plus the scope of models on which the host serves it. */
+const ServerToolConfigSchema = zod.object({
+	id: zod.enum(require_model.objectValues(require_model.SERVER_TOOL)),
+	modelScope: zod.enum(require_model.objectValues(require_model.SERVER_TOOL_MODEL_SCOPE)).default(require_model.SERVER_TOOL_MODEL_SCOPE.MODEL_DEPENDENT),
+	/** Endpoint protocols on which the host serves the tool. Absent ⇒ all configured endpoints. */
+	endpointTypes: require_model.looseArray(require_model.EndpointTypeSchema).optional(),
+	/**
+	* Vendor families the host actually serves the tool for, when narrower than
+	* the tool's model eligibility (e.g. Vertex url-context is Gemini-only: the
+	* vertex-anthropic SDK exposes no webFetch tool). Absent ⇒ no narrowing.
+	*/
+	vendors: require_model.looseArray(zod.enum(Object.keys(VENDOR_PATTERNS))).optional()
+});
+const reasoningFormat = (type) => zod.object({
+	type: zod.literal(type),
+	/** Endpoint-wide wire behavior, interpreted only in Main. */
+	wire: ReasoningWireProfileSchema.optional()
+});
+/** Provider reasoning format — discriminated union by format type. */
+const ProviderReasoningFormatSchema = zod.discriminatedUnion("type", [
+	reasoningFormat("openai-chat"),
+	reasoningFormat("openai-responses"),
+	reasoningFormat("anthropic"),
+	reasoningFormat("gemini"),
+	reasoningFormat("ollama"),
+	reasoningFormat("none")
+]);
+const REASONING_FORMAT_TYPES = ProviderReasoningFormatSchema.options.map((option) => option.shape.type.value);
+const ProviderWebsiteSchema = zod.object({ website: zod.object({
+	official: zod.url().optional(),
+	docs: zod.url().optional(),
+	apiKey: zod.url().optional(),
+	models: zod.url().optional()
+}) });
+/**
+* How a host deviates from one endpoint's dialect. These are properties of the
+* protocol, not of the vendor: a provider serving both chat-completions and
+* Responses may answer differently for each.
+*/
+const EndpointDialectSchema = zod.object({
+	/** Accepts chat-completions `stream_options` for usage data. Absent ⇒ true. */
+	streamOptions: zod.boolean().optional(),
+	/** Accepts messages with `role: "developer"`. Absent ⇒ false. */
+	developerRole: zod.boolean().optional(),
+	/** Accepts OpenAI Responses `reasoning.summary`. Absent ⇒ use the registry wire. */
+	reasoningSummary: zod.boolean().optional()
+});
+/** Per-endpoint-type configuration in registry */
+const RegistryEndpointConfigSchema = zod.object({
+	/** Base URL for this endpoint type's API */
+	baseUrl: zod.url().optional(),
+	/** URLs for fetching available models via this endpoint type */
+	modelsApiUrls: zod.object({
+		/** Default models listing endpoint */
+		default: zod.url().optional(),
+		/** Embedding models listing endpoint (if separate from default) */
+		embedding: zod.url().optional(),
+		/** Image models listing endpoint (if separate from default) */
+		image: zod.url().optional(),
+		/** Reranker models listing endpoint (if separate from default) */
+		reranker: zod.url().optional()
+	}).optional(),
+	/** How this endpoint type expects reasoning parameters to be formatted */
+	reasoningFormat: ProviderReasoningFormatSchema.optional(),
+	/**
+	* AI SDK adapter family that handles this endpoint. Aligns with the IDs
+	* registered in `appProviderIds`. Resolvers should prefer this over
+	* heuristic id/baseUrl inference when present.
+	*/
+	adapterFamily: zod.string().optional(),
+	/** Dialect deviations of this host's implementation of the endpoint. */
+	dialect: EndpointDialectSchema.optional(),
+	/** User-selectable request controls supported by this endpoint. */
+	requestControls: zod.object({ serviceTier: ServiceTierRequestControlSchema.optional() }).optional()
+});
+const ProviderConfigSchema = zod.object({
+	/** Unique provider identifier */
+	id: require_model.ProviderIdSchema,
+	presetProviderId: require_model.ProviderIdSchema.optional(),
+	/** Display name */
+	name: zod.string(),
+	/** App editions where this provider is available. Omitted means all editions. */
+	availableInEditions: require_model.looseArray(ProviderEditionSchema, { min: 1 }).optional(),
+	/** Provider description */
+	description: zod.string().optional(),
+	/** Per-endpoint-type configuration (partial record — not all endpoint types need to be present) */
+	endpointConfigs: zod.record(zod.string().refine((k) => endpointTypeValues.includes(k), { message: `Invalid endpoint type key, must be one of: ${require_model.objectValues(require_model.ENDPOINT_TYPE).join(", ")}` }), RegistryEndpointConfigSchema).optional(),
+	/** Default endpoint type for chat requests — null for providers not bound by this (e.g. AWS, Vertex) */
+	defaultChatEndpoint: require_model.EndpointTypeSchema.nullable().default(null),
+	/**
+	* Where this provider's model list comes from. `'registry'` means it cannot
+	* be enumerated over an API (login-based subscription providers); the shipped
+	* registry catalog is returned by the model-list chokepoint instead. Defaults
+	* to `'api'` (the provider exposes a `/models` endpoint).
+	*/
+	modelListSource: zod.enum(["api", "registry"]).default("api"),
+	/** Append registry-only models omitted by the API list. Absent means API-only. */
+	supplementModelsFromRegistry: zod.boolean().optional(),
+	/** Provider-local resource IDs must never match global catalog model names. */
+	modelResolution: zod.discriminatedUnion("source", [zod.object({ source: zod.literal("catalog") }), zod.object({
+		source: zod.literal("provider"),
+		defaults: require_model.ModelConfigSchema.pick({
+			capabilities: true,
+			inputModalities: true,
+			outputModalities: true,
+			endpointTypes: true,
+			imageGeneration: true
+		}).required({
+			capabilities: true,
+			inputModalities: true,
+			outputModalities: true,
+			endpointTypes: true
+		}).extend({ supportsStreaming: zod.boolean() })
+	})]).optional(),
+	/**
+	* Which credential kinds the provider accepts — the auth UIs to surface and
+	* the runtime credential semantics. A *set*, because a provider can offer
+	* more than one (CherryIN takes both a user API key and an app-managed OAuth
+	* login). Members:
+	* - `'api-key'` — user-entered key (the api-key/host inputs).
+	* - `'oauth'` — app-managed OAuth session the app holds and refreshes.
+	* - `'external-cli'` — credential lives in an external CLI's store and only
+	*   works through that CLI's runtime (e.g. `claude-code`); drives env
+	*   stripping and chat-picker hiding.
+	*
+	* Absent ⇒ the default `['api-key']`. "Login-based" (suppress the api-key
+	* inputs) is the derived `!includes('api-key')`, not a value of its own.
+	*/
+	authMethods: require_model.looseArray(zod.enum([
+		"api-key",
+		"oauth",
+		"external-cli"
+	])).optional(),
+	/**
+	* The provider serves requests without any credential — a local server
+	* (ollama / lmstudio / gpustack / ovms) reachable over a baseUrl with no API
+	* key or login. Drives the "no API key required" guards: model sync, painting
+	* and OpenClaw gating skip the missing-key check. Distinct from login-based
+	* (`authMethods` without `'api-key'`), which also suppresses the host UI — a
+	* local provider still needs its baseUrl input. Defaults false.
+	*/
+	authOptional: zod.boolean().default(false),
+	/** Provider-native (server-executed) built-in tools served by this host. */
+	serverTools: require_model.looseArray(ServerToolConfigSchema).default([]),
+	/** Whether usage responses carry the actual billed amount. */
+	reportsActualCost: zod.boolean().default(false),
+	/**
+	* Registry-owned currency for provider-reported costs whose wire payload
+	* carries an amount but no currency. Absent means the amount stays
+	* unpriced; consumers must not infer a default currency.
+	*/
+	reportedCostCurrency: require_model.ZodCurrencySchema,
+	/** Provider-owned Fast request transport. Effective support is declared per provider-model pair. */
+	fastMode: zod.object({
+		transport: FastModeTransportSchema,
+		serviceTier: zod.string().optional()
+	}).optional(),
+	/** Additional metadata including website URLs */
+	metadata: require_model.MetadataSchema.and(ProviderWebsiteSchema)
+}).refine((data) => {
+	if (data.endpointConfigs && data.defaultChatEndpoint) return data.defaultChatEndpoint in data.endpointConfigs;
+	return true;
+}, { message: "defaultChatEndpoint must exist as a key in endpointConfigs" });
+const ProviderListSchema = zod.object({
+	version: require_model.VersionSchema,
+	providers: require_model.looseArray(ProviderConfigSchema)
+});
+//#endregion
+Object.defineProperty(exports, "FastModeTransportSchema", {
+	enumerable: true,
+	get: function() {
+		return FastModeTransportSchema;
+	}
+});
+Object.defineProperty(exports, "ProviderConfigSchema", {
+	enumerable: true,
+	get: function() {
+		return ProviderConfigSchema;
+	}
+});
+Object.defineProperty(exports, "ProviderEditionSchema", {
+	enumerable: true,
+	get: function() {
+		return ProviderEditionSchema;
+	}
+});
+Object.defineProperty(exports, "ProviderListSchema", {
+	enumerable: true,
+	get: function() {
+		return ProviderListSchema;
+	}
+});
+Object.defineProperty(exports, "REASONING_FORMAT_TYPES", {
+	enumerable: true,
+	get: function() {
+		return REASONING_FORMAT_TYPES;
+	}
+});
+Object.defineProperty(exports, "REASONING_WIRE_TARGETS", {
+	enumerable: true,
+	get: function() {
+		return REASONING_WIRE_TARGETS;
+	}
+});
+Object.defineProperty(exports, "ReasoningFormatWireProfileSchema", {
+	enumerable: true,
+	get: function() {
+		return ReasoningFormatWireProfileSchema;
+	}
+});
+Object.defineProperty(exports, "ReasoningWireProfileSchema", {
+	enumerable: true,
+	get: function() {
+		return ReasoningWireProfileSchema;
+	}
+});
+Object.defineProperty(exports, "ServerToolConfigSchema", {
+	enumerable: true,
+	get: function() {
+		return ServerToolConfigSchema;
+	}
+});
+Object.defineProperty(exports, "ServiceTierDeliverySchema", {
+	enumerable: true,
+	get: function() {
+		return ServiceTierDeliverySchema;
+	}
+});
+Object.defineProperty(exports, "ServiceTierOptionsSchema", {
+	enumerable: true,
+	get: function() {
+		return ServiceTierOptionsSchema;
+	}
+});
+Object.defineProperty(exports, "ServiceTierRequestControlSchema", {
+	enumerable: true,
+	get: function() {
+		return ServiceTierRequestControlSchema;
+	}
+});
+Object.defineProperty(exports, "ServiceTierSelectionSchema", {
+	enumerable: true,
+	get: function() {
+		return ServiceTierSelectionSchema;
+	}
+});
+Object.defineProperty(exports, "VENDOR_PATTERNS", {
+	enumerable: true,
+	get: function() {
+		return VENDOR_PATTERNS;
+	}
+});
+Object.defineProperty(exports, "isVendor", {
+	enumerable: true,
+	get: function() {
+		return isVendor;
+	}
+});
+Object.defineProperty(exports, "matchVendor", {
+	enumerable: true,
+	get: function() {
+		return matchVendor;
+	}
+});

package/dist/provider-models-BjKC53mr.cjs

@@ -0,0 +1,85 @@
+const require_model = require("./model-kwW2vWDI.cjs");
+const require_provider = require("./provider-DkSIaann.cjs");
+let zod = require("zod");
+zod = require_model.__toESM(zod, 1);
+//#region src/schemas/provider-models.ts
+/**
+* Provider-Model mapping schema definitions
+* Defines how providers can override specific model configurations
+*
+* This file was renamed from override.ts for clearer semantics
+*/
+const CapabilityOverrideSchema = zod.object({
+	add: require_model.looseArray(require_model.ModelCapabilityTypeSchema).optional(),
+	remove: require_model.looseArray(require_model.ModelCapabilityTypeSchema).optional(),
+	force: require_model.looseArray(require_model.ModelCapabilityTypeSchema).optional()
+});
+const ReasoningEndpointTypeSchema = zod.enum([
+	require_model.ENDPOINT_TYPE.OPENAI_RESPONSES,
+	require_model.ENDPOINT_TYPE.OPENAI_CHAT_COMPLETIONS,
+	require_model.ENDPOINT_TYPE.ANTHROPIC_MESSAGES,
+	require_model.ENDPOINT_TYPE.GOOGLE_GENERATE_CONTENT,
+	require_model.ENDPOINT_TYPE.OLLAMA_CHAT,
+	require_model.ENDPOINT_TYPE.OLLAMA_GENERATE,
+	require_model.ENDPOINT_TYPE.OPENAI_TEXT_COMPLETIONS
+]);
+const ProviderModelReasoningContractSchema = zod.object({
+	/** Provider/endpoint-specific support. Declared controls replace intrinsic model controls. */
+	support: require_model.ReasoningSupportSchema.optional(),
+	/** Exact provider/endpoint wire behavior. */
+	wire: require_provider.ReasoningWireProfileSchema.optional()
+}).refine((contract) => contract.support || contract.wire, { message: "provider-model reasoning contract must declare support or wire" });
+const ProviderModelOverrideSchema = zod.object({
+	providerId: require_model.ProviderIdSchema,
+	modelId: require_model.ModelIdSchema,
+	apiModelId: zod.string().optional(),
+	modelVariants: zod.array(zod.string().min(1)).optional(),
+	capabilities: CapabilityOverrideSchema.optional(),
+	limits: zod.object({
+		contextWindow: zod.number().optional(),
+		maxOutputTokens: zod.number().optional(),
+		maxInputTokens: zod.number().optional()
+	}).optional(),
+	pricing: require_model.PartialModelPricingSchema.optional(),
+	/** Exact reasoning behavior keyed by the endpoint used for this provider-model pair. */
+	reasoningContracts: zod.partialRecord(ReasoningEndpointTypeSchema, ProviderModelReasoningContractSchema).optional(),
+	/** Whether this exact provider-model pair supports the provider's Fast transport. */
+	supportsFastMode: zod.boolean().optional(),
+	/** Model-specific option overrides for endpoint-owned request controls. */
+	requestControls: zod.object({ serviceTier: zod.object({ options: require_provider.ServiceTierOptionsSchema }).optional() }).optional(),
+	parameterSupport: require_model.ParameterSupportSchema.partial().optional(),
+	endpointTypes: require_model.looseArray(require_model.EndpointTypeSchema).optional(),
+	inputModalities: require_model.looseArray(require_model.ModalitySchema).optional(),
+	outputModalities: require_model.looseArray(require_model.ModalitySchema).optional(),
+	name: zod.string().optional(),
+	description: zod.string().optional(),
+	family: zod.string().optional(),
+	ownedBy: zod.string().optional(),
+	imageGeneration: require_model.ImageGenerationSupportSchema.optional(),
+	disabled: zod.boolean().optional(),
+	replaceWith: require_model.ModelIdSchema.optional(),
+	reason: zod.string().optional()
+});
+const ProviderModelListSchema = zod.object({
+	version: require_model.VersionSchema,
+	overrides: require_model.looseArray(ProviderModelOverrideSchema)
+});
+//#endregion
+Object.defineProperty(exports, "ProviderModelListSchema", {
+	enumerable: true,
+	get: function() {
+		return ProviderModelListSchema;
+	}
+});
+Object.defineProperty(exports, "ProviderModelOverrideSchema", {
+	enumerable: true,
+	get: function() {
+		return ProviderModelOverrideSchema;
+	}
+});
+Object.defineProperty(exports, "ProviderModelReasoningContractSchema", {
+	enumerable: true,
+	get: function() {
+		return ProviderModelReasoningContractSchema;
+	}
+});

package/dist/provider-models-BkxD9T17.mjs

@@ -0,0 +1,67 @@
+import { b as ENDPOINT_TYPE, c as PartialModelPricingSchema, d as looseArray, f as EndpointTypeSchema, g as VersionSchema, h as ProviderIdSchema, i as ModelCapabilityTypeSchema, m as ModelIdSchema, n as ImageGenerationSupportSchema, r as ModalitySchema, s as ParameterSupportSchema, u as ReasoningSupportSchema } from "./model-NFEbqWMs.mjs";
+import { c as ServiceTierOptionsSchema, p as ReasoningWireProfileSchema } from "./provider-D14qMZsE.mjs";
+import * as z from "zod";
+//#region src/schemas/provider-models.ts
+/**
+* Provider-Model mapping schema definitions
+* Defines how providers can override specific model configurations
+*
+* This file was renamed from override.ts for clearer semantics
+*/
+const CapabilityOverrideSchema = z.object({
+	add: looseArray(ModelCapabilityTypeSchema).optional(),
+	remove: looseArray(ModelCapabilityTypeSchema).optional(),
+	force: looseArray(ModelCapabilityTypeSchema).optional()
+});
+const ReasoningEndpointTypeSchema = z.enum([
+	ENDPOINT_TYPE.OPENAI_RESPONSES,
+	ENDPOINT_TYPE.OPENAI_CHAT_COMPLETIONS,
+	ENDPOINT_TYPE.ANTHROPIC_MESSAGES,
+	ENDPOINT_TYPE.GOOGLE_GENERATE_CONTENT,
+	ENDPOINT_TYPE.OLLAMA_CHAT,
+	ENDPOINT_TYPE.OLLAMA_GENERATE,
+	ENDPOINT_TYPE.OPENAI_TEXT_COMPLETIONS
+]);
+const ProviderModelReasoningContractSchema = z.object({
+	/** Provider/endpoint-specific support. Declared controls replace intrinsic model controls. */
+	support: ReasoningSupportSchema.optional(),
+	/** Exact provider/endpoint wire behavior. */
+	wire: ReasoningWireProfileSchema.optional()
+}).refine((contract) => contract.support || contract.wire, { message: "provider-model reasoning contract must declare support or wire" });
+const ProviderModelOverrideSchema = z.object({
+	providerId: ProviderIdSchema,
+	modelId: ModelIdSchema,
+	apiModelId: z.string().optional(),
+	modelVariants: z.array(z.string().min(1)).optional(),
+	capabilities: CapabilityOverrideSchema.optional(),
+	limits: z.object({
+		contextWindow: z.number().optional(),
+		maxOutputTokens: z.number().optional(),
+		maxInputTokens: z.number().optional()
+	}).optional(),
+	pricing: PartialModelPricingSchema.optional(),
+	/** Exact reasoning behavior keyed by the endpoint used for this provider-model pair. */
+	reasoningContracts: z.partialRecord(ReasoningEndpointTypeSchema, ProviderModelReasoningContractSchema).optional(),
+	/** Whether this exact provider-model pair supports the provider's Fast transport. */
+	supportsFastMode: z.boolean().optional(),
+	/** Model-specific option overrides for endpoint-owned request controls. */
+	requestControls: z.object({ serviceTier: z.object({ options: ServiceTierOptionsSchema }).optional() }).optional(),
+	parameterSupport: ParameterSupportSchema.partial().optional(),
+	endpointTypes: looseArray(EndpointTypeSchema).optional(),
+	inputModalities: looseArray(ModalitySchema).optional(),
+	outputModalities: looseArray(ModalitySchema).optional(),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	family: z.string().optional(),
+	ownedBy: z.string().optional(),
+	imageGeneration: ImageGenerationSupportSchema.optional(),
+	disabled: z.boolean().optional(),
+	replaceWith: ModelIdSchema.optional(),
+	reason: z.string().optional()
+});
+const ProviderModelListSchema = z.object({
+	version: VersionSchema,
+	overrides: looseArray(ProviderModelOverrideSchema)
+});
+//#endregion
+export { ProviderModelOverrideSchema as n, ProviderModelReasoningContractSchema as r, ProviderModelListSchema as t };