dsh-codearts 1.1.3 → 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 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-5YK7bW-e.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";
@@ -545,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.
@@ -734,8 +736,8 @@ var CodeArtsPiAiAdapter = class extends PiAiAdapter {
 * 用户只看得到一句「本轮运行失败」。
 *
 * 什么时候会拿到旧的那份：profile 顶层被别的插件 hoist 了一个低版本，而本插件的依赖
-* 没落地到自己的 `node_modules`。1.1.3 起 `@earendil-works/pi-ai` 已从 peerDependencies
-* 移进 dependencies，区间真正生效；这里再探测一次，把「版本不兼容」明说，而不是让
+* 没落地到自己的 `node_modules`。1.1.4 起 pi-ai 直接打包进 `lib/`（不再经 npm 解析），
+* 版本漂移在结构上不可能了；这里仍探测一次，把「产物损坏/不兼容」明说，而不是让
 * 每条消息各自崩在一个看不懂的 TypeError 上。
 *
 * 探测用能力而不是版本号：不依赖 package.json 能不能读到，也对未来的版本漂移免疫。
@@ -751,10 +753,10 @@ function probePiAiCompat() {
 	return probe;
 }
 async function runProbe() {
-	const hint = `需要 @earendil-works/pi-ai >= ${MIN_PI_AI_VERSION}，请重装 dsh-codearts（1.1.3 起它自带这份依赖），或把 profile 顶层那份升级到同一区间`;
+	const hint = `需要 @earendil-works/pi-ai >= ${MIN_PI_AI_VERSION} 的行为；1.1.4 起它已打进插件产物，探测失败说明产物损坏或被改动，请重装 dsh-codearts`;
 	let estimate;
 	try {
-		({estimateMessageTokens: estimate} = await import("@earendil-works/pi-ai/utils/estimate"));
+		({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}`;
 	}

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 };