llmconfig 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT masol <https://github.com/masol>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,42 @@
+# pkg-placeholder
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+[![License][license-src]][license-href]
+
+_description_
+
+## Note for Developers
+
+This starter recommands using [npm Trusted Publisher](https://github.com/e18e/ecosystem-issues/issues/201), where the release is done on CI to ensure the security of the packages.
+
+To do so, you need to run `pnpm publish` manually for the very first time to create the package on npm, and then go to `https://www.npmjs.com/package/<your-package-name>/access` to set the connection to your GitHub repo.
+
+Then for the future releases, you can run `pnpm run release` to do the release and the GitHub Actions will take care of the release process.
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+[MIT](./LICENSE) License © [Anthony Fu](https://github.com/antfu)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/pkg-placeholder?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/pkg-placeholder
+[npm-downloads-src]: https://img.shields.io/npm/dm/pkg-placeholder?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/pkg-placeholder
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/pkg-placeholder?style=flat&colorA=080f12&colorB=1fa669&label=minzip
+[bundle-href]: https://bundlephobia.com/result?p=pkg-placeholder
+[license-src]: https://img.shields.io/github/license/antfu/pkg-placeholder.svg?style=flat&colorA=080f12&colorB=1fa669
+[license-href]: https://github.com/antfu/pkg-placeholder/blob/main/LICENSE
+[jsdocs-src]: https://img.shields.io/badge/jsdocs-reference-080f12?style=flat&colorA=080f12&colorB=1fa669
+[jsdocs-href]: https://www.jsdocs.io/package/pkg-placeholder

package/dist/index.d.mts

@@ -0,0 +1,147 @@
+import { LanguageModelUsage, ModelMessage } from "ai";
+import { Table } from "dexie";
+import z$1, { z } from "zod";
+
+//#region src/utils/const.d.ts
+declare const TableSchema: {
+  readonly provider: "id,name,createdAt";
+  readonly llms: "id,pid,model,bility,createdAt";
+};
+declare const LLMBilities: readonly ["text", "image", "image_modify", "video", "video_modify", "speech", "speech_modify", "music", "music_modify"];
+//#endregion
+//#region src/types/llmconfig.d.ts
+type LLMBility = typeof LLMBilities[number];
+interface LLMProvider {
+  id: string;
+  name: string;
+  apiKey: string;
+  createdAt: number;
+  baseUrl?: string;
+}
+/**
+ * LLM配置接口
+ */
+interface LLMConfig {
+  id: string;
+  pid: string;
+  model: string;
+  bility: LLMBility;
+  createdAt: number;
+  enabled?: boolean;
+  temperature?: number;
+  maxTokens?: number;
+}
+//#endregion
+//#region src/types/llmwrapper.d.ts
+/**
+ * 基础调用结果接口
+ */
+interface CallResult {
+  success: boolean;
+  response?: string;
+  error?: Error;
+  usage?: LanguageModelUsage;
+  responseTime?: number;
+}
+/**
+ * JSON调用结果接口
+ */
+interface JSONCallResult extends CallResult {
+  json?: unknown;
+}
+/**
+ * 生成对象结果接口
+ */
+interface GenerateObjectResult<T> extends CallResult {
+  object?: T;
+  finishReason?: string;
+}
+/**
+ * 生成对象选项
+ */
+interface GenerateObjectOptions {
+  mode?: 'auto' | 'json' | 'tool';
+  schemaName?: string;
+  schemaDescription?: string;
+}
+/**
+ * 基础 LLMWrapper 接口
+ */
+interface ILLMWrapper {
+  readonly callCount: number;
+  /**
+   * 调用 LLM
+   * @param input 输入内容（字符串、数字或消息数组）
+   * @returns 调用结果
+   */
+  call: (input: string | ModelMessage[]) => Promise<CallResult>;
+  /**
+   * 流式调用 LLM
+   * @param input 输入内容
+   * @param onChunk 数据块回调函数
+   * @returns 调用结果
+   */
+  callStream: (input: string | ModelMessage[], onChunk: (chunk: string) => void) => Promise<CallResult>;
+  /**
+   * 获取配置信息
+   * @returns LLM配置
+   */
+  getConfig: () => LLMConfig;
+}
+/**
+ * 支持结构化输出的 LLMWrapper 接口
+ */
+interface ITextLLMWrapper extends ILLMWrapper {
+  /**
+   * 调用 LLM 并返回 JSON（基于文本解析）
+   * @param input 输入内容
+   * @param maxRetries 最大重试次数，默认2次
+   * @returns JSON调用结果
+   */
+  callJSON: (input: string | ModelMessage[], maxRetries?: number) => Promise<JSONCallResult>;
+  /**
+   * 使用 schema 生成结构化对象（推荐使用）
+   * @param input 输入内容
+   * @param schema Zod schema
+   * @param options 生成选项
+   * @returns 生成对象结果
+   */
+  generateObject: <T extends z.ZodType>(input: string | ModelMessage[], schema: T, options?: GenerateObjectOptions) => Promise<GenerateObjectResult<z.infer<T>>>;
+}
+//#endregion
+//#region src/manager.d.ts
+type WrapperPredicate = (wrapper: ILLMWrapper) => boolean;
+declare class Manager {
+  #private;
+  get configs(): LLMConfig[];
+  get providers(): LLMProvider[];
+  get wrappers(): ILLMWrapper[];
+  getWrapper(id: string): ILLMWrapper | undefined;
+  filterWrapper(pred: WrapperPredicate): ILLMWrapper[];
+  findWrapper(pred: WrapperPredicate): ILLMWrapper | undefined;
+  reLoad(models: LLMConfig[], provides: LLMProvider[]): void;
+  upsertWrapper(cfg: LLMConfig): boolean;
+  delWrapper(id: string): void;
+  private getMatchingWrapper;
+  call(bility: LLMBility, input: string | ModelMessage[]): Promise<CallResult>;
+  callJSON(input: string | ModelMessage[], maxRetries?: number): Promise<JSONCallResult>;
+  generateObject<T extends z$1.ZodType>(input: string | ModelMessage[], schema: T, options?: GenerateObjectOptions): Promise<GenerateObjectResult<z$1.infer<T>>>;
+}
+//#endregion
+//#region src/library.d.ts
+declare class Library extends Manager {
+  #private;
+  get modelTable(): Table<LLMConfig>;
+  get providerTable(): Table<LLMProvider>;
+  init(models: Table<LLMConfig>, providers: Table<LLMProvider>): Promise<void>;
+  upsertModel(cfg: LLMConfig): Promise<boolean>;
+  delModel(id: string): Promise<void>;
+  upsertProvider(provider: LLMProvider): Promise<boolean>;
+  delProvider(pid: string): Promise<void>;
+}
+declare const llmcfgInst: Library;
+//#endregion
+//#region src/wrapper/providers.d.ts
+declare function listModels(provider: LLMProvider): Promise<string[]>;
+//#endregion
+export { type CallResult, type GenerateObjectOptions, type GenerateObjectResult, type ILLMWrapper, type ITextLLMWrapper, type JSONCallResult, LLMBilities, type LLMBility, type LLMConfig, type LLMProvider, TableSchema, llmcfgInst as default, llmcfgInst, listModels };

package/dist/index.mjs

@@ -0,0 +1,617 @@
+import { Output, generateText, streamText } from "ai";
+import { decode } from "html-entities";
+import JSON5 from "json5";
+import { isEmpty } from "lodash";
+import { marked } from "marked";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createXai } from "@ai-sdk/xai";
+
+//#region src/utils/guard.ts
+/**
+* 类型守卫：判断是否为 ITextLLMWrapper
+* @param wrapper LLMWrapper 实例
+* @returns 是否支持结构化输出
+*/
+function isTextLLMWrapper(wrapper) {
+	return "callJSON" in wrapper && typeof wrapper.callJSON === "function" && "generateObject" in wrapper && typeof wrapper.generateObject === "function";
+}
+
+//#endregion
+//#region src/wrapper/json-parser.ts
+/**
+* JSON 解析工具类
+*/
+var JSONParser = class {
+	/**
+	* 解析 JSON 字符串
+	*/
+	static parseJSON(jsonString) {
+		const parsingAttempts = [() => JSON5.parse(jsonString), () => JSON5.parse(decode(jsonString))];
+		for (const attempt of parsingAttempts) try {
+			const result = attempt();
+			if (!isEmpty(result)) return result;
+		} catch {
+			continue;
+		}
+		return null;
+	}
+	/**
+	* 从 Markdown 中提取 JSON 代码块
+	*/
+	static extractJsonBlock(markdown) {
+		const jsonBlocks = marked.lexer(markdown).filter((t) => t.type === "code").filter((t) => !t.lang || t.lang.toLowerCase() === "json").map((t) => {
+			try {
+				return this.parseJSON(t.text.trim());
+			} catch {
+				return null;
+			}
+		}).filter(Boolean);
+		if (jsonBlocks.length > 0) return jsonBlocks[0];
+		return null;
+	}
+	/**
+	* 提取 JSON（尝试多种方式）
+	*/
+	static async extractJSON(jsonString) {
+		const parsingAttempts = [() => this.parseJSON(jsonString), () => this.extractJsonBlock(jsonString)];
+		for (const attempt of parsingAttempts) try {
+			const result = attempt();
+			if (result && !isEmpty(result)) return result;
+		} catch {
+			continue;
+		}
+		return null;
+	}
+	/**
+	* 创建 JSON 修复提示词
+	*/
+	static createJSONFixPrompt(invalidResponse) {
+		return `
+以下内容应该是JSON格式，但因为语法错误，解析失败了：
+
+${invalidResponse}
+
+请修复并返回正确的JSON格式。只返回修复后的JSON，不要添加任何解释或其他内容。
+        `.trim();
+	}
+};
+
+//#endregion
+//#region src/wrapper/providers.ts
+const PROVIDER_CONFIG = {
+	qianwen: {
+		baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+		apikeyURL: "https://dashscope.console.aliyun.com/apiKey"
+	},
+	deepseek: {
+		baseURL: "https://api.deepseek.com",
+		apikeyURL: "https://platform.deepseek.com/api_keys"
+	},
+	qianfan: {
+		baseURL: "https://qianfan.baidubce.com/v2",
+		apikeyURL: "https://console.bce.baidu.com/iam/#/iam/apikey/list"
+	},
+	zhipu: {
+		baseURL: "https://open.bigmodel.cn/api/paas/v4",
+		apikeyURL: "https://bigmodel.cn/usercenter/proj-mgmt/apikeys"
+	},
+	hunyuan: {
+		baseURL: "https://api.hunyuan.cloud.tencent.com/v1",
+		apikeyURL: "https://console.cloud.tencent.com/hunyuan/api-key"
+	},
+	openrouter: {
+		baseURL: "https://openrouter.ai/api/v1",
+		apikeyURL: "https://openrouter.ai/settings/keys"
+	},
+	deepinfra: {
+		baseURL: "https://api.deepinfra.com/v1/openai",
+		apikeyURL: "https://deepinfra.com/dash/api_keys"
+	},
+	google: {
+		baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
+		apikeyURL: "https://aistudio.google.com/api-keys"
+	},
+	openai: {
+		baseURL: "https://api.openai.com/v1",
+		apikeyURL: "https://platform.openai.com/api-keys"
+	},
+	groq: {
+		baseURL: "https://api.groq.com/openai/v1",
+		apikeyURL: "https://console.groq.com/keys"
+	},
+	moonshot: {
+		baseURL: "https://api.moonshot.cn/v1",
+		apikeyURL: "https://platform.moonshot.cn/console/api-keys"
+	},
+	poe: {
+		baseURL: "https://api.poe.com/v1",
+		apikeyURL: "https://poe.com/api_key"
+	}
+};
+const ProviderNames = Object.keys(PROVIDER_CONFIG);
+async function listModels(provider) {
+	const providerConfig = PROVIDER_CONFIG[provider.name];
+	if (!providerConfig) throw new Error(`不支持的提供商: ${provider.name}`);
+	const baseURL = providerConfig.baseURL.trim();
+	const response = await fetch(`${baseURL}/models`, { headers: {
+		"Authorization": `Bearer ${provider.apiKey}`,
+		"Content-Type": "application/json"
+	} });
+	if (!response.ok) throw new Error(`获取模型列表失败: ${response.statusText}`);
+	return (await response.json()).data.map((model) => model.id);
+}
+
+//#endregion
+//#region src/wrapper/model-factory.ts
+/**
+* 模型工厂类 - 负责创建各种 LLM 模型实例
+*/
+var ModelFactory = class {
+	/**
+	* 创建 AI SDK 模型实例
+	*/
+	static createModel(config, provider) {
+		const constProvider = PROVIDER_CONFIG[provider.name];
+		if (!constProvider) throw new Error(`不支持的提供商: ${config.pid}`);
+		const modelName = config.model.trim();
+		const apiKey = provider.apiKey;
+		const baseURL = constProvider.baseURL?.trim();
+		const protocol = constProvider.protocal || "openai";
+		try {
+			return this.createModelByProtocol(protocol, modelName, apiKey, baseURL);
+		} catch (error) {
+			console.error(`创建模型失败 (${config.pid}):`, error);
+			throw new Error(`无法创建模型: ${config.pid} - ${modelName}`);
+		}
+	}
+	/**
+	* 根据协议类型创建模型
+	*/
+	static createModelByProtocol(protocol, modelName, apiKey, baseURL) {
+		switch (protocol) {
+			case "openai": return this.createOpenAIModel(modelName, apiKey, baseURL, true);
+			case "anthropic": return this.createAnthropicModel(modelName, apiKey, baseURL);
+			case "xai": return this.createXaiModel(modelName, apiKey, baseURL);
+			case "google": return this.createGoogleModel(modelName, apiKey, baseURL);
+			case "huggingface": return this.createHuggingFaceModel(modelName, apiKey, baseURL);
+			case "perplexity": return this.createPerplexityModel(modelName, apiKey, baseURL);
+			case "ollama": return this.createOllamaModel(modelName, baseURL);
+			default: return this.createOpenAIModel(modelName, apiKey, baseURL, false);
+		}
+	}
+	/**
+	* 创建 OpenAI 模型
+	* @param modelName - 模型名称．
+	* @param strict - true 为严格模式，false 为兼容模式
+	*/
+	static createOpenAIModel(modelName, apiKey, baseURL, strict = true) {
+		return createOpenAI({
+			apiKey,
+			baseURL,
+			fetch: strict ? void 0 : async (url, init) => {
+				try {
+					return await fetch(url, init);
+				} catch (error) {
+					console.warn("OpenAI compatible fetch error:", error);
+					throw error;
+				}
+			}
+		}).chat(modelName);
+	}
+	/**
+	* 创建 Anthropic 模型
+	*/
+	static createAnthropicModel(modelName, apiKey, baseURL) {
+		return createAnthropic({
+			apiKey,
+			baseURL
+		}).chat(modelName);
+	}
+	/**
+	* 创建 xAI 模型
+	*/
+	static createXaiModel(modelName, apiKey, baseURL) {
+		return createXai({
+			apiKey,
+			baseURL
+		})(modelName);
+	}
+	/**
+	* 创建 Google Generative AI 模型
+	*/
+	static createGoogleModel(modelName, apiKey, baseURL) {
+		return createGoogleGenerativeAI({
+			apiKey,
+			baseURL
+		})(modelName);
+	}
+	/**
+	* 创建 HuggingFace 模型（使用 OpenAI 兼容接口）
+	*/
+	static createHuggingFaceModel(modelName, apiKey, baseURL) {
+		return createOpenAI({
+			apiKey,
+			baseURL: baseURL || "https://api-inference.huggingface.co/v1"
+		})(modelName);
+	}
+	/**
+	* 创建 Perplexity 模型（使用 OpenAI 兼容接口）
+	*/
+	static createPerplexityModel(modelName, apiKey, baseURL) {
+		return createOpenAI({
+			apiKey,
+			baseURL: baseURL || "https://api.perplexity.ai"
+		})(modelName);
+	}
+	/**
+	* 创建 Ollama 模型
+	*/
+	static createOllamaModel(modelName, baseURL) {
+		return createOpenAI({
+			apiKey: "ollama",
+			baseURL: baseURL || "http://localhost:11434/v1"
+		})(modelName);
+	}
+};
+
+//#endregion
+//#region src/wrapper/text.ts
+var TextWrapper = class {
+	model;
+	#callCount = 0;
+	get callCount() {
+		return this.#callCount;
+	}
+	constructor(config, provider) {
+		this.config = config;
+		this.provider = provider;
+		this.model = ModelFactory.createModel(config, provider);
+	}
+	/**
+	* 将输入转换为消息格式
+	*/
+	prepareMessages(input) {
+		if (Array.isArray(input)) return input;
+		return [{
+			role: "user",
+			content: typeof input === "number" ? input.toString() : input
+		}];
+	}
+	/**
+	* 调用 LLM
+	*/
+	async call(input) {
+		const startTime = Date.now();
+		try {
+			const messages = this.prepareMessages(input);
+			const { text } = await generateText({
+				model: this.model,
+				messages,
+				temperature: this.config?.temperature
+			});
+			return {
+				success: true,
+				response: text,
+				responseTime: Date.now() - startTime
+			};
+		} catch (error) {
+			const responseTime = Date.now() - startTime;
+			const err = error;
+			console.error(`LLM调用失败 (${this.config.model}):`, error);
+			return {
+				success: false,
+				error: err,
+				responseTime
+			};
+		}
+	}
+	/**
+	* 调用 LLM 并返回 JSON（基于文本解析，保留向后兼容）
+	*/
+	async callJSON(input, maxRetries = 2) {
+		const startTime = Date.now();
+		const callResult = await this.call(input);
+		if (!callResult.success) return {
+			...callResult,
+			responseTime: Date.now() - startTime
+		};
+		let response = callResult.response;
+		let jsonResult = await JSONParser.extractJSON(response);
+		if (jsonResult !== null) return {
+			success: true,
+			response,
+			json: jsonResult,
+			responseTime: Date.now() - startTime
+		};
+		let attempts = 0;
+		while (attempts < maxRetries) {
+			attempts++;
+			try {
+				const fixPrompt = JSONParser.createJSONFixPrompt(response);
+				const fixResult = await this.call(fixPrompt);
+				if (!fixResult.success) continue;
+				response = fixResult.response;
+				jsonResult = await JSONParser.extractJSON(response);
+				if (jsonResult !== null) return {
+					success: true,
+					response,
+					json: jsonResult,
+					responseTime: Date.now() - startTime
+				};
+			} catch (error) {
+				console.warn(`JSON修复第${attempts}次尝试失败:`, error);
+			}
+		}
+		return {
+			success: false,
+			error: /* @__PURE__ */ new Error("无法解析为有效JSON格式"),
+			response,
+			responseTime: Date.now() - startTime
+		};
+	}
+	/**
+	* 使用 schema 生成结构化对象（推荐使用）
+	*/
+	async generateObject(input, schema, options) {
+		const startTime = Date.now();
+		try {
+			const messages = this.prepareMessages(input);
+			const result = await generateText({
+				model: this.model,
+				output: Output.object({
+					schema,
+					name: options?.schemaName,
+					description: options?.schemaDescription
+				}),
+				messages,
+				temperature: this.config?.temperature
+			});
+			const responseTime = Date.now() - startTime;
+			return {
+				success: true,
+				object: result.output,
+				finishReason: result.finishReason,
+				usage: result.usage,
+				responseTime
+			};
+		} catch (error) {
+			const responseTime = Date.now() - startTime;
+			const err = error;
+			console.error(`生成对象失败 (${this.config.model}):`, error);
+			return {
+				success: false,
+				error: err,
+				responseTime
+			};
+		}
+	}
+	/**
+	* 流式调用 LLM
+	*/
+	async callStream(input, onChunk) {
+		const startTime = Date.now();
+		try {
+			const messages = this.prepareMessages(input);
+			const { textStream } = await streamText({
+				model: this.model,
+				messages,
+				temperature: this.config?.temperature
+			});
+			let fullResponse = "";
+			for await (const chunk of textStream) {
+				fullResponse += chunk;
+				onChunk(chunk);
+			}
+			const responseTime = Date.now() - startTime;
+			return {
+				success: true,
+				response: fullResponse,
+				responseTime
+			};
+		} catch (error) {
+			const responseTime = Date.now() - startTime;
+			const err = error;
+			console.error(`LLM流式调用失败 (${this.config.model}):`, error);
+			return {
+				success: false,
+				error: err,
+				responseTime
+			};
+		}
+	}
+	/**
+	* 获取配置信息
+	*/
+	getConfig() {
+		return { ...this.config };
+	}
+};
+
+//#endregion
+//#region src/wrapper/index.ts
+/**
+* 包装器工厂
+*/
+var WrapperFactory = class {
+	/**
+	* 根据 tag 创建相应的包装器
+	*/
+	static createWrapper(config, provider) {
+		const bility = this.getModelTypeFromTag(config.bility);
+		switch (bility) {
+			case "text": return new TextWrapper(config, provider);
+			case "image": break;
+		}
+		throw new Error(`不支持的模型标签: ${bility}`);
+	}
+	/**
+	* 获取标签对应的模型类型
+	*/
+	static getModelTypeFromTag(tag) {
+		if (tag === "text") return "text";
+		if (tag === "image" || tag === "image_modify") return "image";
+		if (tag === "video" || tag === "video_modify") return "video";
+		if (tag === "speech" || tag === "speech_modify" || tag === "music" || tag === "music_modify") return "audio";
+		throw new Error(`未知的能力标签: ${tag}`);
+	}
+};
+
+//#endregion
+//#region src/manager.ts
+const CallError = {
+	success: false,
+	error: /* @__PURE__ */ new Error("Not Found or All Error")
+};
+var Manager = class {
+	#providers = [];
+	#wrappers = /* @__PURE__ */ new Map();
+	get configs() {
+		return Array.from(this.#wrappers.values()).map((wrapper) => wrapper.getConfig());
+	}
+	get providers() {
+		return this.#providers;
+	}
+	get wrappers() {
+		return Array.from(this.#wrappers.values());
+	}
+	getWrapper(id) {
+		return this.#wrappers.get(id);
+	}
+	filterWrapper(pred) {
+		return Array.from(this.#wrappers.values()).filter(pred);
+	}
+	findWrapper(pred) {
+		return Array.from(this.#wrappers.values()).find(pred);
+	}
+	reLoad(models, provides) {
+		this.#providers = [...provides];
+		this.#wrappers.clear();
+		models.forEach((model) => {
+			this.upsertWrapper(model);
+		});
+	}
+	upsertWrapper(cfg) {
+		if (this.#wrappers.has(cfg.id)) this.#wrappers.delete(cfg.id);
+		if (!cfg.enabled) return true;
+		const provider = this.#providers.find((p) => p.id === cfg.pid);
+		if (!provider) return false;
+		const wrapper = WrapperFactory.createWrapper(cfg, provider);
+		this.#wrappers.set(cfg.id, wrapper);
+		return true;
+	}
+	delWrapper(id) {
+		if (this.#wrappers.has(id)) this.#wrappers.delete(id);
+	}
+	getMatchingWrapper(bility) {
+		return Array.from(this.#wrappers.values()).filter((value) => {
+			const cfg = value.getConfig();
+			return cfg.enabled && cfg.bility === bility;
+		}).sort((a, b) => a.callCount - b.callCount);
+	}
+	async call(bility, input) {
+		const matchingWrappers = this.getMatchingWrapper(bility);
+		for (const wrapper of matchingWrappers) {
+			const result = await wrapper.call(input);
+			if (result.success) return result;
+		}
+		return CallError;
+	}
+	async callJSON(input, maxRetries = 3) {
+		const matchingWrappers = this.getMatchingWrapper("text");
+		for (const wrapper of matchingWrappers) if (isTextLLMWrapper(wrapper)) {
+			const result = await wrapper.callJSON(input, maxRetries);
+			if (result.success) return result;
+		}
+		return CallError;
+	}
+	async generateObject(input, schema, options) {
+		const matchingWrappers = this.getMatchingWrapper("text");
+		for (const wrapper of matchingWrappers) if (isTextLLMWrapper(wrapper)) {
+			const result = await wrapper.generateObject(input, schema, options);
+			if (result.success) return result;
+		}
+		return CallError;
+	}
+};
+
+//#endregion
+//#region src/library.ts
+var Library = class extends Manager {
+	#modelTable;
+	#providerTable;
+	get modelTable() {
+		return this.#modelTable;
+	}
+	get providerTable() {
+		return this.#providerTable;
+	}
+	async init(models, providers) {
+		this.#modelTable = models;
+		this.#providerTable = providers;
+		const allModels = await models.toArray();
+		const allProviders = await providers.toArray();
+		super.reLoad(allModels, allProviders);
+	}
+	async upsertModel(cfg) {
+		if (!super.upsertWrapper(cfg)) return false;
+		return await this.#modelTable.put(cfg) === cfg.id;
+	}
+	async delModel(id) {
+		super.delWrapper(id);
+		await this.#modelTable.delete(id);
+	}
+	async upsertProvider(provider) {
+		const idx = super.providers.findIndex((p) => p.id === provider.id);
+		await this.#providerTable.put(provider);
+		if (idx >= 0) {
+			super.providers[idx] = { ...provider };
+			super.configs.filter((cfg) => cfg.pid === provider.id).forEach((model) => {
+				super.upsertWrapper(model);
+			});
+		} else super.providers.push({ ...provider });
+		return true;
+	}
+	async delProvider(pid) {
+		const idx = super.providers.findIndex((p) => p.id === pid);
+		if (idx !== -1) {
+			await this.#providerTable.delete(pid);
+			super.providers.splice(idx, 1);
+			const affectModels = super.configs.filter((cfg) => cfg.pid === pid);
+			if (affectModels.length > 0) {
+				const ids = affectModels.map((model) => {
+					super.delWrapper(model.id);
+					return model.id;
+				});
+				await this.#modelTable.bulkDelete(ids);
+			}
+		}
+	}
+};
+const llmcfgInst = new Library();
+
+//#endregion
+//#region src/utils/const.ts
+const TableSchema = {
+	provider: "id,name,createdAt",
+	llms: "id,pid,model,bility,createdAt"
+};
+const LLMBilities = [
+	"text",
+	"image",
+	"image_modify",
+	"video",
+	"video_modify",
+	"speech",
+	"speech_modify",
+	"music",
+	"music_modify"
+];
+
+//#endregion
+//#region src/index.ts
+var src_default = llmcfgInst;
+
+//#endregion
+export { LLMBilities, TableSchema, src_default as default, listModels, llmcfgInst };

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "llmconfig",
+  "type": "module",
+  "version": "0.0.1",
+  "packageManager": "pnpm@10.25.0",
+  "description": "基于@ai-sdk,允许封装多个llm provider.使得配置与调用分离。",
+  "author": "lizhutang",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/masol",
+  "homepage": "https://github.com/masol/llmconfig#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/masol/llmconfig.git"
+  },
+  "bugs": "https://github.com/masol/llmconfig/issues",
+  "keywords": [
+    "llm",
+    "config"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "eslint",
+    "prepublishOnly": "nr build",
+    "release": "bumpp",
+    "start": "tsx src/index.ts",
+    "test": "vitest",
+    "typecheck": "tsc",
+    "prepare": "simple-git-hooks"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "catalog:",
+    "@ai-sdk/google": "catalog:",
+    "@ai-sdk/openai": "catalog:",
+    "@ai-sdk/xai": "catalog:",
+    "ai": "catalog:",
+    "html-entities": "catalog:",
+    "json5": "catalog:",
+    "lodash": "catalog:",
+    "marked": "catalog:",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "catalog:cli",
+    "@antfu/ni": "catalog:cli",
+    "@antfu/utils": "catalog:inlined",
+    "@types/lodash": "catalog:",
+    "@types/node": "catalog:types",
+    "bumpp": "catalog:cli",
+    "dexie": "catalog:",
+    "eslint": "catalog:cli",
+    "lint-staged": "catalog:cli",
+    "publint": "catalog:cli",
+    "simple-git-hooks": "catalog:cli",
+    "tinyexec": "catalog:testing",
+    "tsdown": "catalog:",
+    "tsx": "catalog:cli",
+    "typescript": "catalog:cli",
+    "vite": "catalog:",
+    "vitest": "catalog:testing",
+    "vitest-package-exports": "catalog:testing",
+    "yaml": "catalog:testing"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm i --frozen-lockfile --ignore-scripts --offline && npx lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}