dsh-connect-agnes-token-plan 0.5.0

package/lib/raccoon-llm-adapter-n6ZdIdvk.js

@@ -0,0 +1,143 @@
+import { a as name } from "./host-config-BNGgm_j7.js";
+import { i as raccoonRoster, n as RACCOON_PROVIDER_ID, r as buildRaccoonDescriptors, t as RACCOON_DISPLAY_NAME } from "./raccoon-models-DV1sQN4n.js";
+import { n as buildRetryPolicyConfig, t as reclassifyStream } from "./llm-error-fix-DQUng8AL.js";
+import { createProvider } from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
+import { resolveImageAttachmentAccess, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+
+//#region src/host/raccoon-llm-adapter.ts
+/**
+* The peer-dependent half of the directly-registered Raccoon provider —
+* "second upstream provider" (ROADMAP §6.1).
+*
+* Mirrors `llm-adapter.ts`'s shape: ONE `PiAiAdapter` carrying ONE profile
+* (`sensenova-raccoon` → `https://xiaohuanxiong.com/api/web/llm/v2`), an
+* INERT pi-ai auth plane (the Raccoon JWT is resolved per request from the
+* plugin's own credential store, pi-ai never manufactures it), both IMAGE
+* hooks wired (a vision model that receives an image answers
+* `UNSUPPORTED_CONTENT` otherwise), and no token baked into the profile —
+* the picker advertises models without one and a request fails at resolve
+* time, where the panel status is visible.
+*
+* The descriptor mapping lives in the peer-free `raccoon-models.ts`, so this
+* module holds only assembly against the runtime and is exercised by the
+* wiring/e2e checks, exactly as `llm-adapter.ts` is.
+*
+* @module dsh-connect-agnes-token-plan/raccoon-llm-adapter
+*/
+/** Idle ceiling while one stream read is outstanding (dsh-llm-pi-ai default). */
+const STREAM_IDLE_TIMEOUT_MS = 3e5;
+/**
+* Image budgets at the dsh-llm-pi-ai defaults. The Raccoon gateway caps one
+* request body at ~10 MB (`HTTP_413`), so the per-image byte ceiling is the
+* binding constraint; the pixel budget keeps an image inside it.
+*/
+const REQUEST_IMAGE_BUDGETS = {
+	maxRequestImageBytes: 20971520,
+	requestImagePixelBudget: 64e4,
+	requestImageMaxBytes: 1048576
+};
+/**
+* Inert pi-ai auth plane.
+*
+* Authentication goes through `resolveToken` (the stored Raccoon JWT, read
+* per request from `raccoon-store.ts`) — pi-ai's own credential lifecycle
+* must never manufacture a credential for this route, so every ambient
+* question answers "nothing stored, nothing set".
+*/
+const INERT_AUTH = {
+	credentials: {
+		async read() {},
+		async list() {
+			return [];
+		},
+		async modify() {},
+		async delete() {}
+	},
+	authContext: {
+		async env() {},
+		async fileExists() {
+			return false;
+		}
+	}
+};
+/**
+* Assemble the Raccoon adapter for one credential/catalogue snapshot.
+*
+* A fresh instance per rebuild is deliberate: `PiAiAdapter` memoizes the
+* profiles snapshot internally, so the caller REPLACES the registered
+* adapter when the credential or catalogue changes and emits
+* `llm/adapters-updated`.
+* @param {object} options - wiring.
+* @param {object[]} [options.rows] - the Raccoon roster rows (`raccoonRoster`).
+* @param {object} [options.officeIdentity] - the credential's `office_identity`
+*   (`""` for a personal account) — feeds the per-request headers.
+* @param {() => Promise<string>} options.resolveToken - resolves the live Raccoon
+*   JWT per request (refreshes inside the expiry window first).
+* @param {(service: string) => unknown} [options.get] - service resolver for
+*   the image hooks (`attachments`, `fs`).
+* @returns {{adapter: object, providerIds: string[]}} the adapter and the ids
+*   it owns.
+*/
+function createRaccoonAdapter({ rows, officeIdentity = "", resolveToken, get } = {}) {
+	const models = buildRaccoonDescriptors(rows ?? raccoonRoster(null), { officeIdentity });
+	const provider = {
+		...createProvider({
+			id: RACCOON_PROVIDER_ID,
+			name: RACCOON_DISPLAY_NAME,
+			auth: { apiKey: {
+				name: "Raccoon access token",
+				async resolve({ credential } = {}) {
+					const token = credential?.key;
+					return token === void 0 || token === "" ? void 0 : {
+						auth: { apiKey: token },
+						source: RACCOON_DISPLAY_NAME
+					};
+				}
+			} },
+			models,
+			api: openAICompletionsApi()
+		}),
+		getModels: () => models
+	};
+	const profiles = /* @__PURE__ */ new Map([[RACCOON_PROVIDER_ID, {
+		provider: RACCOON_PROVIDER_ID,
+		displayName: RACCOON_DISPLAY_NAME,
+		streamIdleTimeoutMs: STREAM_IDLE_TIMEOUT_MS,
+		retryPolicy: resolveRetryPolicy(buildRetryPolicyConfig(), `${name}.${RACCOON_PROVIDER_ID}.retryPolicy`),
+		configuredMaxTokens: /* @__PURE__ */ new Map(),
+		modelErrors: /* @__PURE__ */ new Map(),
+		...REQUEST_IMAGE_BUDGETS,
+		piProvider: provider
+	}]]);
+	const inner = new PiAiAdapter({
+		profiles: () => profiles,
+		auth: INERT_AUTH,
+		resolveApiKey: async () => resolveToken(),
+		resolveAttachments: () => get?.("attachments"),
+		resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(attachments, (hostPath) => (get?.("fs"))?.processPathFromHostPath?.(hostPath), ref)
+	});
+	return {
+		adapter: new Proxy(inner, { get(target, prop, receiver) {
+			const value = Reflect.get(target, prop, receiver);
+			if (prop === "stream") return (options) => reclassifyStream(target.stream(options));
+			if (typeof value === "function" && prop === "prepareCall") return (...args) => {
+				const prepared = value.apply(target, args);
+				if (prepared && typeof prepared.then === "function") return prepared.then((p) => p && typeof p.stream === "function" ? {
+					...p,
+					stream: (o) => reclassifyStream(p.stream(o))
+				} : p);
+				return prepared && typeof prepared.stream === "function" ? {
+					...prepared,
+					stream: (o) => reclassifyStream(prepared.stream(o))
+				} : prepared;
+			};
+			return value;
+		} }),
+		providerIds: [RACCOON_PROVIDER_ID]
+	};
+}
+
+//#endregion
+export { createRaccoonAdapter };

package/lib/raccoon-models-DV1sQN4n.js

@@ -0,0 +1,491 @@
+import { c as num, p as str, u as obj } from "./host-config-BNGgm_j7.js";
+import { randomBytes } from "node:crypto";
+
+//#region src/host/raccoon.ts
+/**
+* The Raccoon Work（商汤小浣熊）protocol layer — the pure, peer-free API half
+* of the second upstream provider (ROADMAP §6.1 "second upstream provider").
+*
+* Mechanism reference only (ROADMAP §6.1: "机制参考，不抄代码"): the endpoints,
+* the QR/SMS login walk, and the credit semantics were probed against the live
+* gateway and re-stated here, not ported. The desktop `~/.box-agent` token
+* route is REJECTED (§6.1.1: the refresh token is single-use; a 401 ×2 write-
+* back probe), so this half never touches a desktop credential file — login is
+* a self-built WeChat-QR walk whose tokens land in the DSH credentials service
+* (`raccoon-store.ts`), never in this plugin's directory, git, or logs.
+*
+* Wire facts this module encodes (all probed 2026-09 against the gateway):
+*   - envelope `{ code, message, details, data }`, success is `code === 0`;
+*   - the QR page is public: any self-made 32-hex code enters `pending` and is
+*     verified server-side, so the code is generated LOCALLY (`generateQrCode`);
+*   - the refresh token is SINGLE-USE: the server rotates BOTH tokens, so a
+*     refresh always re-stores the pair (the store owns that write-back);
+*   - `thinking` control is a PROVIDER-LEVEL dialect (`extra_body.thinking`,
+*     two states only); `reasoning_effort` is accepted by the schema but has
+*     no observable effect, so this module never emits it.
+*
+* Everything here takes an injected fetcher and pure data, so the offline
+* suites exercise it without a network; no Host peer is imported.
+*
+* @module dsh-connect-agnes-token-plan/raccoon
+*/
+/** The gateway this provider talks to. */
+const RACCOON_API_BASE = "https://xiaohuanxiong.com";
+/** Auth endpoints. */
+const RACCOON_AUTH_PREFIX = "/api/web/auth/v1";
+/** Inference + model catalogue. */
+const RACCOON_LLM_PREFIX = "/api/web/llm/v2";
+/** Credits (balance). */
+const RACCOON_POINTS_PREFIX = "/api/web/points/v1";
+/** The OpenAI-compatible chat endpoint the adapter targets. */
+const RACCOON_CHAT_URL = `${RACCOON_API_BASE}${RACCOON_LLM_PREFIX}/chat/completions`;
+/** The WeChat-QR login page the phone opens after a scan. */
+function raccoonQrLoginUrl(code) {
+	const params = new URLSearchParams({
+		code: str(code, ""),
+		appname: "商汤小浣熊官网"
+	});
+	return `${RACCOON_API_BASE}/login/mp?${params.toString()}`;
+}
+/**
+* One 32-hex scan code (16 random bytes), the exact shape the gateway's own
+* client generates. Any self-made code is accepted and held `pending` until a
+* phone confirms it, so generation is local and needs no server round-trip.
+* @returns {string} the code.
+*/
+function generateRaccoonQrCode() {
+	return randomBytes(16).toString("hex");
+}
+/** The QR poll's status values, exactly as the gateway spells them. */
+const RACCOON_QR_STATUS = Object.freeze({
+	PENDING: "pending",
+	LOGGING: "logging",
+	CANCELED: "canceled",
+	SUCCESS: "success"
+});
+/** Decode a JWT's `exp` claim to MILLISECONDS; `undefined` on any failure. */
+function decodeRaccoonJwtExpMs(token) {
+	if (typeof token !== "string" || token.length === 0) return void 0;
+	const parts = token.split(".");
+	if (parts.length < 2) return void 0;
+	try {
+		const payload = JSON.parse(Buffer.from(parts[1] ?? "", "base64url").toString("utf8"));
+		if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return void 0;
+		const seconds = num(payload.exp);
+		return typeof seconds === "number" ? seconds * 1e3 : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The header set one Raccoon request carries.
+*
+* `X-Org-Code` is EMPTY for a personal account (the client always sends the
+* header, with an empty value for personal). The optional client-identity
+* headers let a Host pose as the desktop client's family; they are advisory —
+* the gateway does not gate on them.
+* @param {object} credential - `{ access_token, office_identity?, device_id? }`.
+* @param {object} [options]
+* @param {string} [options.platform] - `X-Client-Platform` (e.g. `desktop-windows`).
+* @param {string} [options.version] - `X-Client-Version` (e.g. `v1.0.35`).
+* @returns {object} the header map.
+*/
+function raccoonHeaders(credential, options = {}) {
+	const source = obj(credential);
+	const headers = {
+		Accept: "application/json",
+		"Content-Type": "application/json",
+		Authorization: `Bearer ${str(source.access_token, "")}`,
+		"X-Org-Code": str(source.office_identity, ""),
+		"X-Raccoon-Language": "zh"
+	};
+	if (typeof options.platform === "string" && options.platform !== "") headers["X-Client-Platform"] = options.platform;
+	if (typeof options.version === "string" && options.version !== "") headers["X-Client-Version"] = options.version;
+	if (typeof source.device_id === "string" && source.device_id !== "") headers["X-Client-Device-ID"] = source.device_id;
+	return headers;
+}
+/**
+* Parse one gateway envelope. Success is `code === 0`; anything else is a
+* refusal whose `code`/`message` are surfaced (redacted at the call site when
+* a credential may be echoed back).
+*
+* `code` is read with a plain `Number` check, NOT the shared `num` helper:
+* `num` rejects `0` (it means "positive or fall back"), but `0` is exactly
+* this gateway's SUCCESS value — routing it through `num` would read every
+* successful envelope as a `-1` refusal.
+* @param {unknown} raw - the parsed JSON body.
+* @param {number} [status] - the HTTP status, for a machine-readable detail.
+* @returns {{code: number, message: string, data: object|null, status?: number}}
+*/
+function parseRaccoonEnvelope(raw, status) {
+	const body = obj(raw);
+	const parsedCode = Number(body.code);
+	return {
+		code: Number.isFinite(parsedCode) ? parsedCode : -1,
+		message: str(body.message, ""),
+		data: body.data === null || typeof body.data !== "object" || Array.isArray(body.data) ? null : obj(body.data),
+		...typeof status === "number" ? { status } : {}
+	};
+}
+/**
+* One poll of the QR login status. Any anomaly degrades to `pending`: the
+* caller polls on a 2 s cadence, and a transient network hiccup or an unknown
+* status must never read as `success` (an empty token would stall the flow)
+* or `canceled` (a live scan would be voided).
+* @param {string} code - the scan code being polled.
+* @param {typeof fetch} [fetcher] - injected fetch.
+* @returns {Promise<object>} `{ status }` plus, on success, the token pair.
+*/
+async function pollRaccoonQrLogin(code, fetcher) {
+	const effective = fetcher ?? globalThis.fetch;
+	let envelope;
+	try {
+		const response = await effective(`${RACCOON_API_BASE}${RACCOON_AUTH_PREFIX}/login_with_qrcode_code`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			},
+			body: JSON.stringify({ qrcode_code: str(code, "") })
+		});
+		envelope = parseRaccoonEnvelope(await response.json().catch(() => ({})), response.status);
+	} catch {
+		return { status: RACCOON_QR_STATUS.PENDING };
+	}
+	if (envelope.code !== 0 || envelope.data === null) return { status: RACCOON_QR_STATUS.PENDING };
+	const rawStatus = str(envelope.data.status, "");
+	if (rawStatus === RACCOON_QR_STATUS.CANCELED) return { status: RACCOON_QR_STATUS.CANCELED };
+	if (rawStatus === RACCOON_QR_STATUS.LOGGING) return {
+		status: RACCOON_QR_STATUS.LOGGING,
+		...str(envelope.data.expired_at, "") !== "" ? { expiredAt: str(envelope.data.expired_at, "") } : {}
+	};
+	if (rawStatus === RACCOON_QR_STATUS.SUCCESS) {
+		const accessToken = str(envelope.data.access_token, "");
+		if (accessToken === "") return { status: RACCOON_QR_STATUS.PENDING };
+		const refreshToken = str(envelope.data.refresh_token, "");
+		const expMs = decodeRaccoonJwtExpMs(accessToken);
+		return {
+			status: RACCOON_QR_STATUS.SUCCESS,
+			accessToken,
+			refreshToken,
+			...expMs !== void 0 ? { expiresAtMs: expMs } : {}
+		};
+	}
+	return { status: RACCOON_QR_STATUS.PENDING };
+}
+/**
+* Rotate a credential pair through the refresh endpoint. The response carries
+* the NEW pair (the refresh token is single-use — the server rotates both), so
+* the caller must re-store what this returns; keeping the old refresh token is
+* what strands a desktop-file route in a 401 loop.
+* @param {object} credential - `{ refresh_token }`.
+* @param {typeof fetch} [fetcher] - injected fetch.
+* @returns {Promise<object>} `{ ok, accessToken, refreshToken, expiresAtMs?, code?, message? }`.
+*/
+async function refreshRaccoonCredential(credential, fetcher) {
+	const effective = fetcher ?? globalThis.fetch;
+	const refreshToken = str(obj(credential).refresh_token, "");
+	if (refreshToken === "") return {
+		ok: false,
+		code: "no_refresh_token",
+		message: "the stored credential has no refresh token"
+	};
+	let envelope;
+	try {
+		const response = await effective(`${RACCOON_API_BASE}${RACCOON_AUTH_PREFIX}/refresh_token`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			},
+			body: JSON.stringify({ refresh_token: refreshToken })
+		});
+		envelope = parseRaccoonEnvelope(await response.json().catch(() => ({})), response.status);
+	} catch (error) {
+		return {
+			ok: false,
+			code: "refresh_failed",
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+	if (envelope.code !== 0 || envelope.data === null) return {
+		ok: false,
+		code: envelope.code === 401 || envelope.code === 200003 ? "session_dead" : "refresh_rejected",
+		message: envelope.message || `refresh refused (code ${envelope.code})`
+	};
+	const accessToken = str(envelope.data.access_token, "");
+	if (accessToken === "") return {
+		ok: false,
+		code: "refresh_rejected",
+		message: "the refresh response carried no access token"
+	};
+	const refreshTokenOut = str(envelope.data.refresh_token, "");
+	const expMs = decodeRaccoonJwtExpMs(accessToken);
+	return {
+		ok: true,
+		accessToken,
+		refreshToken: refreshTokenOut,
+		...expMs !== void 0 ? { expiresAtMs: expMs } : {}
+	};
+}
+/**
+* Fetch the live model catalogue, or `null` when it cannot be read.
+*
+* The adapter falls back to a static roster when this returns `null`, so a
+* transient catalogue outage degrades to the known-good models instead of
+* breaking the provider — the silent-fallback discipline of `console-client`.
+* @param {object} credential - `{ access_token }`.
+* @param {typeof fetch} [fetcher] - injected fetch.
+* @returns {Promise<object[]|null>} the normalized `[{id, name, multiplier, vision, contextWindow, maxOutputLength}]`, or `null`.
+*/
+async function fetchRaccoonCatalog(credential, fetcher) {
+	const effective = fetcher ?? globalThis.fetch;
+	try {
+		const response = await effective(`${RACCOON_API_BASE}${RACCOON_LLM_PREFIX}/model_catalog`, {
+			headers: raccoonHeaders(credential),
+			signal: AbortSignal.timeout(3e4)
+		});
+		if (!response.ok) return null;
+		const envelope = parseRaccoonEnvelope(await response.json().catch(() => ({})), response.status);
+		if (envelope.code !== 0 || envelope.data === null) return null;
+		const categories = Array.isArray(envelope.data.categories) ? envelope.data.categories : [];
+		for (const category of categories) {
+			if (obj(category).type !== "chat") continue;
+			const models = Array.isArray(obj(category).models) ? obj(category).models : [];
+			const seen = /* @__PURE__ */ new Set();
+			const out = [];
+			for (const raw of models) {
+				const model = obj(raw);
+				if (model.visible === false) continue;
+				const id = str(model.id, "");
+				if (id === "" || seen.has(id)) continue;
+				seen.add(id);
+				out.push({
+					id,
+					name: str(model.name, id),
+					multiplier: typeof model.multiplier === "number" ? model.multiplier : void 0,
+					vision: model.vision === true || (Array.isArray(model.input_modalities) ? model.input_modalities.includes("image") : false),
+					contextWindow: num(model.context_window ?? model.context_length),
+					maxOutputLength: num(model.max_output_tokens ?? model.max_output_length)
+				});
+			}
+			if (out.length > 0) return out;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Read the account's credit balance. Read-only: the gateway has NO endpoint
+* for the daily 300-point grant (the server awards it automatically as
+* `daily_grant`), so the panel must not offer a check-in button.
+* @param {object} credential - `{ access_token }`.
+* @param {typeof fetch} [fetcher] - injected fetch.
+* @returns {Promise<number|null>} the balance, or `null` when unreadable.
+*/
+async function fetchRaccoonBalance(credential, fetcher) {
+	const effective = fetcher ?? globalThis.fetch;
+	try {
+		const response = await effective(`${RACCOON_API_BASE}${RACCOON_POINTS_PREFIX}/balance`, {
+			headers: raccoonHeaders(credential),
+			signal: AbortSignal.timeout(3e4)
+		});
+		if (!response.ok) return null;
+		const envelope = parseRaccoonEnvelope(await response.json().catch(() => ({})), response.status);
+		if (envelope.code !== 0 || envelope.data === null) return null;
+		return numOrNullSafe(envelope.data.balance ?? envelope.data.available ?? envelope.data.amount);
+	} catch {
+		return null;
+	}
+}
+/** Read a finite number (0 counts), else `null`. */
+function numOrNullSafe(value) {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+/**
+* The static fallback roster: the six `visible: true` chat models the gateway
+* listed at probe time (2026-09). Used ONLY when `fetchRaccoonCatalog` comes
+* back empty, so the provider still offers models; a fresh catalogue always
+* wins over this table.
+*/
+const RACCOON_FALLBACK_MODELS = Object.freeze([
+	{
+		id: "sn-sensenova-6-8-flash",
+		name: "SenseNova 6.8 Flash",
+		multiplier: 0,
+		vision: true,
+		contextWindow: 256e3,
+		maxOutputLength: 63999
+	},
+	{
+		id: "sn-sensenova-6-8-flash-lite",
+		name: "SenseNova 6.8 Flash Lite",
+		multiplier: 0,
+		vision: true,
+		contextWindow: 256e3,
+		maxOutputLength: 63999
+	},
+	{
+		id: "sn-glm-5-3",
+		name: "GLM-5.3",
+		multiplier: .75,
+		vision: true,
+		contextWindow: 1e6,
+		maxOutputLength: 65536
+	},
+	{
+		id: "sn-kimi-k3",
+		name: "Kimi K3",
+		multiplier: 1,
+		vision: true,
+		contextWindow: 1e6,
+		maxOutputLength: 65536
+	},
+	{
+		id: "sn-glm-5-3-flash",
+		name: "GLM-5.3 Flash",
+		multiplier: .2,
+		vision: false,
+		contextWindow: 1e6,
+		maxOutputLength: 65536
+	},
+	{
+		id: "sn-deepseek-v4-1-flash",
+		name: "DeepSeek V4.1 Flash",
+		multiplier: .25,
+		vision: false,
+		contextWindow: 1e6,
+		maxOutputLength: 65536
+	}
+]);
+
+//#endregion
+//#region src/host/raccoon-models.ts
+/**
+* Raccoon catalogue entry → pi-ai model descriptor mapping — the peer-free half
+* of the second upstream provider.
+*
+* Mirrors `llm-models.ts`'s discipline: build plain objects only (no Host peer
+* import) so the mapping decisions are testable on a clean checkout.
+* `raccoon-llm-adapter.ts` is the peer-dependent half that hands these
+* descriptors to `createProvider`.
+*
+* Two decisions carried here:
+*   1. `reasoning: false` for now — the Raccoon gateway's ONLY effective
+*      thinking channel is `extra_body.thinking` (a provider-level dialect),
+*      which pi-ai's openai-completions does NOT emit. Offering a thinking
+*      selector would 400 or be silently ignored, so the honest v1 shape is
+*      "no toggle; the gateway defaults to thinking ON". This is a stated
+*      limitation, not an oversight.
+*   2. The Raccoon auth/identity headers ride in each descriptor's `headers`
+*      map (pi-ai merges `model.headers` into the OpenAI client), because the
+*      gateway reads `X-Org-Code` / `X-Raccoon-Language` per request.
+*
+* @module dsh-connect-agnes-token-plan/raccoon-models
+*/
+/** The provider id this plugin registers under for Raccoon. */
+const RACCOON_PROVIDER_ID = "sensenova-raccoon";
+/** What the DSH model picker shows as the Raccoon provider's name. */
+const RACCOON_DISPLAY_NAME = "SenseNova Raccoon";
+/**
+* The Raccoon LLM base URL the OpenAI-compatible chat endpoint addresses.
+* `openAICompletionsApi` appends `chat/completions` to this.
+*/
+const RACCOON_BASE_URL = `${RACCOON_API_BASE}${RACCOON_LLM_PREFIX}`;
+/** The zero-cost sentinel: per-token prices are unknowable (credit-gated). */
+const NO_COST = Object.freeze({
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+});
+/** The Raccoon auth/identity headers every request carries. */
+function raccoonRequestHeaders(officeIdentity = "") {
+	return {
+		Accept: "application/json",
+		"Content-Type": "application/json",
+		"X-Org-Code": str(officeIdentity, ""),
+		"X-Raccoon-Language": "zh"
+	};
+}
+/**
+* The Raccoon model rows the panel shows and the adapter offers.
+*
+* A live catalogue row always beats the static fallback roster: the caller
+* passes the fetched catalogue, and only when it is `null`/empty does this
+* fall back to `RACCOON_FALLBACK_MODELS`. The row keeps only what the picker
+* and panel need (id, a display name, vision, window, multiplier) — the raw
+* catalogue field the gateway adds later does not leak into the panel.
+* @param {object[]|null} [catalog] - the `fetchRaccoonCatalog` result.
+* @returns {object[]} the Raccoon model rows.
+*/
+function raccoonRoster(catalog) {
+	const rows = Array.isArray(catalog) && catalog.length > 0 ? catalog : RACCOON_FALLBACK_MODELS;
+	const out = [];
+	for (const row of rows) {
+		const id = str(row?.id, "");
+		if (id === "") continue;
+		out.push({
+			id,
+			name: str(row?.name, id),
+			vision: row?.vision === true,
+			multiplier: typeof row?.multiplier === "number" ? row.multiplier : void 0,
+			contextWindow: num(row?.contextWindow),
+			maxOutputLength: num(row?.maxOutputLength)
+		});
+	}
+	return out;
+}
+/**
+* Map one Raccoon row onto the pi-ai model descriptor the adapter offers.
+* @param {object} row - a {@link raccoonRoster} row (must carry `id`).
+* @param {object} [options] - `{ officeIdentity }` for the request headers.
+* @returns {object} the pi-ai descriptor.
+*/
+function raccoonToDescriptor(row, options = {}) {
+	const id = str(row?.id, "");
+	if (id === "") throw new Error("racconToDescriptor: row has no id");
+	const vision = row?.vision === true;
+	const multiplier = typeof row?.multiplier === "number" ? row.multiplier : void 0;
+	const suffix = multiplier === void 0 ? "" : multiplier === 0 ? "（free）" : multiplier === 1 ? "" : `（×${multiplier}）`;
+	return {
+		id,
+		name: `${str(row?.name, id)}${suffix}`,
+		api: "openai-completions",
+		provider: RACCOON_PROVIDER_ID,
+		baseUrl: RACCOON_BASE_URL,
+		input: vision ? ["text", "image"] : ["text"],
+		reasoning: false,
+		cost: { ...NO_COST },
+		contextWindow: num(row?.contextWindow) ?? 256e3,
+		maxTokens: num(row?.maxOutputLength) ?? 32e3,
+		headers: raccoonRequestHeaders(options.officeIdentity),
+		compat: {
+			maxTokensField: "max_tokens",
+			supportsDeveloperRole: false
+		}
+	};
+}
+/**
+* Build the whole descriptor list for one Raccoon roster.
+* @param {object[]} [roster] - the {@link raccoonRoster} result.
+* @param {object} [options] - `{ officeIdentity }`.
+* @returns {object[]} the pi-ai descriptors.
+*/
+function buildRaccoonDescriptors(roster, options = {}) {
+	const list = Array.isArray(roster) ? roster : raccoonRoster(null);
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const row of list) {
+		const id = str(row?.id, "");
+		if (id === "" || seen.has(id)) continue;
+		seen.add(id);
+		out.push(raccoonToDescriptor(row, options));
+	}
+	return out;
+}
+
+//#endregion
+export { RACCOON_FALLBACK_MODELS as a, fetchRaccoonBalance as c, pollRaccoonQrLogin as d, raccoonQrLoginUrl as f, raccoonRoster as i, fetchRaccoonCatalog as l, RACCOON_PROVIDER_ID as n, RACCOON_QR_STATUS as o, refreshRaccoonCredential as p, buildRaccoonDescriptors as r, decodeRaccoonJwtExpMs as s, RACCOON_DISPLAY_NAME as t, generateRaccoonQrCode as u };