@cherrystudio/provider-registry 0.0.0-stage → 0.1.0

package/dist/provider-D14qMZsE.mjs

@@ -0,0 +1,431 @@
+import { C as REASONING_EFFORT, D as objectValues, E as SERVER_TOOL_MODEL_SCOPE, T as SERVER_TOOL, _ as ZodCurrencySchema, a as ModelConfigSchema, b as ENDPOINT_TYPE, d as looseArray, f as EndpointTypeSchema, g as VersionSchema, h as ProviderIdSchema, p as MetadataSchema } from "./model-NFEbqWMs.mjs";
+import * as z from "zod";
+//#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 = z.enum(REASONING_WIRE_TARGETS);
+const ReasoningEffortSchema = z.enum(objectValues(REASONING_EFFORT));
+const ReasoningWireValueSchema = z.discriminatedUnion("source", [
+	z.object({
+		source: z.literal("literal"),
+		value: z.union([
+			z.string(),
+			z.number(),
+			z.boolean()
+		])
+	}),
+	z.object({ source: z.literal("effort") }),
+	z.object({ source: z.literal("budget") }),
+	z.object({ source: z.literal("assistant-summary") })
+]);
+const ReasoningWireOperationSchema = z.object({
+	target: ReasoningWireTargetSchema,
+	value: ReasoningWireValueSchema
+});
+const NonBudgetReasoningWireValueSchema = z.discriminatedUnion("source", [
+	z.object({
+		source: z.literal("literal"),
+		value: z.union([
+			z.string(),
+			z.number(),
+			z.boolean()
+		])
+	}),
+	z.object({ source: z.literal("effort") }),
+	z.object({ source: z.literal("assistant-summary") })
+]);
+const NonBudgetReasoningWireOperationSchema = z.object({
+	target: ReasoningWireTargetSchema,
+	value: NonBudgetReasoningWireValueSchema
+});
+const ReasoningBudgetPolicySchema = z.object({
+	min: z.number().nonnegative().optional(),
+	autoValue: z.number().optional(),
+	clampToMaxTokens: z.boolean().optional(),
+	missing: z.discriminatedUnion("type", [
+		z.object({ type: z.literal("omit-value") }),
+		z.object({ type: z.literal("omit-mode") }),
+		z.object({
+			type: z.literal("fallback"),
+			value: z.number()
+		})
+	])
+});
+const ReasoningEffortMapSchema = z.partialRecord(ReasoningEffortSchema, ReasoningEffortSchema).optional();
+const ReasoningWireModeSchema = z.union([z.object({
+	operations: z.array(NonBudgetReasoningWireOperationSchema).min(1),
+	effortMap: ReasoningEffortMapSchema
+}), z.object({
+	operations: z.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 = z.object({
+	/** Endpoint deliberately emits no reasoning parameters. */
+	disabled: z.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 = z.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 = objectValues(ENDPOINT_TYPE);
+const ProviderEditionSchema = z.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 = z.enum(["openai-priority", "claude-code"]);
+const ServiceTierSelectionSchema = z.enum([
+	"standard",
+	"auto",
+	"fast",
+	"flex"
+]);
+const ServiceTierOptionsSchema = z.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 = z.discriminatedUnion("type", [z.object({
+	type: z.literal("provider-option"),
+	key: z.string().min(1)
+}), z.object({
+	type: z.literal("request-body"),
+	key: z.string().min(1)
+})]);
+const ServiceTierRequestControlSchema = z.object({
+	default: ServiceTierSelectionSchema,
+	options: ServiceTierOptionsSchema,
+	wire: z.object({
+		delivery: ServiceTierDeliverySchema,
+		values: z.partialRecord(ServiceTierSelectionSchema, z.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 = z.object({
+	id: z.enum(objectValues(SERVER_TOOL)),
+	modelScope: z.enum(objectValues(SERVER_TOOL_MODEL_SCOPE)).default(SERVER_TOOL_MODEL_SCOPE.MODEL_DEPENDENT),
+	/** Endpoint protocols on which the host serves the tool. Absent ⇒ all configured endpoints. */
+	endpointTypes: looseArray(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: looseArray(z.enum(Object.keys(VENDOR_PATTERNS))).optional()
+});
+const reasoningFormat = (type) => z.object({
+	type: z.literal(type),
+	/** Endpoint-wide wire behavior, interpreted only in Main. */
+	wire: ReasoningWireProfileSchema.optional()
+});
+/** Provider reasoning format — discriminated union by format type. */
+const ProviderReasoningFormatSchema = z.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 = z.object({ website: z.object({
+	official: z.url().optional(),
+	docs: z.url().optional(),
+	apiKey: z.url().optional(),
+	models: z.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 = z.object({
+	/** Accepts chat-completions `stream_options` for usage data. Absent ⇒ true. */
+	streamOptions: z.boolean().optional(),
+	/** Accepts messages with `role: "developer"`. Absent ⇒ false. */
+	developerRole: z.boolean().optional(),
+	/** Accepts OpenAI Responses `reasoning.summary`. Absent ⇒ use the registry wire. */
+	reasoningSummary: z.boolean().optional()
+});
+/** Per-endpoint-type configuration in registry */
+const RegistryEndpointConfigSchema = z.object({
+	/** Base URL for this endpoint type's API */
+	baseUrl: z.url().optional(),
+	/** URLs for fetching available models via this endpoint type */
+	modelsApiUrls: z.object({
+		/** Default models listing endpoint */
+		default: z.url().optional(),
+		/** Embedding models listing endpoint (if separate from default) */
+		embedding: z.url().optional(),
+		/** Image models listing endpoint (if separate from default) */
+		image: z.url().optional(),
+		/** Reranker models listing endpoint (if separate from default) */
+		reranker: z.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: z.string().optional(),
+	/** Dialect deviations of this host's implementation of the endpoint. */
+	dialect: EndpointDialectSchema.optional(),
+	/** User-selectable request controls supported by this endpoint. */
+	requestControls: z.object({ serviceTier: ServiceTierRequestControlSchema.optional() }).optional()
+});
+const ProviderConfigSchema = z.object({
+	/** Unique provider identifier */
+	id: ProviderIdSchema,
+	presetProviderId: ProviderIdSchema.optional(),
+	/** Display name */
+	name: z.string(),
+	/** App editions where this provider is available. Omitted means all editions. */
+	availableInEditions: looseArray(ProviderEditionSchema, { min: 1 }).optional(),
+	/** Provider description */
+	description: z.string().optional(),
+	/** Per-endpoint-type configuration (partial record — not all endpoint types need to be present) */
+	endpointConfigs: z.record(z.string().refine((k) => endpointTypeValues.includes(k), { message: `Invalid endpoint type key, must be one of: ${objectValues(ENDPOINT_TYPE).join(", ")}` }), RegistryEndpointConfigSchema).optional(),
+	/** Default endpoint type for chat requests — null for providers not bound by this (e.g. AWS, Vertex) */
+	defaultChatEndpoint: 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: z.enum(["api", "registry"]).default("api"),
+	/** Append registry-only models omitted by the API list. Absent means API-only. */
+	supplementModelsFromRegistry: z.boolean().optional(),
+	/** Provider-local resource IDs must never match global catalog model names. */
+	modelResolution: z.discriminatedUnion("source", [z.object({ source: z.literal("catalog") }), z.object({
+		source: z.literal("provider"),
+		defaults: ModelConfigSchema.pick({
+			capabilities: true,
+			inputModalities: true,
+			outputModalities: true,
+			endpointTypes: true,
+			imageGeneration: true
+		}).required({
+			capabilities: true,
+			inputModalities: true,
+			outputModalities: true,
+			endpointTypes: true
+		}).extend({ supportsStreaming: z.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: looseArray(z.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: z.boolean().default(false),
+	/** Provider-native (server-executed) built-in tools served by this host. */
+	serverTools: looseArray(ServerToolConfigSchema).default([]),
+	/** Whether usage responses carry the actual billed amount. */
+	reportsActualCost: z.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: ZodCurrencySchema,
+	/** Provider-owned Fast request transport. Effective support is declared per provider-model pair. */
+	fastMode: z.object({
+		transport: FastModeTransportSchema,
+		serviceTier: z.string().optional()
+	}).optional(),
+	/** Additional metadata including website URLs */
+	metadata: 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 = z.object({
+	version: VersionSchema,
+	providers: looseArray(ProviderConfigSchema)
+});
+//#endregion
+export { REASONING_FORMAT_TYPES as a, ServiceTierOptionsSchema as c, REASONING_WIRE_TARGETS as d, ReasoningFormatWireProfileSchema as f, matchVendor as g, isVendor as h, ProviderListSchema as i, ServiceTierRequestControlSchema as l, VENDOR_PATTERNS as m, ProviderConfigSchema as n, ServerToolConfigSchema as o, ReasoningWireProfileSchema as p, ProviderEditionSchema as r, ServiceTierDeliverySchema as s, FastModeTransportSchema as t, ServiceTierSelectionSchema as u };