@huaweidevtools/aishell-dsh-llm 0.0.1-beta.2 → 0.0.2

package/lib/index.js

@@ -1,25 +1,1052 @@
 import { createCredentialsStore } from "@huaweidevtools/aishell-dsh-credentials-store";
-import { LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
+import { IMAGE_OFFLOAD_REQUIRED_CODE, LlmAdapter, LlmError, contentHasImage, offloadedImageText, projectOffloadedImages, requestImageHandleText, requiredImageOffload, resolveImageAttachmentAccess } from "@deepseek-ai/dsh-llm";
+import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
 import { brandString } from "@deepseek-ai/dsh-brand";
 import { EventSourceParserStream } from "eventsource-parser/stream";
 import { sign } from "@huaweidevtools/aishell-dsh-credentials-store/signer";
 
+//#region ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.5/node_modules/@deepseek-ai/cosmokit/lib/index.js
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+/** Shared config references used by schema validators and plugin runtimes. */
+const write = Symbol.for("cosmokit.volatile.write");
+function snapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (typeof value === "function") throw new TypeError("volatile config cannot contain functions");
+	if (value === null || typeof value !== "object") return value;
+	if (ancestors.has(value)) throw new TypeError("volatile config cannot contain cycles");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return Object.freeze(value.map((item) => snapshot(item, ancestors)));
+		if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("volatile config objects must be plain objects or arrays");
+		return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item, ancestors)])));
+	} finally {
+		ancestors.delete(value);
+	}
+}
+/**
+* Create a detached reference containing an immutable copy of the supplied data.
+* @param value - validated config data; class instances and functions are unsupported.
+* @returns a reference whose value is updated only by its owning runtime.
+*/
+function createVolatile(value) {
+	let current = snapshot(value);
+	return Object.freeze({
+		get: () => current,
+		[write]: (value$1) => {
+			current = value$1;
+		}
+	});
+}
+/**
+* Identify references across ESM/CJS copies of the shared library.
+* @param value - a parsed config value.
+* @returns whether the value implements the shared reference protocol.
+*/
+function isVolatile(value) {
+	return typeof value === "object" && value !== null && write in value;
+}
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value$1) => is(type, value$1);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+/** Binary source detection and base64/hex conversion helpers. */
+var Binary;
+(function(Binary$1) {
+	Binary$1.is = isArrayBufferLike;
+	Binary$1.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary$1.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary$1.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary$1.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary$1.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary$1.fromHex = fromHex;
+})(Binary || (Binary = {}));
+/** Decode a base64 string into binary data. */
+const base64ToArrayBuffer = Binary.fromBase64;
+/** Encode binary data as base64. */
+const arrayBufferToBase64 = Binary.toBase64;
+/** Decode a hex string into binary data. */
+const hexToArrayBuffer = Binary.fromHex;
+/** Encode binary data as hex. */
+const arrayBufferToHex = Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result$1 = [];
+		refs.set(source, result$1);
+		source.forEach((value, index) => {
+			result$1[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result$1;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/**
+* Compare values recursively, treating two volatile references as equal regardless of value.
+* Strict comparison distinguishes null/undefined, treats opaque objects by identity,
+* compares URLs by normalized href, treats array holes as undefined, and considers distinct cyclic structures unequal.
+* @param a - first value.
+* @param b - second value.
+* @param strict - whether to require strict data equality outside volatile references.
+* @returns whether the values compare equal.
+*/
+function deepEqual(a, b, strict) {
+	const ancestors = /* @__PURE__ */ new Set();
+	function compare(a$1, b$1) {
+		if (a$1 === b$1) return true;
+		if (isVolatile(a$1) || isVolatile(b$1)) return isVolatile(a$1) && isVolatile(b$1);
+		if (!strict && isNullable(a$1) && isNullable(b$1)) return true;
+		if (typeof a$1 !== typeof b$1 || typeof a$1 !== "object" || !a$1 || !b$1) return false;
+		if (ancestors.has(a$1)) return false;
+		function check(test, then) {
+			return test(a$1) ? test(b$1) ? then(a$1, b$1) : false : test(b$1) ? false : void 0;
+		}
+		ancestors.add(a$1);
+		try {
+			return check(Array.isArray, (a$2, b$2) => {
+				if (a$2.length !== b$2.length) return false;
+				for (let index = 0; index < a$2.length; index++) if (!compare(a$2[index], b$2[index])) return false;
+				return true;
+			}) ?? check(is("Date"), (a$2, b$2) => a$2.valueOf() === b$2.valueOf()) ?? check(is("URL"), (a$2, b$2) => a$2.href === b$2.href) ?? check(is("RegExp"), (a$2, b$2) => a$2.source === b$2.source && a$2.flags === b$2.flags) ?? check(isArrayBufferLike, (a$2, b$2) => {
+				if (a$2.byteLength !== b$2.byteLength) return false;
+				const viewA = new Uint8Array(a$2);
+				const viewB = new Uint8Array(b$2);
+				for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+				return true;
+			}) ?? ((!strict || [a$1, b$1].every((value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) && Object.keys({
+				...a$1,
+				...b$1
+			}).every((key) => compare(a$1[key], b$1[key])));
+		} finally {
+			ancestors.delete(a$1);
+		}
+	}
+	return compare(a, b);
+}
+/** Time constants plus parsing and formatting helpers. */
+var Time;
+(function(Time$1) {
+	Time$1.millisecond = 1;
+	Time$1.second = 1e3;
+	Time$1.minute = Time$1.second * 60;
+	Time$1.hour = Time$1.minute * 60;
+	Time$1.day = Time$1.hour * 24;
+	Time$1.week = Time$1.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time$1.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time$1.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time$1.minute - offset) / 1440);
+	}
+	Time$1.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time$1.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time$1.minute);
+	}
+	Time$1.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time$1.week || 0) + (parseFloat(capture[2]) * Time$1.day || 0) + (parseFloat(capture[3]) * Time$1.hour || 0) + (parseFloat(capture[4]) * Time$1.minute || 0) + (parseFloat(capture[5]) * Time$1.second || 0);
+	}
+	Time$1.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time$1.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time$1.day - Time$1.hour / 2) return Math.round(ms / Time$1.day) + "d";
+		else if (abs >= Time$1.hour - Time$1.minute / 2) return Math.round(ms / Time$1.hour) + "h";
+		else if (abs >= Time$1.minute - Time$1.second / 2) return Math.round(ms / Time$1.minute) + "m";
+		else if (abs >= Time$1.second) return Math.round(ms / Time$1.second) + "s";
+		return ms + "ms";
+	}
+	Time$1.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time$1.toDigits = toDigits;
+	function template(template$1, time = /* @__PURE__ */ new Date()) {
+		return template$1.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time$1.template = template;
+})(Time || (Time = {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+schemastery@3.18.4/node_modules/@deepseek-ai/schemastery/lib/index.mjs
+const kSchema = Symbol.for("schemastery");
+const kValidationError = Symbol.for("ValidationError");
+globalThis.__schemastery_index__ ??= 0;
+globalThis.__schemastery_refs__ = void 0;
+var ValidationError = class extends TypeError {
+	options;
+	name = "ValidationError";
+	constructor(message, options) {
+		let prefix = "$";
+		for (const segment of options.path || []) if (typeof segment === "string") prefix += "." + segment;
+		else if (typeof segment === "number") prefix += "[" + segment + "]";
+		else if (typeof segment === "symbol") prefix += `[Symbol(${segment.toString()})]`;
+		if (prefix.startsWith(".")) prefix = prefix.slice(1);
+		super((prefix === "$" ? "" : `${prefix} `) + message);
+		this.options = options;
+	}
+	static is(error) {
+		return !!error?.[kValidationError];
+	}
+};
+Object.defineProperty(ValidationError.prototype, kValidationError, { value: true });
+const Schema = function(options) {
+	const schema = function(data, options$1 = {}) {
+		return Schema.resolve(data, schema, options$1)[0];
+	};
+	if (options.refs) {
+		const refs = mapValues(options.refs, (options$1) => new Schema(options$1));
+		const getRef = (uid) => refs[uid];
+		for (const key in refs) {
+			const options$1 = refs[key];
+			options$1.sKey = getRef(options$1.sKey);
+			options$1.inner = getRef(options$1.inner);
+			options$1.list = options$1.list && options$1.list.map(getRef);
+			options$1.dict = options$1.dict && mapValues(options$1.dict, getRef);
+		}
+		return refs[options.uid];
+	}
+	Object.assign(schema, options);
+	if (typeof schema.callback === "string") try {
+		schema.callback = new Function("return " + schema.callback)();
+	} catch {}
+	Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+	Object.setPrototypeOf(schema, Schema.prototype);
+	schema.meta ||= {};
+	schema.toString = schema.toString.bind(schema);
+	return schema;
+};
+Schema.prototype = Object.create(Function.prototype);
+Schema.prototype[kSchema] = true;
+Object.defineProperty(Schema.prototype, "~standard", { get() {
+	return {
+		version: 1,
+		vendor: "schemastery",
+		validate: (value) => {
+			try {
+				return { value: Schema.resolve(value, this, {})[0] };
+			} catch (error) {
+				if (ValidationError.is(error)) return { issues: [{
+					message: error.message,
+					path: error.options.path
+				}] };
+				throw error;
+			}
+		}
+	};
+} });
+Schema.ValidationError = ValidationError;
+Schema.prototype.toJSON = function toJSON() {
+	if (globalThis.__schemastery_refs__) {
+		globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+		return this.uid;
+	}
+	globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+	globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+	const result = {
+		uid: this.uid,
+		refs: globalThis.__schemastery_refs__
+	};
+	globalThis.__schemastery_refs__ = void 0;
+	return result;
+};
+Schema.prototype.set = function set(key, value) {
+	this.dict[key] = value;
+	return this;
+};
+Schema.prototype.push = function push(value) {
+	this.list.push(value);
+	return this;
+};
+function mergeDesc(original, messages) {
+	const result = typeof original === "string" ? { "": original } : { ...original };
+	for (const locale in messages) {
+		const value = messages[locale];
+		if (value?.$description || value?.$desc) result[locale] = value.$description || value.$desc;
+		else if (typeof value === "string") result[locale] = value;
+	}
+	return result;
+}
+function getInner(value) {
+	return value?.$value ?? value?.$inner;
+}
+function extractKeys(data) {
+	return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+}
+Schema.prototype.i18n = function i18n(messages) {
+	const schema = Schema(this);
+	const desc = mergeDesc(schema.meta.description, messages);
+	if (Object.keys(desc).length) schema.meta.description = desc;
+	if (schema.dict) schema.dict = mapValues(schema.dict, (inner, key) => {
+		return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+	});
+	if (schema.list) schema.list = schema.list.map((inner, index) => {
+		return inner.i18n(mapValues(messages, (data = {}) => {
+			if (Array.isArray(getInner(data))) return getInner(data)[index];
+			if (Array.isArray(data)) return data[index];
+			return extractKeys(data);
+		}));
+	});
+	if (schema.inner) schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+		if (getInner(data)) return getInner(data);
+		return extractKeys(data);
+	}));
+	if (schema.sKey) schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+	return schema;
+};
+Schema.prototype.extra = function extra(key, value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+};
+for (const key of [
+	"required",
+	"disabled",
+	"collapse",
+	"hidden",
+	"loose"
+]) Object.assign(Schema.prototype, { [key](value = true) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.deprecated = function deprecated() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "deprecated",
+		type: "danger"
+	});
+	return schema;
+};
+Schema.prototype.experimental = function experimental() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "experimental",
+		type: "warning"
+	});
+	return schema;
+};
+Schema.prototype.pattern = function pattern(regexp) {
+	const schema = Schema(this);
+	const pattern$1 = pick(regexp, ["source", "flags"]);
+	schema.meta = {
+		...schema.meta,
+		pattern: pattern$1
+	};
+	return schema;
+};
+Schema.prototype.simplify = function simplify(value) {
+	if (isVolatile(value)) value = value.get();
+	if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+	if (isNullable(value)) return value;
+	if (this.type === "object" || this.type === "dict") {
+		const result = {};
+		for (const key in value) {
+			const item = (this.type === "object" ? this.dict[key] : this.inner)?.simplify(value[key]);
+			if (this.type === "dict" || !isNullable(item)) result[key] = item;
+		}
+		if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+		return result;
+	} else if (this.type === "array" || this.type === "tuple") {
+		const result = [];
+		value.forEach((value$1, index) => {
+			const schema = this.type === "array" ? this.inner : this.list[index];
+			const item = schema ? schema.simplify(value$1) : value$1;
+			result.push(item);
+		});
+		return result;
+	} else if (this.type === "intersect") {
+		const result = {};
+		for (const item of this.list) Object.assign(result, item.simplify(value));
+		return result;
+	} else if (this.type === "union") for (const schema of this.list) try {
+		Schema.resolve(value, schema, {});
+		return schema.simplify(value);
+	} catch {}
+	return value;
+};
+Schema.prototype.toString = function toString(inline) {
+	return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+};
+Schema.prototype.role = function role(role$1, extra) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		role: role$1,
+		extra
+	};
+	return schema;
+};
+for (const key of [
+	"default",
+	"link",
+	"comment",
+	"description",
+	"max",
+	"min",
+	"step"
+]) Object.assign(Schema.prototype, { [key](value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.volatile = function volatile() {
+	if (this.meta.volatile) throw new TypeError("volatile schema is already wrapped");
+	return this.extra("volatile", true);
+};
+const resolvers = {};
+const checkedVolatile = Symbol("checked-volatile-schema");
+function validateVolatileSchema(schema, path = [], blocked = false, seen = /* @__PURE__ */ new Map()) {
+	const states = seen.get(schema) ?? /* @__PURE__ */ new Set();
+	if (states.has(blocked)) return;
+	states.add(blocked);
+	seen.set(schema, states);
+	if (schema.meta?.volatile && blocked) throw new ValidationError("volatile fields require a fixed object path without an enclosing volatile field", { path });
+	const nested = blocked || !!schema.meta?.volatile;
+	if (schema.dict) for (const [key, child] of Object.entries(schema.dict)) validateVolatileSchema(child, [...path, key], nested, seen);
+	if (schema.sKey) validateVolatileSchema(schema.sKey, [...path, "<key>"], true, seen);
+	if (schema.inner && (schema.type !== "lazy" || schema.inner[kSchema])) validateVolatileSchema(schema.inner, [...path, "*"], true, seen);
+	if (schema.list) for (let index = 0; index < schema.list.length; index++) validateVolatileSchema(schema.list[index], [...path, String(index)], true, seen);
+}
+Schema.extend = function extend(type, resolve) {
+	resolvers[type] = resolve;
+};
+Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+	if (!schema) return [data];
+	if (!options[checkedVolatile]) {
+		validateVolatileSchema(schema, options.path);
+		options = {
+			...options,
+			[checkedVolatile]: true
+		};
+	}
+	if (schema.meta?.volatile) {
+		const inner = Schema(schema);
+		inner.meta = {
+			...schema.meta,
+			volatile: false
+		};
+		const [value, adapted] = Schema.resolve(data, inner, options, strict);
+		try {
+			return [createVolatile(value), adapted];
+		} catch (error) {
+			throw new ValidationError(error instanceof Error ? error.message : String(error), options);
+		}
+	}
+	if (options.ignore?.(data, schema)) return [data];
+	if (isNullable(data) && schema.type !== "lazy") {
+		if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+		let current = schema;
+		let fallback = schema.meta.default;
+		while (current?.type === "intersect" && isNullable(fallback)) {
+			current = current.list[0];
+			fallback = current?.meta.default;
+		}
+		if (isNullable(fallback)) return [data];
+		data = clone(fallback);
+	}
+	const callback = resolvers[schema.type];
+	if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+	try {
+		return callback(data, schema, options, strict);
+	} catch (error) {
+		if (!schema.meta.loose) throw error;
+		return [schema.meta.default];
+	}
+};
+Schema.from = function from(source) {
+	if (isNullable(source)) return Schema.any();
+	else if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof source)) return Schema.const(source).required();
+	else if (source[kSchema]) return source;
+	else if (typeof source === "function") switch (source) {
+		case String: return Schema.string().required();
+		case Number: return Schema.number().required();
+		case Boolean: return Schema.boolean().required();
+		case Function: return Schema.function().required();
+		default: return Schema.is(source).required();
+	}
+	else throw new TypeError(`cannot infer schema from ${source}`);
+};
+Schema.lazy = function lazy(builder) {
+	const toJSON = () => {
+		if (!schema.inner[kSchema]) {
+			schema.inner = schema.builder();
+			schema.inner.meta = {
+				...schema.meta,
+				...schema.inner.meta
+			};
+		}
+		return schema.inner.toJSON();
+	};
+	const schema = new Schema({
+		type: "lazy",
+		builder,
+		inner: { toJSON }
+	});
+	return schema;
+};
+Schema.natural = function natural() {
+	return Schema.number().step(1).min(0);
+};
+Schema.percent = function percent() {
+	return Schema.number().step(.01).min(0).max(1).role("slider");
+};
+Schema.date = function date() {
+	return Schema.union([Schema.is(Date), Schema.transform(Schema.string().role("datetime"), (value, options) => {
+		const date$1 = new Date(value);
+		if (isNaN(+date$1)) throw new ValidationError(`invalid date "${value}"`, options);
+		return date$1;
+	}, true)]);
+};
+Schema.regExp = function regExp(flag = "") {
+	return Schema.union([Schema.is(RegExp), Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+		try {
+			return new RegExp(value, flag);
+		} catch (e) {
+			throw new ValidationError(e.message, options);
+		}
+	}, true)]);
+};
+Schema.arrayBuffer = function arrayBuffer(encoding) {
+	return Schema.union([
+		Schema.is(ArrayBuffer),
+		Schema.is(SharedArrayBuffer),
+		Schema.transform(Schema.any(), (value, options) => {
+			if (Binary.isSource(value)) return Binary.fromSource(value);
+			throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+		}, true),
+		...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+			try {
+				return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+			} catch (e) {
+				throw new ValidationError(e.message, options);
+			}
+		}, true)] : []
+	]);
+};
+Schema.extend("lazy", (data, schema, options, strict) => {
+	if (!schema.inner[kSchema]) {
+		schema.inner = schema.builder();
+		schema.inner.meta = {
+			...schema.meta,
+			...schema.inner.meta
+		};
+		validateVolatileSchema(schema.inner, options.path, true);
+	}
+	return Schema.resolve(data, schema.inner, options, strict);
+});
+Schema.extend("any", (data) => {
+	return [data];
+});
+Schema.extend("never", (data, _, options) => {
+	throw new ValidationError(`expected nullable but got ${data}`, options);
+});
+Schema.extend("const", (data, { value }, options) => {
+	if (deepEqual(data, value)) return [value];
+	throw new ValidationError(`expected ${value} but got ${data}`, options);
+});
+function checkWithinRange(data, meta, description, options, skipMin = false) {
+	const { max = Infinity, min = -Infinity } = meta;
+	if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+	if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+}
+Schema.extend("string", (data, { meta }, options) => {
+	if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+	if (meta.pattern) {
+		const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+		if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+	}
+	checkWithinRange(data.length, meta, "string length", options);
+	return [data];
+});
+function decimalShift(data, digits) {
+	const str = data.toString();
+	if (str.includes("e")) return data * Math.pow(10, digits);
+	const index = str.indexOf(".");
+	if (index === -1) return data * Math.pow(10, digits);
+	const frac = str.slice(index + 1);
+	const integer = str.slice(0, index);
+	if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+	return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+}
+function isMultipleOf(data, min, step) {
+	step = Math.abs(step);
+	if (!/^\d+\.\d+$/.test(step.toString())) return (data - min) % step === 0;
+	const index = step.toString().indexOf(".");
+	const digits = step.toString().slice(index + 1).length;
+	return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+}
+Schema.extend("number", (data, { meta }, options) => {
+	if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+	checkWithinRange(data, meta, "number", options);
+	const { step } = meta;
+	if (step && !isMultipleOf(data, meta.min ?? 0, step)) throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+	return [data];
+});
+Schema.extend("boolean", (data, _, options) => {
+	if (typeof data === "boolean") return [data];
+	throw new ValidationError(`expected boolean but got ${data}`, options);
+});
+Schema.extend("bitset", (data, { bits, meta }, options) => {
+	let value = 0, keys = [];
+	if (typeof data === "number") {
+		value = data;
+		for (const key in bits) if (data & bits[key]) keys.push(key);
+	} else if (Array.isArray(data)) {
+		keys = data;
+		for (const key of keys) {
+			if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+			if (key in bits) value |= bits[key];
+		}
+	} else throw new ValidationError(`expected number or array but got ${data}`, options);
+	if (value === meta.default) return [value];
+	return [value, keys];
+});
+Schema.extend("function", (data, _, options) => {
+	if (typeof data === "function") return [data];
+	throw new ValidationError(`expected function but got ${data}`, options);
+});
+Schema.extend("is", (data, { constructor }, options) => {
+	if (typeof constructor === "function") {
+		if (data instanceof constructor) return [data];
+		throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+	} else {
+		if (isNullable(data)) throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+		let prototype = Object.getPrototypeOf(data);
+		while (prototype) {
+			if (prototype.constructor?.name === constructor) return [data];
+			prototype = Object.getPrototypeOf(prototype);
+		}
+		throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+	}
+});
+function property(data, key, schema, options) {
+	try {
+		const [value, adapted] = Schema.resolve(data[key], schema, {
+			...options,
+			path: [...options.path || [], key]
+		});
+		if (adapted !== void 0) data[key] = adapted;
+		return value;
+	} catch (e) {
+		if (!options?.autofix) throw e;
+		delete data[key];
+		return schema.meta.volatile ? createVolatile(schema.meta.default) : schema.meta.default;
+	}
+}
+Schema.extend("array", (data, { inner, meta }, options) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+	return [data.map((_, index) => property(data, index, inner, options))];
+});
+Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in data) {
+		let rKey;
+		try {
+			rKey = Schema.resolve(key, sKey, options)[0];
+		} catch (error) {
+			if (strict) continue;
+			throw error;
+		}
+		result[rKey] = property(data, key, inner, options);
+		data[rKey] = data[key];
+		if (key !== rKey) delete data[key];
+	}
+	return [result];
+});
+Schema.extend("tuple", (data, { list }, options, strict) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	const result = list.map((inner, index) => property(data, index, inner, options));
+	if (strict) return [result];
+	result.push(...data.slice(list.length));
+	return [result];
+});
+function merge(result, data) {
+	for (const key in data) {
+		if (key in result) continue;
+		result[key] = data[key];
+	}
+}
+Schema.extend("object", (data, { dict }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in dict) {
+		const value = property(data, key, dict[key], options);
+		if (!isNullable(value) || key in data) result[key] = value;
+	}
+	if (!strict) merge(result, data);
+	return [result];
+});
+Schema.extend("union", (data, { list, toString }, options, strict) => {
+	const messages = [];
+	for (const inner of list) try {
+		return Schema.resolve(data, inner, options, strict);
+	} catch (error) {
+		messages.push(error);
+	}
+	throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+});
+Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+	if (!list.length) return [data];
+	let result;
+	for (const inner of list) {
+		const value = Schema.resolve(data, inner, options, true)[0];
+		if (isNullable(value)) continue;
+		if (isNullable(result)) result = value;
+		else if (typeof result !== typeof value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+		else if (typeof value === "object") merge(result ??= {}, value);
+		else if (result !== value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+	}
+	if (!strict && isPlainObject(data)) merge(result, data);
+	return [result];
+});
+Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+	const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+	if (preserve) return [callback(result)];
+	else return [callback(result), callback(adapted)];
+});
+const formatters = {};
+function defineMethod(name$1, keys, format) {
+	formatters[name$1] = format;
+	Object.assign(Schema, { [name$1](...args) {
+		const schema = new Schema({ type: name$1 });
+		keys.forEach((key, index) => {
+			switch (key) {
+				case "sKey":
+					schema.sKey = args[index] ?? Schema.string();
+					break;
+				case "inner":
+					schema.inner = Schema.from(args[index]);
+					break;
+				case "list":
+					schema.list = args[index].map(Schema.from);
+					break;
+				case "dict":
+					schema.dict = mapValues(args[index], Schema.from);
+					break;
+				case "bits":
+					schema.bits = {};
+					for (const key$1 in args[index]) {
+						if (typeof args[index][key$1] !== "number") continue;
+						schema.bits[key$1] = args[index][key$1];
+					}
+					break;
+				case "callback": {
+					const callback = schema.callback = args[index];
+					callback["toJSON"] ||= () => callback.toString();
+					break;
+				}
+				case "constructor": {
+					const constructor = schema.constructor = args[index];
+					if (typeof constructor === "function") constructor["toJSON"] ||= () => constructor["name"];
+					break;
+				}
+				default: schema[key] = args[index];
+			}
+		});
+		if (name$1 === "object" || name$1 === "dict") schema.meta.default = {};
+		else if (name$1 === "array" || name$1 === "tuple") schema.meta.default = [];
+		else if (name$1 === "bitset") schema.meta.default = 0;
+		return schema;
+	} });
+}
+defineMethod("is", ["constructor"], ({ constructor }) => {
+	if (typeof constructor === "function") return constructor.name;
+	else return constructor;
+});
+defineMethod("any", [], () => "any");
+defineMethod("never", [], () => "never");
+defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+defineMethod("string", [], () => "string");
+defineMethod("number", [], () => "number");
+defineMethod("boolean", [], () => "boolean");
+defineMethod("bitset", ["bits"], () => "bitset");
+defineMethod("function", [], () => "function");
+defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+defineMethod("object", ["dict"], ({ dict }) => {
+	if (Object.keys(dict).length === 0) return "{}";
+	return `{ ${Object.entries(dict).map(([key, inner]) => {
+		return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+	}).join(", ")} }`;
+});
+defineMethod("union", ["list"], ({ list }, inline) => {
+	const result = list.map(({ toString: format }) => format()).join(" | ");
+	return inline ? `(${result})` : result;
+});
+defineMethod("intersect", ["list"], ({ list }) => {
+	return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+});
+defineMethod("transform", [
+	"inner",
+	"callback",
+	"preserve"
+], ({ inner }, isInner) => inner.toString(isInner));
+
+//#endregion
+//#region src/images.ts
+/**
+* True when any message carries an image block — the guard that decides
+* whether this adapter needs the attachment service at all.
+*
+* @param messages - complete request history.
+* @returns whether any message content holds an image.
+*/
+function historyHasImage(messages) {
+	return messages.some((message) => contentHasImage(message.content));
+}
+/**
+* Reject image blocks in roles the wire format cannot carry them in.
+*
+* A user or tool-result message maps onto content parts, so an image there is
+* representable. Every other role serializes to a plain string (assistant
+* text plus tool calls, system/developer prose), where an image would be
+* silently dropped — the exact failure this module exists to remove, so it
+* fails loud instead.
+*
+* @param messages - complete request history.
+* @throws LlmError `UNSUPPORTED_CONTENT` naming the offending role.
+*/
+function assertImageRoles(messages) {
+	for (const message of messages) {
+		if (message.role === "user" || message.role === "tool") continue;
+		if (contentHasImage(message.content)) throw new LlmError(`aishell-llm cannot represent an image in a ${message.role} message`, "UNSUPPORTED_CONTENT");
+	}
+}
+/**
+* Resolve one request version per retained image, keyed by durable attachment
+* id so a reference shared by several occurrences is read once.
+*
+* Occurrences already marked `offloaded` are skipped: their bytes are not sent
+* (serialization replaces them with placeholder text), so reading them would
+* be work whose result nothing consumes.
+*
+* @param messages - complete request history.
+* @param attachments - mounted attachment service.
+* @param budget - projection policy for this route.
+* @param signal - request cancellation, honoured by the attachment read.
+* @returns request versions by durable attachment id.
+*/
+async function prepareRequestImages(messages, attachments, budget, signal) {
+	const refs = new Map();
+	for (const message of messages) for (const block of message.content) {
+		if (block.type !== "image" || block.offloaded === true) continue;
+		refs.set(block.attachment.attachmentId, block.attachment);
+	}
+	const ordered = [...refs.values()];
+	const versions = await Promise.all(ordered.map((ref) => attachments.readImageRequest(ref, {
+		...requestImageDimensions(ref.width, ref.height, budget.maxPixels),
+		maxBytes: budget.maxBytes
+	}, signal)));
+	return new Map(ordered.map((ref, index) => [ref.attachmentId, versions[index]]));
+}
+/**
+* Request version for one retained occurrence, or a loud failure.
+*
+* Every image block reaching serialization must have been prepared, so a
+* miss is a bug in this adapter rather than bad input — but the alternative
+* (letting the lookup produce `undefined` and reading `.bytes` off it) turns
+* it into a `TypeError` from deep inside the request body, so it is named.
+*
+* @param images - prepared request versions.
+* @param ref - durable reference of one retained occurrence.
+* @returns the request version carrying that image's bytes.
+* @throws LlmError `INVALID_REQUEST` when the reference was never prepared.
+*/
+function requireRequestImage(images, ref) {
+	const version = images.get(ref.attachmentId);
+	if (version === void 0) throw new LlmError(`aishell-llm request image ${String(ref.attachmentId)} was not prepared`, "INVALID_REQUEST");
+	return version;
+}
+/**
+* Replace every offloaded occurrence with its placeholder text.
+*
+* The durable `offloaded` mark is a surface fact shared by all routes; only
+* the placeholder wording is route-owned. Request assembly does not do this
+* for adapters, so an adapter that skips it would send an image whose bytes
+* it deliberately never loaded.
+*
+* @param messages - complete request history.
+* @param resolveAccess - execution-world path resolver, when one is available.
+* @returns the history with offloaded occurrences projected to text.
+*/
+function projectOffloaded(messages, resolveAccess) {
+	return projectOffloadedImages(messages, (ref) => offloadedImageText(ref, resolveAccess?.(ref)));
+}
+/**
+* Fail the request when its retained images exceed the route's byte budget.
+*
+* This adapter does not offload on its own: the durable decision belongs to
+* the surface, and `dsh-compaction-image-offload` (mounted by `dsh-base`) is
+* the component that records it and retries the step. Throwing the canonical
+* code with the required count is what hands it that decision.
+*
+* @param messages - complete request history, carrying the surface's offload marks.
+* @param images - prepared request versions.
+* @param maxBytes - accumulated represented base64 bytes this route accepts.
+* @throws LlmError `IMAGE_OFFLOAD_REQUIRED` carrying how many more occurrences must be offloaded.
+*/
+function assertRequestImageBudget(messages, images, maxBytes) {
+	const offloadImages = requiredImageOffload(messages, {
+		representation: "base64",
+		maxBytes
+	}, (block) => requireRequestImage(images, block.attachment).bytes);
+	if (offloadImages > 0) throw new LlmError(`aishell-llm request images exceed the ${maxBytes}-byte base64 bound; ${offloadImages} more oldest occurrence(s) must be offloaded.`, IMAGE_OFFLOAD_REQUIRED_CODE, { offloadImages });
+}
+
+//#endregion
 //#region src/serialize.ts
-/** Build the POST body for `/chat/completions`. */
-function serializeRequest(options) {
+/**
+* Build the POST body for `/chat/completions`.
+*
+* @param options - provider-neutral request.
+* @param images - prepared request versions, required only when the history carries a retained image.
+* @param resolveAccess - execution-world path resolver for image handle text, when a provider exposes one.
+* @returns the OpenAI-compatible request body.
+*/
+function serializeRequest(options, images, resolveAccess) {
 	const messages = [];
-	for (const message of options.messages) if (message.role === "user") {
-		const textBlocks = message.content.filter((block) => block.type === "text" || block.type === "reasoning");
+	if (options.system !== void 0) messages.push({
+		role: "system",
+		content: options.system
+	});
+	let pendingToolImages = [];
+	for (const [index, message] of options.messages.entries()) if (message.role === "user") messages.push({
+		role: "user",
+		content: contentFor(message.content, images, resolveAccess) ?? blocksToText(message.content)
+	});
+	else if (message.role === "tool") {
+		const toolText = blocksToText(message.content);
+		const hasImages = message.content.some((block) => block.type === "image");
 		messages.push({
-			role: "user",
-			content: textBlocks.length > 0 ? blocksToText(textBlocks) : ""
+			role: "tool",
+			tool_call_id: String(message.toolCallId),
+			content: toolText.length > 0 || !hasImages ? toolText : TOOL_IMAGES_ONLY
 		});
-	} else if (message.role === "tool") messages.push({
-		role: "tool",
-		tool_call_id: String(message.toolCallId),
-		content: blocksToText(message.content)
-	});
-	else if (message.role === "developer") {
+		if (hasImages) pendingToolImages.push(message.content);
+		if (isLastToolOfRun(options.messages, index)) {
+			const hoisted = hoistedToolImages(pendingToolImages, images, resolveAccess);
+			pendingToolImages = [];
+			if (hoisted !== void 0) messages.push({
+				role: "user",
+				content: hoisted
+			});
+		}
+	} else if (message.role === "developer") {
 		const text = blocksToText(message.content);
 		if (text) messages.push({
 			role: "system",
@@ -49,6 +1076,122 @@ function serializeRequest(options) {
 		...options.stop !== void 0 ? { stop: options.stop } : {}
 	};
 }
+/** Intro line naming what the hoisted parts are, matching the ecosystem's wording. */
+const TOOL_IMAGES_INTRO = "Attached image(s) from tool result:";
+/** Stand-in for a tool result whose only content was an image, which cannot ride the tool message itself. */
+const TOOL_IMAGES_ONLY = "(see attached image)";
+/**
+* Whether the tool-role message at `index` is the last of its consecutive run.
+*
+* Tool results arrive as a run, one per call the assistant issued in a single
+* turn, and they must stay adjacent to that assistant turn on the wire. The
+* hoisted user turn therefore waits for the run's end rather than following
+* whichever result happened to carry the image.
+*
+* @param messages - the complete request history.
+* @param index - position of the tool-role message being serialized.
+* @returns whether no further tool-role message follows.
+*/
+function isLastToolOfRun(messages, index) {
+	return messages[index + 1]?.role !== "tool";
+}
+/**
+* Parts for one tool-result run's images, hoisted into a user turn.
+*
+* An OpenAI tool message carries text only, so an image a tool returned has
+* nowhere to go in its own message; sending it as a following `user` turn is
+* how the one OpenAI-path serializer in the ecosystem handles the same
+* situation. The tool messages keep their text (or a placeholder), so the
+* model is not left with an empty result to explain away.
+*
+* @param run - content blocks of every image-bearing tool result in one run.
+* @param images - prepared request versions.
+* @param resolveAccess - execution-world path resolver, when available.
+* @returns the user-turn part list, or `undefined` when the run carried no image.
+*/
+function hoistedToolImages(run, images, resolveAccess) {
+	if (run.length === 0) return void 0;
+	if (images === void 0) throw new LlmError("aishell-llm request images were not prepared", "INVALID_REQUEST");
+	const parts = [{
+		type: "text",
+		text: TOOL_IMAGES_INTRO
+	}];
+	for (const blocks of run) for (const block of blocks) {
+		if (block.type !== "image") continue;
+		const version = requireRequestImage(images, block.attachment);
+		parts.push({
+			type: "text",
+			text: requestImageHandleText(block.attachment, version, resolveAccess?.(block.attachment))
+		});
+		parts.push({
+			type: "image_url",
+			image_url: { url: dataUrl(version) }
+		});
+	}
+	return parts;
+}
+/**
+* Content for one user message: a parts list when it carries an image,
+* otherwise `undefined` so the caller falls back to plain text.
+*
+* Each image is preceded by a text part carrying its stable model-facing
+* handle, which names the image and the dimensions it was projected to — so a
+* model that cannot use the bytes can still refer to the occurrence, and one
+* that can reads what was actually sent rather than what was uploaded.
+*
+* @param blocks - content blocks of one user message.
+* @param images - prepared request versions.
+* @param resolveAccess - execution-world path resolver, when available.
+* @returns the part list, or `undefined` when the message has no image.
+*/
+function contentFor(blocks, images, resolveAccess) {
+	if (!blocks.some((block) => block.type === "image")) return void 0;
+	if (images === void 0) throw new LlmError("aishell-llm request images were not prepared", "INVALID_REQUEST");
+	const parts = [];
+	for (const block of blocks) {
+		if (block.type === "image") {
+			const version = requireRequestImage(images, block.attachment);
+			parts.push({
+				type: "text",
+				text: requestImageHandleText(block.attachment, version, resolveAccess?.(block.attachment))
+			});
+			parts.push({
+				type: "image_url",
+				image_url: { url: dataUrl(version) }
+			});
+			continue;
+		}
+		if (block.type === "text" || block.type === "reasoning") {
+			if (block.text.length > 0) parts.push({
+				type: "text",
+				text: block.text
+			});
+		}
+	}
+	return parts;
+}
+/**
+* Inline data URL for one prepared image.
+*
+* Media type comes from the request *version*, not the source reference: the
+* attachment service may re-encode during projection (that is what the byte
+* target is for), so the version is the only description of the bytes actually
+* being sent.
+*
+* Encoded through `btoa` over the byte string rather than `Buffer`: this
+* package compiles host and browser halves in one project under `types: []`
+* with the DOM lib, so the Node global is neither declared nor reachable here.
+* `btoa` is a global in both Node 22+ and every browser, which is why it is
+* the one that typechecks in both halves.
+*
+* @param version - prepared request version.
+* @returns a base64 data URL.
+*/
+function dataUrl(version) {
+	let binary = "";
+	for (const byte of version.data) binary += String.fromCharCode(byte);
+	return `data:${version.mediaType};base64,${btoa(binary)}`;
+}
 /** Type guard for tool-call blocks. */
 function isToolCallBlock(block) {
 	return block.type === "tool-call";
@@ -81,7 +1224,8 @@ function serializeTool(tool) {
 //#region src/sse.ts
 const DONE = "[DONE]";
 async function* parseSse(stream) {
-	const events = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream());
+	const decoder = new TextDecoderStream();
+	const events = stream.pipeThrough(decoder).pipeThrough(new EventSourceParserStream());
 	for await (const { data } of events) {
 		yield data;
 		if (data === DONE) return;
@@ -267,6 +1411,29 @@ const AK_ACCOUNT = "HW_ACCESS_KEY";
 const SK_ACCOUNT = "HW_SECRET_KEY";
 const TOKEN_ACCOUNT = "HW_SECURITY_TOKEN";
 /**
+* Whether a gateway error body reports an id the gateway does not carry.
+*
+* Both fields are accepted because the gateway emits them from one definition
+* and either proves the same fact; a proxy that strips one should not disable
+* the diagnosis. A body that is not the gateway's JSON is not a match.
+*
+* @param text - the error response body, as received.
+* @returns whether this is the "model not configured on this gateway" answer.
+*/
+function isModelNotFound(text) {
+	let body;
+	try {
+		body = JSON.parse(text);
+	} catch {
+		return false;
+	}
+	if (typeof body !== "object" || body === null) return false;
+	const envelope = body;
+	if (envelope.error_code === "AISHELL.1004") return true;
+	const inner = envelope.error;
+	return typeof inner === "object" && inner !== null && inner.code === "model_not_found";
+}
+/**
 * Map the gateway's `modalities` array (e.g. `["text","image"]`) to DSH's
 * `ModelModality` vocabulary. DSH currently defines only `'text' | 'image'`;
 * other modalities (audio, video) are dropped — the gateway still accepts
@@ -281,6 +1448,11 @@ var GatewayAdapter = class GatewayAdapter extends LlmAdapter {
 	constructor(opts) {
 		super();
 		this.opts = opts;
+		this.imageAccess = (ref) => {
+			const attachments = this.opts.resolveAttachments?.();
+			if (attachments === void 0) return void 0;
+			return resolveImageAttachmentAccess(attachments, (hostPath) => this.opts.resolveHostPath?.(hostPath), ref);
+		};
 	}
 	providerInfo(provider) {
 		return {
@@ -297,8 +1469,7 @@ var GatewayAdapter = class GatewayAdapter extends LlmAdapter {
 	async fetchWireModels() {
 		const now = Date.now();
 		if (this.modelsCache !== void 0 && this.modelsCache.expires > now) return this.modelsCache.promise;
-		const creds = this.readCredentials();
-		if (!creds?.ak) return [];
+		if (!this.hasCredentials()) return [];
 		const promise = (async () => {
 			const response = await this.signedFetch("/models", "GET", void 0, void 0);
 			if (!response.ok) return [];
@@ -343,6 +1514,19 @@ var GatewayAdapter = class GatewayAdapter extends LlmAdapter {
 			})) } } : {}
 		};
 	}
+	/**
+	* Whether a usable AK/SK pair is stored.
+	*
+	* The one predicate behind every "can this route do anything" question:
+	* `fetchWireModels` returns an empty catalog without it, and the Models-page
+	* card reports readiness from it. Kept in one place so the catalog and the
+	* card cannot disagree about whether this route is usable.
+	*
+	* @returns whether both halves of the signing credential are present.
+	*/
+	hasCredentials() {
+		return this.readCredentials() !== void 0;
+	}
 	/** Read AK/SK (and optional SecurityToken) from the credential store. */
 	readCredentials() {
 		const ak = this.opts.keyring.get(AK_ACCOUNT);
@@ -367,9 +1551,9 @@ var GatewayAdapter = class GatewayAdapter extends LlmAdapter {
 	*/
 	async signedFetch(path, method, body, signal) {
 		const creds = this.requireCredentials();
-		const url = new URL(this.opts.baseUrl);
-		const headers = sign(method, url.host, path, {}, body ?? "", creds);
-		return fetch(`${this.opts.baseUrl}${path}`, {
+		const requestUrl = new URL(`${this.opts.resolveBaseUrl()}${path}`);
+		const headers = sign(method, requestUrl.host, requestUrl.pathname, {}, body ?? "", creds);
+		return fetch(requestUrl, {
 			method,
 			headers: {
 				host: headers.host,
@@ -382,18 +1566,66 @@ var GatewayAdapter = class GatewayAdapter extends LlmAdapter {
 			...signal ? { signal } : {}
 		});
 	}
+	/**
+	* Diagnose an "unsupported model" rejection and append what to do about it.
+	*
+	* The gateway answers a model id it does not carry with `AISHELL.1004`
+	* (`model_not_found`, HTTP 404 — see {@link isModelNotFound}). The default
+	* selection is a pinned literal (it must be readable before any credential or
+	* network call could enumerate the catalog), so the day the catalog drops
+	* that id, every fresh session fails here. Rather than leave the user to
+	* reverse-engineer the supported set, the failure itself asks the gateway
+	* (the catalog cache usually makes this a second signed GET already in
+	* flight) and names the models it currently accepts.
+	*
+	* Returns '' for any other failure, so the message stays untouched there.
+	*/
+	async unsupportedModelHint(text, options) {
+		if (!isModelNotFound(text)) return "";
+		const ids = (await this.fetchWireModels().catch(() => [])).map((m) => m.id).filter((id) => id.length > 0);
+		if (ids.length === 0) return "";
+		return ` (this gateway currently supports: ${ids.join(", ")}; switch the model in the picker — the switch also becomes your saved default. Requested: ${options.model})`;
+	}
+	/**
+	* Turn the harness history into the wire body, loading image bytes on the
+	* way.
+	*
+	* Deliberately the whole image pipeline and nothing else, so `stream` stays
+	* about transport. Ordering matters and mirrors the official adapters:
+	* resolve the attachment service, prepare one request version per retained
+	* image, fail the request if the budget is exceeded (handing
+	* `dsh-compaction-image-offload` its decision), and only then project the
+	* offloaded occurrences to placeholder text — a mark set by an earlier
+	* request's offload decision, which serialization must replace rather than
+	* look up bytes for.
+	*/
+	async buildBody(options) {
+		if (!historyHasImage(options.messages)) return JSON.stringify(serializeRequest(options, void 0, this.imageAccess));
+		assertImageRoles(options.messages);
+		const attachments = this.opts.resolveAttachments?.();
+		if (attachments === void 0) throw new LlmError("aishell-llm image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
+		const messages = options.messages;
+		const images = await prepareRequestImages(messages, attachments, this.opts.resolveImageBudget(), options.signal);
+		assertRequestImageBudget(messages, images, this.opts.resolveMaxRequestImageBytes());
+		const projected = [...projectOffloaded(messages, this.imageAccess)];
+		return JSON.stringify(serializeRequest({
+			...options,
+			messages: projected
+		}, images, this.imageAccess));
+	}
 	async *stream(options) {
-		const body = JSON.stringify(serializeRequest(options));
+		const body = await this.buildBody(options);
 		let response;
 		try {
 			response = await this.signedFetch("/chat/completions", "POST", body, options.signal);
 		} catch (error) {
 			if (options.signal?.aborted) throw error;
+			if (error instanceof LlmError) throw error;
 			throw new LlmError(`aishell-llm: request failed: ${error instanceof Error ? error.message : String(error)}`, "NETWORK_ERROR");
 		}
 		if (!response.ok) {
 			const text = await response.text().catch(() => "");
-			throw new LlmError(`aishell-llm: gateway returned ${response.status}: ${text}`, "PROVIDER_ERROR", { status: response.status });
+			throw new LlmError(`aishell-llm: gateway returned ${response.status}: ${text}` + await this.unsupportedModelHint(text, options), "PROVIDER_ERROR", { status: response.status });
 		}
 		if (!response.body) throw new LlmError("aishell-llm: gateway returned no body", "EMPTY_RESPONSE");
 		yield* translate(parseSse(response.body));
@@ -403,21 +1635,98 @@ GatewayAdapter.MODELS_TTL_MS = 6e4;
 
 //#endregion
 //#region src/index.ts
-/** Default chat API base URL. */
-const DEFAULT_BASE_URL = "https://api.aishell.openbuildlab.com";
+/** Default chat API base URL. Both `/chat/completions` and `/models` hang below `/v1`. */
+const DEFAULT_BASE_URL = "https://api.aishell.openbuildlab.com/v1";
+/**
+* Default total-pixel cap one request image is scaled into, and the encoded
+* byte target the encoder aims for. Both match the pi-ai defaults, for the
+* same reason: the gateway publishes no image budget, so the route needs a
+* bound that keeps one large upload from dominating a request.
+*/
+const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET = 4194304;
+const DEFAULT_REQUEST_IMAGE_MAX_BYTES = 1048576;
+/**
+* Default accumulated base64 bytes one request may carry before its oldest
+* images must be offloaded. Above this the request fails with
+* `IMAGE_OFFLOAD_REQUIRED` and `dsh-compaction-image-offload` (mounted by
+* `dsh-base`) replaces the oldest occurrences with placeholders. Again the
+* pi-ai default.
+*/
+const DEFAULT_MAX_REQUEST_IMAGE_BYTES = 20971520;
+/**
+* Settings schema for this entry.
+*
+* The schema exists for two reasons beyond configurability: the settings
+* mirror only lists namespaces whose plugin declares a Config, and the Models
+* page derives a provider row's existence from that listing — without a
+* schema, the `aishell` route registers its adapter but never shows up as a
+* configurable provider.
+*/
+const Config = Schema.object({
+	baseUrl: Schema.string().default(DEFAULT_BASE_URL).volatile(),
+	keyringService: Schema.string().volatile(),
+	requestImagePixelBudget: Schema.number().step(1).min(1).default(DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET).volatile(),
+	requestImageMaxBytes: Schema.number().step(1).min(1).default(DEFAULT_REQUEST_IMAGE_MAX_BYTES).volatile(),
+	maxRequestImageBytes: Schema.number().step(1).min(1).default(DEFAULT_MAX_REQUEST_IMAGE_BYTES).volatile()
+});
+/** Route the Models-page card reads the live gateway catalog from. */
+const MODELS_PATH = "/api/aishell/models";
+/**
+* Build the route body from the adapter's own catalog cache, so the card and
+* the pickers cannot disagree about what the gateway carries.
+*
+* `credentialsPresent` is read from the adapter rather than assumed: without
+* credentials `listModels` answers `[]` for a reason that is not "the gateway
+* has no models", and the card's empty state is the one place a fresh user
+* learns which of the two it is.
+*
+* Returned as a plain function of the adapter so a test can pin the mapping
+* without a live context; `apply` wires it to the fetch route.
+*/
+function createModelsRoute(adapter) {
+	return () => adapter.listModels(PROVIDER).then((models) => Response.json({
+		credentialsPresent: adapter.hasCredentials(),
+		models: models.map((m) => ({
+			id: m.id,
+			inputModalities: [...m.inputModalities ?? []]
+		}))
+	}, { headers: { "cache-control": "no-store" } }));
+}
 const name = "aishell-llm";
-const inject = ["llm"];
+const inject = ["llm", "connection"];
 /** The provider route this plugin owns. */
 const PROVIDER = "aishell";
-function apply(ctx, config = {}) {
-	const store = createCredentialsStore(config.keyringService ? { service: config.keyringService } : {});
+/** Human-readable provider name the Models page and pickers show. */
+const PROVIDER_DISPLAY_NAME = "AI Shell (Huawei Cloud)";
+function apply(ctx, config) {
+	const keyringService = config.keyringService.get();
+	const store = createCredentialsStore(keyringService === void 0 || keyringService === "" ? {} : { service: keyringService });
 	const adapter = new GatewayAdapter({
-		baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
-		keyring: store
+		resolveBaseUrl: () => config.baseUrl.get(),
+		keyring: store,
+		resolveAttachments: () => ctx.get("attachments"),
+		resolveHostPath: (hostPath) => ctx.get("fs")?.processPathFromHostPath(hostPath),
+		resolveImageBudget: () => ({
+			maxPixels: config.requestImagePixelBudget.get(),
+			maxBytes: config.requestImageMaxBytes.get()
+		}),
+		resolveMaxRequestImageBytes: () => config.maxRequestImageBytes.get()
 	});
 	ctx.llm.registerAdapter([PROVIDER], adapter);
+	ctx.llm.registerConfigurableProviders([{
+		provider: PROVIDER,
+		displayName: PROVIDER_DISPLAY_NAME,
+		settingsNs: ctx.fiber.entry?.options.id ?? name,
+		settingsPath: []
+	}]);
+	ctx.effect(() => ctx.connection.fetch.register({
+		path: MODELS_PATH,
+		methods: ["GET"],
+		requestBody: "buffered",
+		fetch: createModelsRoute(adapter)
+	}), "aishell-llm: models catalog route");
 }
 
 //#endregion
-export { PROVIDER, apply, inject, name };
+export { Config, PROVIDER, PROVIDER_DISPLAY_NAME, apply, createModelsRoute, inject, name };
 //# sourceMappingURL=index.js.map