dsh-codearts 1.1.1 → 1.1.4

package/lib/index.mjs

@@ -1,9 +1,8 @@
-import { A as filterEnabledModels, C as rateLimitFrame, D as FALLBACK_CODEARTS_MODELS, E as CodeArtsCatalog, F as codeartsAccountsPath, I as codeartsAuthPath, L as startLogin, M as isBenefitModel, N as CodeArtsAccountStore, O as clearBenefitBlocked, P as CodeArtsCredentialStore, S as prepareChatBody, T as upstreamErrorMessage, _ as isQueueableRate, a as SNAP_HOST, b as maxTokensCeilingFor, c as claimDailyWelfare, d as fetchCallerIdentity, f as fetchModels, g as isParamInvalidFrame, h as isConcurrencyCap, i as refreshCatalog, j as isBenefitBlocked, k as creditRatioLabel, l as clearQueueStatus, m as fetchWelfareCampaigns, n as codeartsUsagePath, o as canonicalModel, p as fetchQueueStatus, r as discoverModels, s as chatStream, t as CodeArtsUsageTracker, u as degradeTokenCeiling, v as isTpmLimit, w as signedGet, x as pickDailyWelfareCampaign, y as isWelfareClaimedStatus } from "./usage-zgF0QuQ4.mjs";
+import { A as filterEnabledModels, C as rateLimitFrame, D as FALLBACK_CODEARTS_MODELS, E as CodeArtsCatalog, F as MANUAL_ACCOUNT_ID, I as codeartsAccountsPath, L as codeartsAuthPath, M as isBenefitModel, N as CodeArtsAccountStore, O as clearBenefitBlocked, P as CodeArtsCredentialStore, R as startLogin, S as prepareChatBody, T as upstreamErrorMessage, _ as isQueueableRate, a as SNAP_HOST, b as maxTokensCeilingFor, c as claimDailyWelfare, d as fetchCallerIdentity, f as fetchModels, g as isParamInvalidFrame, h as isConcurrencyCap, i as refreshCatalog, j as isBenefitBlocked, k as creditRatioLabel, l as clearQueueStatus, m as fetchWelfareCampaigns, n as codeartsUsagePath, o as canonicalModel, p as fetchQueueStatus, r as discoverModels, s as chatStream, t as CodeArtsUsageTracker, u as degradeTokenCeiling, v as isTpmLimit, w as signedGet, x as pickDailyWelfareCampaign, y as isWelfareClaimedStatus } from "./usage-B0NfG8vZ.mjs";
+import { i as lazyApi, r as createProvider } from "./models-CgKCibpk.mjs";
 import z from "@deepseek-ai/schemastery";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
-import { createProvider } from "@earendil-works/pi-ai";
-import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
 import * as settingsModule from "@deepseek-ai/dsh-settings";
@@ -106,6 +105,22 @@ var CodeArtsAccountPool = class {
 		account.disabled = true;
 		account.lastError = reason;
 	}
+	/**
+	* 用户重新登录（凭据已换新）后调用：把账号从禁用/冷却里捞出来。
+	*
+	* `sync()` 只对齐成员、特意保留运行时状态（account-pool 不读凭据文档），所以
+	* 「同一账号重新登录」不会自动清掉 disabled —— 以前只能靠重启（见 issue #1）。
+	* 登录成功的语义就是「这个号现在该能用了」，由登录路径显式调这里复位。
+	*/
+	revive(id) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return;
+		account.disabled = false;
+		account.coolUntil = 0;
+		account.cappedUntil = 0;
+		account.errorCount = 0;
+		account.lastError = void 0;
+	}
 	/** 上游 5xx / 软限流：短时冷却。 */
 	cooldown(id, ms, reason) {
 		const account = this.accounts.get(id);
@@ -529,6 +544,9 @@ var CodeArtsCreditCache = class {
 	}
 };
 //#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@1.3.0_@aws-sdk+credential-provider-node@3.972.84_@smithy+signature-v4@5.7.4_ws@8.22.0_zod@4.6.5/node_modules/@earendil-works/pi-ai/dist/api/openai-completions.lazy.js
+const openAICompletionsApi = () => lazyApi(() => import("./openai-completions-Cn5ZQvOO.mjs"));
+//#endregion
 //#region src/adapter.ts
 /**
 * The `codearts` pi-ai provider.
@@ -706,6 +724,56 @@ var CodeArtsPiAiAdapter = class extends PiAiAdapter {
 	}
 };
 //#endregion
+//#region src/pi-ai-compat.ts
+/**
+* `@earendil-works/pi-ai` 运行时自检。
+*
+* 本插件编译时对齐的是 1.3.0，而宿主（`dsh-llm-pi-ai` 0.2.1-rc.2 起）会先把系统提示
+* 折叠成一条 `role:"system"`、`content` 为**字符串**的消息，再交给 provider。1.3.0 之前
+* 的 `estimateMessageTokens` 没有 system 分支：字符串内容被按字符遍历，每个"块"是单个
+* 字符，`block.name` 为 undefined，于是每条消息都死在
+* `Cannot read properties of undefined (reading 'length')` 上 —— 而且是在出网之前，
+* 用户只看得到一句「本轮运行失败」。
+*
+* 什么时候会拿到旧的那份：profile 顶层被别的插件 hoist 了一个低版本，而本插件的依赖
+* 没落地到自己的 `node_modules`。1.1.4 起 pi-ai 直接打包进 `lib/`（不再经 npm 解析），
+* 版本漂移在结构上不可能了；这里仍探测一次，把「产物损坏/不兼容」明说，而不是让
+* 每条消息各自崩在一个看不懂的 TypeError 上。
+*
+* 探测用能力而不是版本号：不依赖 package.json 能不能读到，也对未来的版本漂移免疫。
+*
+* @module dsh-codearts/pi-ai-compat
+*/
+/** 折叠后的系统消息要能被估token；从这一版起才支持。 */
+const MIN_PI_AI_VERSION = "1.3.0";
+let probe;
+/** 不兼容时的说明；兼容时 undefined。结果只算一次（模块加载后版本不会再变）。 */
+function probePiAiCompat() {
+	probe ??= runProbe();
+	return probe;
+}
+async function runProbe() {
+	const hint = `需要 @earendil-works/pi-ai >= ${MIN_PI_AI_VERSION} 的行为；1.1.4 起它已打进插件产物，探测失败说明产物损坏或被改动，请重装 dsh-codearts`;
+	let estimate;
+	try {
+		({estimateMessageTokens: estimate} = await import("./estimate-BePoD-Np.mjs").then((n) => n.n));
+	} catch (error) {
+		return `pi-ai 不兼容：读不到 @earendil-works/pi-ai/utils/estimate（${messageOf(error)}）。${hint}`;
+	}
+	if (typeof estimate !== "function") return `pi-ai 不兼容：这份 @earendil-works/pi-ai 没有 estimateMessageTokens。${hint}`;
+	try {
+		estimate({
+			role: "system",
+			content: "probe"
+		});
+	} catch (error) {
+		return `pi-ai 不兼容：这份 @earendil-works/pi-ai 处理不了宿主折叠出的 system 消息（${messageOf(error)}），每条请求都会在出网前失败。${hint}`;
+	}
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
 //#region src/loopback.ts
 /**
 * Shared loopback gates for the plugin's local HTTP surfaces: the loopback
@@ -816,6 +884,40 @@ function queuedMessage(model, gate) {
 	const upstream = gate.message.trim();
 	return `${upstream === "" ? `上游排队中：${model} 第 ${gate.position} 位（共 ${gate.length} 条）` : upstream} 插件没有一直等下去，请稍后重试。`;
 }
+/**
+* 「一个账号都选不出来」时的报错：把真实原因说清 —— 是禁用（附最后错误）、冷却
+* （附剩余秒数），还是本地槽位全满。以前三种都回同一句「没有可用账号」，禁用那
+* 种还把真因（比如 billion-context 本地拒签的 403）整个吞掉（issue #1）。
+*
+* 全部被禁用时回 401（宿主只自动重试 429，401 一次就把「去重新登录」说清）；
+* 只要还有会自己恢复的（冷却/槽位满）就回 429，宿主重试有概率直接救回来。
+*/
+function noAccountError(accounts) {
+	const now = Date.now();
+	const disabled = accounts.filter((a) => a.disabled);
+	const cooling = accounts.filter((a) => !a.disabled && now < a.coolUntil);
+	const busy = accounts.filter((a) => !a.disabled && now >= a.coolUntil);
+	const parts = [];
+	if (disabled.length > 0) {
+		const reasons = disabled.map((a) => a.lastError === void 0 ? a.id : `${a.id}（${a.lastError.slice(0, 120)}）`).join("、");
+		parts.push(`${disabled.length} 个被禁用：${reasons}——请到设置卡片重新登录（若在用 billion-context，先检查它的 resign 配置）`);
+	}
+	if (cooling.length > 0) {
+		const secs = Math.max(1, Math.ceil((Math.min(...cooling.map((a) => a.coolUntil)) - now) / 1e3));
+		parts.push(`${cooling.length} 个在短时冷却中（约 ${secs} 秒后恢复）`);
+	}
+	if (busy.length > 0) parts.push(`${busy.length} 个的本地并发槽位已满（每账号最多 ${busy[0]?.maxConcurrent ?? 2} 个在飞请求），等几秒再发`);
+	const message = `codearts 当前没有可用账号：${parts.join("；")}`;
+	return disabled.length === accounts.length ? {
+		status: 401,
+		kind: "session_dead",
+		message
+	} : {
+		status: 429,
+		kind: "soft_rate",
+		message
+	};
+}
 function readBody$1(req) {
 	return new Promise((resolve, reject) => {
 		const chunks = [];
@@ -1199,7 +1301,8 @@ function createCodeArtsShim(options) {
 			}
 		}
 		if (lastKind === void 0) {
-			writeOpenAIError(res, 429, "soft_rate", "codearts 当前没有可用账号（全部被禁用或冷却中），请稍后重试");
+			const none = noAccountError(pool.list());
+			writeOpenAIError(res, none.status, none.kind, none.message);
 			return;
 		}
 		const explanation = upstreamErrorMessage(lastMessage, lastStatus);
@@ -1483,11 +1586,14 @@ async function buildStatus(deps) {
 	const accounts = await deps.store.list();
 	const cred = await deps.store.current();
 	const usage = usageOf(deps);
+	const piAi = await probePiAiCompat();
+	const compat = piAi === void 0 ? {} : { piAiError: piAi };
 	if (accounts.length === 0 || cred === void 0) return {
 		status: "signed-out",
 		models,
 		accounts,
-		usage
+		usage,
+		...compat
 	};
 	const usable = accounts.some(accountUsable);
 	const identity = {
@@ -1499,11 +1605,13 @@ async function buildStatus(deps) {
 	};
 	if (!usable) return {
 		status: "expired",
-		...identity
+		...identity,
+		...compat
 	};
 	return {
 		status: "signed-in",
 		...identity,
+		...compat,
 		...await creditsOf(deps)
 	};
 }
@@ -1613,6 +1721,7 @@ function tokenPostHandler(deps) {
 			}
 			const label = typeof body?.label === "string" && body.label.trim() !== "" ? body.label.trim() : void 0;
 			await deps.store.set(token, label);
+			deps.reviveAccount?.(MANUAL_ACCOUNT_ID);
 			json(res, 200, await buildStatus(deps));
 		} catch (error) {
 			json(res, 500, { error: safeMessage(error) });
@@ -1882,6 +1991,8 @@ function loginStartHandler(deps, active, recent) {
 					const identity = await probeIdentity(token);
 					const id = await deps.store.upsertFromOAuth(token, void 0, identity ?? void 0);
 					if (identity !== null && id !== identity.userId) await deps.store.adoptIdentity(id, identity);
+					deps.reviveAccount?.(id);
+					if (identity !== null && identity.userId !== id) deps.reviveAccount?.(identity.userId);
 					recordLoginOutcome(recent, session.url, "done");
 				} catch {
 					recordLoginOutcome(recent, session.url, "error");
@@ -2084,6 +2195,7 @@ function apply(ctx, rawConfig) {
 		enabledModels,
 		setEnabledModels,
 		pool: () => pool.list(),
+		reviveAccount: (id) => pool.revive(id),
 		usage: () => usage.snapshot(),
 		queue: () => queue.snapshot(),
 		recentRequests: () => recentRequestShapes(),
@@ -2200,9 +2312,11 @@ function apply(ctx, rawConfig) {
 		logger: ctx.logger
 	});
 	usage.load().catch(() => {});
-	shim.ready.then(() => {
+	shim.ready.then(async () => {
 		if (stopped) return;
 		discover();
+		const incompatible = await probePiAiCompat();
+		if (incompatible !== void 0) ctx.logger.error(`dsh-codearts: ${incompatible}`);
 		const codearts = createCodeArtsAdapter({
 			shim,
 			catalog,

package/lib/models-CgKCibpk.mjs

@@ -0,0 +1,377 @@
+//#region node_modules/.pnpm/@earendil-works+pi-ai@1.3.0_@aws-sdk+credential-provider-node@3.972.84_@smithy+signature-v4@5.7.4_ws@8.22.0_zod@4.6.5/node_modules/@earendil-works/pi-ai/dist/utils/event-stream.js
+var FifoQueue = class {
+	incoming = [];
+	outgoing = [];
+	get length() {
+		return this.incoming.length + this.outgoing.length;
+	}
+	enqueue(value) {
+		this.incoming.push(value);
+	}
+	dequeue() {
+		if (this.outgoing.length === 0) while (this.incoming.length > 0) this.outgoing.push(this.incoming.pop());
+		return this.outgoing.pop();
+	}
+};
+var EventStream = class {
+	queue = new FifoQueue();
+	waiting = new FifoQueue();
+	done = false;
+	finalResultPromise;
+	resolveFinalResult;
+	isComplete;
+	extractResult;
+	constructor(isComplete, extractResult) {
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+		this.finalResultPromise = new Promise((resolve) => {
+			this.resolveFinalResult = resolve;
+		});
+	}
+	push(event) {
+		if (this.done) return;
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		const waiter = this.waiting.dequeue();
+		if (waiter) waiter({
+			value: event,
+			done: false
+		});
+		else this.queue.enqueue(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) this.resolveFinalResult(result);
+		while (this.waiting.length > 0) this.waiting.dequeue()({
+			value: void 0,
+			done: true
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this.queue.length > 0) yield this.queue.dequeue();
+		else if (this.done) return;
+		else {
+			const result = await new Promise((resolve) => this.waiting.enqueue(resolve));
+			if (result.done) return;
+			yield result.value;
+		}
+	}
+	result() {
+		return this.finalResultPromise;
+	}
+};
+/**
+* Event stream of one assistant response. It also times the response: the final message (`done` or `error` event, or
+* the result passed to `end()`) gets `durationMs`, measured with a monotonic clock from the stream's creation, unless
+* the message already has one or its `timestamp` predates the stream. A stream that forwards a response which started
+* elsewhere, such as a deferred result fetched later, therefore leaves it untimed.
+*/
+var AssistantMessageEventStream = class extends EventStream {
+	#startedAt = Date.now();
+	#startedAtMonotonic = performance.now();
+	constructor() {
+		super((event) => event.type === "done" || event.type === "error", (event) => {
+			if (event.type === "done") return event.message;
+			else if (event.type === "error") return event.error;
+			throw new Error("Unexpected event type for final result");
+		});
+	}
+	push(event) {
+		if (event.type === "done") this.#time(event.message);
+		else if (event.type === "error") this.#time(event.error);
+		super.push(event);
+	}
+	end(result) {
+		if (result !== void 0) this.#time(result);
+		super.end(result);
+	}
+	#time(message) {
+		if (this.done || message.durationMs !== void 0 || message.timestamp < this.#startedAt) return;
+		message.durationMs = Math.max(0, Math.round(performance.now() - this.#startedAtMonotonic));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@1.3.0_@aws-sdk+credential-provider-node@3.972.84_@smithy+signature-v4@5.7.4_ws@8.22.0_zod@4.6.5/node_modules/@earendil-works/pi-ai/dist/api/lazy.js
+function createSetupErrorMessage(model, error, timestamp) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		},
+		stopReason: "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp
+	};
+}
+function hasResult(source) {
+	return typeof source.result === "function";
+}
+async function forwardStream(target, source) {
+	for await (const event of source) target.push(event);
+	target.end(hasResult(source) ? await source.result() : void 0);
+}
+/**
+* Returns a stream synchronously while running async setup (auth resolution,
+* lazy module loading) behind it. Setup failures terminate the stream with an
+* error event.
+*/
+function lazyStream(model, setup) {
+	const startedAt = Date.now();
+	const outer = new AssistantMessageEventStream();
+	setup().then((inner) => forwardStream(outer, inner)).catch((error) => {
+		const message = createSetupErrorMessage(model, error, startedAt);
+		outer.push({
+			type: "error",
+			reason: "error",
+			error: message
+		});
+		outer.end(message);
+	});
+	return outer;
+}
+function lazyApi(load, capabilities) {
+	const api = {
+		stream: (model, context, options) => lazyStream(model, async () => (await load()).stream(model, context, options)),
+		streamSimple: (model, context, options) => lazyStream(model, async () => (await load()).streamSimple(model, context, options))
+	};
+	if (capabilities?.fetchDeferred) api.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+		const implementation = await load();
+		if (!implementation.fetchDeferred) throw new Error("API does not support deferred responses");
+		return implementation.fetchDeferred(model, handle, options);
+	});
+	if (capabilities?.cancelDeferred) api.cancelDeferred = async (model, handle, options) => {
+		const implementation = await load();
+		if (!implementation.cancelDeferred) throw new Error("API cannot cancel deferred responses");
+		await implementation.cancelDeferred(model, handle, options);
+	};
+	return api;
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@1.3.0_@aws-sdk+credential-provider-node@3.972.84_@smithy+signature-v4@5.7.4_ws@8.22.0_zod@4.6.5/node_modules/@earendil-works/pi-ai/dist/utils/diagnostics.js
+function formatThrownValue(value) {
+	if (value instanceof Error) return value.message || value.name;
+	if (typeof value === "string") return value;
+	return String(value);
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@1.3.0_@aws-sdk+credential-provider-node@3.972.84_@smithy+signature-v4@5.7.4_ws@8.22.0_zod@4.6.5/node_modules/@earendil-works/pi-ai/dist/utils/models-error.js
+var ModelsError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(withCauseDetail(message, options?.cause), options);
+		this.name = "ModelsError";
+		this.code = code;
+	}
+};
+/** Callers surface `error.message` only, so keep the underlying reason in it. */
+function withCauseDetail(message, cause) {
+	if (cause === void 0 || cause === null) return message;
+	const detail = formatThrownValue(cause).trim();
+	if (!detail || message.includes(detail)) return message;
+	return `${message}: ${detail}`;
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@1.3.0_@aws-sdk+credential-provider-node@3.972.84_@smithy+signature-v4@5.7.4_ws@8.22.0_zod@4.6.5/node_modules/@earendil-works/pi-ai/dist/utils/model-operations.js
+/** The type of a model. Models without `type` are chat models. */
+function getModelType(model) {
+	return model.type ?? "chat";
+}
+/** Runtime-checked model type narrowing, including legacy chat models without `type`. */
+function isModelType(model, type) {
+	return getModelType(model) === type;
+}
+function imageErrorResult(model, error, aborted = false) {
+	return {
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		output: [],
+		stopReason: aborted ? "aborted" : "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now()
+	};
+}
+function classifierErrorResult(model, error, aborted = false) {
+	return {
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		answers: {},
+		stopReason: aborted ? "aborted" : "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now()
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@1.3.0_@aws-sdk+credential-provider-node@3.972.84_@smithy+signature-v4@5.7.4_ws@8.22.0_zod@4.6.5/node_modules/@earendil-works/pi-ai/dist/models.js
+const KNOWN_MODEL_TYPES = {
+	chat: true,
+	image: true,
+	classifier: true
+};
+/** Models from stores and remote sources may have types that only newer versions know. */
+function hasKnownModelType(model) {
+	return Object.hasOwn(KNOWN_MODEL_TYPES, getModelType(model));
+}
+/**
+* Builds a provider from parts. Built-in provider factories and models.json
+* custom providers both go through this. A single `api` streams all chat
+* models; an `api` map dispatches on `model.api`, and a model whose api has
+* no entry produces a stream error. One-shot operation maps dispatch on
+* `model.api` the same way. At least one concrete implementation across
+* `api`/`images`/`classifiers` is required; empty maps are rejected.
+*/
+function createProvider(input) {
+	const single = input.api && typeof input.api.stream === "function" ? input.api : void 0;
+	const byApi = single || !input.api ? void 0 : input.api;
+	const images = input.images;
+	const classifiers = input.classifiers;
+	const streams = single ? [single] : Object.values(byApi ?? {}).filter((entry) => entry !== void 0);
+	const imageImplementations = Object.values(images ?? {}).filter((entry) => entry !== void 0);
+	const classifierImplementations = Object.values(classifiers ?? {}).filter((entry) => entry !== void 0);
+	if (streams.length === 0 && imageImplementations.length === 0 && classifierImplementations.length === 0) throw new Error(`Provider ${input.id}: at least one of "api", "images", or "classifiers" is required.`);
+	const baselineModels = input.models;
+	let dynamicModels = [];
+	const fetchModels = input.fetchModels;
+	const currentModels = () => {
+		const merged = [...baselineModels];
+		for (const model of dynamicModels) {
+			const index = merged.findIndex((entry) => getModelType(entry) === getModelType(model) && entry.id === model.id);
+			if (index >= 0) merged[index] = model;
+			else merged.push(model);
+		}
+		return merged;
+	};
+	const apiFor = (model) => single ?? byApi?.[model.api];
+	const dispatch = (model, run) => {
+		const streams = apiFor(model);
+		if (!streams) return lazyStream(model, async () => {
+			throw new ModelsError("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);
+		});
+		return run(streams);
+	};
+	const provider = {
+		id: input.id,
+		name: input.name ?? input.id,
+		baseUrl: input.baseUrl,
+		headers: input.headers,
+		auth: input.auth,
+		getModels: () => currentModels().filter((model) => isModelType(model, "chat")),
+		getAllModels: currentModels,
+		refreshModels: fetchModels ? async (context) => {
+			if (context.stored) {
+				const restored = context.stored.models.filter((model) => model.provider === input.id).map((model) => model);
+				if (!await context.publish({ update: () => {
+					dynamicModels = restored;
+				} })) return;
+			}
+			if (!context.allowNetwork || context.signal.aborted) return;
+			const fetched = await fetchModels(context);
+			if (context.signal.aborted) return;
+			const refreshed = fetched.filter(hasKnownModelType);
+			await context.publish({
+				persist: {
+					models: refreshed,
+					checkedAt: Date.now()
+				},
+				update: () => {
+					dynamicModels = refreshed;
+				}
+			});
+		} : void 0,
+		filterModels: input.filterModels,
+		filterAllModels: input.filterAllModels,
+		stream: (model, context, options) => dispatch(model, (streams) => streams.stream(model, context, options)),
+		streamSimple: (model, context, options) => dispatch(model, (streams) => streams.streamSimple(model, context, options))
+	};
+	if (streams.some((entry) => entry.fetchDeferred !== void 0)) provider.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+		const implementation = apiFor(model);
+		if (!implementation?.fetchDeferred) throw new ModelsError("provider", `Provider ${input.id} does not support deferred responses for "${model.api}"`);
+		return implementation.fetchDeferred(model, handle, options);
+	});
+	if (streams.some((entry) => entry.cancelDeferred !== void 0)) provider.cancelDeferred = async (model, handle, options) => {
+		const implementation = apiFor(model);
+		if (!implementation?.cancelDeferred) throw new ModelsError("provider", `Provider ${input.id} cannot cancel deferred responses for "${model.api}"`);
+		await implementation.cancelDeferred(model, handle, options);
+	};
+	if (images && imageImplementations.length > 0) provider.generateImages = async (model, context, options) => {
+		const implementation = images[model.api];
+		if (!implementation) return imageErrorResult(model, new ModelsError("provider", `Provider ${input.id} has no image generation implementation for "${model.api}"`));
+		return implementation.generateImages(model, context, options);
+	};
+	if (classifiers && classifierImplementations.length > 0) provider.classify = async (model, context, options) => {
+		const implementation = classifiers[model.api];
+		if (!implementation) return classifierErrorResult(model, new ModelsError("provider", `Provider ${input.id} has no classifier implementation for "${model.api}"`));
+		return implementation.classify(model, context, options);
+	};
+	return provider;
+}
+function calculateCost(model, usage) {
+	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+	let rates = model.cost;
+	let matchedThreshold = -1;
+	for (const tier of model.cost.tiers ?? []) if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+		rates = tier;
+		matchedThreshold = tier.inputTokensAbove;
+	}
+	const longWrite = usage.cacheWrite1h ?? 0;
+	const shortWrite = usage.cacheWrite - longWrite;
+	usage.cost.input = rates.input / 1e6 * usage.input;
+	usage.cost.output = rates.output / 1e6 * usage.output;
+	usage.cost.cacheRead = rates.cacheRead / 1e6 * usage.cacheRead;
+	usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1e6;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	return usage.cost;
+}
+const EXTENDED_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function getSupportedThinkingLevels(model) {
+	if (!model.reasoning) return ["off"];
+	return EXTENDED_THINKING_LEVELS.filter((level) => {
+		const mapped = model.thinkingLevelMap?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== void 0;
+		return true;
+	});
+}
+function clampThinkingLevel(model, level) {
+	const availableLevels = getSupportedThinkingLevels(model);
+	if (availableLevels.includes(level)) return level;
+	const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
+	if (requestedIndex === -1) return availableLevels[0] ?? "off";
+	for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i++) {
+		const candidate = EXTENDED_THINKING_LEVELS[i];
+		if (availableLevels.includes(candidate)) return candidate;
+	}
+	for (let i = requestedIndex - 1; i >= 0; i--) {
+		const candidate = EXTENDED_THINKING_LEVELS[i];
+		if (availableLevels.includes(candidate)) return candidate;
+	}
+	return availableLevels[0] ?? "off";
+}
+//#endregion
+export { AssistantMessageEventStream as a, lazyApi as i, clampThinkingLevel as n, createProvider as r, calculateCost as t };