@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/azure-openai-responses-DuukbD0F.mjs

@@ -0,0 +1,274 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { r as __exportAll } from "./fs-promises-shim-Bx0fpxuk.mjs";
+import { P as $env } from "./src-BgpusnsB.mjs";
+import { B as OpenAIHttpError, g as MissingApiKeyError, l as finalize, n as StreamTimeoutError, s as ProviderResponseError, t as ConfigurationError, v as AbortError } from "./error-Dd8DIqs-.mjs";
+import { L as sanitizeSchemaForOpenAIResponses, k as toolWireSchema, s as resolveCacheRetention } from "./utils-Cp76gCyk.mjs";
+import { C as applyResponsesReasoningParams, D as buildResponsesInput, K as getOpenAIPromptCacheKey, N as createInitialResponsesAssistantMessage, Q as isOpenAIResponsesProgressEvent, g as applyCommonResponsesSamplingParams, it as parseAzureDeploymentNameMap, n as getEnvApiKey, ot as processResponsesStream, yt as mapToOpenAIResponsesToolChoice } from "./stream-CRtexYLe.mjs";
+import { t as createAbortSourceTracker } from "./abort-dIkZBV7Q.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-BbFZJy-z.mjs";
+import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs } from "./idle-iterator-DUjKQEGT.mjs";
+import { c as postOpenAIStream, r as createOpenAIReasoningEffortFallbackKey, s as resolveOpenAIReasoningEffortFallback, t as applyOpenAIReasoningEffortFallback } from "./openai-reasoning-fallback-Nj6yB2rY.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/azure-openai-responses.ts
+var azure_openai_responses_exports = /* @__PURE__ */ __exportAll({ streamAzureOpenAIResponses: () => streamAzureOpenAIResponses });
+const DEFAULT_AZURE_API_VERSION = "v1";
+const AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE = "Azure OpenAI responses stream timed out while waiting for the first event";
+function resolveDeploymentName(model, options) {
+	if (options?.azureDeploymentName) return options.azureDeploymentName;
+	return parseAzureDeploymentNameMap($env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(model.id) ?? model.id;
+}
+/**
+* Generate function for Azure OpenAI Responses API
+*/
+const streamAzureOpenAIResponses = (model, context, options) => {
+	if (options?.promptCache?.mode === "explicit" && resolveCacheRetention(options.cacheRetention) !== "none") throw new ConfigurationError(`OpenAI explicit prompt caching is unsupported for ${model.provider}/${model.id}; Azure Responses does not emit explicit cache controls.`);
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		let firstTokenTime;
+		const deploymentName = resolveDeploymentName(model, options);
+		const output = createInitialResponsesAssistantMessage("azure-openai-responses", model.provider, model.id);
+		let rawRequestDump;
+		const abortTracker = createAbortSourceTracker(options?.signal);
+		const firstEventTimeoutAbortError = new StreamTimeoutError(AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE);
+		const { requestAbortController, requestSignal } = abortTracker;
+		const onSseEvent = options?.onSseEvent;
+		const rawSseObserver = onSseEvent ? (event) => {
+			if (!event.event && event.data && event.data !== "[DONE]") try {
+				const parsed = JSON.parse(event.data);
+				const resolvedEvent = typeof parsed.type === "string" ? parsed.type : typeof parsed.object === "string" ? parsed.object : null;
+				if (resolvedEvent) {
+					event.event = resolvedEvent;
+					event.raw = [`event: ${resolvedEvent}`, ...event.raw];
+				}
+			} catch {}
+			onSseEvent(event, model);
+		} : void 0;
+		try {
+			const { url, headers, baseUrl } = buildAzureResponsesRequest(model, options?.apiKey || getEnvApiKey(model.provider) || "", options);
+			const requestModel = modelForAzureEndpoint(model, baseUrl);
+			let params = buildParams(requestModel, context, options, deploymentName);
+			const replacementPayload = await options?.onPayload?.(params, requestModel);
+			if (replacementPayload !== void 0) params = replacementPayload;
+			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
+			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs);
+			const requestTimeoutMs = firstEventTimeoutMs !== void 0 && firstEventTimeoutMs > 0 ? firstEventTimeoutMs : void 0;
+			rawRequestDump = {
+				provider: model.provider,
+				api: output.api,
+				model: model.id,
+				method: "POST",
+				url,
+				body: params
+			};
+			const reasoningEffortFallbackKey = createOpenAIReasoningEffortFallbackKey("azure-responses", url, typeof params.model === "string" ? params.model : model.id);
+			const attemptedReasoningEffortFallbacks = /* @__PURE__ */ new Set();
+			let openaiStream;
+			while (true) {
+				let requestTimeout;
+				if (requestTimeoutMs !== void 0) requestTimeout = setTimeout(() => abortTracker.abortLocally(firstEventTimeoutAbortError), requestTimeoutMs);
+				try {
+					const headersWithTimeout = { ...headers };
+					if (requestTimeoutMs !== void 0) headersWithTimeout["X-Stainless-Timeout"] = Math.floor(requestTimeoutMs / 1e3).toString();
+					openaiStream = (await postOpenAIStream({
+						url,
+						headers: headersWithTimeout,
+						body: params,
+						signal: requestSignal,
+						fetch: options?.fetch,
+						onSseEvent: rawSseObserver
+					})).events;
+					break;
+				} catch (error) {
+					const capturedErrorResponse = error instanceof OpenAIHttpError ? error.captured : void 0;
+					const reasoningEffortFallback = !requestSignal.aborted ? resolveOpenAIReasoningEffortFallback(error, capturedErrorResponse, params) : void 0;
+					if (reasoningEffortFallback === void 0) throw error;
+					const retryMarker = `${reasoningEffortFallbackKey}:${String(reasoningEffortFallback)}`;
+					if (attemptedReasoningEffortFallbacks.has(retryMarker)) throw error;
+					attemptedReasoningEffortFallbacks.add(retryMarker);
+					applyOpenAIReasoningEffortFallback(params, reasoningEffortFallback);
+					rawRequestDump.body = params;
+				} finally {
+					if (requestTimeout !== void 0) clearTimeout(requestTimeout);
+				}
+			}
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			const timedOpenaiStream = iterateWithIdleTimeout(openaiStream, {
+				idleTimeoutMs,
+				firstItemTimeoutMs: firstEventTimeoutMs,
+				firstItemErrorMessage: AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE,
+				errorMessage: "Azure OpenAI responses stream stalled while waiting for the next event",
+				onIdle: () => requestAbortController.abort(),
+				onFirstItemTimeout: () => abortTracker.abortLocally(firstEventTimeoutAbortError),
+				abortSignal: options?.signal,
+				isProgressItem: isOpenAIResponsesProgressEvent
+			});
+			let sawTerminalResponseEvent = false;
+			await processResponsesStream(timedOpenaiStream, output, stream, model, {
+				onFirstToken: () => {
+					if (!firstTokenTime) firstTokenTime = performance.now();
+				},
+				onCompleted: () => {
+					sawTerminalResponseEvent = true;
+				}
+			});
+			const firstEventTimeoutError = abortTracker.getLocalAbortReason();
+			if (firstEventTimeoutError) throw firstEventTimeoutError;
+			if (abortTracker.wasCallerAbort()) throw new AbortError();
+			if (!sawTerminalResponseEvent) throw new ProviderResponseError("Azure OpenAI responses stream closed before a terminal response event was received", {
+				provider: model.provider,
+				kind: "incomplete-stream"
+			});
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+				provider: model.provider,
+				kind: "output"
+			});
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			const result = await finalize(error, {
+				api: model.api,
+				abortTracker,
+				rawRequestDump
+			});
+			output.stopReason = result.stopReason;
+			output.errorStatus = result.status;
+			output.errorId = result.id;
+			output.errorMessage = result.message;
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+function resolveAzureConfig(model, options) {
+	const apiVersion = options?.azureApiVersion || $env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION;
+	const baseUrl = options?.azureBaseUrl?.trim() || $env.AZURE_OPENAI_BASE_URL?.trim() || void 0;
+	const resourceName = options?.azureResourceName || $env.AZURE_OPENAI_RESOURCE_NAME;
+	let resolvedBaseUrl = baseUrl;
+	if (!resolvedBaseUrl && resourceName) resolvedBaseUrl = `https://${resourceName}.openai.azure.com/openai/v1`;
+	if (!resolvedBaseUrl && model.baseUrl) resolvedBaseUrl = model.baseUrl;
+	if (!resolvedBaseUrl) throw new ConfigurationError("Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or pass azureBaseUrl, azureResourceName, or model.baseUrl.");
+	return {
+		baseUrl: resolvedBaseUrl.replace(/\/+$/, ""),
+		apiVersion
+	};
+}
+function modelForAzureEndpoint(model, baseUrl) {
+	if (model.supportsComputerUseConfig !== void 0 || model.supportsComputerUse !== true) return model;
+	try {
+		const url = new URL(baseUrl);
+		if (url.protocol === "https:" && (url.hostname.endsWith(".openai.azure.com") || url.hostname === "models.inference.ai.azure.com")) return model;
+	} catch {}
+	return {
+		...model,
+		supportsComputerUse: false
+	};
+}
+/**
+* Replicates the `AzureOpenAI` SDK client's request shape for `/responses`:
+* a string api key becomes a single `api-key` header (azure.mjs `authHeaders`;
+* never `Authorization: Bearer`), `api-version` rides as a query parameter
+* (azure.mjs constructor `defaultQuery`), and `/responses` is not a
+* deployment-scoped path, so no `/deployments/{model}` URL rewriting applies.
+* Custom model/options headers may override the auth header, matching the SDK's
+* `buildHeaders` precedence.
+*/
+function buildAzureResponsesRequest(model, apiKey, options) {
+	if (!apiKey) {
+		const envKey = $env.AZURE_OPENAI_API_KEY;
+		if (!envKey) throw new MissingApiKeyError(void 0, "Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.");
+		apiKey = envKey;
+	}
+	const headers = {
+		"api-key": apiKey,
+		...model.headers ?? {}
+	};
+	if (options?.headers) Object.assign(headers, options.headers);
+	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
+	return {
+		url: `${baseUrl}/responses?api-version=${encodeURIComponent(apiVersion)}`,
+		headers,
+		baseUrl
+	};
+}
+function buildParams(model, context, options, deploymentName) {
+	const systemRole = model.reasoning && model.compat.supportsDeveloperRole ? "developer" : "system";
+	const params = {
+		model: deploymentName,
+		input: buildResponsesInput({
+			model,
+			context,
+			strictResponsesPairing: true,
+			supportsImageDetailOriginal: model.compat.supportsImageDetailOriginal,
+			systemRole,
+			nativeHistory: {
+				replay: true,
+				filterReasoning: false
+			},
+			includeThinkingSignatures: true,
+			developerStringContent: true,
+			preserveAssistantMessageIds: true
+		}),
+		stream: true,
+		prompt_cache_key: getOpenAIPromptCacheKey(options),
+		store: false
+	};
+	applyCommonResponsesSamplingParams(params, options, model);
+	if (options?.include?.length) params.include = Array.from(new Set(options.include));
+	if (context.tools) {
+		const serializedTools = [];
+		for (const tool of context.tools) {
+			if (tool.native?.type === "computer") {
+				if (model.supportsComputerUse === true) {
+					serializedTools.push({ type: "computer" });
+					continue;
+				}
+			} else if (tool.native !== void 0) continue;
+			serializedTools.push({
+				type: "function",
+				name: tool.name,
+				description: tool.description || "",
+				parameters: sanitizeSchemaForOpenAIResponses(toolWireSchema(tool)),
+				strict: false
+			});
+		}
+		if (serializedTools.length > 0) {
+			params.tools = serializedTools;
+			if (options?.toolChoice) {
+				let toolChoice = mapToOpenAIResponsesToolChoice(options.toolChoice);
+				const hasComputerTool = serializedTools.some((tool) => tool.type === "computer");
+				if (toolChoice && typeof toolChoice !== "string" && toolChoice.type === "computer" && !hasComputerTool) {
+					const computer = context.tools.find((tool) => tool.native?.type === "computer");
+					if (computer && serializedTools.some((tool) => tool.type === "function" && tool.name === computer.name)) toolChoice = {
+						type: "function",
+						name: computer.name
+					};
+				}
+				if (toolChoice && typeof toolChoice !== "string" && toolChoice.type === "function" && hasComputerTool) {
+					if (context.tools.find((tool) => tool.native?.type === "computer")?.name === toolChoice.name) toolChoice = { type: "computer" };
+				}
+				if (toolChoice && (typeof toolChoice === "string" || toolChoice.type === "computer" && hasComputerTool || toolChoice.type === "function" && serializedTools.some((tool) => tool.type === "function" && tool.name === toolChoice.name))) params.tool_choice = toolChoice;
+			}
+		}
+	}
+	applyResponsesReasoningParams(params, model, options);
+	return params;
+}
+//#endregion
+export { azure_openai_responses_exports as t };

package/lib/bun-shim.mjs

@@ -15,8 +15,11 @@ import JSON5 from "json5";
 * `fromBase64` extensions Bun adds. Every change here is recorded in step.md
 * ("Bun 兼容" section).
 *
-* `Bun.Image` deliberately throws: plan.md 拍板 image 从 read 去掉（与官方
-* read_image 重复）。
+* `Bun.Image` is backed by `sharp` resolved at runtime (拍板#22, 2026-08-28:
+* 图像链路重建——sharp 兼容层取代构造即抛错的桩，fetch/read 的 resizeImage
+* 后端由此复活）。sharp 是宿主 DSH 的传递依赖（dsh-attachment-local 直接依
+* 赖），本包不打包、不安装，运行时经 createRequire/import 级联解析；解析不到
+* 时抛带指引的错误，`resizeImage` 的 try/catch 降级语义保持不变。
 */
 function patchBase64() {
 	const bufProto = Buffer.prototype;
@@ -110,12 +113,35 @@ var BunFileSliceShim = class extends BunFileShim {
 		this.#start = start;
 		this.#end = end;
 	}
-	get size() {
-		const total = super.size;
-		return Math.max(0, (this.#end ?? total) - this.#start);
-	}
+	/** Resolve the slice window against `total` with Bun's Blob semantics:
+	* negative endpoints count from the end (slice(-8) is a window of length 8,
+	* so the sliced object's size is 8), NaN → 0, out-of-range clamps. */
+	#window(total) {
+		const from = Number.isNaN(this.#start) ? 0 : this.#start;
+		const to = this.#end === void 0 ? total : Number.isNaN(this.#end) ? 0 : this.#end;
+		const start = from < 0 ? Math.max(0, total + from) : Math.min(from, total);
+		const end = to < 0 ? Math.max(0, total + to) : Math.min(to, total);
+		return [start, Math.max(start, end)];
+	}
+	/** S-15a: positional read — open the file and read only the window instead
+	* of reading the whole file and subarray-ing (30MB file + slice(1000,2000)
+	* spiked 29.7MB under the old whole-read). */
 	async #sliced() {
-		return (await fsp.readFile(this.path)).subarray(this.#start, this.#end);
+		const fh = await fsp.open(this.path, "r");
+		try {
+			const [start, end] = this.#window((await fh.stat()).size);
+			const length = end - start;
+			if (length <= 0) return /* @__PURE__ */ new Uint8Array(0);
+			const buf = new Uint8Array(length);
+			const { bytesRead } = await fh.read(buf, 0, length, start);
+			return bytesRead < length ? buf.subarray(0, bytesRead) : buf;
+		} finally {
+			await fh.close();
+		}
+	}
+	get size() {
+		const [start, end] = this.#window(super.size);
+		return end - start;
 	}
 	async text() {
 		return new TextDecoder("utf-8", { fatal: false }).decode(await this.#sliced());
@@ -127,6 +153,13 @@ var BunFileSliceShim = class extends BunFileShim {
 		const b = await this.#sliced();
 		return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
 	}
+	/** Blob semantics: stream yields only the slice window. */
+	stream() {
+		return new ReadableStream({ start: async (controller) => {
+			controller.enqueue(await this.#sliced());
+			controller.close();
+		} });
+	}
 };
 var FileSinkShim = class {
 	#fd = null;
@@ -333,9 +366,171 @@ function bunColor(color, format) {
 	if (format === "ansi256") return `\x1b[38;5;${16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5)}m`;
 	return `\x1b[38;2;${r};${g};${b}m`;
 }
-var BunImageUnavailable = class {
-	constructor() {
-		throw new Error("DSH: Bun.Image 不可用 — read 内图片读取已按 plan.md 去掉，请用 read_image 工具");
+let sharpLoaderPromise;
+async function loadSharp() {
+	if (!sharpLoaderPromise) sharpLoaderPromise = resolveSharp();
+	try {
+		return await sharpLoaderPromise;
+	} catch (error) {
+		sharpLoaderPromise = void 0;
+		throw error;
+	}
+}
+function normalizeSharp(mod) {
+	const candidate = mod?.default ?? mod;
+	const fn = candidate?.sharp ?? candidate;
+	return typeof fn === "function" ? fn : void 0;
+}
+async function resolveSharp() {
+	const errors = [];
+	try {
+		const sharp = normalizeSharp(await import("sharp"));
+		if (sharp) return sharp;
+		errors.push("import(\"sharp\"): no callable export");
+	} catch (error) {
+		errors.push(`import("sharp"): ${error.message.split("\n")[0]}`);
+	}
+	try {
+		const { createRequire } = await import("node:module");
+		const required = normalizeSharp(createRequire(import.meta.url)("sharp"));
+		if (required) return required;
+		errors.push("createRequire(\"sharp\"): no callable export");
+	} catch (error) {
+		errors.push(`createRequire("sharp"): ${error.message.split("\n")[0]}`);
+	}
+	try {
+		const { createRequire } = await import("node:module");
+		const { fileURLToPath } = await import("node:url");
+		const { existsSync } = await import("node:fs");
+		let dir = path.dirname(fileURLToPath(import.meta.url));
+		for (let depth = 0; depth < 10; depth++) {
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			if (existsSync(path.join(parent, "node_modules", "@deepseek-ai", "dsh", "node_modules", "sharp", "package.json"))) {
+				const sharp = normalizeSharp(createRequire(path.join(parent, "noop.js"))("sharp"));
+				if (sharp) return sharp;
+			}
+			dir = parent;
+		}
+	} catch {}
+	throw new Error(`DSH: Bun.Image 需要 sharp，但运行时解析失败（${errors.join("；")}）。sharp 应随宿主 @deepseek-ai/dsh（dsh-attachment-local）安装；图片缩放将按调用方的降级路径处理。`);
+}
+/** Map sharp's format vocabulary onto Bun.Image's (width/height/format[/hasAlpha]). */
+function mapImageMetadata(meta) {
+	const format = typeof meta.format === "string" ? meta.format : void 0;
+	return {
+		width: typeof meta.width === "number" ? meta.width : 0,
+		height: typeof meta.height === "number" ? meta.height : 0,
+		...format !== void 0 ? { format } : {},
+		...typeof meta.channels === "number" ? { hasAlpha: meta.channels === 2 || meta.channels === 4 } : {}
+	};
+}
+var BunImageShim = class BunImageShim {
+	#source;
+	#steps;
+	constructor(bytes, steps) {
+		this.#source = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes;
+		this.#steps = steps ?? [];
+	}
+	#extend(step) {
+		return new BunImageShim(this.#source, [...this.#steps, step]);
+	}
+	async metadata() {
+		return mapImageMetadata(await (await loadSharp())(this.#source, { failOn: "error" }).metadata());
+	}
+	resize(widthOrOpts, height) {
+		if (typeof widthOrOpts === "object" && widthOrOpts !== null) return this.#extend({
+			op: "resize",
+			args: [widthOrOpts.width, widthOrOpts.height]
+		});
+		return this.#extend({
+			op: "resize",
+			args: [widthOrOpts, height]
+		});
+	}
+	/** Bun's resize() accepts { width, height, fit } — expose fit through to sharp. */
+	resizeWithFit(width, height, fit) {
+		return this.#extend({
+			op: "resize",
+			args: [
+				width,
+				height,
+				{ fit }
+			]
+		});
+	}
+	png() {
+		return this.#extend({
+			op: "png",
+			args: []
+		});
+	}
+	jpeg(opts) {
+		return this.#extend({
+			op: "jpeg",
+			args: [opts]
+		});
+	}
+	webp(opts) {
+		return this.#extend({
+			op: "webp",
+			args: [opts]
+		});
+	}
+	rotate() {
+		return this.#extend({
+			op: "rotate",
+			args: []
+		});
+	}
+	flip(flip) {
+		return this.#extend({
+			op: "flip",
+			args: [flip]
+		});
+	}
+	blur(radius) {
+		return this.#extend({
+			op: "blur",
+			args: [radius]
+		});
+	}
+	sharpen(radius) {
+		return this.#extend({
+			op: "sharpen",
+			args: [radius]
+		});
+	}
+	#build() {
+		return loadSharp().then((sharp) => {
+			let pipe = sharp(this.#source, { failOn: "error" });
+			for (const step of this.#steps) switch (step.op) {
+				case "resize": {
+					const [w, h, extra] = step.args;
+					pipe = pipe.resize(w ?? 0, h ?? 0, { fit: extra?.fit ?? "cover" });
+					break;
+				}
+				case "png":
+					pipe = pipe.png();
+					break;
+				case "jpeg":
+					pipe = pipe.jpeg(step.args[0] ?? void 0);
+					break;
+				case "webp": pipe = pipe.webp(step.args[0] ?? void 0);
+			}
+			return pipe.toBuffer();
+		});
+	}
+	async bytes() {
+		return this.#build();
+	}
+	async toBase64() {
+		return Buffer.from(await this.#build()).toString("base64");
+	}
+	async write(destPath) {
+		const data = await this.#build();
+		await fsp.writeFile(destPath, data);
+		return data.byteLength;
 	}
 };
 async function memberToBytes(content) {
@@ -379,6 +574,50 @@ async function archiveWrite(destPath, record, opts) {
 	await fsp.mkdir(path.dirname(destPath), { recursive: true });
 	await fsp.writeFile(destPath, buf);
 }
+/** Consume one escape sequence starting at `esc` (text[esc] === ESC); returns
+* the index of the first char after it. Malformed / unterminated sequences
+* swallow through their last consumed byte (Bun parity on the S-8 corpus). */
+function scanAnsiEscape(text, esc) {
+	const n = text.length;
+	const next = esc + 1 < n ? text.charCodeAt(esc + 1) : -1;
+	if (next === -1) return n;
+	if (next === 27) return esc + 1;
+	if (next === 91) {
+		let i = esc + 2;
+		if (i < n && text.charCodeAt(i) >= 60 && text.charCodeAt(i) <= 63) i++;
+		while (i < n && text.charCodeAt(i) >= 48 && text.charCodeAt(i) <= 63) i++;
+		while (i < n && text.charCodeAt(i) >= 32 && text.charCodeAt(i) <= 47) i++;
+		return i < n && text.charCodeAt(i) >= 64 && text.charCodeAt(i) <= 126 ? i + 1 : i;
+	}
+	if (next === 93 || next === 80 || next === 88 || next === 94 || next === 95) {
+		let i = esc + 2;
+		while (i < n) {
+			const c = text.charCodeAt(i);
+			if (c === 7) return i + 1;
+			if (c === 27 && i + 1 < n && text.charCodeAt(i + 1) === 92) return i + 2;
+			i++;
+		}
+		return n;
+	}
+	let i = esc + 1;
+	while (i < n && text.charCodeAt(i) >= 32 && text.charCodeAt(i) <= 47) i++;
+	return i < n && text.charCodeAt(i) >= 48 && text.charCodeAt(i) <= 126 ? i + 1 : i;
+}
+function bunStripANSI(text) {
+	if (text.indexOf("\x1B") === -1) return text;
+	let out = "";
+	let i = 0;
+	const n = text.length;
+	while (i < n) {
+		if (text.charCodeAt(i) !== 27) {
+			out += text[i];
+			i++;
+			continue;
+		}
+		i = scanAnsiEscape(text, i);
+	}
+	return out;
+}
 function installBunShim() {
 	patchBase64();
 	const g = globalThis;
@@ -394,9 +633,10 @@ function installBunShim() {
 		Glob: GlobShim,
 		Archive: { write: archiveWrite },
 		FileSink: FileSinkShim,
-		Image: BunImageUnavailable,
+		Image: BunImageShim,
 		CryptoHasher: CryptoHasherShim,
 		color: bunColor,
+		stripANSI: bunStripANSI,
 		JSON,
 		JSON5,
 		Encoding: {},
@@ -408,4 +648,4 @@ function installBunShim() {
 	bun.hash.xxHash64 = bunHashXxHash64;
 }
 //#endregion
-export { BunFileShim, BunFileSliceShim, FileSinkShim, GlobShim, installBunShim };
+export { BunFileShim, BunFileSliceShim, BunImageShim, FileSinkShim, GlobShim, bunStripANSI, installBunShim };

package/lib/bundled-references-CSuBco5p.mjs

@@ -0,0 +1,55 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { i as getBundledProviders, r as getBundledModels } from "./models-CfT4coYT.mjs";
+import { r as isZeroCostXaiOAuthReference } from "./identity-DnB63pS7.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@17.3.5/node_modules/@oh-my-pi/pi-catalog/src/provider-models/bundled-references.ts
+/**
+* Project a built `Model` back to spec stage: `compat` becomes the verbatim
+* sparse override record (`compatConfig`), never the resolved view. Discovery
+* mappers spread these references into the specs they hand to the model
+* manager, which rebuilds via `buildModel`.
+*/
+function toModelSpec(model) {
+	const { compat: _compat, compatConfig, ...rest } = model;
+	return {
+		...rest,
+		compat: compatConfig
+	};
+}
+function createBundledReferenceMap(provider) {
+	const references = /* @__PURE__ */ new Map();
+	for (const model of getBundledModels(provider)) references.set(model.id, toModelSpec(model));
+	return references;
+}
+let globalReferences;
+function getGlobalReferences() {
+	if (globalReferences) return globalReferences;
+	const references = /* @__PURE__ */ new Map();
+	for (const provider of getBundledProviders()) for (const model of getBundledModels(provider)) {
+		const candidate = model;
+		if (isZeroCostXaiOAuthReference(candidate)) continue;
+		const existing = references.get(candidate.id);
+		if (!existing) references.set(candidate.id, candidate);
+		else if (candidate.contextWindow !== existing.contextWindow) {
+			if ((candidate.contextWindow ?? 0) > (existing.contextWindow ?? 0)) references.set(candidate.id, candidate);
+		} else if (candidate.maxTokens !== existing.maxTokens) {
+			if ((candidate.maxTokens ?? 0) > (existing.maxTokens ?? 0)) references.set(candidate.id, candidate);
+		} else if (existing.provider !== "openai" && candidate.provider === "openai") references.set(candidate.id, candidate);
+	}
+	globalReferences = references;
+	return references;
+}
+function createReferenceResolver(providerReferenceSource) {
+	let lazyProviderReferences;
+	const getProviderReferences = typeof providerReferenceSource === "function" ? () => lazyProviderReferences ??= providerReferenceSource() : () => providerReferenceSource;
+	return (modelId) => {
+		const providerRefs = getProviderReferences();
+		const globalRefs = getGlobalReferences();
+		const providerRef = providerRefs.get(modelId);
+		if (providerRef) return providerRef;
+		const globalRef = globalRefs.get(modelId);
+		return globalRef ? toModelSpec(globalRef) : void 0;
+	};
+}
+//#endregion
+export { createReferenceResolver as n, toModelSpec as r, createBundledReferenceMap as t };