dsh-image-gen 0.5.0 → 0.6.0

package/lib/index.js

@@ -1,8 +1,8 @@
 import { createRequire } from "node:module";
 import { Context, Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { lstat, mkdir, readFile, readdir, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -16,7 +16,175 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region node_modules/.pnpm/@deepseek-ai+dsh-util-value_e176751d487506fbf1ea91463d745d9b/node_modules/@deepseek-ai/dsh-util-values/lib/index.js
+//#region node_modules/.pnpm/@deepseek-ai+dsh-util-value_005f00f2ec004257b269f27fd5e936b4/node_modules/@deepseek-ai/dsh-util-values/lib/index.js
+/** Duplicate-install-safe JSON and immutable-value helpers. @module @deepseek-ai/dsh-util-values */
+/**
+* Mark an unreachable closed-union branch.
+* @param value - impossible value; an unhandled typed variant fails at the call site.
+* @param context - optional switch-site label included in the failure message.
+* @returns never; a runtime value that escaped its type always throws.
+*/
+function assertNever(value, context) {
+	const rendered = JSON.stringify(value) ?? String(value);
+	throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
+}
+/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
+function hasIntrinsicConstructor$1(prototype, name) {
+	const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
+	if (typeof constructor !== "function") return false;
+	try {
+		return constructor.name === name && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`;
+	} catch {
+		return false;
+	}
+}
+/** Whether a candidate is one realm's intrinsic `Object.prototype`. */
+function isIntrinsicObjectPrototype$1(value) {
+	return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor$1(value, "Object");
+}
+/** Whether an array uses one realm's intrinsic `Array.prototype`, not a subclass or forged prototype. */
+function hasPlainArrayPrototype$1(value) {
+	const prototype = Object.getPrototypeOf(value);
+	if (!Array.isArray(prototype) || !hasIntrinsicConstructor$1(prototype, "Array")) return false;
+	const objectPrototype = Object.getPrototypeOf(prototype);
+	return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype$1(objectPrototype);
+}
+/** Whether an object is a plain or null-prototype record from any JavaScript realm. */
+function hasPlainObjectPrototype(value) {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype$1(prototype);
+}
+/** Return every JSON-visible object key, or reject own data JSON would discard. */
+function enumerableStringKeys(value) {
+	const keys = Reflect.ownKeys(value);
+	if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
+	return keys;
+}
+/** Validate lossless JSON iteratively, optionally materializing a detached snapshot. */
+function walkJsonValue(value, detach) {
+	const ancestors = /* @__PURE__ */ new Set();
+	let root;
+	const assign = (destination, item) => {
+		if (destination === void 0) return;
+		if (destination.kind === "root") root = item;
+		else if (destination.kind === "array") destination.target[destination.index] = item;
+		else Object.defineProperty(destination.target, destination.key, {
+			value: item,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	};
+	const tasks = [{
+		kind: "visit",
+		value,
+		...detach ? { destination: { kind: "root" } } : {}
+	}];
+	for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
+		if (task.kind === "leave") {
+			ancestors.delete(task.source);
+			continue;
+		}
+		if (task.kind === "array-item") {
+			if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
+			tasks.push({
+				kind: "visit",
+				value: task.source[task.index],
+				...task.target === void 0 ? {} : { destination: {
+					kind: "array",
+					target: task.target,
+					index: task.index
+				} }
+			});
+			continue;
+		}
+		if (task.kind === "object-property") {
+			tasks.push({
+				kind: "visit",
+				value: task.source[task.key],
+				...task.target === void 0 ? {} : { destination: {
+					kind: "object",
+					target: task.target,
+					key: task.key
+				} }
+			});
+			continue;
+		}
+		const current = task.value;
+		if (current === null) {
+			assign(task.destination, null);
+			continue;
+		}
+		if (typeof current === "boolean" || typeof current === "string") {
+			assign(task.destination, current);
+			continue;
+		}
+		if (typeof current === "number") {
+			if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
+			assign(task.destination, current);
+			continue;
+		}
+		if (typeof current !== "object") return void 0;
+		if (ancestors.has(current)) return void 0;
+		if (Array.isArray(current)) {
+			if (!hasPlainArrayPrototype$1(current)) return void 0;
+			const length = current.length;
+			if (Reflect.ownKeys(current).length !== length + 1) return void 0;
+			const target = detach ? [] : void 0;
+			if (target !== void 0) assign(task.destination, target);
+			ancestors.add(current);
+			tasks.push({
+				kind: "leave",
+				source: current
+			});
+			for (let index = length - 1; index >= 0; index--) tasks.push({
+				kind: "array-item",
+				source: current,
+				index,
+				...target === void 0 ? {} : { target }
+			});
+			continue;
+		}
+		if (!hasPlainObjectPrototype(current)) return void 0;
+		const keys = enumerableStringKeys(current);
+		if (keys === void 0) return void 0;
+		const target = detach ? {} : void 0;
+		if (target !== void 0) assign(task.destination, target);
+		ancestors.add(current);
+		tasks.push({
+			kind: "leave",
+			source: current
+		});
+		for (let index = keys.length - 1; index >= 0; index--) {
+			const key = keys[index];
+			/* v8 ignore next -- the loop is bounded by the captured key count. */
+			if (key === void 0) return void 0;
+			tasks.push({
+				kind: "object-property",
+				source: current,
+				key,
+				...target === void 0 ? {} : { target }
+			});
+		}
+	}
+	return detach ? root : true;
+}
+/**
+* Validate and detach lossless JSON in one read per property.
+* @param value - candidate value to validate and detach.
+* @returns the detached snapshot, or `undefined` when the value is not losslessly JSON-serializable.
+*/
+function snapshotJsonValue(value) {
+	return walkJsonValue(value, true);
+}
+/**
+* Test the same lossless JSON rules as {@link snapshotJsonValue} without detaching the value.
+* @param value - candidate value to test.
+* @returns whether the value survives a JSON round trip without loss.
+*/
+function isJsonValue(value) {
+	return walkJsonValue(value, false) === true;
+}
 /**
 * Compare JSON-compatible values structurally.
 * @param a - one JSON-compatible value.
@@ -41,7 +209,7 @@ function deepEqualJson(a, b) {
 * @param value - value to freeze.
 * @returns the same value after every reachable enumerable child is frozen.
 */
-function deepFreeze$1(value) {
+function deepFreeze(value) {
 	const seen = /* @__PURE__ */ new WeakSet();
 	const pending = [{
 		kind: "visit",
@@ -79,7 +247,7 @@ function deepFreeze$1(value) {
 	return value;
 }
 //#endregion
-//#region node_modules/.pnpm/@deepseek-ai+dsh-settings@0_ee3e2f9fab981d3a5a4a6c717af48d35/node_modules/@deepseek-ai/dsh-settings/lib/index.js
+//#region node_modules/.pnpm/@deepseek-ai+dsh-settings@0_935f3a2ac52a1f8e83ba61ff4169507a/node_modules/@deepseek-ai/dsh-settings/lib/index.js
 var lib_exports = /* @__PURE__ */ __exportAll({
 	SettingsConflictError: () => SettingsConflictError,
 	SettingsProvider: () => SettingsProvider,
@@ -370,7 +538,7 @@ var SettingsProvider = class extends Service {
 			base: options?.base,
 			applies: options?.applies ?? "live",
 			...options?.validate === void 0 ? {} : { validate: options.validate },
-			resolved: deepFreeze$1(this.resolve(schema, options?.base, this.section(parsedNs), options?.validate)),
+			resolved: deepFreeze(this.resolve(schema, options?.base, this.section(parsedNs), options?.validate)),
 			revision: 0,
 			watchers: /* @__PURE__ */ new Set()
 		};
@@ -542,7 +710,7 @@ var SettingsProvider = class extends Service {
 			const current = this.section(ns) ?? {};
 			if (expectedRevision !== void 0 && expectedRevision !== registration.revision) throw new SettingsConflictError(ns, expectedRevision, registration.revision);
 			const section = mode === "merge" ? mergeLayers(current, snapshot) : mode === "replace" ? snapshot : snapshot["ops"].reduce(applyPathOp, current);
-			const next = deepFreeze$1(this.resolve(registration.schema, registration.base, section, registration.validate));
+			const next = deepFreeze(this.resolve(registration.schema, registration.base, section, registration.validate));
 			await this.persist(ns, section);
 			this.document[ns] = section;
 			if (this.registrations.get(ns) === registration && !this.isStopped()) {
@@ -571,7 +739,7 @@ var SettingsProvider = class extends Service {
 		for (const registration of this.registrations.values()) {
 			let next;
 			try {
-				next = deepFreeze$1(this.resolve(registration.schema, registration.base, this.section(registration.ns), registration.validate));
+				next = deepFreeze(this.resolve(registration.schema, registration.base, this.section(registration.ns), registration.validate));
 			} catch (error) {
 				this.ctx.logger.warn("settings: keeping last good \"%s\" after invalid stored section", registration.ns);
 				this.ctx.logger.warn(error);
@@ -969,83 +1137,192 @@ function scopeTarget(base, key) {
 	return carrier;
 }
 //#endregion
-//#region node_modules/.pnpm/@deepseek-ai+dsh-timeout@0._13401da53fdd229a45877adbff64345d/node_modules/@deepseek-ai/dsh-timeout/lib/index.js
-/** Largest delay Node schedules without clamping it to one millisecond. */
-const MAX_TIMER_DELAY_MS = 2147483647;
-//#endregion
-//#region node_modules/.pnpm/@deepseek-ai+dsh-llm@0.1.1-_de8559ed89b7370843bac1bad71a6196/node_modules/@deepseek-ai/dsh-llm/lib/index.js
+//#region node_modules/.pnpm/@deepseek-ai+dsh-typert-pro_32eafa0ce53608e9afb5dafcec019560/node_modules/@deepseek-ai/dsh-typert-protocol/lib/index.js
+/** The one Remote failure class shared by owners, the Gateway, and consumers. */
 /**
-* dsh-llm's owned branded ids: tool-call correlation and provider request
-* diagnostics.
-*
-* The `Branded<B>` primitive itself lives in `@deepseek-ai/dsh-brand` (a
-* zero-dependency type-only package) so every owner of a cross-boundary id can
-* brand it without depending on dsh-llm; see that package's README for the
-* nominal-typing policy.
-*
-* @module @deepseek-ai/dsh-llm/brand
+* One Remote call failure: a real Error carrying its stable code and typed
+* details. Owners throw it at the failure point; the Host Gateway encodes it
+* onto the wire unchanged; the Client face rebuilds an instance for the
+* `RemoteResult` error branch, so `throw result.error` keeps throw semantics.
+* Discrimination is always by `code`, never by instanceof.
 */
+var RemoteError = class extends Error {
+	code;
+	details;
+	/** Structural marker: cross-realm/bundle identification never uses instanceof. */
+	isDSHRemoteError = true;
+	/**
+	* @param code - stable failure code declared in {@link RemoteErrorDetailsMap}.
+	* @param message - human diagnostic carried across the wire.
+	* @param details - structured payload typed by the code.
+	* @param options - standard Error options (`cause` survives in-process only).
+	*/
+	constructor(code, message, details, options) {
+		super(message, options);
+		this.code = code;
+		this.details = details;
+		this.name = "RemoteError";
+	}
+};
 /**
-* Brand a message identifier.
-* @param id - the opaque message identifier.
-* @returns the same string, branded; no validation is performed.
+* Remote decorators and explicit Gateway bindings backed by versioned
+* descriptors carried on decorated class prototypes. Strict reflection
+* remains a Typert compiler responsibility.
+* @module @deepseek-ai/dsh-typert-protocol
 */
-function MessageId(id) {
-	return id;
-}
+const TYPERT_REMOTE_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
 /**
-* Brand a string as a {@link CallId}.
-* @param id - the provider-issued (or synthesized) call id.
-* @returns the same string, branded; no validation is performed.
+* Test one generated Remote name against the Connection endpoint grammar.
+* @param value - namespace, method, lookup, or Context segment.
+* @returns whether the value can cross the shared RPC carrier unchanged.
 */
-function CallId(id) {
-	return id;
+function isTypertRemoteSegment(value) {
+	return value !== "." && value !== ".." && TYPERT_REMOTE_SEGMENT_PATTERN.test(value);
 }
+const REMOTE_METHOD_DESCRIPTOR = "@deepseek-ai/dsh-typert-protocol/remote-methods";
 /**
-* Deep-freeze a value in place with an iterative traversal, guarding cycles,
-* so later mutation throws without imposing a JavaScript call-stack depth cap.
-* {@link AbortSignal} objects are deliberately skipped because they are the
-* request's live cancellation channel and freezing them breaks abort.
-* @param value - the value to freeze in place.
-* @returns the same value, frozen.
+* Bind one visible Service field to a Cordis key and Remote namespace.
+* @param service - owning Service instance, normally `this`.
+* @param serviceKey - exact Cordis service key.
+* @param options - optional distinct wire namespace.
+* @returns a frozen, inspectable binding with no compiler-injected metadata.
 */
-function deepFreeze(value) {
-	const seen = /* @__PURE__ */ new WeakSet();
-	const pending = [{
-		kind: "visit",
-		node: value
-	}];
-	while (pending.length > 0) {
-		const task = pending.pop();
-		/* v8 ignore next -- the loop condition guarantees one pending task. */
-		if (task === void 0) continue;
-		if (task.kind === "property") {
-			pending.push({
-				kind: "visit",
-				node: task.source[task.key]
-			});
-			continue;
-		}
-		const node = task.node;
-		if (node === null || typeof node !== "object") continue;
-		if (node instanceof AbortSignal) continue;
-		if (seen.has(node)) continue;
-		seen.add(node);
-		Object.freeze(node);
-		const keys = Object.keys(node);
-		for (let index = keys.length - 1; index >= 0; index--) {
-			const key = keys[index];
-			/* v8 ignore next -- the loop is bounded by the captured key count. */
-			if (key === void 0) continue;
-			pending.push({
-				kind: "property",
-				source: node,
-				key
-			});
-		}
+function bindTypertRemote(service, serviceKey, options = {}) {
+	validateName("service key", serviceKey);
+	const namespace = options.namespace ?? serviceKey;
+	validateName("namespace", namespace);
+	return Object.freeze({
+		service,
+		serviceKey,
+		namespace
+	});
+}
+/** Cordis Service base that exposes its registered name through Typert Gateway. */
+var TypertRemoteService = class extends Service {
+	/** Visible binding consumed by the Gateway's source-mode discovery. */
+	typertRemote;
+	/**
+	* Register the Service and bind the same key to Typert Gateway.
+	* @param ctx - owning Cordis Context.
+	* @param serviceKey - exact Cordis service key and default wire namespace.
+	* @param options - optional distinct wire namespace.
+	*/
+	constructor(ctx, serviceKey, options = {}) {
+		super(ctx, serviceKey);
+		this.typertRemote = bindTypertRemote(this, this.name, options);
+	}
+};
+function Remote(methodExportOrOptions, context) {
+	if (typeof methodExportOrOptions === "string") {
+		validateName("Remote export name", methodExportOrOptions);
+		return remoteDecorator({ kind: "direct" }, void 0, methodExportOrOptions);
+	}
+	if (typeof methodExportOrOptions === "object") {
+		if (remoteOptionMode(methodExportOrOptions) !== "stream" || Reflect.ownKeys(methodExportOrOptions).length !== 1) throw new TypeError("typert-protocol: Remote options must contain exactly mode: \"stream\"");
+		return remoteDecorator({ kind: "direct" }, "stream");
+	}
+	if (context === void 0) throw new TypeError("typert-protocol: Remote decorator context is missing");
+	addMarkerInitializer(context, { kind: "direct" });
+}
+function remoteOptionMode(options) {
+	return Reflect.get(options, "mode");
+}
+function remoteDecorator(invocation, mode, exportName) {
+	return function(_method, context) {
+		addMarkerInitializer(context, invocation, mode, exportName);
+	};
+}
+function readRemoteMethodDescriptor(prototype) {
+	const property = Object.getOwnPropertyDescriptor(prototype, REMOTE_METHOD_DESCRIPTOR);
+	if (property === void 0) return void 0;
+	const descriptor = property.value;
+	if (descriptor === null || typeof descriptor !== "object") throw new TypeError("typert-protocol: Remote method descriptor must be an object");
+	const version = Reflect.get(descriptor, "version");
+	if (version !== 1) throw new TypeError(`typert-protocol: unsupported Remote method descriptor version ${String(version)}`);
+	const methods = Reflect.get(descriptor, "methods");
+	if (!Array.isArray(methods)) throw new TypeError("typert-protocol: Remote method descriptor methods must be an array");
+	return descriptor;
+}
+function addMarkerInitializer(context, invocation, mode, exportName) {
+	if (context.private || context.static || typeof context.name !== "string") throw new TypeError("typert-protocol: Remote decorators require a public instance method with a string name");
+	const method = context.name;
+	context.addInitializer(function() {
+		const prototype = Object.getPrototypeOf(this);
+		if (prototype === null) throw new TypeError(`typert-protocol: cannot mark Remote method "${method}" on an object without a prototype`);
+		mark(prototype, method, invocation, mode, exportName);
+	});
+}
+function mark(prototype, method, invocation, mode, exportName) {
+	const descriptor = readRemoteMethodDescriptor(prototype);
+	const marker = Object.freeze({
+		method,
+		...exportName === void 0 || exportName === method ? {} : { exportName },
+		...mode === void 0 ? {} : { mode },
+		invocation: Object.freeze(invocation)
+	});
+	const current = descriptor?.methods.find((candidate) => candidate.method === method);
+	if (current !== void 0) {
+		if (current.exportName === marker.exportName && current.mode === marker.mode && sameInvocation(current.invocation, invocation)) return;
+		throw new Error(`typert-protocol: Remote method "${method}" has conflicting invocation markers`);
 	}
+	Object.defineProperty(prototype, REMOTE_METHOD_DESCRIPTOR, {
+		configurable: true,
+		value: Object.freeze({
+			version: 1,
+			methods: Object.freeze([...descriptor?.methods ?? [], marker])
+		})
+	});
+}
+function sameInvocation(left, right) {
+	if (left.kind === "direct") return right.kind === "direct";
+	if (right.kind === "direct") return false;
+	return left.context === right.context;
+}
+function validateName(subject, value) {
+	if (!isTypertRemoteSegment(value)) throw new TypeError(`typert-protocol: ${subject} must contain only RPC endpoint segment characters`);
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+dsh-util-crypt_66ec5f64228d8b6b846c0e0318a734f3/node_modules/@deepseek-ai/dsh-util-crypto/lib/index.js
+/**
+* Random v4 UUID, minted from `crypto.getRandomValues`.
+* @returns the UUID string.
+*/
+function randomUUID$1() {
+	const bytes = globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	const hex = Array.from(bytes, (byte, index) => {
+		return (index === 6 ? byte & 15 | 64 : index === 8 ? byte & 63 | 128 : byte).toString(16).padStart(2, "0");
+	}).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+dsh-brand@0.1.5-rc.1_@deepseek-ai+cordis@4.0.1/node_modules/@deepseek-ai/dsh-brand/lib/index.js
+/**
+* Duplicate-install-safe nominal primitive helpers.
+*
+* A brand makes structurally identical strings or numbers non-interchangeable
+* at the type level: a `SessionId` cannot be passed where a `ToolCallId` is
+* expected, and an event sequence cannot be passed as a log offset. Comparison,
+* logging, and serialization retain the underlying primitive behavior.
+*
+* This package owns no concrete domain value and keeps no runtime identity or mutable
+* state, so independently installed copies produce interchangeable values.
+*
+* @module @deepseek-ai/dsh-brand
+*/
+/**
+* Apply a compile-time string brand without changing the value.
+* @param value - string admitted by the domain that owns the target brand.
+* @returns the same string with the requested compile-time brand.
+*/
+function brandString(value) {
 	return value;
 }
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+dsh-timeout@0._5b95bb48758e6032066aa142c5fbb450/node_modules/@deepseek-ai/dsh-timeout/lib/index.js
+/** Largest delay Node schedules without clamping it to one millisecond. */
+const MAX_TIMER_DELAY_MS = 2147483647;
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+dsh-llm@0.1.5-rc.1_@deepseek-ai+cordis@4.0.1/node_modules/@deepseek-ai/dsh-llm/lib/index.js
 /**
 * Detach and deep-freeze a message whose identity already exists.
 * @param message - complete message, including its stable identity.
@@ -1062,7 +1339,7 @@ function freezeMessage(message) {
 function createMessage(input) {
 	return freezeMessage({
 		...input,
-		id: MessageId(crypto.randomUUID())
+		id: brandString(randomUUID$1())
 	});
 }
 /**
@@ -1144,255 +1421,1076 @@ const alwaysPolicySchema = z.object({
 	backoff: backoffSchema
 });
 z.union([normalPolicySchema, alwaysPolicySchema]);
+const NORMAL_POLICY_KEYS = /* @__PURE__ */ new Set([
+	"mode",
+	"maxRetries",
+	"retryableCodes",
+	"backoff"
+]);
+const ALWAYS_POLICY_KEYS = /* @__PURE__ */ new Set([
+	"mode",
+	"maxRetries",
+	"retryableCodes",
+	"backoff"
+]);
+const BACKOFF_KEYS = /* @__PURE__ */ new Set([
+	"initialDelayMs",
+	"maxDelayMs",
+	"jitterRatio"
+]);
+function validateKeys(value, allowed, path) {
+	for (const key of Object.keys(value)) if (!allowed.has(key)) throw new Error(`${path}: unknown key "${key}"`);
+}
+function resolveBackoff(config, path) {
+	if (config !== void 0) validateKeys(config, BACKOFF_KEYS, path);
+	const initialDelayMs = config?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+	const maxDelayMs = config?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+	const jitterRatio = config?.jitterRatio ?? DEFAULT_JITTER_RATIO;
+	if (!Number.isFinite(initialDelayMs) || initialDelayMs <= 0 || initialDelayMs > 2147483647) throw new Error(`${path}.initialDelayMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+	if (!Number.isFinite(maxDelayMs) || maxDelayMs <= 0 || maxDelayMs > 2147483647) throw new Error(`${path}.maxDelayMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+	if (initialDelayMs > maxDelayMs) throw new Error(`${path}.initialDelayMs must be less than or equal to maxDelayMs`);
+	if (!Number.isFinite(jitterRatio) || jitterRatio < 0 || jitterRatio > 1) throw new Error(`${path}.jitterRatio must be between 0 and 1`);
+	return Object.freeze({
+		initialDelayMs,
+		maxDelayMs,
+		jitterRatio
+	});
+}
 /**
-* Centralize the non-secret product identity every provider request sends as `User-Agent`, keeping
-* adapters from drifting. See
-* `.agents/notes/implemented/architecture/2026-06-21-mandatory-app-attribution-headers.md`.
-*
-* App-attribution vocabulary for provider requests.
-* @module @deepseek-ai/dsh-llm/attribution
+* Validate, default, and detach one provider-owned retry policy.
+* @param config - optional provider configuration; omission selects normal defaults.
+* @param path - diagnostic path naming the provider config that owns the value.
+* @returns an immutable policy safe to capture in provider registration state.
 */
-const { version } = createRequire(import.meta.url)("../package.json");
-/**
-* Exhaustiveness helper for closed core unions. Use {@link assertNever} at the default branch so a
-* new variant fails compilation at every required handler. Do not use it for declaration-merged
-* unions such as session events or content blocks: handle known variants and explicitly fall
-* through because plugins may add valid unknown cases.
-* @module @deepseek-ai/dsh-llm/never
+function resolveRetryPolicy(config, path) {
+	if (config === void 0) return Object.freeze({
+		mode: "normal",
+		maxRetries: DEFAULT_MAX_RETRIES,
+		retryableCodes: DEFAULT_RETRYABLE_CODES,
+		...resolveBackoff(void 0, `${path}.backoff`)
+	});
+	switch (config.mode) {
+		case "normal": {
+			validateKeys(config, NORMAL_POLICY_KEYS, path);
+			const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+			const retryableCodes = config.retryableCodes ?? [...DEFAULT_RETRYABLE_CODES];
+			if (!Number.isSafeInteger(maxRetries) || maxRetries < 0) throw new Error(`${path}.maxRetries must be a non-negative safe integer`);
+			if (retryableCodes.length === 0) throw new Error(`${path}.retryableCodes must not be empty`);
+			if (retryableCodes.some((code) => typeof code !== "string" || code.length === 0)) throw new Error(`${path}.retryableCodes must contain only non-empty strings`);
+			if (new Set(retryableCodes).size !== retryableCodes.length) throw new Error(`${path}.retryableCodes must not contain duplicates`);
+			return Object.freeze({
+				mode: "normal",
+				maxRetries,
+				retryableCodes: Object.freeze([...retryableCodes]),
+				...resolveBackoff(config.backoff, `${path}.backoff`)
+			});
+		}
+		case "always":
+			validateKeys(config, ALWAYS_POLICY_KEYS, path);
+			return Object.freeze({
+				mode: "always",
+				...resolveBackoff(config.backoff, `${path}.backoff`)
+			});
+		default: throw new Error(`${path}.mode must be "normal" or "always"`);
+	}
+}
+/**
+* Field-wise equality over {@link LlmCallConfig} — the comparison a caller
+* runs to decide whether a proposed configuration is a real change (worth a
+* logged header snapshot) or the held one restated.
+* @param a - one configuration.
+* @param b - the other.
+* @returns whether every field (including the `stop` list, element-wise) matches.
+*/
+function callConfigEquals(a, b) {
+	if (a.provider !== b.provider || a.model !== b.model || a.reasoningEffort !== b.reasoningEffort || a.temperature !== b.temperature || a.maxTokens !== b.maxTokens) return false;
+	if (a.stop === void 0 || b.stop === void 0) return a.stop === b.stop;
+	return a.stop.length === b.stop.length && a.stop.every((s, i) => s === b.stop?.[i]);
+}
+/**
+* Normalization for values thrown by a final LLM adapter boundary.
+*
+* @module @deepseek-ai/dsh-llm/adapter-failure
 */
 /**
-* Mark an unreachable closed-union branch. A newly unhandled typed variant fails at the call site;
-* a value that escaped its type throws with diagnostics at runtime.
-* @param value - the impossible value; typed `never` so an unhandled variant fails compilation at the call site.
-* @param context - optional label (e.g. the switch site) prefixed into the throw message.
-* @returns never — it always throws, with the offending value JSON-rendered in the message.
+* Detach serializable provider facts from a value thrown by an adapter.
+* @param value - arbitrary value thrown during adapter dispatch or iteration.
+* @returns immutable provider-neutral facts suitable for a terminal finish chunk.
+* @internal
 */
-function assertNever(value, context) {
-	const rendered = JSON.stringify(value) ?? String(value);
-	throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
+function normalizeLlmFailure(value) {
+	const error = value instanceof Error ? value : new HarnessError(thrownMessage(value), "UNKNOWN", { cause: value });
+	const carried = ownFailureSnapshot(error);
+	if (carried !== void 0 && carried.code === ownErrorCode(error)) return carried;
+	return Object.freeze({
+		message: errorMessage$2(error),
+		code: harnessErrorCode(error)
+	});
 }
-//#endregion
-//#region node_modules/.pnpm/@deepseek-ai+dsh-session@0._f3475d2e0abd209e639ed06267209bdd/node_modules/@deepseek-ai/dsh-session/lib/index.js
-/** Lossless-JSON validation and detached snapshots for durable session data. @module @deepseek-ai/dsh-session/json */
-/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
-function hasIntrinsicConstructor$1(prototype, name) {
-	const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-	if (typeof constructor !== "function") return false;
+/** Render a non-Error throw without letting hostile coercion escape normalization. */
+function thrownMessage(value) {
 	try {
-		return constructor.name === name && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`;
-	} catch {
-		return false;
+		const message = String(value);
+		return message.length > 0 ? message : "LLM adapter failed";
+	} catch (_hostileThrownValue) {
+		return "LLM adapter failed";
 	}
 }
-/** Whether a candidate is one realm's intrinsic `Object.prototype`. */
-function isIntrinsicObjectPrototype$1(value) {
-	return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor$1(value, "Object");
+/** Read a foreign error's own data-backed `code` without invoking accessors. */
+function ownErrorCode(error) {
+	try {
+		const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+		return descriptor !== void 0 && "value" in descriptor ? descriptor.value : void 0;
+	} catch (_sdkPropertyTrap) {
+		return;
+	}
 }
-/** Whether an array uses one realm's intrinsic `Array.prototype`, not a subclass or forged prototype. */
-function hasPlainArrayPrototype$1(value) {
-	const prototype = Object.getPrototypeOf(value);
-	if (!Array.isArray(prototype) || !hasIntrinsicConstructor$1(prototype, "Array")) return false;
-	const objectPrototype = Object.getPrototypeOf(prototype);
-	return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype$1(objectPrototype);
+/** Snapshot an own data property without invoking an SDK-defined accessor. */
+function ownFailureSnapshot(error) {
+	try {
+		const descriptor = Object.getOwnPropertyDescriptor(error, "failure");
+		return descriptor !== void 0 && "value" in descriptor ? failureSnapshot(descriptor.value) : void 0;
+	} catch (_sdkPropertyTrap) {
+		return;
+	}
 }
-/** Whether an object is a plain or null-prototype record from any JavaScript realm. */
-function hasPlainObjectPrototype(value) {
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype$1(prototype);
+/** Validate and detach an arbitrary serializable failure payload. */
+function failureSnapshot(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	try {
+		const candidate = value;
+		const message = candidate.message;
+		const code = candidate.code;
+		const status = candidate.status;
+		const providerRetryAfterMs = candidate.providerRetryAfterMs;
+		const requestId = candidate.requestId;
+		if (typeof message !== "string" || message.length === 0 || typeof code !== "string" || code.length === 0 || status !== void 0 && (!Number.isInteger(status) || status < 100 || status > 599) || providerRetryAfterMs !== void 0 && (!Number.isFinite(providerRetryAfterMs) || providerRetryAfterMs <= 0) || requestId !== void 0 && (typeof requestId !== "string" || requestId.length === 0)) return void 0;
+		return Object.freeze({
+			message,
+			code,
+			...status === void 0 ? {} : { status },
+			...providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs },
+			...requestId === void 0 ? {} : { requestId }
+		});
+	} catch (_sdkFailureGetter) {
+		return;
+	}
 }
-/** Return every JSON-visible object key, or reject own data JSON would discard. */
-function enumerableStringKeys(value) {
-	const keys = Reflect.ownKeys(value);
-	if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
-	return keys;
+/** Read an SDK error message without letting an accessor replace the primary failure. */
+function errorMessage$2(error) {
+	try {
+		const message = error.message;
+		if (typeof message === "string" && message.length > 0) return message;
+	} catch (_sdkMessageGetter) {}
+	return "LLM adapter failed";
 }
-/** Validate lossless JSON iteratively, optionally materializing a detached snapshot. */
-function walkJsonValue(value, detach) {
-	const ancestors = /* @__PURE__ */ new Set();
-	let root;
-	const assign = (destination, item) => {
-		if (destination === void 0) return;
-		if (destination.kind === "root") root = item;
-		else if (destination.kind === "array") destination.target[destination.index] = item;
-		else Object.defineProperty(destination.target, destination.key, {
-			value: item,
-			enumerable: true,
-			configurable: true,
-			writable: true
-		});
-	};
-	const tasks = [{
-		kind: "visit",
-		value,
-		...detach ? { destination: { kind: "root" } } : {}
-	}];
-	for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
-		if (task.kind === "leave") {
-			ancestors.delete(task.source);
-			continue;
-		}
-		if (task.kind === "array-item") {
-			if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
-			tasks.push({
-				kind: "visit",
-				value: task.source[task.index],
-				...task.target === void 0 ? {} : { destination: {
-					kind: "array",
-					target: task.target,
-					index: task.index
-				} }
-			});
-			continue;
-		}
-		if (task.kind === "object-property") {
-			tasks.push({
-				kind: "visit",
-				value: task.source[task.key],
-				...task.target === void 0 ? {} : { destination: {
-					kind: "object",
-					target: task.target,
-					key: task.key
-				} }
+/** Trust only Harness-owned codes; third-party SDK codes are not our taxonomy. */
+function harnessErrorCode(error) {
+	return error instanceof HarnessError ? error.code : "UNKNOWN";
+}
+function quoted(value) {
+	return JSON.stringify(value);
+}
+/**
+* Stable text shown to a model that cannot accept one durable image reference.
+* @param ref - durable normalized attachment omitted from the request.
+* @returns deterministic text-only placeholder.
+*/
+function textOnlyImageText(ref) {
+	return `[image omitted because this model accepts text only; attachment sha256:${String(ref.attachmentId).slice(7, 15)}]`;
+}
+/**
+* True when typed model content contains an image block, walking nested
+* tool-result content. This is the one recursive image walk shared by every
+* image policy (capability gating, text-only serialization, compaction
+* survey), so a consumer cannot silently diverge on nesting depth.
+* @param content - typed model content blocks.
+* @returns whether any nested block is an image.
+*/
+function contentHasImage(content) {
+	return content.some((block) => block.type === "image" || block.type === "tool-result" && contentHasImage(block.content));
+}
+/**
+* True when typed model content contains a file block, walking nested
+* tool-result content on the same recursion every file policy shares.
+* Reads current content on every call without retaining scan results.
+* @param content - typed model content blocks.
+* @returns whether any nested block is a file.
+*/
+function contentHasFile(content) {
+	for (const block of content) if (block.type === "file" || block.type === "tool-result" && contentHasFile(block.content)) return true;
+	return false;
+}
+/**
+* Stable model-facing handle for one durable file reference: the address of
+* the verbatim stored copy and the instruction to read it on demand. This is
+* the only representation a provider ever receives for a file.
+* @param ref - durable verbatim file reference.
+* @param readonlyPath - execution-world path of the stored copy, when resolvable.
+* @returns deterministic handle text naming the file, its size, and its address.
+*/
+function fileHandleText(ref, readonlyPath) {
+	const digest = String(ref.attachmentId).slice(7, 15);
+	const identity = `File ${quoted(ref.name)} (${ref.bytes} bytes, sha256:${digest})`;
+	if (readonlyPath === void 0) return `[${identity} was uploaded, but the current execution environment cannot access a readable path. Report that limitation if its contents are needed; do not claim to have read it.]`;
+	return `[${identity}: verbatim read-only copy saved at ${quoted(readonlyPath)}. Read that path with your file tools when its contents are needed; copy it to a writable location before modifying it. When delegating file work, include this saved path in the delegation prompt; only subagents sharing this execution environment can read it.]`;
+}
+/** Replace every file occurrence, including nested tool results, with handle text. */
+function replaceFilesWithHandles(blocks, resolvePath) {
+	let next;
+	for (const [index, block] of blocks.entries()) {
+		if (block.type === "file") {
+			next ??= blocks.slice(0, index);
+			next.push({
+				type: "text",
+				text: fileHandleText(block.attachment, resolvePath(block.attachment))
 			});
 			continue;
 		}
-		const current = task.value;
-		if (current === null) {
-			assign(task.destination, null);
-			continue;
-		}
-		if (typeof current === "boolean" || typeof current === "string") {
-			assign(task.destination, current);
-			continue;
-		}
-		if (typeof current === "number") {
-			if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
-			assign(task.destination, current);
-			continue;
+		if (block.type === "tool-result") {
+			const content = replaceFilesWithHandles(block.content, resolvePath);
+			if (content !== block.content) {
+				next ??= blocks.slice(0, index);
+				next.push({
+					...block,
+					content
+				});
+				continue;
+			}
 		}
-		if (typeof current !== "object") return void 0;
-		if (ancestors.has(current)) return void 0;
-		if (Array.isArray(current)) {
-			if (!hasPlainArrayPrototype$1(current)) return void 0;
-			const length = current.length;
-			if (Reflect.ownKeys(current).length !== length + 1) return void 0;
-			const target = detach ? [] : void 0;
-			if (target !== void 0) assign(task.destination, target);
-			ancestors.add(current);
-			tasks.push({
-				kind: "leave",
-				source: current
-			});
-			for (let index = length - 1; index >= 0; index--) tasks.push({
-				kind: "array-item",
-				source: current,
-				index,
-				...target === void 0 ? {} : { target }
+		next?.push(block);
+	}
+	return next ?? blocks;
+}
+/**
+* Project durable file history into deterministic handle text for every model
+* route. Unlike images, no provider receives file blocks natively, so this
+* projection is unconditional in request assembly.
+* @param messages - complete request history.
+* @param resolvePath - resolve one reference's current execution-world read path.
+* @returns the original list without files, otherwise shallow message copies with handle text.
+*/
+function projectFilesToText(messages, resolvePath) {
+	if (!messages.some((message) => contentHasFile(message.content))) return messages;
+	return messages.map((message) => {
+		const content = replaceFilesWithHandles(message.content, resolvePath);
+		return content === message.content ? message : {
+			...message,
+			content
+		};
+	});
+}
+/** Replace every image occurrence, including nested tool results, for a text-only model. */
+function replaceImagesForTextModel(blocks) {
+	let next;
+	for (const [index, block] of blocks.entries()) {
+		if (block.type === "image") {
+			next ??= blocks.slice(0, index);
+			next.push({
+				type: "text",
+				text: textOnlyImageText(block.attachment)
 			});
 			continue;
 		}
-		if (!hasPlainObjectPrototype(current)) return void 0;
-		const keys = enumerableStringKeys(current);
-		if (keys === void 0) return void 0;
-		const target = detach ? {} : void 0;
-		if (target !== void 0) assign(task.destination, target);
-		ancestors.add(current);
-		tasks.push({
-			kind: "leave",
-			source: current
-		});
-		for (let index = keys.length - 1; index >= 0; index--) {
-			const key = keys[index];
-			/* v8 ignore next -- the loop is bounded by the captured key count. */
-			if (key === void 0) return void 0;
-			tasks.push({
-				kind: "object-property",
-				source: current,
-				key,
-				...target === void 0 ? {} : { target }
-			});
+		if (block.type === "tool-result") {
+			const content = replaceImagesForTextModel(block.content);
+			if (content !== block.content) {
+				next ??= blocks.slice(0, index);
+				next.push({
+					...block,
+					content
+				});
+				continue;
+			}
 		}
+		next?.push(block);
 	}
-	return detach ? root : true;
+	return next ?? blocks;
 }
 /**
-* Validate and detach lossless JSON in one read per property, so a stateful
-* getter cannot change between validation and copying. Traversal is iterative,
-* so valid nesting is bounded by available memory rather than the JavaScript
-* call stack. Accepts ordinary arrays, plain or null-prototype objects, and JSON
-* scalars; rejects sparse, cyclic, exotic, negative-zero, and non-finite values.
-* Getter throws propagate.
-*
-* @param value - the candidate value to validate and detach.
-* @returns the detached snapshot, or `undefined` when the value is not
-*   losslessly JSON-serializable.
+* Project durable image history into deterministic text for an exact text-only model.
+* @param messages - complete request history.
+* @returns the original list without images, otherwise shallow message copies with stable placeholders.
 */
-function snapshotJsonValue(value) {
-	return walkJsonValue(value, true);
+function projectImagesForTextModel(messages) {
+	if (!messages.some((message) => contentHasImage(message.content))) return messages;
+	return messages.map((message) => {
+		const content = replaceImagesForTextModel(message.content);
+		return content === message.content ? message : {
+			...message,
+			content
+		};
+	});
 }
 /**
-* Test the same lossless JSON boundary as {@link snapshotJsonValue} without
-* detaching it. Only own enumerable string properties participate; `toJSON`
-* is ignored and getters run, so persistence boundaries use the snapshotter.
-* @param value - the candidate event data to test.
-* @returns whether `value` survives JSON round-trip losslessly.
+* Centralize the non-secret product identity every provider request sends as `User-Agent`, keeping
+* adapters from drifting. See
+* `.agents/notes/implemented/architecture/2026-06-21-mandatory-app-attribution-headers.md`.
+*
+* App-attribution vocabulary for provider requests.
+* @module @deepseek-ai/dsh-llm/attribution
 */
-function isJsonValue(value) {
-	return walkJsonValue(value, false) === true;
-}
-//#endregion
-//#region node_modules/.pnpm/@deepseek-ai+dsh-tools@0.1._7117760508de0db46d4e3da5e4a645e6/node_modules/@deepseek-ai/dsh-tools/lib/index.js
+const { version } = createRequire(import.meta.url)("../package.json");
 /**
-* Enforced JSON Schema subset shared by tool outputs, generated Code Mode
-* types, subagents, and workflows. The subset accepts any JSON root, an
-* annotation-only schema for unconstrained JSON, one scalar `type`, object
-* `properties`/`required`/boolean `additionalProperties`, array `items`,
-* type-correct scalar `enum`/`const`, and exact-one `oneOf`.
+* LLM service: adapter registry with a waterfall-interceptable streaming call
+* API. Exports the `LlmRuntime` default, the abstract `LlmAdapter` for
+* provider backends, and `BlockAssembler` for chunk assembly.
 *
-* Unsupported or misplaced keywords reject rather than being accepted without
-* enforcement. Consumers that require an object root apply
-* {@link assertObjectJsonSchema} before accepting input.
-* @module dsh-tools/json-schema
+* @module @deepseek-ai/dsh-llm
 */
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+		else descriptor[key] = _;
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
 /**
-* Thrown when a raw schema falls outside the enforced subset. `violations`
-* lists every offending path instead of stopping at the first author error.
+* Typed error for LLM-related failures. Extends {@link HarnessError}, so the
+* `code` string (e.g. `AUTH`, `RATE_LIMIT`, `NO_ADAPTER`) is shared taxonomy.
 */
-var JsonSchemaError = class extends HarnessError {
-	/** Individual schema violations in walk order. */
-	violations;
-	constructor(violations) {
-		super(`unsupported JSON schema: ${violations.join("; ")}`, "UNSUPPORTED_SCHEMA");
-		this.name = "JsonSchemaError";
-		this.violations = violations;
+var LlmError = class extends HarnessError {
+	/** Serializable facts retained beside this live Error. */
+	failure;
+	/**
+	* @param message - non-empty human-readable failure summary.
+	* @param code - non-empty stable provider-neutral machine code.
+	* @param options - optional cause and validated serializable provider facts.
+	*/
+	constructor(message, code, options) {
+		if (typeof message !== "string" || message.length === 0) throw new Error("LlmError message must be a non-empty string");
+		if (typeof code !== "string" || code.length === 0) throw new Error("LlmError code must be a non-empty string");
+		if (options?.status !== void 0 && (!Number.isInteger(options.status) || options.status < 100 || options.status > 599)) throw new Error("LlmError status must be an integer from 100 through 599");
+		if (options?.providerRetryAfterMs !== void 0 && (!Number.isFinite(options.providerRetryAfterMs) || options.providerRetryAfterMs <= 0)) throw new Error("LlmError providerRetryAfterMs must be a positive finite number");
+		if (options?.requestId !== void 0 && (typeof options.requestId !== "string" || options.requestId.length === 0)) throw new Error("LlmError requestId must be a non-empty string");
+		super(message, code, options);
+		this.name = "LlmError";
+		this.failure = Object.freeze({
+			message,
+			code,
+			...options?.status === void 0 ? {} : { status: options.status },
+			...options?.providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: options.providerRetryAfterMs },
+			...options?.requestId === void 0 ? {} : { requestId: options.requestId }
+		});
 	}
 };
-const CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
-	"type",
-	"oneOf",
-	"properties",
-	"required",
-	"additionalProperties",
-	"items",
-	"enum",
-	"const"
-]);
-const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
-	"description",
-	"title",
-	"default",
-	"examples"
-]);
-const SCHEMA_TYPES = [
-	"object",
-	"array",
-	"string",
-	"number",
-	"integer",
-	"boolean",
-	"null"
-];
-/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
+(() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _listProviders_decorators;
+	let _listConfigurableProviders_decorators;
+	let _remoteDiscoverModels_decorators;
+	return class LlmRuntime extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_listProviders_decorators = [Remote];
+			_listConfigurableProviders_decorators = [Remote];
+			_remoteDiscoverModels_decorators = [Remote("discoverModels")];
+			__esDecorate(this, null, _listProviders_decorators, {
+				kind: "method",
+				name: "listProviders",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listProviders" in obj,
+					get: (obj) => obj.listProviders
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listConfigurableProviders_decorators, {
+				kind: "method",
+				name: "listConfigurableProviders",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listConfigurableProviders" in obj,
+					get: (obj) => obj.listConfigurableProviders
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _remoteDiscoverModels_decorators, {
+				kind: "method",
+				name: "remoteDiscoverModels",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "remoteDiscoverModels" in obj,
+					get: (obj) => obj.remoteDiscoverModels
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		adapters = (__runInitializers(this, _instanceExtraInitializers), /* @__PURE__ */ new Map());
+		directory = /* @__PURE__ */ new Map();
+		discoveries = /* @__PURE__ */ new Map();
+		constructor(ctx) {
+			super(ctx, "llm");
+		}
+		/** Notify topology observers without letting one broken listener veto the commit. */
+		emitAdaptersUpdated() {
+			let invariantFailure;
+			for (const listener of this.ctx.events.dispatch("emit", ["llm/adapters-updated"])) try {
+				const returned = listener();
+				if (returned != null && typeof returned.then === "function") Promise.resolve(returned).then(void 0, (error) => {
+					this.warnAdaptersListenerFailure(error);
+				});
+			} catch (error) {
+				if (error?.code === "INVARIANT") {
+					invariantFailure ??= error;
+					continue;
+				}
+				this.warnAdaptersListenerFailure(error);
+			}
+			if (invariantFailure !== void 0) throw invariantFailure;
+		}
+		/** Contained-listener diagnostic shared by the sync and async failure paths. */
+		warnAdaptersListenerFailure(error) {
+			this.ctx.logger.warn("llm: an llm/adapters-updated listener failed");
+			this.ctx.logger.warn(error);
+		}
+		/**
+		* Register an adapter for the given provider routes. Throws `LlmError` with code
+		* `DUPLICATE_ADAPTER` if any provider already has an adapter (all-or-nothing).
+		* Disposed with the fiber.
+		* @param providers - every provider route this adapter should serve.
+		* @param adapter - the adapter that streams calls for those providers.
+		* @returns the disposer, carrying {@link AdapterRegistrationHandle.replace}.
+		*/
+		registerAdapter(providers, adapter) {
+			const owned = /* @__PURE__ */ new Set();
+			let released = false;
+			const dispose = this.ctx.effect(function* () {
+				if (providers.length === 0) throw new LlmError("an adapter must register at least one provider", "INVALID_ADAPTER");
+				this.commitRoutes(owned, this.prepareRoutes(providers, adapter, owned));
+				yield () => {
+					released = true;
+					for (const provider of owned) this.adapters.delete(provider);
+					owned.clear();
+					this.emitAdaptersUpdated();
+				};
+			}.bind(this), "llm.registerAdapter()");
+			const handle = (() => void dispose());
+			handle.replace = (next) => {
+				if (released) throw new LlmError("a disposed adapter registration cannot replace its routes", "REGISTRATION_DISPOSED");
+				this.commitRoutes(owned, this.prepareRoutes(next, adapter, owned));
+			};
+			return handle;
+		}
+		/**
+		* Validate one candidate route set for `adapter`, treating routes this
+		* registration already holds as available. Nothing is mutated: a rejected
+		* candidate leaves the registry exactly as it was.
+		*/
+		prepareRoutes(providers, adapter, owned) {
+			const unique = /* @__PURE__ */ new Set();
+			const registrations = [];
+			for (const provider of providers) {
+				if (provider.length === 0) throw new LlmError("adapter provider names must be non-empty", "INVALID_ADAPTER");
+				if (unique.has(provider) || this.adapters.has(provider) && !owned.has(provider)) throw new LlmError(`an adapter for provider "${provider}" is already registered`, "DUPLICATE_ADAPTER");
+				const info = adapter.providerInfo(provider);
+				if (typeof info.id !== "string" || info.id !== provider || typeof info.name !== "string" || info.name.length === 0) throw new LlmError(`adapter metadata for provider "${provider}" must preserve its id and have a non-empty name`, "INVALID_ADAPTER");
+				unique.add(provider);
+				const retryPolicy = adapter.providerRetryPolicy(provider) ?? resolveRetryPolicy(void 0, `llm: provider "${provider}" retryPolicy`);
+				registrations.push({
+					adapter,
+					provider: {
+						id: info.id,
+						name: info.name
+					},
+					retryPolicy
+				});
+			}
+			return registrations;
+		}
+		/**
+		* Swap this registration's routes for the prepared ones in one synchronous
+		* section, so no observer can see the registry between the release and the
+		* re-registration. The route set's one mutation point is also where
+		* `llm/adapters-updated` is published, so a `replace` announces itself
+		* exactly like a first registration.
+		*/
+		commitRoutes(owned, registrations) {
+			for (const provider of owned) this.adapters.delete(provider);
+			owned.clear();
+			for (const registration of registrations) {
+				this.adapters.set(registration.provider.id, registration);
+				owned.add(registration.provider.id);
+			}
+			this.emitAdaptersUpdated();
+		}
+		/**
+		* Describe provider routes with a registered adapter.
+		* @returns detached provider metadata in registration order.
+		*/
+		listProviders() {
+			return [...this.adapters.values()].map(({ provider }) => ({ ...provider }));
+		}
+		/**
+		* Declare provider routes an adapter plugin can activate through
+		* configuration. Registration is all-or-nothing: an empty list, invalid
+		* entry, or a provider already declared by any registration throws
+		* `LlmError` without registering the rest. Disposed with the fiber.
+		* @param entries - every configurable provider this plugin owns.
+		* @returns a handle that withdraws all of them, and can atomically replace them.
+		*/
+		registerConfigurableProviders(entries) {
+			let held = [];
+			let disposed = false;
+			/**
+			* Validate a candidate set in full against everything this registration
+			* does not already hold, then publish it. Nothing is written until the
+			* whole set passes, so a refused candidate leaves the current entries in
+			* place — the property that makes `replace` a swap rather than a
+			* delete-then-add that can strand the directory empty.
+			*/
+			const commit = (candidates) => {
+				const detached = [];
+				const own = new Set(held.map((entry) => entry.provider));
+				for (const entry of candidates) {
+					if (entry.provider.length === 0 || entry.displayName.length === 0 || entry.settingsNs.length === 0) throw new LlmError("configurable providers need a non-empty provider, displayName, and settingsNs", "INVALID_DIRECTORY");
+					if (entry.settingsPath.some((segment) => segment.length === 0)) throw new LlmError(`configurable provider "${entry.provider}" has an empty settingsPath segment`, "INVALID_DIRECTORY");
+					if (this.directory.has(entry.provider) && !own.has(entry.provider) || detached.some((seen) => seen.provider === entry.provider)) throw new LlmError(`configurable provider "${entry.provider}" is already declared`, "DUPLICATE_DIRECTORY");
+					detached.push({
+						...entry,
+						settingsPath: [...entry.settingsPath]
+					});
+				}
+				for (const entry of held) this.directory.delete(entry.provider);
+				for (const entry of detached) this.directory.set(entry.provider, entry);
+				held = detached;
+				this.emitAdaptersUpdated();
+			};
+			const dispose = this.ctx.effect(function* () {
+				if (entries.length === 0) throw new LlmError("a configurable-provider registration must declare at least one provider", "INVALID_DIRECTORY");
+				commit(entries);
+				yield () => {
+					disposed = true;
+					for (const entry of held) this.directory.delete(entry.provider);
+					held = [];
+					this.emitAdaptersUpdated();
+				};
+			}.bind(this), "llm.registerConfigurableProviders()");
+			const handle = (() => void dispose());
+			handle.replace = (next) => {
+				if (disposed) throw new LlmError("this configurable-provider registration was disposed", "REGISTRATION_DISPOSED");
+				commit(next);
+			};
+			return handle;
+		}
+		/**
+		* List every declared configurable provider, registered or dormant.
+		* @returns detached directory entries in declaration order.
+		*/
+		listConfigurableProviders() {
+			return [...this.directory.values()].map((entry) => ({
+				...entry,
+				settingsPath: [...entry.settingsPath]
+			}));
+		}
+		/**
+		* Offer to interrogate provider endpoints on behalf of the settings
+		* namespace this plugin owns. The namespace is the key because that is what
+		* a configuration surface already holds from the configurable-provider
+		* directory, and because a provider being *added* has no route to name yet.
+		* Disposed with the fiber.
+		* @param settingsNs - the namespace whose profiles this discovery serves.
+		* @param discover - interrogates one endpoint and must honor the supplied signal.
+		* @returns the disposer that withdraws the offer.
+		*/
+		registerModelDiscovery(settingsNs, discover) {
+			const dispose = this.ctx.effect(function* () {
+				if (settingsNs.length === 0) throw new LlmError("model discovery needs a non-empty settings namespace", "INVALID_DISCOVERY");
+				if (this.discoveries.has(settingsNs)) throw new LlmError(`model discovery for "${settingsNs}" is already registered`, "DUPLICATE_DISCOVERY");
+				this.discoveries.set(settingsNs, discover);
+				yield () => {
+					this.discoveries.delete(settingsNs);
+				};
+			}.bind(this), "llm.registerModelDiscovery()");
+			return () => void dispose();
+		}
+		/**
+		* Interrogate one provider endpoint for the models it advertises. The
+		* request describes a draft, not a stored route, so nothing here reads or
+		* writes settings or credentials — the caller owns both, and the reply is
+		* candidate metadata a surface may offer for adoption.
+		* @param settingsNs - namespace whose registered discovery serves this draft.
+		* @param request - the endpoint, protocol, and one-shot credential to use.
+		* @param signal - caller cancellation.
+		* @returns the advertised models, deduplicated in endpoint order.
+		*/
+		async discoverModels(settingsNs, request, signal) {
+			const discover = this.discoveries.get(settingsNs);
+			if (discover === void 0) throw new LlmError(`no model discovery is registered for "${settingsNs}"`, "NO_DISCOVERY");
+			if ((request.provider ?? "").length === 0 && (request.baseURL ?? "").length === 0) throw new LlmError("model discovery needs a provider route or a baseURL", "INVALID_DISCOVERY");
+			const discovered = signal === void 0 ? await discover(request) : await discover(request, signal);
+			const seen = /* @__PURE__ */ new Set();
+			const models = [];
+			for (const model of discovered) {
+				if (typeof model.id !== "string" || model.id.length === 0 || seen.has(model.id)) continue;
+				seen.add(model.id);
+				models.push({
+					id: model.id,
+					...model.name === void 0 ? {} : { name: model.name },
+					...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
+					...model.maxTokens === void 0 ? {} : { maxTokens: model.maxTokens }
+				});
+			}
+			return models;
+		}
+		/**
+		* Remote adapter for one draft provider interrogation.
+		* @param settingsNs - namespace whose registered discovery serves this draft.
+		* @param request - endpoint, protocol, and one-shot credential to use.
+		* @param signal - caller cancellation supplied by the Remote carrier.
+		* @returns advertised models in endpoint order.
+		* @throws RemoteError with `llm/model-discovery-rejected` when discovery refuses or fails.
+		*/
+		async remoteDiscoverModels(settingsNs, request, signal) {
+			try {
+				return await this.discoverModels(settingsNs, request, signal);
+			} catch (error) {
+				throw new RemoteError("llm/model-discovery-rejected", error instanceof Error ? error.message : String(error), {
+					settingsNs,
+					...request.baseURL === void 0 ? {} : { baseURL: request.baseURL }
+				}, { cause: error });
+			}
+		}
+		/**
+		* Resolve the retry policy captured when one provider route was registered.
+		* @param provider - registered provider route to inspect.
+		* @returns the provider-owned policy, with normal defaults already resolved.
+		*/
+		providerRetryPolicy(provider) {
+			return this.registration(provider).retryPolicy;
+		}
+		/**
+		* Resolve provider-side request-image pricing for one exact route, or
+		* `undefined` when the provider is unregistered or declares none. Unknown
+		* providers degrade to `undefined` rather than throwing because callers
+		* price durable history whose route may no longer be mounted.
+		* @param provider - provider route named by a request header.
+		* @param model - exact model id named by the same header.
+		* @returns the owning adapter's image pricing for the route, when declared.
+		*/
+		imageRequestPricing(provider, model) {
+			return this.adapters.get(provider)?.adapter.imageRequestPricing(provider, model);
+		}
+		/**
+		* Resolve the exact text one durable file occurrence contributes to every
+		* provider request in the current execution environment.
+		* @param ref - durable verbatim file reference from model history.
+		* @returns the same deterministic handle text used at adapter dispatch.
+		*/
+		fileRequestText(ref) {
+			return fileHandleText(ref, this.fileReadPath(ref));
+		}
+		/** Detach typed adapter-owned modality metadata. */
+		detachedModalities(modalities) {
+			return modalities === void 0 ? void 0 : [...modalities];
+		}
+		/**
+		* Discover models advertised by one registered provider. Catalog membership
+		* is advisory and never changes routing or request validation.
+		* @param provider - registered provider route to inspect.
+		* @returns detached model metadata in adapter-preferred order.
+		*/
+		async listModels(provider) {
+			const models = await this.registration(provider).adapter.listModels(provider);
+			const seen = /* @__PURE__ */ new Set();
+			return models.map((model) => {
+				if (typeof model.provider !== "string" || model.provider !== provider || typeof model.id !== "string" || model.id.length === 0 || typeof model.name !== "string" || model.name.length === 0 || model.description !== void 0 && typeof model.description !== "string" || seen.has(model.id)) throw new LlmError(`adapter returned invalid or duplicate model metadata for provider "${provider}"`, "INVALID_CATALOG");
+				seen.add(model.id);
+				const inputModalities = this.detachedModalities(model.inputModalities);
+				return {
+					provider: model.provider,
+					id: model.id,
+					name: model.name,
+					...model.description === void 0 ? {} : { description: model.description },
+					...inputModalities === void 0 ? {} : { inputModalities }
+				};
+			});
+		}
+		/**
+		* Resolve and validate all metadata from the adapter that owns one exact
+		* route. The result is detached from adapter-owned objects; catalog
+		* membership remains advisory and does not control request routing.
+		* @param provider - registered provider route to inspect.
+		* @param model - exact model id passed to the adapter.
+		* @param signal - optional cancellation for adapter-owned asynchronous lookup.
+		* @returns exact model identity plus available context and reasoning metadata.
+		*/
+		async resolveModelInfo(provider, model, signal) {
+			return this.resolveModelInfoFor(this.registration(provider), model, signal);
+		}
+		async resolveModelInfoFor(registration, model, signal) {
+			const resolved = await registration.adapter.resolveModel(registration.provider.id, model, signal);
+			return this.normalizeModelInfo(registration, model, resolved);
+		}
+		/** Validate and detach one adapter-returned exact model result. */
+		normalizeModelInfo(registration, model, resolved) {
+			const provider = registration.provider.id;
+			if (typeof resolved.provider !== "string" || resolved.provider !== provider || typeof resolved.id !== "string" || resolved.id !== model || typeof resolved.name !== "string" || resolved.name.length === 0 || resolved.description !== void 0 && typeof resolved.description !== "string") throw new LlmError(`adapter returned invalid exact model metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_INFO");
+			const context = resolved.context;
+			if (context !== void 0 && (!Number.isInteger(context.contextWindow) || context.contextWindow <= 0)) throw new LlmError(`adapter returned invalid context metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_CONTEXT");
+			const inputModalities = this.detachedModalities(resolved.inputModalities);
+			const systemPromptUpdate = resolved.systemPromptUpdate;
+			if (systemPromptUpdate !== void 0 && systemPromptUpdate !== "in-history") throw new LlmError(`adapter returned invalid system prompt update mode for provider "${provider}" model "${model}"`, "INVALID_MODEL_INFO");
+			const defaultMaxTokens = resolved.defaultMaxTokens;
+			if (defaultMaxTokens !== void 0 && (!Number.isSafeInteger(defaultMaxTokens) || defaultMaxTokens <= 0)) throw new LlmError(`adapter returned invalid default maxTokens for provider "${provider}" model "${model}"`, "INVALID_MODEL_MAX_TOKENS");
+			const info = {
+				provider,
+				id: model,
+				name: resolved.name,
+				...resolved.description === void 0 ? {} : { description: resolved.description },
+				...inputModalities === void 0 ? {} : { inputModalities },
+				...context === void 0 ? {} : { context: { contextWindow: context.contextWindow } },
+				...defaultMaxTokens === void 0 ? {} : { defaultMaxTokens },
+				...resolved.systemPromptUpdate === void 0 ? {} : { systemPromptUpdate: resolved.systemPromptUpdate }
+			};
+			const reasoning = resolved.reasoning;
+			if (reasoning === void 0) return info;
+			if (reasoning.efforts.length === 0) throw new LlmError(`adapter returned invalid reasoning metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+			const seen = /* @__PURE__ */ new Set();
+			const efforts = reasoning.efforts.map((effort) => {
+				if (typeof effort.id !== "string" || effort.id.length === 0 || typeof effort.name !== "string" || effort.name.length === 0 || effort.description !== void 0 && typeof effort.description !== "string" || seen.has(effort.id)) throw new LlmError(`adapter returned invalid or duplicate reasoning effort metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+				seen.add(effort.id);
+				return {
+					id: effort.id,
+					name: effort.name,
+					...effort.description === void 0 ? {} : { description: effort.description }
+				};
+			});
+			if (reasoning.defaultEffort !== void 0 && !seen.has(reasoning.defaultEffort)) throw new LlmError(`adapter returned an unknown default reasoning effort for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+			return {
+				...info,
+				reasoning: {
+					efforts,
+					...reasoning.defaultEffort === void 0 ? {} : { defaultEffort: reasoning.defaultEffort }
+				}
+			};
+		}
+		/**
+		* Validate a conversation call config against its exact model capability and
+		* materialize adapter-configured defaults. Unsupported explicit efforts
+		* reject before provider I/O; no clamping or aliasing is performed. This
+		* standalone query does not bind a later dispatch; use {@link prepareCall}
+		* when logging and streaming must share one adapter registration.
+		* @param config - provider/model route and optional request controls.
+		* @param signal - optional cancellation for adapter-owned capability lookup.
+		* @returns a detached config only when a default must be materialized.
+		*/
+		async resolveCallConfig(config, signal) {
+			return (await this.resolveCallFor(this.registration(config.provider), config, signal)).config;
+		}
+		async resolveCallFor(registration, config, signal) {
+			const info = await this.resolveModelInfoFor(registration, config.model, signal);
+			return this.resolveCallWithInfo(config, info);
+		}
+		/** Validate request controls against one already-bound exact model result. */
+		resolveCallWithInfo(config, info) {
+			const defaulted = config.maxTokens === void 0 && info.defaultMaxTokens !== void 0 ? {
+				...config,
+				maxTokens: info.defaultMaxTokens
+			} : config;
+			const reasoning = info.reasoning;
+			const requested = defaulted.reasoningEffort;
+			let resolvedConfig = defaulted;
+			if (reasoning === void 0) {
+				if (requested !== void 0) throw new LlmError(`provider "${config.provider}" model "${config.model}" does not support reasoning effort "${requested}"`, "UNSUPPORTED_REASONING_EFFORT");
+			} else {
+				const effective = requested ?? reasoning.defaultEffort;
+				if (effective !== void 0) {
+					if (!reasoning.efforts.some((effort) => effort.id === effective)) throw new LlmError(`provider "${config.provider}" model "${config.model}" does not support reasoning effort "${effective}"`, "UNSUPPORTED_REASONING_EFFORT");
+					if (requested !== effective) resolvedConfig = {
+						...defaulted,
+						reasoningEffort: effective
+					};
+				}
+			}
+			return {
+				config: resolvedConfig,
+				...info.context === void 0 ? {} : { context: info.context },
+				modelInfo: info
+			};
+		}
+		/**
+		* Resolve one call under its current adapter registration. The returned
+		* one-shot handle keeps that registration across header logging and dispatch,
+		* so HMR cannot combine one adapter's capability result with another adapter.
+		* @param config - provider/model route and optional request controls.
+		* @param signal - optional cancellation for adapter-owned capability lookup.
+		* @returns a prepared config and its registration-bound stream entry point.
+		*/
+		async prepareCall(config, signal) {
+			const registration = this.registration(config.provider);
+			const adapterCall = await registration.adapter.prepareCall(config.provider, config.model, signal);
+			const modelInfo = this.normalizeModelInfo(registration, config.model, adapterCall.model);
+			const resolved = this.resolveCallWithInfo(config, modelInfo);
+			const resolvedConfig = deepFreeze(structuredClone(resolved.config));
+			const context = resolved.context === void 0 ? void 0 : deepFreeze(structuredClone(resolved.context));
+			const adapterDefaults = deepFreeze({
+				...config.reasoningEffort === void 0 && resolvedConfig.reasoningEffort !== void 0 ? { reasoningEffort: true } : {},
+				...config.maxTokens === void 0 && resolvedConfig.maxTokens !== void 0 ? { maxTokens: true } : {}
+			});
+			let dispatched = false;
+			return Object.freeze({
+				config: resolvedConfig,
+				retryPolicy: registration.retryPolicy,
+				adapterDefaults,
+				...context === void 0 ? {} : { context },
+				...modelInfo.inputModalities === void 0 ? {} : { inputModalities: Object.freeze([...modelInfo.inputModalities]) },
+				...modelInfo.systemPromptUpdate === void 0 ? {} : { systemPromptUpdate: modelInfo.systemPromptUpdate },
+				stream: (options) => {
+					if (dispatched) throw new LlmError("a prepared LLM call can only be dispatched once", "INVALID_PREPARED_CALL");
+					if (!callConfigEquals(options, resolvedConfig)) throw new LlmError("prepared LLM call config changed before adapter dispatch", "INVALID_PREPARED_CALL");
+					dispatched = true;
+					return this.streamWithRegistration(options, {
+						registration,
+						config: resolvedConfig,
+						modelInfo,
+						dispatch: (options) => adapterCall.stream(options)
+					});
+				}
+			});
+		}
+		registration(provider) {
+			const registration = this.adapters.get(provider);
+			if (!registration) throw new LlmError(`no adapter registered for provider "${provider}"`, "NO_ADAPTER");
+			return registration;
+		}
+		/** Remove replay state whose historical route is owned by another adapter. */
+		forAdapter(options, adapter) {
+			const messages = options.messages.map((message) => {
+				const source = message.source;
+				if (message.role !== "assistant" || source.kind !== "model" || source.replayState === void 0) return message;
+				if (this.adapters.get(source.provider)?.adapter === adapter) return message;
+				return freezeMessage({
+					...message,
+					source: {
+						kind: "model",
+						provider: source.provider,
+						model: source.model
+					}
+				});
+			});
+			if (messages.every((message, index) => message === options.messages[index])) return options;
+			const filtered = {
+				...options,
+				messages
+			};
+			return Object.isFrozen(options) ? deepFreeze(filtered) : filtered;
+		}
+		/**
+		* Resolve the current execution-world read path of one durable file
+		* reference through the mounted attachment and filesystem providers.
+		*/
+		fileReadPath(ref) {
+			let hostPath;
+			try {
+				hostPath = this.ctx.get("attachments")?.fileHostPath(ref);
+			} catch {
+				return;
+			}
+			if (hostPath === void 0) return void 0;
+			return this.ctx.get("fs")?.processPathFromHostPath(hostPath);
+		}
+		/**
+		* Final adapter boundary. Adapter selection, dispatch, iterator construction,
+		* and iteration failures become one terminal failure chunk. Middleware and
+		* downstream consumer failures remain thrown plugin or consumer errors.
+		*/
+		async *adapterStream(options, prepared) {
+			let iterator;
+			try {
+				const registration = prepared?.registration ?? this.registration(options.provider);
+				const adapter = registration.adapter;
+				let modelInfo;
+				let resolvedConfig;
+				let dispatch;
+				if (prepared === void 0) {
+					const adapterCall = await adapter.prepareCall(options.provider, options.model, options.signal);
+					modelInfo = this.normalizeModelInfo(registration, options.model, adapterCall.model);
+					resolvedConfig = this.resolveCallWithInfo(options, modelInfo).config;
+					dispatch = (options) => adapterCall.stream(options);
+				} else {
+					modelInfo = prepared.modelInfo;
+					resolvedConfig = prepared.config;
+					dispatch = prepared.dispatch;
+				}
+				if (prepared !== void 0 && !callConfigEquals(options, resolvedConfig)) throw new LlmError("prepared LLM call config changed before adapter dispatch", "INVALID_PREPARED_CALL");
+				const resolvedOptions = callConfigEquals(options, resolvedConfig) ? options : Object.isFrozen(options) ? deepFreeze({
+					...options,
+					...resolvedConfig
+				}) : {
+					...options,
+					...resolvedConfig
+				};
+				let projectedMessages = resolvedOptions.messages;
+				if (projectedMessages.some((message) => contentHasFile(message.content))) projectedMessages = projectFilesToText(projectedMessages, (ref) => this.fileReadPath(ref));
+				if (modelInfo.inputModalities !== void 0 && !modelInfo.inputModalities.includes("image") && projectedMessages.some((message) => contentHasImage(message.content))) projectedMessages = projectImagesForTextModel(projectedMessages);
+				const projectedOptions = projectedMessages === resolvedOptions.messages ? resolvedOptions : Object.isFrozen(resolvedOptions) ? deepFreeze({
+					...resolvedOptions,
+					messages: projectedMessages
+				}) : {
+					...resolvedOptions,
+					messages: projectedMessages
+				};
+				iterator = dispatch(this.forAdapter(projectedOptions, adapter))[Symbol.asyncIterator]();
+			} catch (error) {
+				yield adapterFailureChunk(error, options.signal);
+				return;
+			}
+			let completed = false;
+			try {
+				while (true) {
+					let item;
+					try {
+						const next = await iterator.next();
+						item = next.done ? { done: true } : {
+							done: false,
+							value: next.value
+						};
+					} catch (error) {
+						completed = true;
+						yield adapterFailureChunk(error, options.signal);
+						return;
+					}
+					if (item.done) {
+						completed = true;
+						return;
+					}
+					yield item.value;
+				}
+			} finally {
+				if (!completed) {
+					const close = iterator.return?.bind(iterator);
+					if (close) await close();
+				}
+			}
+		}
+		/**
+		* Stream one model call as raw chunks (token-level deltas). Replay state is
+		* retained only when the same adapter instance owns its historical provider
+		* and the target provider. Final adapter selection remains fixed through
+		* asynchronous exact-model resolution and dispatch. Adapter selection,
+		* dispatch, and iteration failures become terminal `error` or `aborted`
+		* finish chunks; middleware, nested-call, cleanup, and consumer failures
+		* remain thrown.
+		* @param options - the full request; `options.provider` selects the adapter.
+		* @returns the chunk stream, possibly wrapped by `llm/stream` listeners.
+		*/
+		stream(options) {
+			return this.streamWithRegistration(options);
+		}
+		streamWithRegistration(options, prepared) {
+			return this.ctx.waterfall(this, "llm/stream", options, () => this.adapterStream(options, prepared));
+		}
+	};
+})();
+/** Convert one adapter throw into the stream protocol's terminal outcome. */
+function adapterFailureChunk(error, signal) {
+	const failure = normalizeLlmFailure(error);
+	return {
+		type: "finish",
+		reason: signal?.aborted || failure.code === "ABORTED" ? {
+			kind: "aborted",
+			failure
+		} : {
+			kind: "error",
+			failure
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+dsh-tools@0.1._aaa8ad560a1b4ea9b6e9490b78b8a32d/node_modules/@deepseek-ai/dsh-tools/lib/index.js
+/**
+* Enforced JSON Schema subset shared by tool outputs, generated PTC mode
+* types, subagents, and workflows. The subset accepts any JSON root, an
+* annotation-only schema for unconstrained JSON, one scalar `type`, object
+* `properties`/`required`/boolean `additionalProperties`, array `items`,
+* type-correct scalar `enum`/`const`, and exact-one `oneOf`.
+*
+* Unsupported or misplaced keywords reject rather than being accepted without
+* enforcement. Consumers that require an object root apply
+* {@link assertObjectJsonSchema} before accepting input.
+* @module dsh-tools/json-schema
+*/
+/**
+* Thrown when a raw schema falls outside the enforced subset. `violations`
+* lists every offending path instead of stopping at the first author error.
+*/
+var JsonSchemaError = class extends HarnessError {
+	/** Individual schema violations in walk order. */
+	violations;
+	constructor(violations) {
+		super(`unsupported JSON schema: ${violations.join("; ")}`, "UNSUPPORTED_SCHEMA");
+		this.name = "JsonSchemaError";
+		this.violations = violations;
+	}
+};
+const CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"oneOf",
+	"properties",
+	"required",
+	"additionalProperties",
+	"items",
+	"enum",
+	"const"
+]);
+const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
+	"description",
+	"title",
+	"default",
+	"examples"
+]);
+const SCHEMA_TYPES = [
+	"object",
+	"array",
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"null"
+];
+/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
 function hasIntrinsicConstructor(prototype, name) {
 	const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
 	if (typeof constructor !== "function") return false;
@@ -2194,13 +3292,13 @@ function defineTool(options) {
 	return tool;
 }
 /**
-* Code Mode `run_code` transport. Programs call the registry's agent-visible
+* PTC mode `run_code` transport. Programs call the registry's agent-visible
 * tools through nested executions scheduled under the native concurrency
 * contract; each sub-dispatch is logged for reconstruction, while only the
 * outer curated result enters model history.
-* @module @deepseek-ai/dsh-tools/src/code-mode
+* @module @deepseek-ai/dsh-tools/src/ptc
 */
-/** The model-facing name of the Code Mode tool. */
+/** The model-facing name of the PTC mode tool. */
 const RUN_CODE_NAME = "run_code";
 /**
 * The TypeScript flavor: the fallback for a schema read with no runtime
@@ -2518,7 +3616,7 @@ function createRunCodeTool(registry, options) {
 				if (runOver()) throw new Error(`run_code run is over (${String(runController.signal.reason)}); ${name} not dispatched`);
 				const normalized = jsonNormalizeArgs(rawArgs);
 				const n = ++dispatches;
-				const subCallId = CallId(`${String(exec.callId)}:code:${n}`);
+				const subCallId = brandString(`${String(exec.callId)}:ptc:${n}`);
 				const input = {
 					callId: subCallId,
 					rootCallId: exec.rootCallId,
@@ -2550,7 +3648,7 @@ function createRunCodeTool(registry, options) {
 								isError: result.isError,
 								content: result.content
 							});
-							agent.session.append("tool/code-dispatch", {
+							agent.session.append("tool/ptc-dispatch", {
 								rootCallId: exec.rootCallId,
 								parentCallId: exec.callId,
 								subCallId,
@@ -2572,7 +3670,7 @@ function createRunCodeTool(registry, options) {
 							reject(/* @__PURE__ */ new Error(`run_code run is over (${String(runController.signal.reason)}); ${name} tool call abandoned`));
 						},
 						async start() {
-							exec.agent?.session.append("tool/code-dispatch-start", {
+							exec.agent?.session.append("tool/ptc-dispatch-start", {
 								rootCallId: exec.rootCallId,
 								parentCallId: exec.callId,
 								subCallId,
@@ -2606,7 +3704,7 @@ function createRunCodeTool(registry, options) {
 								content: result.content,
 								source: {
 									kind: "plugin",
-									plugin: "tools-code-mode"
+									plugin: "tools-ptc"
 								}
 							}));
 							for (const context of result.additionalContexts ?? []) exec.deferContext(context);
@@ -2690,7 +3788,7 @@ function createRunCodeTool(registry, options) {
 	return definition;
 }
 /**
-* Code Mode codegen: the pure projection from registered tool schemas to the TypeScript SDK
+* PTC mode codegen: the pure projection from registered tool schemas to the TypeScript SDK
 * text the model programs against (the `tools:sdk` prompt section). Sibling of
 * `json-schema.ts` — `schemas()` (native function calling) and this module (the generated
 * `declare const tools` API) are two projections of the same store.
@@ -2897,17 +3995,35 @@ function jsonSchemaToTs(schema, indent = 0) {
 		return "unknown";
 	}
 }
-/** The fixed model-facing usage contract rendered above the declarations (see the Code Mode Agent Note's "What the model sees"). */
+/** The fixed model-facing usage contract rendered above the declarations (see the PTC mode Agent Note's "What the model sees"). */
 const SDK_INSTRUCTIONS$1 = `## Writing code for run_code
 
-\`run_code\` takes two required arguments: \`code\` — the body of an async TypeScript function (erasable syntax only — no \`enum\` or namespaces; type annotations are advisory, the code runs type-stripped) — and \`description\`, a short summary of what the program does. Inside the program:
+\`run_code\` takes two required arguments: \`code\` — the body of an async TypeScript function (erasable syntax only — no \`enum\` or namespaces; type annotations are advisory, the code runs type-stripped) — and \`description\`, a short summary of what the program does. The declarations below are SDK bindings for this program. A declaration does not make its name a directly callable tool; only names supplied as separate tool schemas may be called directly.`;
+const SDK_PROGRAM_INSTRUCTIONS = `Inside the program:
 
 - Call tools as \`await tools.name(args)\` — quoted access for exotic names: \`tools["my-tool"](args)\`. Every call resolves to the tool's typed canonical JSON value. Tool arguments must be lossless JSON.
 - A FAILED tool call rejects with \`ToolCallError\`, whose \`toolName\` identifies the failed tool and whose \`message\` is human-readable — \`try/catch\` it to handle and continue.
 - Independent read-only calls MAY overlap under \`Promise.all\` (safe calls run concurrently; mutating calls run alone, in submission order). Sequence dependent work with \`await\`.
 - Emit results with \`return\` and/or \`console.log(...)\`. Only what you print or return is program output. A successful tool result containing an image is attached after the run so you can inspect it on the next step; every other intermediate result stays out of the conversation, so extract just what you need.
 
-The available tools:`;
+Program-only SDK bindings:`;
+/** Whether one string schema accepts the literal used by the bash example. */
+function acceptsExampleString(schema, value) {
+	return schema?.type === "string" && (schema.const === void 0 || schema.const === value) && (schema.enum === void 0 || schema.enum.includes(value));
+}
+/** Render the bash example only when its literal arguments satisfy the current parameter schema. */
+function renderBashExample(schemas) {
+	const bash = schemas.find((schema) => schema.name === "bash");
+	if (bash === void 0) return "";
+	const parameters = bash.parameters;
+	if (parameters.type !== "object") return "";
+	const required = parameters.required ?? [];
+	if (required.some((name) => name !== "command" && name !== "description")) return "";
+	if (!acceptsExampleString(parameters.properties?.command, "pwd")) return "";
+	const needsDescription = required.includes("description");
+	if (needsDescription && !acceptsExampleString(parameters.properties?.description, "Show current directory")) return "";
+	return ` When no separate \`bash\` schema is supplied, invoke a declared \`bash\` binding inside \`run_code\`:\n\n\`run_code({ code: "return await tools.bash({ command: 'pwd'${needsDescription ? ", description: 'Show current directory'" : ""} })", description: "Show current directory" })\``;
+}
 /**
 * Render the full `tools:sdk` prompt section: the fixed usage instructions
 * plus one `declare const tools` interface covering every given tool.
@@ -2929,7 +4045,7 @@ function renderToolsSdk(schemas) {
 		argsMembers.push(`${pad$1(1)}${renderKey(schema.name)}: ${jsonSchemaToTs(schema.parameters, 1)};`);
 		outputMembers.push(`${pad$1(1)}${renderKey(schema.name)}: ${jsonSchemaToTs(schema.output, 1)};`);
 	}
-	return `${SDK_INSTRUCTIONS$1}\n\n\`\`\`ts\ntype JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue }\n\n${[
+	const declaration = [
 		`interface ToolArgsMap {${argsMembers.length > 0 ? `\n${argsMembers.join("\n")}\n` : ""}}`,
 		`interface ToolOutputMap {${outputMembers.length > 0 ? `\n${outputMembers.join("\n")}\n` : ""}}`,
 		"type ToolName = keyof ToolOutputMap",
@@ -2944,16 +4060,17 @@ function renderToolsSdk(schemas) {
 			"  [K in ToolName]: (args: ToolArgsMap[K]) => Promise<ToolOutputMap[K]>;",
 			"}"
 		].join("\n")
-	].join("\n\n")}\n\`\`\``;
+	].join("\n\n");
+	return `${SDK_INSTRUCTIONS$1}${renderBashExample(sorted)}\n\n${SDK_PROGRAM_INSTRUCTIONS}\n\n\`\`\`ts\ntype JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue }\n\n${declaration}\n\`\`\``;
 }
 /**
-* Code Mode codegen — Python flavor. The pure projection from registered tool schemas to the
+* PTC mode codegen — Python flavor. The pure projection from registered tool schemas to the
 * Python SDK text the model programs against under `runtime.language === 'python'`. Sibling of
 * {@link ./ts-types.ts | ts-types.ts}; the two files are two projections of the same registry
 * store, keyed by the loaded {@link @deepseek-ai/dsh-code-runtime#CodeRuntime.language | code
 * runtime's language}.
 *
-* Under `mode: 'code'` the native tool schemas are omitted from the request, so this generated
+* Under `mode: 'ptc'` the native tool schemas are omitted from the request, so this generated
 * SDK is the model's ONLY source for each tool's argument names, required fields, types,
 * descriptions, and canonical output shapes; under `mode: 'both'` the native schemas ship
 * alongside it and it is one of two. Object-shaped arguments and outputs therefore render as one
@@ -2974,7 +4091,7 @@ const IDENTIFIER = /^[\p{XID_Start}_]\p{XID_Continue}*$/u;
 * Python identifiers are not ASCII: `路径` is as legal a field name as `path`,
 * and rejecting it would degrade the whole enclosing object, dropping every
 * field's name, requiredness, and type — information whose only source under
-* `mode: 'code'` is this generated text.
+* `mode: 'ptc'` is this generated text.
 *
 * NFKC stability is a second and separate condition, because CPython
 * normalizes identifiers at compile time while JSON keys are compared as
@@ -3121,7 +4238,7 @@ function pad(indent) {
 * (`SyntaxError: source code string cannot contain null bytes`), whether it
 * sits in a docstring or in a comment, so one such byte anywhere in a schema
 * description would make the whole generated SDK unparseable — under
-* `mode: 'code'`, the model's only declaration of the tools. The rest are
+* `mode: 'ptc'`, the model's only declaration of the tools. The rest are
 * legal but invisible; escaping them with the same rule keeps the emitted text
 * readable and the treatment uniform.
 *
@@ -3187,7 +4304,7 @@ function describe(schema) {
 * Backslashes are doubled first, every quote is escaped, and a trailing
 * backslash cannot survive: a description ending in `"` or an odd backslash
 * would otherwise merge with (or escape) the closing triple quote and make
-* the generated block — Code Mode's only SDK — syntactically invalid Python.
+* the generated block — PTC mode's only SDK — syntactically invalid Python.
 */
 function docLines(description, indent) {
 	const collapsed = describe({ description });
@@ -3641,7 +4758,7 @@ function renderToolsSdkPy(schemas) {
 * section under a non-native mode; a runtime whose language is not a key
 * fails the assembly loudly (same idiom as `toolOrder` violations). Adding a
 * new backend language is three parallel edits — a {@link CodeSdkLanguage}
-* member, an entry here, and a `RUN_CODE_FLAVORS` entry in `code-mode.ts` for
+* member, an entry here, and a `RUN_CODE_FLAVORS` entry in `ptc.ts` for
 * its `run_code` schema strings — plus the renderer function this table points
 * at. The `satisfies` clause pins this table's key set to that union, which
 * the flavor table is checked against too, so any of the three left out is a
@@ -3652,17 +4769,11 @@ function renderToolsSdkPy(schemas) {
 * {@link Config.mode} JSDoc.
 */
 /**
-* Prompt order of the `code` collapse statement: after the persona and before
-* the 100-199 per-tool guidance band, so the model reads which tools it may
-* call before it reads what each one is for.
-*/
-const COLLAPSE_SECTION_ORDER = 99;
-/**
-* The model-facing statement of the `code` collapse. Names the consequence
+* The model-facing statement of the `ptc` collapse. Names the consequence
 * (the call fails) and the route (inside the program), because a rule the
 * model can only discover by being denied is one it corrects too late.
 */
-const CODE_ONLY_INSTRUCTION = `\`${RUN_CODE_NAME}\` is the only tool you can call directly — a tool call naming any other tool fails. Reach every tool the SDK declares below from inside the program.`;
+const PTC_ONLY_INSTRUCTION = `\`${RUN_CODE_NAME}\` is the only tool you can call directly — a tool call naming any other tool fails. Reach every tool the SDK declares below from inside the program.`;
 const SDK_RENDERERS = {
 	typescript: renderToolsSdk,
 	python: renderToolsSdkPy
@@ -3809,7 +4920,7 @@ function resolveMaxParallelSubCalls(value) {
 	static Config = z.object({
 		mode: z.union([
 			"native",
-			"code",
+			"ptc",
 			"both"
 		]).default("native"),
 		maxParallelSubCalls: z.natural().min(1).default(10)
@@ -3838,10 +4949,10 @@ function resolveMaxParallelSubCalls(value) {
 	/**
 	* Reserved presentation transport, kept outside the filterable registration
 	* layers. Built on first need rather than at construction: which agents run
-	* a code mode is no longer known when the service is constructed, and the
+	* a PTC mode is no longer known when the service is constructed, and the
 	* transport is stateless beyond its closures over `this`.
 	*/
-	codeTransport;
+	ptcTransport;
 	constructor(ctx, config = {}) {
 		super(ctx, "tools");
 		this.defaultMode = config.mode ?? "native";
@@ -3853,34 +4964,33 @@ function resolveMaxParallelSubCalls(value) {
 		}
 	}
 	/**
-	* The prompt statement of the `code` executor collapse, registered wherever
-	* {@link sdkSection} is and rendering empty outside an effective `code`.
+	* The prompt statement of the `ptc` executor collapse, registered wherever
+	* {@link sdkSection} is and rendering empty outside an effective `ptc`.
 	*
 	* Every tool contributes its own guidance section naming its tool, none of
-	* them qualify how that tool is reached, and they all render before the SDK
-	* (orders 100-199 against {@link SDK_SECTION_ORDER}). Without this the model
-	* reads a catalog of tools it is told to use and no statement that only
-	* `run_code` may be called, so it emits a native call, receives
-	* `UNKNOWN_TOOL` for a tool the prompt just declared, and concludes the
-	* deployment is inconsistent. {@link COLLAPSE_SECTION_ORDER} places the rule
-	* before that guidance rather than after it.
+	* them qualify how that tool is reached, and they all render before the SDK.
+	* Without this the model reads a catalog of tools it is told to use and no
+	* statement that only `run_code` may be called, so it emits a native call,
+	* receives `UNKNOWN_TOOL` for a tool the prompt just declared, and concludes
+	* the deployment is inconsistent. Its order places the rule before that
+	* guidance rather than after it.
 	*
 	* `both` renders empty: native calls do execute there, so the rule is false.
 	* @returns the section registration.
 	*/
 	collapseSection() {
 		return {
-			name: "tools:code-only",
-			order: COLLAPSE_SECTION_ORDER,
-			text: (context) => this.modeFor(context.scope) === "code" ? CODE_ONLY_INSTRUCTION : ""
+			name: "tools:ptc-only",
+			order: this.ctx.systemPrompt.getSectionOrder("PTC_ONLY"),
+			text: (context) => this.modeFor(context.scope) === "ptc" ? PTC_ONLY_INSTRUCTION : ""
 		};
 	}
 	/**
-	* The generated-SDK prompt section, registered globally by a code-mode
+	* The generated-SDK prompt section, registered globally by a PTC mode
 	* deployment and per scope by {@link presentAs}.
 	*
 	* The body regenerates from the CALLING scope, and renders empty for an
-	* agent presenting natively — an agent that opted out under a code-mode
+	* agent presenting natively — an agent that opted out under a PTC mode
 	* deployment still sees the global registration, and an empty section is
 	* dropped from the rendered prompt.
 	* @returns the section registration.
@@ -3888,7 +4998,7 @@ function resolveMaxParallelSubCalls(value) {
 	sdkSection() {
 		return {
 			name: "tools:sdk",
-			order: 150,
+			order: this.ctx.systemPrompt.getSectionOrder("TOOLS_SDK"),
 			text: (context) => {
 				const mode = this.modeFor(context.scope);
 				if (mode === "native") return "";
@@ -3924,13 +5034,13 @@ function resolveMaxParallelSubCalls(value) {
 	* @returns the shared transport definition.
 	*/
 	requireCodeTransport() {
-		this.codeTransport ??= createRunCodeTool(this, {
+		this.ptcTransport ??= createRunCodeTool(this, {
 			requireRuntime: () => this.requireCodeRuntime(this.defaultMode),
 			peekRuntime: () => this.ctx.get("codeRuntime"),
 			maxParallel: this.maxParallelSubCalls,
 			shapeDispatchLog: (dispatch) => this.shapeDispatchLog(dispatch)
 		});
-		return this.codeTransport;
+		return this.ptcTransport;
 	}
 	/**
 	* Present the calling scope's tools in `mode` instead of the deployment
@@ -3938,7 +5048,7 @@ function resolveMaxParallelSubCalls(value) {
 	* declaration covers every agent joined under it.
 	*
 	* Scoped only, and one declaration per scope: this is how an agent preset
-	* composes Code Mode agents beside native ones in the same process, and a
+	* composes PTC mode agents beside native ones in the same process, and a
 	* process-global override would be the `mode` config field instead.
 	* @param mode - the presentation the covered agents' models see.
 	* @returns the exact disposer that restores the deployment default.
@@ -3973,7 +5083,7 @@ function resolveMaxParallelSubCalls(value) {
 		};
 		this.requireCodeRuntime(mode);
 		const schemas = [...view.visible.values()].map((definition) => this.schemaOf(definition, false));
-		if (mode === "code") return {
+		if (mode === "ptc") return {
 			schemas: schemas.filter((schema) => schema.name === RUN_CODE_NAME),
 			knownNames: [RUN_CODE_NAME]
 		};
@@ -3987,16 +5097,14 @@ function resolveMaxParallelSubCalls(value) {
 	* Read at use time (assembly / run_code execution), NOT via static
 	* `inject`: an inject entry would hold `ctx.tools` — and every tool plugin
 	* behind it — hostage to a code runtime existing even under `mode:
-	* 'native'` (the loop's optional-backend idiom, same as
-	* `sessionPersistence`).
+	* 'native'`.
 	*
 	* Assembly and `run_code` execution read separately, so the language is not
 	* bound to a request. Harmless while one published backend exists — both
 	* reads return the same flavor — but a reload that swapped in a second
 	* language between them would hand a program written against one SDK to the
 	* other. Binding it is deferred until a second backend ships (the first
-	* point it is testable); rationale in the
-	* [language-dispatch note](../../../../.agents/notes/implemented/feature/2026-07-31-code-mode-language-dispatch.md).
+	* point it is testable).
 	*/
 	requireCodeRuntime(mode) {
 		const runtime = this.ctx.get("codeRuntime");
@@ -4020,7 +5128,7 @@ function resolveMaxParallelSubCalls(value) {
 		assertSupportedJsonSchema(output.schema);
 		const timeoutMs = definition.timeoutMs;
 		if (timeoutMs !== void 0 && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) throw new TypeError(`tool "${name}" timeoutMs must be a positive finite number`);
-		if (name === "run_code") throw new Error(`tool name "${RUN_CODE_NAME}" is reserved for the Code Mode presentation transport and cannot be registered or shadowed`);
+		if (name === "run_code") throw new Error(`tool name "${RUN_CODE_NAME}" is reserved for the PTC mode presentation transport and cannot be registered or shadowed`);
 		return this.layers.effect(this.ctx, (layer) => layer.tools.insert(name, definition), { label: "tools.register()" });
 	}
 	/**
@@ -4040,7 +5148,7 @@ function resolveMaxParallelSubCalls(value) {
 			...allow !== void 0 ? { allow: new Set(allow) } : {},
 			...deny !== void 0 ? { deny: new Set(deny) } : {}
 		};
-		if ([...allow ?? [], ...deny ?? []].includes("run_code")) throw new Error(`tools.restrict() cannot name reserved Code Mode presentation transport "${RUN_CODE_NAME}"; restrict end-capability tools instead`);
+		if ([...allow ?? [], ...deny ?? []].includes("run_code")) throw new Error(`tools.restrict() cannot name reserved PTC mode presentation transport "${RUN_CODE_NAME}"; restrict end-capability tools instead`);
 		const known = this.view(scope).restrictableNames;
 		const unknown = [...allow ?? [], ...deny ?? []].filter((name) => !known.has(name));
 		if (unknown.length > 0) throw new Error(`tools.restrict() names unknown global tool${unknown.length > 1 ? "s" : ""} ${unknown.map((n) => `"${n}"`).join(", ")}; known global tools: ${[...known].sort().join(", ") || "(none)"}`);
@@ -4082,9 +5190,9 @@ function resolveMaxParallelSubCalls(value) {
 	* A restriction filters what a scope inherits — the global layer and every
 	* ancestor layer on its chain — and never what its OWN layer registers.
 	* That exemption is what a per-child capability filter has to keep intact:
-	* the delegation runtime registers a child's reporting and structured-output
-	* tools into the child's own layer, and a filter naming the capabilities the
-	* child may use must not strip the machinery it answers through.
+	* the delegation runtime registers a child's structured-output tool into the
+	* child's own layer, and a filter naming the capabilities the child may use
+	* must not strip the machinery it answers through.
 	*
 	* Reading the exempt set as "the global layer" instead of "not mine" held
 	* only while every model-facing tool sat in the host composition. Once
@@ -4136,7 +5244,7 @@ function resolveMaxParallelSubCalls(value) {
 	/**
 	* Resolve the definition that MAY EXECUTE for a call, applying the mode
 	* collapse at the operation boundary that owns it. The registry view
-	* (`get`) is presentation-agnostic; here a MODEL-DIRECT call under `code`
+	* (`get`) is presentation-agnostic; here a MODEL-DIRECT call under `ptc`
 	* may only name the reserved `run_code` transport, while a nested
 	* sub-dispatch (a `parent` token set — the `run_code` SDK calling a tool
 	* it bound) may call any visible tool. Denial surfaces as `UNKNOWN_TOOL`
@@ -4161,7 +5269,7 @@ function resolveMaxParallelSubCalls(value) {
 	schemas(scope) {
 		return [...this.view(scope).visible.values()].map((definition) => this.schemaOf(definition, true));
 	}
-	/** Project visible callable tools onto the generated Code Mode SDK contract. */
+	/** Project visible callable tools onto the generated PTC mode SDK contract. */
 	sdkSchemas(scope) {
 		return [...this.view(scope).visible.values()].filter((definition) => definition.name !== RUN_CODE_NAME).map((definition) => {
 			const output = snapshotJsonValue(definition.output.schema);
@@ -4201,8 +5309,8 @@ function resolveMaxParallelSubCalls(value) {
 		}
 	}
 	/**
-	* Run the `tools/code-dispatch-log` waterfall over one settled sub-dispatch
-	* and return the content the bridge should log on `tool/code-dispatch`.
+	* Run the `tools/ptc-dispatch-log` waterfall over one settled sub-dispatch
+	* and return the content the bridge should log on `tool/ptc-dispatch`.
 	* Contained: when a listener throws, the method logs the original settled
 	* content; that failure must not fail the dispatch or omit the settle event. Private:
 	* the ONE consumer is the `run_code` bridge this registry constructs, which
@@ -4211,20 +5319,20 @@ function resolveMaxParallelSubCalls(value) {
 	*/
 	async shapeDispatchLog(dispatch) {
 		try {
-			return await this.ctx.waterfall(scopeTarget(this, dispatch.agent), "tools/code-dispatch-log", dispatch, () => Promise.resolve(dispatch.content));
+			return await this.ctx.waterfall(scopeTarget(this, dispatch.agent), "tools/ptc-dispatch-log", dispatch, () => Promise.resolve(dispatch.content));
 		} catch (error) {
-			this.ctx.logger.warn(`tools: code-dispatch-log listener failed for ${dispatch.name}: ${errorMessage$1(error)}; logging the original settled content`);
+			this.ctx.logger.warn(`tools: ptc-dispatch-log listener failed for ${dispatch.name}: ${errorMessage$1(error)}; logging the original settled content`);
 			return dispatch.content;
 		}
 	}
 	/**
-	* Whether the `code` mode collapse denies a model-direct call: only the
+	* Whether the `ptc` mode collapse denies a model-direct call: only the
 	* reserved `run_code` transport may be named. Nested sub-dispatches (a
 	* `parent` token set) bypass the collapse. One home for the
 	* security-relevant predicate, shared by {@link resolveExecution} and
 	* {@link createExecution} so the two can never drift apart.
 	*
-	* Resolved through {@link modeFor}, NOT `defaultMode`: an agent given `code`
+	* Resolved through {@link modeFor}, NOT `defaultMode`: an agent given `ptc`
 	* by an agent preset under a native deployment is the composition
 	* `dsh-agent-tool-presentation` exists for, and reading the deployment default would
 	* leave exactly that agent uncollapsed — announcing one surface while
@@ -4234,7 +5342,7 @@ function resolveMaxParallelSubCalls(value) {
 	* @param nested - whether the call is a transport sub-dispatch, not a model-direct call.
 	*/
 	collapses(name, scope, nested) {
-		return !nested && this.modeFor(scope) === "code" && name !== "run_code";
+		return !nested && this.modeFor(scope) === "ptc" && name !== "run_code";
 	}
 	/**
 	* Execute through pre-policy, guards, around-dispatch, post-policy,
@@ -4841,6 +5949,19 @@ const INSPIRATION_ROUTE = "/plugins/dsh-image-gen/inspiration";
 const SAVE_WORKSPACE_ROUTE = "/plugins/dsh-image-gen/save-workspace";
 /** Browser route the settings card probes provider connectivity through. */
 const TEST_CONNECTION_ROUTE = "/plugins/dsh-image-gen/test";
+/** Browser route the workbench infinite canvas pushes live state through. */
+const CANVAS_STATE_ROUTE = "/plugins/dsh-image-gen/canvas-state";
+/** Every accepted canvas node kind, for validating untrusted pushes. */
+const CANVAS_NODE_KINDS = [
+	"image",
+	"draw",
+	"text",
+	"note",
+	"geo",
+	"arrow",
+	"frame",
+	"other"
+];
 /** Namespace persisted through DSH Settings. */
 const IMAGE_GENERATION_NAMESPACE = "image-generation";
 /** Supported providers. */
@@ -5175,7 +6296,7 @@ function selectComfyUIWorkflow(active, requested) {
 	return workflow;
 }
 //#endregion
-//#region node_modules/.pnpm/@deepseek-ai+dsh-credential_07859f6f9ce036fd17600077e6a695b1/node_modules/@deepseek-ai/dsh-credentials/lib/index.js
+//#region node_modules/.pnpm/@deepseek-ai+dsh-credential_bc2d3e5c9a179df7ac53b40c354d894e/node_modules/@deepseek-ai/dsh-credentials/lib/index.js
 /**
 * Service Definition for the credential-reference capability seam (`ctx.credentials`). Settings and composition files carry
 * *references* to secrets — environment-variable names — while providers own
@@ -5193,7 +6314,7 @@ const REF_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 */
 function credentialRef(value) {
 	if (!isCredentialRefName(value)) throw new TypeError(`credential ref "${value}" must match ${String(REF_PATTERN)}`);
-	return value;
+	return brandString(value);
 }
 /**
 * Whether a raw string could name a reference at all. Consumers that receive
@@ -5220,15 +6341,738 @@ async function resolveApiKey(ctx, provider) {
 	return value.length > 0 ? value : void 0;
 }
 /**
-* Resolve one provider's API key or fail with a user-facing message that says
-* where to configure it. Passing `tool` selects the Agent-facing English
-* wording; without it the message is the browser-facing Chinese one used by
-* the Studio route.
+* Resolve one provider's API key or fail with a user-facing message that says
+* where to configure it. Passing `tool` selects the Agent-facing English
+* wording; without it the message is the browser-facing Chinese one used by
+* the Studio route.
+*/
+async function requireApiKey(ctx, provider, tool) {
+	const value = await resolveApiKey(ctx, provider);
+	if (value !== void 0) return value;
+	throw new Error(tool === void 0 ? `${PROVIDER_DISPLAY_NAMES[provider]} 尚未配置 API Key，请先到 设置 > 插件 > 图像生成 配置` : `${tool} requires the ${PROVIDER_DISPLAY_NAMES[provider]} API key; configure it in Settings > Plugins > Image generation.`);
+}
+//#endregion
+//#region lib/types/canvas-state.js
+/** How many node lines the digest lists before collapsing to "+N more". */
+const DIGEST_NODE_LIMIT = 24;
+/** How many selected shapes the digest itemizes before collapsing. */
+const DIGEST_SELECTION_LIMIT = 12;
+/**
+* Identity-bearing selection signature. Count and kinds alone would make
+* "1 selected image" of the lion and of the monster indistinguishable; the
+* item summaries (name, attachment id, dimensions, text) keep them apart.
+*/
+function signatureOf(count, kinds, items) {
+	return JSON.stringify([
+		count,
+		kinds,
+		items
+	]);
+}
+function describeNode(node) {
+	switch (node.kind) {
+		case "image": return [
+			"image",
+			typeof node.width === "number" && typeof node.height === "number" ? `${node.width}x${node.height}` : void 0,
+			typeof node.name === "string" && node.name.length > 0 ? `"${node.name}"` : void 0,
+			typeof node.attachmentId === "string" ? `conversation attachment ${node.attachmentId}` : void 0,
+			typeof node.provider === "string" && node.provider.length > 0 ? `generated by ${node.provider}${typeof node.model === "string" && node.model.length > 0 ? `/${node.model}` : ""}` : void 0,
+			typeof node.prompt === "string" && node.prompt.length > 0 ? `prompt "${node.prompt}"` : void 0
+		].filter((part) => part !== void 0).join(" ");
+		case "draw": return "draw (freehand stroke)";
+		case "text":
+		case "note": {
+			const preview = typeof node.text === "string" && node.text.length > 0 ? `"${node.text}"` : "(empty)";
+			return `${node.kind} ${preview}`;
+		}
+		case "geo": return typeof node.name === "string" && node.name.length > 0 ? `shape ${node.name}` : "shape";
+		default: return node.kind;
+	}
+}
+/** The most recently applied connected entry, or undefined when none is connected. */
+function freshestEntry(entries) {
+	let latest;
+	for (const entry of entries) if (latest === void 0 || entry.seq > latest.seq) latest = entry;
+	return latest;
+}
+/**
+* Host-side mirror of every currently connected workbench canvas.
+*
+* One instance is shared by the canvas-state route, the canvas tools, and the
+* system-prompt context registration. More than one canvas can be mounted at
+* once (right-sidebar studio tab, conversation gallery tab); each instance
+* pushes under its own `clientInstance` id and `latest()` reads the freshest.
+*/
+var CanvasMirror = class {
+	entries = /* @__PURE__ */ new Map();
+	nextSeq = 0;
+	/**
+	* Apply one validated push. A disconnect removes the instance; an unchanged
+	* selection keeps the previously received screenshot bytes so the model can
+	* still view them while unrelated canvas edits keep flowing in.
+	*/
+	apply(push, selectionImage) {
+		if (!push.connected) {
+			this.entries.delete(push.clientInstance);
+			return;
+		}
+		const previous = this.entries.get(push.clientInstance);
+		const selectionCount = push.selection?.count ?? 0;
+		const selectionKinds = [...push.selection?.kinds ?? []];
+		const selectionItems = [...push.selection?.items ?? []];
+		const selectionSignature = signatureOf(selectionCount, selectionKinds, selectionItems);
+		const keepImage = previous !== void 0 && previous.selectionSignature === selectionSignature ? previous.selectionImage : void 0;
+		this.entries.set(push.clientInstance, {
+			clientInstance: push.clientInstance,
+			connected: true,
+			nodeCount: push.nodeCount,
+			nodes: [...push.nodes ?? []],
+			selectionCount,
+			selectionKinds,
+			selectionItems,
+			selectionSignature,
+			...selectionImage !== void 0 ? { selectionImage } : keepImage !== void 0 ? { selectionImage: keepImage } : {},
+			receivedAt: Date.now(),
+			seq: ++this.nextSeq,
+			updatedAt: push.updatedAt
+		});
+	}
+	/** The freshest connected canvas entry, or undefined. */
+	latest() {
+		return freshestEntry(this.entries.values());
+	}
+	/** The in-memory selection screenshot of the freshest canvas, if present. */
+	latestSelectionImage() {
+		return this.latest()?.selectionImage;
+	}
+	/** Whether any canvas instance is currently connected. */
+	connected() {
+		return this.latest() !== void 0;
+	}
+	/**
+	* Compact one-screen digest of the canvas for the system prompt and tools.
+	* Evaluated per call so the "updated N ago" line stays current between pushes.
+	*/
+	digest(now = Date.now()) {
+		const entry = this.latest();
+		if (entry === void 0) return ["Image-gen workbench canvas: not connected.", "No image-gen workbench infinite canvas is open right now. If the user refers to a canvas, drawings, or a sketch, ask them to open the image-gen workbench (gallery tab or right-sidebar studio tab) and switch it to the infinite canvas view."].join(" ");
+		const lines = [];
+		const kindCounts = /* @__PURE__ */ new Map();
+		for (const node of entry.nodes) kindCounts.set(node.kind, (kindCounts.get(node.kind) ?? 0) + 1);
+		const unlisted = Math.max(0, entry.nodeCount - entry.nodes.length);
+		const shapeTotal = `${entry.nodeCount} shape${entry.nodeCount === 1 ? "" : "s"}`;
+		const breakdown = [...kindCounts.entries()].map(([kind, count]) => `${count} ${kind}${count === 1 ? "" : "s"}`).join(", ");
+		const age = Math.max(0, Math.round((now - entry.receivedAt) / 1e3));
+		const ageText = age < 5 ? "just now" : age < 90 ? `${age}s ago` : `${Math.round(age / 60)}min ago`;
+		lines.push(`Image-gen workbench canvas: ${shapeTotal}${breakdown.length > 0 ? ` (${breakdown})` : ""}, updated ${ageText}.`);
+		for (const node of entry.nodes.slice(0, DIGEST_NODE_LIMIT)) lines.push(`- ${describeNode(node)}`);
+		if (entry.nodes.length > DIGEST_NODE_LIMIT) lines.push(`- ... ${entry.nodes.length - DIGEST_NODE_LIMIT} more shapes omitted`);
+		if (unlisted > 0) lines.push(`- (${unlisted} further shapes not itemized)`);
+		if (entry.selectionCount === 0) lines.push("Selection: none. Ask the user to select shapes on the canvas when they want you to work on something specific.");
+		else {
+			const kinds = entry.selectionKinds.length > 0 ? ` (${entry.selectionKinds.join(", ")})` : "";
+			lines.push(`Selection: ${entry.selectionCount} shape${entry.selectionCount === 1 ? "" : "s"}${kinds}.`);
+			for (const item of entry.selectionItems.slice(0, DIGEST_SELECTION_LIMIT)) lines.push(`- selected: ${describeNode(item)}`);
+			if (entry.selectionItems.length > DIGEST_SELECTION_LIMIT) lines.push(`- ... ${entry.selectionItems.length - DIGEST_SELECTION_LIMIT} more selected shapes omitted`);
+			const unlistedSelection = Math.max(0, entry.selectionCount - entry.selectionItems.length);
+			if (unlistedSelection > 0) lines.push(`- (${unlistedSelection} further selected shapes not itemized)`);
+			const screenshot = entry.selectionImage !== void 0 ? "A screenshot of the selection is available; call view_canvas to see it. edit_image with source=canvas_selection sends the full-resolution originals of selected conversation images, plus the screenshot when the selection also contains other content (hand-drawn strokes, pasted images)." : "No selection screenshot yet — the canvas pushes one about a second after the selection settles. edit_image with source=canvas_selection can still use the full-resolution originals of selected conversation images; for anything else ask the user to re-select the shapes.";
+			lines.push(screenshot);
+		}
+		return lines.join("\n");
+	}
+};
+//#endregion
+//#region lib/types/canvas-state-route.js
+const MAX_CLIENT_INSTANCE_CHARS = 64;
+const MAX_NODE_TEXT_CHARS = 200;
+const MAX_ID_CHARS = 256;
+/** Provider ids come from the shared enum (longest is "openai-compat"). */
+const MAX_PROVIDER_CHARS = 32;
+/** Model ids and ComfyUI workflow labels are user-facing strings. */
+const MAX_MODEL_CHARS = 128;
+const MAX_NODE_COUNT = 1e5;
+const MAX_SELECTION_COUNT = 1e3;
+/** Serve one canvas-state push. */
+async function serveCanvasState(req, res, deps) {
+	if (req.method !== "POST") return jsonError$4(res, 405, "method-not-allowed");
+	if (!(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) return jsonError$4(res, 415, "json-required");
+	const origin = req.headers.origin;
+	const host = req.headers.host;
+	if (origin !== void 0 && host !== void 0 && origin !== `http://${host}` && origin !== `https://${host}`) return jsonError$4(res, 403, "origin-rejected");
+	let body;
+	try {
+		body = JSON.parse(await readBody$3(req, deps.maxBodyBytes));
+	} catch (error) {
+		return jsonError$4(res, error instanceof Error && error.message === "request-too-large" ? 413 : 400, "invalid-request");
+	}
+	const push = parseCanvasStatePush(body);
+	if (push === void 0) return jsonError$4(res, 400, "invalid-canvas-state");
+	let selectionImage;
+	if (push.selectionImage !== void 0) {
+		const decoded = decodeSelectionImage(push.selectionImage);
+		if (decoded === void 0) return jsonError$4(res, 400, "invalid-selection-image");
+		if (decoded.data.byteLength > deps.maxImageBytes) return jsonError$4(res, 413, "selection-image-too-large");
+		selectionImage = decoded;
+	}
+	deps.mirror.apply(push, selectionImage);
+	res.writeHead(200, {
+		"content-type": "application/json",
+		"cache-control": "no-store"
+	});
+	res.end(JSON.stringify({ ok: true }));
+}
+/**
+* Validate one untrusted canvas-state push at the HTTP boundary.
+* Returns a normalized copy, or undefined when any field is malformed.
+* Present-but-malformed known fields reject the whole push: they signal a
+* client/server version skew rather than a legitimately absent value.
+*/
+function parseCanvasStatePush(value) {
+	try {
+		return parsePush(value);
+	} catch (error) {
+		if (error instanceof InvalidPush) return void 0;
+		throw error;
+	}
+}
+/** Sentinel thrown by field validators; caught at the public parse boundary. */
+var InvalidPush = class extends Error {};
+function parsePush(value) {
+	const record = plainRecord(value);
+	if (record === void 0) throw new InvalidPush();
+	const clientInstance = boundedString(record.clientInstance, 1, MAX_CLIENT_INSTANCE_CHARS);
+	if (clientInstance === void 0) throw new InvalidPush();
+	if (typeof record.connected !== "boolean") throw new InvalidPush();
+	if (!nonNegativeInteger$1(record.nodeCount) || record.nodeCount > MAX_NODE_COUNT) throw new InvalidPush();
+	if (!nonNegativeInteger$1(record.updatedAt)) throw new InvalidPush();
+	if (Math.abs(record.updatedAt - Date.now()) > 3e5) throw new InvalidPush();
+	let nodes;
+	if (record.nodes !== void 0) {
+		if (!Array.isArray(record.nodes) || record.nodes.length > 48) throw new InvalidPush();
+		const parsed = [];
+		for (const raw of record.nodes) {
+			const node = parseNodeSummary(raw);
+			if (node === void 0) throw new InvalidPush();
+			parsed.push(node);
+		}
+		nodes = parsed;
+	}
+	let selection;
+	if (record.selection !== void 0) {
+		const raw = plainRecord(record.selection);
+		if (raw === void 0) throw new InvalidPush();
+		if (!nonNegativeInteger$1(raw.count) || raw.count > MAX_SELECTION_COUNT) throw new InvalidPush();
+		if (!Array.isArray(raw.kinds) || raw.kinds.length > 8) throw new InvalidPush();
+		const kinds = [];
+		for (const kind of raw.kinds) {
+			if (typeof kind !== "string" || !CANVAS_NODE_KINDS.includes(kind)) throw new InvalidPush();
+			kinds.push(kind);
+		}
+		let items;
+		if (raw.items !== void 0) {
+			if (!Array.isArray(raw.items) || raw.items.length > 16) throw new InvalidPush();
+			if (raw.items.length > raw.count) throw new InvalidPush();
+			const parsed = [];
+			for (const item of raw.items) {
+				const node = parseNodeSummary(item);
+				if (node === void 0) throw new InvalidPush();
+				parsed.push(node);
+			}
+			items = parsed;
+		}
+		selection = items === void 0 ? {
+			count: raw.count,
+			kinds
+		} : {
+			count: raw.count,
+			kinds,
+			items
+		};
+	}
+	if (record.selectionImage !== void 0 && typeof record.selectionImage !== "string") throw new InvalidPush();
+	return {
+		clientInstance,
+		connected: record.connected,
+		nodeCount: record.nodeCount,
+		...nodes === void 0 ? {} : { nodes },
+		...selection === void 0 ? {} : { selection },
+		...typeof record.selectionImage === "string" ? { selectionImage: record.selectionImage } : {},
+		updatedAt: record.updatedAt
+	};
+}
+/** Decode and sanity-check an embedded selection screenshot data URL. */
+function decodeSelectionImage(dataUrl) {
+	const match = /^data:(image\/(?:png|jpeg|webp));base64,([A-Za-z0-9+/]*={0,2})$/.exec(dataUrl);
+	if (match === null) return void 0;
+	const mediaType = match[1];
+	const base64 = match[2];
+	if (mediaType === void 0 || base64 === void 0) return void 0;
+	try {
+		const buffer = Buffer.from(base64, "base64");
+		if (buffer.byteLength === 0) return void 0;
+		return {
+			data: new Uint8Array(buffer),
+			mediaType
+		};
+	} catch {
+		return;
+	}
+}
+function parseNodeSummary(value) {
+	const record = plainRecord(value);
+	if (record === void 0) return void 0;
+	if (typeof record.kind !== "string" || !CANVAS_NODE_KINDS.includes(record.kind)) return void 0;
+	const galleryId = optionalBoundedString(record.galleryId, MAX_ID_CHARS);
+	const attachmentId = optionalBoundedString(record.attachmentId, MAX_ID_CHARS);
+	const name = optionalBoundedString(record.name, MAX_ID_CHARS);
+	const text = optionalBoundedString(record.text, MAX_NODE_TEXT_CHARS);
+	const prompt = optionalBoundedString(record.prompt, 120);
+	const provider = optionalBoundedString(record.provider, MAX_PROVIDER_CHARS);
+	const model = optionalBoundedString(record.model, MAX_MODEL_CHARS);
+	const width = optionalDimension(record.width);
+	const height = optionalDimension(record.height);
+	return {
+		kind: record.kind,
+		...galleryId === void 0 ? {} : { galleryId },
+		...attachmentId === void 0 ? {} : { attachmentId },
+		...name === void 0 ? {} : { name },
+		...width === void 0 ? {} : { width },
+		...height === void 0 ? {} : { height },
+		...text === void 0 ? {} : { text },
+		...prompt === void 0 ? {} : { prompt },
+		...provider === void 0 ? {} : { provider },
+		...model === void 0 ? {} : { model }
+	};
+}
+function plainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function boundedString(value, min, max) {
+	if (typeof value !== "string" || value.length < min || value.length > max) return void 0;
+	return value;
+}
+/** Absent is fine; present-but-not-a-bounded-string rejects the whole push. */
+function optionalBoundedString(value, max) {
+	if (value === void 0) return void 0;
+	const parsed = boundedString(value, 0, max);
+	if (parsed === void 0) throw new InvalidPush();
+	return parsed;
+}
+/** Absent is fine; present-but-not-a-finite-dimension rejects the whole push. */
+function optionalDimension(value) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1e6) throw new InvalidPush();
+	return Math.round(value);
+}
+function nonNegativeInteger$1(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+async function readBody$3(req, maxBytes) {
+	const chunks = [];
+	let bytes = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		bytes += buffer.byteLength;
+		if (bytes > maxBytes) throw new Error("request-too-large");
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+function jsonError$4(res, status, code) {
+	res.writeHead(status, {
+		"content-type": "application/json",
+		"cache-control": "no-store"
+	});
+	res.end(JSON.stringify({ error: code }));
+}
+//#endregion
+//#region lib/types/reference-image.js
+/** Latest-DSH compatibility boundary for resolving conversation image references. */
+/**
+* Resolve one or more edit references while keeping every DSH-specific detail
+* behind this compatibility boundary. Explicit selectors preserve caller order;
+* without selectors, all images in the newest image-bearing message are used.
+*/
+async function resolveReferenceImages(input) {
+	const sourceAttachmentIds = mergeSelectors({
+		single: input.sourceAttachmentId,
+		multiple: input.sourceAttachmentIds,
+		singleName: "source_attachment_id",
+		multipleName: "source_attachment_ids",
+		equal: attachmentIdsEqual
+	});
+	const sourcePaths = mergeSelectors({
+		single: input.sourcePath,
+		multiple: input.sourcePaths,
+		singleName: "source_path",
+		multipleName: "source_paths",
+		equal: (left, right) => left.trim() === right.trim()
+	});
+	if (sourceAttachmentIds !== void 0 && sourcePaths !== void 0) throw new Error("edit_image accepts only one of source_attachment_id, source_attachment_ids, source_path, or source_paths");
+	if (sourcePaths !== void 0) return Promise.all(sourcePaths.map((sourcePath) => readWorkspaceReferenceImage({
+		sourcePath,
+		...input.agent?.session.header?.cwd === void 0 ? {} : { workspaceRoot: input.agent.session.header.cwd },
+		...input.maxBytes === void 0 ? {} : { maxBytes: input.maxBytes },
+		signal: input.signal
+	})));
+	if (input.agent === void 0) throw new Error("edit_image requires an active DSH agent session to resolve a reference image");
+	const refs = findReferenceImages(input.agent.session.deriveMessages(), sourceAttachmentIds);
+	if (refs.length === 0) {
+		if (sourceAttachmentIds !== void 0) throw new Error(`edit_image could not find image attachment ${sourceAttachmentIds[0]} in the current conversation`);
+		throw new Error("edit_image requires an image in the current conversation; upload or generate an image first");
+	}
+	if (sourceAttachmentIds !== void 0 && refs.length !== sourceAttachmentIds.length) {
+		const missing = sourceAttachmentIds.find((id) => !refs.some((ref) => attachmentIdsEqual(String(ref.attachmentId), id)));
+		throw new Error(`edit_image could not find image attachment ${missing ?? "unknown"} in the current conversation`);
+	}
+	return Promise.all(refs.map(async (ref) => {
+		const stored = await input.attachments.readImage(ref, input.signal);
+		if (input.maxBytes !== void 0 && stored.data.byteLength > input.maxBytes) throw new Error(`edit_image source image is too large (${stored.data.byteLength} bytes; maximum ${input.maxBytes})`);
+		return {
+			data: stored.data,
+			mediaType: stored.ref.mediaType
+		};
+	}));
+}
+/** Find images in caller order, or every image in the newest image-bearing message. */
+function findReferenceImages(messages, sourceAttachmentIds) {
+	if (sourceAttachmentIds !== void 0) return sourceAttachmentIds.flatMap((id) => {
+		const ref = findReferenceImage(messages, id);
+		return ref === void 0 ? [] : [ref];
+	});
+	const latestHumanMessage = [...messages].reverse().find((message) => message.source?.kind === "user");
+	if (latestHumanMessage !== void 0) {
+		const refs = collectInBlocks(latestHumanMessage.content);
+		if (refs.length > 0) return refs;
+	}
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const refs = collectInBlocks(messages[index]?.content ?? []);
+		if (refs.length > 0) return refs;
+	}
+	return [];
+}
+/**
+* Read an explicitly named workspace image without exposing filesystem or DSH
+* details to provider adapters. Both lexical and real-path containment are
+* enforced so absolute paths, parent traversal, and symlink escapes fail.
+*/
+async function readWorkspaceReferenceImage(input) {
+	const requested = input.sourcePath.trim();
+	if (requested.length === 0) throw new Error("edit_image source_path must not be empty");
+	if (input.workspaceRoot === void 0) throw new Error("edit_image source_path requires an active DSH session workspace");
+	const root = resolve(input.workspaceRoot);
+	const candidate = isAbsolute(requested) ? resolve(requested) : resolve(root, requested);
+	if (!containsPath$1(root, candidate)) throw new Error("edit_image source_path must stay inside the session workspace: " + requested);
+	let realRoot;
+	let realCandidate;
+	try {
+		[realRoot, realCandidate] = await Promise.all([realpath(root), realpath(candidate)]);
+	} catch (error) {
+		if (error.code === "ENOENT") throw new Error("edit_image could not find workspace image: " + requested);
+		throw error;
+	}
+	if (!containsPath$1(realRoot, realCandidate)) throw new Error("edit_image source_path resolves outside the session workspace: " + requested);
+	const file = await stat(realCandidate);
+	if (!file.isFile()) throw new Error("edit_image source_path is not a file: " + requested);
+	if (input.maxBytes !== void 0 && file.size > input.maxBytes) throw new Error("edit_image source image is too large (" + file.size + " bytes; maximum " + input.maxBytes + ")");
+	const data = await readFile(realCandidate, { signal: input.signal });
+	const mediaType = detectImageMediaType(data);
+	if (mediaType === void 0) throw new Error("edit_image source_path is not a supported PNG, JPEG, WebP, or GIF image: " + requested);
+	return {
+		data: new Uint8Array(data),
+		mediaType
+	};
+}
+/** Find the newest matching image in the effective, replacement-aware history. */
+function findReferenceImage(messages, sourceAttachmentId) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const found = findInBlocks(messages[index]?.content ?? [], sourceAttachmentId);
+		if (found !== void 0) return found;
+	}
+}
+/** Validate an untrusted serialized image reference at an HTTP/UI boundary. */
+function parseImageAttachmentRef(value) {
+	const ref = record$7(value);
+	if (ref === void 0) return void 0;
+	if (typeof ref.attachmentId !== "string" || !imageMediaType$4(ref.mediaType)) return void 0;
+	if (!nonNegativeInteger(ref.bytes) || !positiveInteger(ref.width) || !positiveInteger(ref.height)) return void 0;
+	if (ref.name !== void 0 && typeof ref.name !== "string") return void 0;
+	const originalDimensions = ref.originalDimensions === void 0 ? void 0 : parseDimensions(ref.originalDimensions);
+	if (ref.originalDimensions !== void 0 && originalDimensions === void 0) return void 0;
+	return {
+		attachmentId: ref.attachmentId,
+		mediaType: ref.mediaType,
+		bytes: ref.bytes,
+		width: ref.width,
+		height: ref.height,
+		...typeof ref.name === "string" ? { name: ref.name } : {},
+		...originalDimensions === void 0 ? {} : { originalDimensions }
+	};
+}
+function findInBlocks(blocks, sourceAttachmentId) {
+	for (let index = blocks.length - 1; index >= 0; index -= 1) {
+		const block = blocks[index];
+		if (block === void 0) continue;
+		if (block.type === "image") {
+			if (sourceAttachmentId === void 0 || attachmentIdsEqual(String(block.attachment.attachmentId), sourceAttachmentId)) return block.attachment;
+			continue;
+		}
+		if (block.type === "tool-result") {
+			const nested = findInBlocks(block.content, sourceAttachmentId);
+			if (nested !== void 0) return nested;
+		}
+	}
+}
+function parseDimensions(value) {
+	const dimensions = record$7(value);
+	if (dimensions === void 0 || !positiveInteger(dimensions.width) || !positiveInteger(dimensions.height)) return void 0;
+	return {
+		width: dimensions.width,
+		height: dimensions.height
+	};
+}
+function imageMediaType$4(value) {
+	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
+}
+function collectInBlocks(blocks) {
+	const refs = [];
+	for (const block of blocks) {
+		if (block.type === "image") refs.push(block.attachment);
+		if (block.type === "tool-result") refs.push(...collectInBlocks(block.content));
+	}
+	return refs;
+}
+function attachmentIdsEqual(actual, requested) {
+	if (actual === requested) return true;
+	const actualDigest = sha256Digest(actual);
+	const requestedDigest = sha256Digest(requested);
+	return actualDigest !== void 0 && actualDigest === requestedDigest;
+}
+function sha256Digest(value) {
+	return /^(?:sha256:)?([0-9a-f]{64})$/i.exec(value.trim())?.[1]?.toLowerCase();
+}
+function mergeSelectors(input) {
+	if (input.multiple === void 0) return input.single === void 0 ? void 0 : [input.single];
+	if (input.multiple.length === 0) {
+		if (input.single !== void 0) return [input.single];
+		throw new Error(`edit_image ${input.multipleName} must not be empty`);
+	}
+	const single = input.single;
+	if (single !== void 0 && !input.multiple.some((value) => input.equal(single, value))) throw new Error(`edit_image ${input.singleName} must also appear in ${input.multipleName} when both are provided`);
+	return input.multiple;
+}
+function detectImageMediaType(data) {
+	if (startsWith(data, [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	])) return "image/png";
+	if (startsWith(data, [
+		255,
+		216,
+		255
+	])) return "image/jpeg";
+	if (ascii(data, 0, 6) === "GIF87a" || ascii(data, 0, 6) === "GIF89a") return "image/gif";
+	if (ascii(data, 0, 4) === "RIFF" && ascii(data, 8, 4) === "WEBP") return "image/webp";
+}
+function startsWith(data, signature) {
+	return signature.every((byte, index) => data[index] === byte);
+}
+function ascii(data, offset, length) {
+	return String.fromCharCode(...data.subarray(offset, offset + length));
+}
+function containsPath$1(parent, child) {
+	const rel = relative(parent, child);
+	return rel === "" || rel !== ".." && !rel.startsWith(".." + sep) && !isAbsolute(rel);
+}
+function positiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function nonNegativeInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function record$7(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+//#endregion
+//#region lib/types/canvas-tools.js
+/** Register the canvas tools on a context that owns a canvas mirror. */
+function registerCanvasTools(ctx, mirror, deps) {
+	ctx.tools.register(defineTool({
+		name: "canvas_state",
+		description: "Inspect the current state of the image-gen workbench infinite canvas: what shapes are on it (generated images, hand-drawn strokes, text notes) and what is currently selected. Use whenever the user refers to \"the canvas\", something they drew or placed there, or a selection, and before view_canvas or edit_image with source=canvas_selection.",
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					digest: {
+						type: "string",
+						required: true
+					},
+					connected: {
+						type: "boolean",
+						required: true
+					},
+					nodeCount: {
+						type: "integer",
+						required: true
+					},
+					selectionCount: {
+						type: "integer",
+						required: true
+					},
+					hasSelectionImage: {
+						type: "boolean",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.digest
+			}]
+		},
+		async execute() {
+			const entry = mirror.latest();
+			return {
+				digest: mirror.digest(),
+				connected: entry !== void 0,
+				nodeCount: entry?.nodeCount ?? 0,
+				selectionCount: entry?.selectionCount ?? 0,
+				hasSelectionImage: mirror.latestSelectionImage() !== void 0
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "view_canvas",
+		description: "View the current selection on the image-gen workbench infinite canvas as an image (a screenshot the canvas pushed for its selection: hand-drawn sketches, annotated images, or any selected shapes). Call it after canvas_state confirms a selection exists. When nothing is selected, ask the user to select the shapes first. The image becomes part of the conversation, so you can reason about it directly.",
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					digest: {
+						type: "string",
+						required: true
+					},
+					attachment: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							attachmentId: {
+								type: "string",
+								required: true
+							},
+							mediaType: {
+								type: "string",
+								required: true
+							},
+							bytes: {
+								type: "integer",
+								required: true
+							},
+							width: {
+								type: "integer",
+								required: true
+							},
+							height: {
+								type: "integer",
+								required: true
+							},
+							name: { type: "string" }
+						}
+					}
+				}
+			},
+			render: (_args, value) => {
+				if (value.attachment === void 0) return [{
+					type: "text",
+					text: `${value.digest}\nNo selection screenshot is available. Ask the user to open the image-gen workbench infinite canvas and select the shapes, then try again.`
+				}];
+				return [{
+					type: "text",
+					text: `${value.digest}\nThe screenshot of the current canvas selection is attached below. Respond to the user without calling read or other tools to locate it.`
+				}, {
+					type: "image",
+					attachment: value.attachment
+				}];
+			}
+		},
+		async execute() {
+			const image = mirror.latestSelectionImage();
+			const attachment = image === void 0 ? void 0 : await deps.persistSelectionImage(image);
+			return {
+				digest: mirror.digest(),
+				...attachment === void 0 ? {} : { attachment: attachmentMeta$1(attachment) }
+			};
+		}
+	}));
+}
+function attachmentMeta$1(ref) {
+	return {
+		attachmentId: ref.attachmentId,
+		mediaType: ref.mediaType,
+		bytes: ref.bytes,
+		width: ref.width,
+		height: ref.height,
+		...ref.name === void 0 ? {} : { name: ref.name }
+	};
+}
+/**
+* Resolve the mirrored canvas selection as an edit reference image for
+* edit_image's `canvas_selection` source. The screenshot comes straight from
+* the mirror's in-memory bytes — identical to what view_canvas shows the
+* model — and is never persisted here: reference images go to the image
+* provider, not the conversation.
 */
-async function requireApiKey(ctx, provider, tool) {
-	const value = await resolveApiKey(ctx, provider);
-	if (value !== void 0) return value;
-	throw new Error(tool === void 0 ? `${PROVIDER_DISPLAY_NAMES[provider]} 尚未配置 API Key，请先到 设置 > 插件 > 图像生成 配置` : `${tool} requires the ${PROVIDER_DISPLAY_NAMES[provider]} API key; configure it in Settings > Plugins > Image generation.`);
+async function resolveCanvasSelectionReferences(input) {
+	const entry = input.mirror.latest();
+	if (entry === void 0) throw new Error("The image-gen workbench canvas is not connected. Ask the user to open the image-gen workbench (gallery tab or right-sidebar studio tab), switch to the infinite canvas view, and select the shapes to edit.");
+	if (entry.selectionCount === 0) throw new Error("The image-gen workbench canvas has no selection to use as a reference image. Ask the user to select the shapes (for example their sketch) on the infinite canvas, then retry.");
+	const attachmentIds = [];
+	let attachmentBacked = 0;
+	for (const item of entry.selectionItems) {
+		if (item.kind !== "image" || typeof item.attachmentId !== "string" || item.attachmentId.length === 0) continue;
+		attachmentIds.push(item.attachmentId);
+		attachmentBacked += 1;
+	}
+	const fullCoverage = entry.selectionItems.length === entry.selectionCount;
+	const originals = [];
+	if (attachmentIds.length > 0 && input.agent !== void 0) {
+		const refs = findReferenceImages(input.agent.session.deriveMessages(), attachmentIds);
+		for (const ref of refs) {
+			const stored = await input.attachments.readImage(ref, input.signal);
+			if (input.maxBytes !== void 0 && stored.data.byteLength > input.maxBytes) throw new Error(`edit_image canvas selection image is too large (${stored.data.byteLength} bytes; maximum ${input.maxBytes})`);
+			originals.push({
+				data: stored.data,
+				mediaType: stored.ref.mediaType
+			});
+		}
+	}
+	if (originals.length > 0 && fullCoverage && attachmentBacked === entry.selectionItems.length && originals.length === attachmentIds.length) return originals;
+	const screenshot = readSelectionScreenshot(entry, input);
+	if (screenshot !== void 0) return [...originals, screenshot];
+	if (originals.length > 0) return originals;
+	throw new Error("The image-gen workbench canvas selection has no usable reference image yet. Ask the user to keep the shapes selected for a moment longer (the canvas pushes a screenshot about a second after the selection settles), then retry.");
+}
+/** The mirrored selection screenshot bytes, or undefined when none was pushed. */
+function readSelectionScreenshot(entry, input) {
+	const image = entry.selectionImage;
+	if (image === void 0) return void 0;
+	if (input.maxBytes !== void 0 && image.data.byteLength > input.maxBytes) throw new Error(`edit_image canvas selection screenshot is too large (${image.data.byteLength} bytes; maximum ${input.maxBytes})`);
+	return {
+		data: image.data,
+		mediaType: image.mediaType
+	};
 }
 //#endregion
 //#region lib/types/comfyui-workflow.js
@@ -5271,8 +7115,8 @@ function prepareComfyUIWorkflow(workflowJson, prompt, seed = randomSeed(), image
 	};
 	let imageInputs = 0;
 	const prepared = Object.fromEntries(Object.entries(workflow).map(([nodeId, value]) => {
-		const node = record$7(value);
-		const inputs = node === void 0 ? void 0 : record$7(node.inputs);
+		const node = record$6(value);
+		const inputs = node === void 0 ? void 0 : record$6(node.inputs);
 		if (inputs === void 0) return [nodeId, value];
 		const nextInputs = inject(inputs);
 		if (isImagePlaceholder(nextInputs[IMAGE_INPUT_KEY])) {
@@ -5308,7 +7152,7 @@ function parseWorkflow(workflowJson) {
 	}
 	if (!isRecord(value) || Object.keys(value).length === 0) throw new Error("ComfyUI workflow must be a non-empty API-format JSON object");
 	if (!Object.values(value).some((node) => {
-		const inputs = record$7(node)?.inputs;
+		const inputs = record$6(node)?.inputs;
 		return inputs !== void 0 && containsPromptPlaceholder(inputs);
 	})) throw new Error(`ComfyUI workflow must contain ${COMFYUI_PROMPT_PLACEHOLDER} (or ${LEGACY_PROMPT_PLACEHOLDER}) in a text input`);
 	return value;
@@ -5324,7 +7168,7 @@ function containsPromptPlaceholder(value) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function record$7(value) {
+function record$6(value) {
 	return isRecord(value) ? value : void 0;
 }
 //#endregion
@@ -5458,9 +7302,9 @@ async function waitForOutput(baseURL, promptId, signal) {
 		});
 		const text = await readBoundedText$3(response, MAX_HISTORY_BYTES);
 		if (!response.ok) throw new Error(`ComfyUI history request failed (${response.status}): ${redactSecrets(text).slice(0, ERROR_LIMIT$3)}`);
-		const entry = record$6(parseJsonRecord(text, "ComfyUI history returned invalid JSON")[promptId]);
+		const entry = record$5(parseJsonRecord(text, "ComfyUI history returned invalid JSON")[promptId]);
 		if (entry !== void 0) {
-			const status = record$6(entry.status);
+			const status = record$5(entry.status);
 			if (status?.status_str === "error") throw new Error(`ComfyUI workflow failed: ${redactSecrets(JSON.stringify(status.messages ?? status)).slice(0, ERROR_LIMIT$3)}`);
 			const output = firstOutputImage(entry.outputs);
 			if (output !== void 0) return output;
@@ -5470,13 +7314,13 @@ async function waitForOutput(baseURL, promptId, signal) {
 	}
 }
 function firstOutputImage(value) {
-	const outputs = record$6(value);
+	const outputs = record$5(value);
 	if (outputs === void 0) return void 0;
 	for (const nodeOutput of Object.values(outputs)) {
-		const images = record$6(nodeOutput)?.images;
+		const images = record$5(nodeOutput)?.images;
 		if (!Array.isArray(images)) continue;
 		for (const image of images) {
-			const item = record$6(image);
+			const item = record$5(image);
 			if (typeof item?.filename !== "string" || item.filename.length === 0) continue;
 			const output = {
 				filename: item.filename,
@@ -5497,7 +7341,7 @@ async function downloadOutput(baseURL, output, maxBytes, signal) {
 		signal
 	});
 	if (!response.ok) throw new Error(`ComfyUI image download failed (${response.status})`);
-	const mediaType = imageMediaType$4(response.headers.get("content-type")) ?? imageMediaTypeFromName(output.filename);
+	const mediaType = imageMediaType$3(response.headers.get("content-type")) ?? imageMediaTypeFromName(output.filename);
 	if (mediaType === void 0) throw new Error("ComfyUI image download returned an unsupported content type");
 	return {
 		data: await readBoundedBytes$2(response, maxBytes),
@@ -5517,7 +7361,7 @@ function comfyUIBaseURL(value) {
 function endpoint(baseURL, path) {
 	return new URL(path, baseURL);
 }
-function record$6(value) {
+function record$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function parseJsonRecord(text, message) {
@@ -5527,11 +7371,11 @@ function parseJsonRecord(text, message) {
 	} catch {
 		throw new Error(message);
 	}
-	const parsed = record$6(value);
+	const parsed = record$5(value);
 	if (parsed === void 0) throw new Error(message);
 	return parsed;
 }
-function imageMediaType$4(value) {
+function imageMediaType$3(value) {
 	const mediaType = value?.split(";", 1)[0]?.trim().toLowerCase();
 	return mediaType === "image/png" || mediaType === "image/jpeg" || mediaType === "image/webp" || mediaType === "image/gif" ? mediaType : void 0;
 }
@@ -5752,13 +7596,13 @@ async function requestGoogleImage(input) {
 	};
 }
 function outputImage(value) {
-	const interaction = record$5(value);
+	const interaction = record$4(value);
 	if (interaction === void 0) return void 0;
 	const direct = imageContent(interaction.output_image, false);
 	if (direct !== void 0) return direct;
 	if (!Array.isArray(interaction.steps)) return void 0;
 	for (const step of interaction.steps) {
-		const modelOutput = record$5(step);
+		const modelOutput = record$4(step);
 		if (modelOutput?.type !== "model_output" || !Array.isArray(modelOutput.content)) continue;
 		for (const content of modelOutput.content) {
 			const image = imageContent(content, true);
@@ -5767,14 +7611,14 @@ function outputImage(value) {
 	}
 }
 function imageContent(value, requiresImageType) {
-	const image = record$5(value);
+	const image = record$4(value);
 	if (image === void 0 || requiresImageType && image.type !== "image" || typeof image.data !== "string") return void 0;
 	return {
 		data: image.data,
 		mime_type: image.mime_type
 	};
 }
-function record$5(value) {
+function record$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function mediaTypeOf(value) {
@@ -5812,220 +7656,6 @@ async function readBoundedText$2(response, maxBytes, label) {
 	return new TextDecoder().decode(joined);
 }
 //#endregion
-//#region lib/types/reference-image.js
-/** Latest-DSH compatibility boundary for resolving conversation image references. */
-/**
-* Resolve one or more edit references while keeping every DSH-specific detail
-* behind this compatibility boundary. Explicit selectors preserve caller order;
-* without selectors, all images in the newest image-bearing message are used.
-*/
-async function resolveReferenceImages(input) {
-	const sourceAttachmentIds = mergeSelectors({
-		single: input.sourceAttachmentId,
-		multiple: input.sourceAttachmentIds,
-		singleName: "source_attachment_id",
-		multipleName: "source_attachment_ids",
-		equal: attachmentIdsEqual
-	});
-	const sourcePaths = mergeSelectors({
-		single: input.sourcePath,
-		multiple: input.sourcePaths,
-		singleName: "source_path",
-		multipleName: "source_paths",
-		equal: (left, right) => left.trim() === right.trim()
-	});
-	if (sourceAttachmentIds !== void 0 && sourcePaths !== void 0) throw new Error("edit_image accepts only one of source_attachment_id, source_attachment_ids, source_path, or source_paths");
-	if (sourcePaths !== void 0) return Promise.all(sourcePaths.map((sourcePath) => readWorkspaceReferenceImage({
-		sourcePath,
-		...input.agent?.session.header?.cwd === void 0 ? {} : { workspaceRoot: input.agent.session.header.cwd },
-		...input.maxBytes === void 0 ? {} : { maxBytes: input.maxBytes },
-		signal: input.signal
-	})));
-	if (input.agent === void 0) throw new Error("edit_image requires an active DSH agent session to resolve a reference image");
-	const refs = findReferenceImages(input.agent.session.deriveMessages(), sourceAttachmentIds);
-	if (refs.length === 0) {
-		if (sourceAttachmentIds !== void 0) throw new Error(`edit_image could not find image attachment ${sourceAttachmentIds[0]} in the current conversation`);
-		throw new Error("edit_image requires an image in the current conversation; upload or generate an image first");
-	}
-	if (sourceAttachmentIds !== void 0 && refs.length !== sourceAttachmentIds.length) {
-		const missing = sourceAttachmentIds.find((id) => !refs.some((ref) => attachmentIdsEqual(String(ref.attachmentId), id)));
-		throw new Error(`edit_image could not find image attachment ${missing ?? "unknown"} in the current conversation`);
-	}
-	return Promise.all(refs.map(async (ref) => {
-		const stored = await input.attachments.readImage(ref, input.signal);
-		if (input.maxBytes !== void 0 && stored.data.byteLength > input.maxBytes) throw new Error(`edit_image source image is too large (${stored.data.byteLength} bytes; maximum ${input.maxBytes})`);
-		return {
-			data: stored.data,
-			mediaType: stored.ref.mediaType
-		};
-	}));
-}
-/** Find images in caller order, or every image in the newest image-bearing message. */
-function findReferenceImages(messages, sourceAttachmentIds) {
-	if (sourceAttachmentIds !== void 0) return sourceAttachmentIds.flatMap((id) => {
-		const ref = findReferenceImage(messages, id);
-		return ref === void 0 ? [] : [ref];
-	});
-	const latestHumanMessage = [...messages].reverse().find((message) => message.source?.kind === "user");
-	if (latestHumanMessage !== void 0) {
-		const refs = collectInBlocks(latestHumanMessage.content);
-		if (refs.length > 0) return refs;
-	}
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const refs = collectInBlocks(messages[index]?.content ?? []);
-		if (refs.length > 0) return refs;
-	}
-	return [];
-}
-/**
-* Read an explicitly named workspace image without exposing filesystem or DSH
-* details to provider adapters. Both lexical and real-path containment are
-* enforced so absolute paths, parent traversal, and symlink escapes fail.
-*/
-async function readWorkspaceReferenceImage(input) {
-	const requested = input.sourcePath.trim();
-	if (requested.length === 0) throw new Error("edit_image source_path must not be empty");
-	if (input.workspaceRoot === void 0) throw new Error("edit_image source_path requires an active DSH session workspace");
-	const root = resolve(input.workspaceRoot);
-	const candidate = isAbsolute(requested) ? resolve(requested) : resolve(root, requested);
-	if (!containsPath$1(root, candidate)) throw new Error("edit_image source_path must stay inside the session workspace: " + requested);
-	let realRoot;
-	let realCandidate;
-	try {
-		[realRoot, realCandidate] = await Promise.all([realpath(root), realpath(candidate)]);
-	} catch (error) {
-		if (error.code === "ENOENT") throw new Error("edit_image could not find workspace image: " + requested);
-		throw error;
-	}
-	if (!containsPath$1(realRoot, realCandidate)) throw new Error("edit_image source_path resolves outside the session workspace: " + requested);
-	const file = await stat(realCandidate);
-	if (!file.isFile()) throw new Error("edit_image source_path is not a file: " + requested);
-	if (input.maxBytes !== void 0 && file.size > input.maxBytes) throw new Error("edit_image source image is too large (" + file.size + " bytes; maximum " + input.maxBytes + ")");
-	const data = await readFile(realCandidate, { signal: input.signal });
-	const mediaType = detectImageMediaType(data);
-	if (mediaType === void 0) throw new Error("edit_image source_path is not a supported PNG, JPEG, WebP, or GIF image: " + requested);
-	return {
-		data: new Uint8Array(data),
-		mediaType
-	};
-}
-/** Find the newest matching image in the effective, replacement-aware history. */
-function findReferenceImage(messages, sourceAttachmentId) {
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const found = findInBlocks(messages[index]?.content ?? [], sourceAttachmentId);
-		if (found !== void 0) return found;
-	}
-}
-/** Validate an untrusted serialized image reference at an HTTP/UI boundary. */
-function parseImageAttachmentRef(value) {
-	const ref = record$4(value);
-	if (ref === void 0) return void 0;
-	if (typeof ref.attachmentId !== "string" || !imageMediaType$3(ref.mediaType)) return void 0;
-	if (!nonNegativeInteger(ref.bytes) || !positiveInteger(ref.width) || !positiveInteger(ref.height)) return void 0;
-	if (ref.name !== void 0 && typeof ref.name !== "string") return void 0;
-	const originalDimensions = ref.originalDimensions === void 0 ? void 0 : parseDimensions(ref.originalDimensions);
-	if (ref.originalDimensions !== void 0 && originalDimensions === void 0) return void 0;
-	return {
-		attachmentId: ref.attachmentId,
-		mediaType: ref.mediaType,
-		bytes: ref.bytes,
-		width: ref.width,
-		height: ref.height,
-		...typeof ref.name === "string" ? { name: ref.name } : {},
-		...originalDimensions === void 0 ? {} : { originalDimensions }
-	};
-}
-function findInBlocks(blocks, sourceAttachmentId) {
-	for (let index = blocks.length - 1; index >= 0; index -= 1) {
-		const block = blocks[index];
-		if (block === void 0) continue;
-		if (block.type === "image") {
-			if (sourceAttachmentId === void 0 || attachmentIdsEqual(String(block.attachment.attachmentId), sourceAttachmentId)) return block.attachment;
-			continue;
-		}
-		if (block.type === "tool-result") {
-			const nested = findInBlocks(block.content, sourceAttachmentId);
-			if (nested !== void 0) return nested;
-		}
-	}
-}
-function parseDimensions(value) {
-	const dimensions = record$4(value);
-	if (dimensions === void 0 || !positiveInteger(dimensions.width) || !positiveInteger(dimensions.height)) return void 0;
-	return {
-		width: dimensions.width,
-		height: dimensions.height
-	};
-}
-function imageMediaType$3(value) {
-	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
-}
-function collectInBlocks(blocks) {
-	const refs = [];
-	for (const block of blocks) {
-		if (block.type === "image") refs.push(block.attachment);
-		if (block.type === "tool-result") refs.push(...collectInBlocks(block.content));
-	}
-	return refs;
-}
-function attachmentIdsEqual(actual, requested) {
-	if (actual === requested) return true;
-	const actualDigest = sha256Digest(actual);
-	const requestedDigest = sha256Digest(requested);
-	return actualDigest !== void 0 && actualDigest === requestedDigest;
-}
-function sha256Digest(value) {
-	return /^(?:sha256:)?([0-9a-f]{64})$/i.exec(value.trim())?.[1]?.toLowerCase();
-}
-function mergeSelectors(input) {
-	if (input.multiple === void 0) return input.single === void 0 ? void 0 : [input.single];
-	if (input.multiple.length === 0) {
-		if (input.single !== void 0) return [input.single];
-		throw new Error(`edit_image ${input.multipleName} must not be empty`);
-	}
-	const single = input.single;
-	if (single !== void 0 && !input.multiple.some((value) => input.equal(single, value))) throw new Error(`edit_image ${input.singleName} must also appear in ${input.multipleName} when both are provided`);
-	return input.multiple;
-}
-function detectImageMediaType(data) {
-	if (startsWith(data, [
-		137,
-		80,
-		78,
-		71,
-		13,
-		10,
-		26,
-		10
-	])) return "image/png";
-	if (startsWith(data, [
-		255,
-		216,
-		255
-	])) return "image/jpeg";
-	if (ascii(data, 0, 6) === "GIF87a" || ascii(data, 0, 6) === "GIF89a") return "image/gif";
-	if (ascii(data, 0, 4) === "RIFF" && ascii(data, 8, 4) === "WEBP") return "image/webp";
-}
-function startsWith(data, signature) {
-	return signature.every((byte, index) => data[index] === byte);
-}
-function ascii(data, offset, length) {
-	return String.fromCharCode(...data.subarray(offset, offset + length));
-}
-function containsPath$1(parent, child) {
-	const rel = relative(parent, child);
-	return rel === "" || rel !== ".." && !rel.startsWith(".." + sep) && !isAbsolute(rel);
-}
-function positiveInteger(value) {
-	return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-function nonNegativeInteger(value) {
-	return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-function record$4(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-//#endregion
 //#region lib/types/workspace-save.js
 /** Persist one generated image as a file under the session workspace. */
 /** File extension for each supported image media type. */
@@ -6505,10 +8135,11 @@ async function downloadImage$1(url, provider, input) {
 		...input.apiKey === void 0 ? {} : { headers: { authorization: `Bearer ${input.apiKey}` } }
 	});
 	if (!response.ok) throw new Error(`${provider} image download failed (${response.status})`);
-	const mediaType = imageMediaType$2(response.headers.get("content-type"));
+	const data = await readBoundedBytes$1(response, input.maxBytes);
+	const mediaType = detectImageMediaType(data) ?? imageMediaType$2(response.headers.get("content-type"));
 	if (mediaType === void 0) throw new Error(`${provider} image download returned unsupported content type`);
 	return {
-		data: await readBoundedBytes$1(response, input.maxBytes),
+		data,
 		mediaType
 	};
 }
@@ -17897,6 +19528,8 @@ async function serveStudio(req, res, deps) {
 	if (req.method !== "POST") return jsonError$1(res, 405, "method-not-allowed");
 	if (!(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) return jsonError$1(res, 415, "json-required");
 	const controller = new AbortController();
+	const upstreamTimeout = AbortSignal.timeout(15e4);
+	const signal = AbortSignal.any([controller.signal, upstreamTimeout]);
 	const onConnectionClose = () => {
 		if (!res.writableEnded) controller.abort(/* @__PURE__ */ new Error("The browser closed the image generation request."));
 	};
@@ -17912,10 +19545,11 @@ async function serveStudio(req, res, deps) {
 		} catch (error) {
 			return jsonError$1(res, 400, errorMessage(error, "invalid-request"));
 		}
-		const output = await deps.generate(input, controller.signal);
+		const output = await deps.generate(input, signal);
 		if (!res.headersSent && !res.writableEnded && !res.destroyed) json$1(res, 200, output);
 	} catch (error) {
 		if (res.headersSent || res.writableEnded || res.destroyed) return;
+		if (upstreamTimeout.aborted) return jsonError$1(res, 504, "上游生成超时（150 秒未返回），请检查网络或代理后重试");
 		jsonError$1(res, controller.signal.aborted ? 499 : 502, errorMessage(error, "generation-failed"));
 	} finally {
 		res.off("close", onConnectionClose);
@@ -18364,6 +19998,7 @@ function providerOverrideOf(value) {
 function apply(ctx, config = {}) {
 	let current = () => migrateOpenAICompatConfig(config);
 	const knownWorkspaceRoots = /* @__PURE__ */ new Set();
+	const canvasMirror = new CanvasMirror();
 	installImageSettings(ctx, config, {
 		setSource: (source) => {
 			current = () => migrateOpenAICompatConfig(source());
@@ -18422,6 +20057,27 @@ function apply(ctx, config = {}) {
 			config: () => current()
 		})
 	}), "dsh-image-gen: test connection route");
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: CANVAS_STATE_ROUTE,
+		handler: (req, res) => serveCanvasState(req, res, {
+			mirror: canvasMirror,
+			maxBodyBytes: Math.ceil(ctx.attachments.imageLimits.maxImageBytes * 1.4) + 262144,
+			maxImageBytes: ctx.attachments.imageLimits.maxImageBytes
+		})
+	}), "dsh-image-gen: canvas state route");
+	ctx.inject(["systemPrompt"], (promptCtx) => {
+		promptCtx.systemPrompt.context({
+			name: "dsh-image-gen:canvas",
+			order: 60,
+			text: () => canvasMirror.digest()
+		});
+	});
+	registerCanvasTools(ctx, canvasMirror, { persistSelectionImage: (image) => ctx.attachments.saveImage({
+		data: image.data,
+		mediaType: image.mediaType,
+		name: "canvas-selection"
+	}) });
 	ctx.effect(() => ctx.webServer.register({
 		kind: "exact",
 		path: STUDIO_ROUTE,
@@ -18568,7 +20224,7 @@ function apply(ctx, config = {}) {
 	}));
 	ctx.tools.register(defineTool({
 		name: "edit_image",
-		description: "Edit, combine, or restyle existing images with the configured provider. Images attached inline to the latest human message are already readable DSH attachments even when no workspace file exists. In that case, call edit_image immediately with prompt only; NEVER call read_image, glob, or shell to locate them, and NEVER invent @ paths. All inline images will be used in upload order. For specific older conversation images use source_attachment_id or source_attachment_ids; both canonical sha256: IDs and full bare SHA-256 digests are accepted. For files the user explicitly names in the workspace use source_path or source_paths. Provide exactly one selector field. Without a selector, images from the latest human message take priority; only when that message has no images does editing fall back to the newest conversation image.",
+		description: "Edit, combine, or restyle existing images with the configured provider. Images attached inline to the latest human message are already readable DSH attachments even when no workspace file exists. In that case, call edit_image immediately with prompt only; NEVER call read_image, glob, or shell to locate them, and NEVER invent @ paths. All inline images will be used in upload order. For specific older conversation images use source_attachment_id or source_attachment_ids; both canonical sha256: IDs and full bare SHA-256 digests are accepted. For files the user explicitly names in the workspace use source_path or source_paths. For what the user selected or drew on the image-gen workbench canvas (for example a hand-drawn sketch) use source=canvas_selection; canvas_state can verify a selection exists first. Provide exactly one selector field. Without a selector, images from the latest human message take priority; only when that message has no images does editing fall back to the newest conversation image.",
 		parameters: {
 			prompt: {
 				type: "string",
@@ -18593,6 +20249,11 @@ function apply(ctx, config = {}) {
 				type: "string",
 				description: "Optional model name for this call only, overriding the configured model. Not used by ComfyUI (use workflow instead)."
 			},
+			source: {
+				type: "string",
+				enum: ["canvas_selection"],
+				description: "Use the current selection on the image-gen workbench infinite canvas as the reference image(s): full-resolution originals when the selection is conversation-generated images, plus a screenshot of the whole selection when it also contains other content (hand-drawn strokes, pasted images). Choose this when the user refers to what they selected or drew on the canvas; combine with no other selector field."
+			},
 			source_attachment_id: {
 				type: "string",
 				description: "Optional attachment id of a specific image already present in the current conversation."
@@ -18645,7 +20306,15 @@ function apply(ctx, config = {}) {
 		output: imageOutput("Edited"),
 		async execute(args, exec) {
 			const active = resolveProvider(withProviderOverrides(current(), providerOverrideOf(args.provider), args.model));
-			const sourceImages = await resolveReferenceImages({
+			const canvasSelection = args.source === "canvas_selection";
+			if (canvasSelection && (args.source_attachment_id !== void 0 || Array.isArray(args.source_attachment_ids) || args.source_path !== void 0 || Array.isArray(args.source_paths))) throw new Error("edit_image source=canvas_selection cannot be combined with source_attachment_id, source_attachment_ids, source_path, or source_paths; provide exactly one selector");
+			const sourceImages = canvasSelection ? await resolveCanvasSelectionReferences({
+				mirror: canvasMirror,
+				attachments: ctx.attachments,
+				...exec.agent === void 0 ? {} : { agent: exec.agent },
+				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+				signal: exec.signal
+			}) : await resolveReferenceImages({
 				...exec.agent === void 0 ? {} : { agent: exec.agent },
 				attachments: ctx.attachments,
 				...typeof args.source_attachment_id === "string" ? { sourceAttachmentId: args.source_attachment_id } : {},
@@ -18896,4 +20565,4 @@ function installImageSettings(ctx, config, hooks) {
 	ctx.logger.warn("dsh-image-gen: this DSH exposes neither settings API generation; settings UI stays on the composition entry");
 }
 //#endregion
-export { Config, DELETE_ROUTE, IMAGE_ROUTE, INSPIRATION_ROUTE, SAVE_WORKSPACE_ROUTE, STUDIO_ROUTE, TEST_CONNECTION_ROUTE, apply, imageAttachmentFromMeta, inject, name };
+export { CANVAS_STATE_ROUTE, Config, DELETE_ROUTE, IMAGE_ROUTE, INSPIRATION_ROUTE, SAVE_WORKSPACE_ROUTE, STUDIO_ROUTE, TEST_CONNECTION_ROUTE, apply, imageAttachmentFromMeta, inject, name };