@deepseek-ai/dsh-llm 0.1.2-alpha.5 → 0.1.3-alpha.2

package/lib/index.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
-import { assertNever, deepFreeze } from "@deepseek-ai/dsh-util-values";
+import { assertNever, deepFreeze, snapshotJsonValue } from "@deepseek-ai/dsh-util-values";
 import { randomUUID } from "@deepseek-ai/dsh-util-crypto";
 import { brandString } from "@deepseek-ai/dsh-brand";
 import z from "@deepseek-ai/schemastery";
@@ -557,6 +557,74 @@ function offloadedImageText(ref, access) {
 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.
+* @param content - typed model content blocks.
+* @returns whether any nested block is a file.
+*/
+function contentHasFile(content) {
+	return content.some((block) => block.type === "file" || block.type === "tool-result" && contentHasFile(block.content));
+}
+/**
+* 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;
+		}
+		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;
+			}
+		}
+		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
+		};
+	});
+}
 /** Base64 length of raw image bytes, including padding. */
 function base64Length(bytes) {
 	return Math.ceil(bytes / 3) * 4;
@@ -770,6 +838,14 @@ function ProviderRequestId(id) {
 	return brandString(id);
 }
 /**
+* Brand one loop-owned streaming attempt identifier.
+* @param id - the opaque Agent-lifecycle-local identifier.
+* @returns the same string with the attempt-id brand.
+*/
+function LlmAttemptId(id) {
+	return brandString(id);
+}
+/**
 * Brand an adapter-owned reasoning-effort identifier.
 * @param id - the opaque identifier exposed by one model capability.
 * @returns the same string, branded; no validation is performed.
@@ -973,6 +1049,446 @@ var BlockAssembler = class {
 	}
 };
 //#endregion
+//#region lib/types/assistant-stream.js
+/**
+* Lossless compact representation of one model-stream attempt, plus record-level
+* readers that answer common consumer questions without materializing members.
+* Readers trust the static record type; expandAssistantStream is the validating
+* path for records read at a durable boundary.
+*/
+function safeTime(value) {
+	if (!Number.isSafeInteger(value)) throw new TypeError(`Assistant stream time must be a safe integer, got ${String(value)}`);
+	return value;
+}
+function safeIndex(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0 || Object.is(value, -0)) throw new TypeError(`${label} index must be a non-negative safe integer`);
+	return value;
+}
+function snapshotChunk(chunk) {
+	const snapshot = snapshotJsonValue(chunk);
+	if (snapshot === void 0) throw new TypeError("Assistant stream chunk must be losslessly JSON-serializable");
+	return snapshot;
+}
+function safeGap(previous, next) {
+	const gap = next - previous;
+	return Number.isSafeInteger(gap) && previous + gap === next ? gap : void 0;
+}
+/** Incrementally compacts one attempt without retaining a second raw-chunk list. */
+var AssistantStreamAccumulator = class {
+	records = [];
+	/**
+	* Add one timed chunk to the compact attempt stream.
+	* @param value - model chunk and its original Session timestamp.
+	* @returns a detached immutable copy for assembly and live publication.
+	*/
+	push(value) {
+		const time = safeTime(value.time);
+		const chunk = snapshotChunk(value.chunk);
+		const timed = deepFreeze({
+			time,
+			chunk
+		});
+		const previous = this.records.at(-1);
+		switch (chunk.type) {
+			case "text-delta":
+			case "reasoning-delta": {
+				safeIndex(chunk.index, chunk.type);
+				if (typeof chunk.text !== "string") throw new TypeError(`${chunk.type} text must be a string`);
+				const type = chunk.type === "text-delta" ? "text-chunks" : "reasoning-chunks";
+				const gap = previous !== void 0 && previous.type === type ? safeGap(previous.lastTime, time) : void 0;
+				if (previous !== void 0 && previous.type === type && previous.index === chunk.index && gap !== void 0) {
+					previous.dt.push(gap);
+					previous.texts.push(chunk.text);
+					previous.lastTime = time;
+				} else this.records.push({
+					type,
+					time0: time,
+					index: chunk.index,
+					dt: [],
+					texts: [chunk.text],
+					lastTime: time
+				});
+				return timed;
+			}
+			case "tool-call-delta": {
+				safeIndex(chunk.index, chunk.type);
+				if (typeof chunk.id !== "string") throw new TypeError("tool-call-delta id must be a string");
+				if (Object.hasOwn(chunk, "name") && typeof chunk.name !== "string") throw new TypeError("tool-call-delta name must be a string");
+				if (typeof chunk.argumentsDelta !== "string") throw new TypeError("tool-call-delta argumentsDelta must be a string");
+				if (chunk.id.length === 0 || chunk.name === "") {
+					this.records.push({
+						type: "chunk",
+						time,
+						chunk
+					});
+					return timed;
+				}
+				const gap = previous?.type === "tool-call-chunks" ? safeGap(previous.lastTime, time) : void 0;
+				const sameName = previous?.type === "tool-call-chunks" && Object.hasOwn(previous, "name") === Object.hasOwn(chunk, "name") && previous.name === chunk.name;
+				if (previous?.type === "tool-call-chunks" && previous.index === chunk.index && previous.id === chunk.id && sameName && gap !== void 0) {
+					previous.dt.push(gap);
+					previous.args.push(chunk.argumentsDelta);
+					previous.lastTime = time;
+				} else this.records.push({
+					type: "tool-call-chunks",
+					time0: time,
+					index: chunk.index,
+					dt: [],
+					id: chunk.id,
+					...Object.hasOwn(chunk, "name") ? { name: chunk.name } : {},
+					args: [chunk.argumentsDelta],
+					lastTime: time
+				});
+				return timed;
+			}
+			case "block-start":
+			case "block-end":
+			case "usage":
+			case "finish":
+				this.records.push({
+					type: "chunk",
+					time,
+					chunk
+				});
+				return timed;
+			default: return assertNever(chunk, "AssistantStreamAccumulator.push");
+		}
+	}
+	/**
+	* Return the current compact attempt stream.
+	* @returns a detached immutable record list suitable for a durable event.
+	*/
+	snapshot() {
+		return deepFreeze(this.records.map((record) => {
+			if (record.type === "chunk") return { ...record };
+			const { lastTime: _lastTime, ...durable } = record;
+			if (durable.type === "tool-call-chunks") return {
+				...durable,
+				dt: [...durable.dt],
+				args: [...durable.args]
+			};
+			return {
+				...durable,
+				dt: [...durable.dt],
+				texts: [...durable.texts]
+			};
+		}));
+	}
+};
+/**
+* Expand compact records into the exact timed chunk sequence.
+* @param stream - compact records from one durable Assistant settlement.
+* @returns detached timed chunks with every original delta boundary preserved.
+* @throws {TypeError} when a record or reconstructed timestamp is invalid.
+*/
+function expandAssistantStream(stream) {
+	const chunks = [];
+	for (const candidate of stream) {
+		const record = validateRecord(candidate);
+		if (record.type === "chunk") {
+			chunks.push({
+				time: record.time,
+				chunk: record.chunk
+			});
+			continue;
+		}
+		const members = record.type === "tool-call-chunks" ? record.args : record.texts;
+		let time = record.time0;
+		for (let index = 0; index < members.length; index += 1) {
+			if (index > 0) time += record.dt[index - 1];
+			let chunk;
+			if (record.type === "text-chunks") chunk = {
+				type: "text-delta",
+				index: record.index,
+				text: members[index]
+			};
+			else if (record.type === "reasoning-chunks") chunk = {
+				type: "reasoning-delta",
+				index: record.index,
+				text: members[index]
+			};
+			else chunk = {
+				type: "tool-call-delta",
+				index: record.index,
+				id: record.id,
+				...Object.hasOwn(record, "name") ? { name: record.name } : {},
+				argumentsDelta: members[index]
+			};
+			chunks.push({
+				time,
+				chunk
+			});
+		}
+	}
+	return chunks;
+}
+function hasNonWhitespace(text) {
+	return /\S/.test(text);
+}
+function blockIsVisible(block) {
+	if (block.type === "tool-call") return false;
+	if (block.type === "text" || block.type === "reasoning") return hasNonWhitespace(block.text);
+	return true;
+}
+/**
+* Whether one chunk carries the model's first output token for latency measurement.
+* @param chunk - any stream chunk.
+* @returns true for a non-empty text, reasoning, or Tool-call arguments fragment and for
+*   every name-bearing Tool-call delta; false for block, usage, and finish chunks.
+*/
+function isTokenDelta(chunk) {
+	switch (chunk.type) {
+		case "text-delta":
+		case "reasoning-delta": return chunk.text !== "";
+		case "tool-call-delta": return chunk.argumentsDelta !== "" || chunk.name !== void 0;
+		default: return false;
+	}
+}
+/**
+* Whether one chunk by itself contributes reader-visible transcript content.
+* Text and reasoning count only with non-whitespace content, streamed as a delta or
+* completed as a block; a block of any other kind counts at its start and its end,
+* except a Tool call, which is protocol rather than content. Usage and finish never count.
+* @param chunk - any stream chunk.
+* @returns whether a transcript reader would see this chunk.
+*/
+function isVisibleChunk(chunk) {
+	switch (chunk.type) {
+		case "text-delta":
+		case "reasoning-delta": return hasNonWhitespace(chunk.text);
+		case "block-start": return chunk.blockType !== "text" && chunk.blockType !== "reasoning" && chunk.blockType !== "tool-call";
+		case "block-end": return blockIsVisible(chunk.block);
+		default: return false;
+	}
+}
+/**
+* Whether one chunk carries non-whitespace text, as a text delta or a completed text block.
+* Reasoning, Tool calls, and other block kinds never count.
+* @param chunk - any stream chunk.
+* @returns whether the chunk contributes visible text.
+*/
+function chunkHasVisibleText(chunk) {
+	if (chunk.type === "text-delta") return hasNonWhitespace(chunk.text);
+	return chunk.type === "block-end" && chunk.block.type === "text" && hasNonWhitespace(chunk.block.text);
+}
+function firstRunMemberTime(run, predicate) {
+	const fragments = run.type === "tool-call-chunks" ? run.args : run.texts;
+	let time = run.time0;
+	for (let index = 0; index < fragments.length; index += 1) {
+		if (index > 0) time += run.dt[index - 1];
+		if (predicate(fragments[index])) return time;
+	}
+}
+/**
+* Time of the first member of one packed run that {@link isTokenDelta} accepts: a
+* name-bearing Tool-call run starts at its first member, otherwise the first non-empty fragment.
+* Stops scanning at that member.
+* @param run - one packed delta run.
+* @returns the member's reconstructed time, or undefined when no member qualifies.
+*/
+function runFirstTokenTime(run) {
+	if (run.type === "tool-call-chunks" && run.name !== void 0) return run.time0;
+	return firstRunMemberTime(run, (fragment) => fragment !== "");
+}
+/**
+* Time of the first member of one packed run that {@link isVisibleChunk} accepts: the first
+* non-whitespace text or reasoning fragment. A Tool-call run has none. Stops scanning at that member.
+* @param run - one packed delta run.
+* @returns the member's reconstructed time, or undefined when no member qualifies.
+*/
+function runFirstVisibleTime(run) {
+	return run.type === "tool-call-chunks" ? void 0 : firstRunMemberTime(run, hasNonWhitespace);
+}
+/**
+* Time of the first token in one compact stream per {@link isTokenDelta}, read from the
+* records themselves and stopping at the first qualifying member.
+* @param stream - compact records from one durable Assistant settlement.
+* @returns the first token's time, or undefined when the stream carries no token.
+*/
+function assistantStreamFirstTokenTime(stream) {
+	for (const record of stream) {
+		const time = record.type === "chunk" ? isTokenDelta(record.chunk) ? record.time : void 0 : runFirstTokenTime(record);
+		if (time !== void 0) return time;
+	}
+}
+/**
+* Whether one compact stream carries any reader-visible content per {@link isVisibleChunk},
+* stopping at the first qualifying member.
+* @param stream - compact records from one durable Assistant settlement.
+* @returns whether a transcript reader would see anything from this stream.
+*/
+function assistantStreamHasVisibleContent(stream) {
+	return stream.some((record) => record.type === "chunk" ? isVisibleChunk(record.chunk) : runFirstVisibleTime(record) !== void 0);
+}
+/**
+* Whether one compact stream carries non-whitespace text per {@link chunkHasVisibleText},
+* stopping at the first qualifying member.
+* @param stream - compact records from one durable Assistant settlement.
+* @returns whether the stream contributes visible text.
+*/
+function assistantStreamHasVisibleText(stream) {
+	return stream.some((record) => record.type === "text-chunks" ? record.texts.some(hasNonWhitespace) : record.type === "chunk" && chunkHasVisibleText(record.chunk));
+}
+/**
+* The last raw chunk of one never-packed type, scanning backwards and stopping at the first hit.
+* @param stream - compact records from one durable Assistant settlement.
+* @param type - chunk type that only appears as a raw record.
+* @returns the stream's final chunk of that type, or undefined when it has none.
+*/
+function lastAssistantStreamChunk(stream, type) {
+	for (let index = stream.length - 1; index >= 0; index -= 1) {
+		const record = stream[index];
+		if (record.type === "chunk" && record.chunk.type === type) return record.chunk;
+	}
+}
+/**
+* Every raw chunk of one never-packed type, in stream order.
+* @param stream - compact records from one durable Assistant settlement.
+* @param type - chunk type that only appears as a raw record.
+* @returns the matching chunks; empty when the stream has none.
+*/
+function assistantStreamChunks(stream, type) {
+	const chunks = [];
+	for (const record of stream) if (record.type === "chunk" && record.chunk.type === type) chunks.push(record.chunk);
+	return chunks;
+}
+/**
+* Every streamed text-delta fragment joined in stream order; reasoning and Tool-call fragments are excluded.
+* @param stream - compact records from one durable Assistant settlement.
+* @returns the joined text, empty when the stream carries no text delta.
+*/
+function joinAssistantStreamText(stream) {
+	const parts = [];
+	for (const record of stream) if (record.type === "text-chunks") parts.push(record.texts.join(""));
+	else if (record.type === "chunk" && record.chunk.type === "text-delta") parts.push(record.chunk.text);
+	return parts.join("");
+}
+/**
+* Feed one compact stream into a {@link BlockAssembler} without materializing members.
+* Each run contributes one delta carrying its joined fragments, which assembles the same
+* blocks as the original per-member deltas because assembly only concatenates them;
+* raw chunks are pushed as recorded. The records are trusted, not validated: validate a
+* stream read at a durable boundary with {@link expandAssistantStream} first.
+* @param stream - compact records from one durable Assistant settlement.
+* @param assembler - assembler to feed; a fresh one by default.
+* @returns the same assembler after every record was pushed.
+*/
+function assembleAssistantStream(stream, assembler = new BlockAssembler()) {
+	for (const record of stream) switch (record.type) {
+		case "chunk":
+			assembler.push(record.chunk);
+			break;
+		case "text-chunks":
+			assembler.push({
+				type: "text-delta",
+				index: record.index,
+				text: record.texts.join("")
+			});
+			break;
+		case "reasoning-chunks":
+			assembler.push({
+				type: "reasoning-delta",
+				index: record.index,
+				text: record.texts.join("")
+			});
+			break;
+		case "tool-call-chunks":
+			assembler.push({
+				type: "tool-call-delta",
+				index: record.index,
+				id: record.id,
+				...record.name === void 0 ? {} : { name: record.name },
+				argumentsDelta: record.args.join("")
+			});
+			break;
+		default: assertNever(record, "assembleAssistantStream");
+	}
+	return assembler;
+}
+function validateRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("Assistant stream record must be an object");
+	const record = value;
+	switch (record.type) {
+		case "text-chunks":
+		case "reasoning-chunks": {
+			exactKeys(record, [
+				"type",
+				"time0",
+				"index",
+				"dt",
+				"texts"
+			], record.type);
+			const texts = stringArray(record.texts, `${record.type} texts`);
+			if (texts.length === 0) throw new TypeError(`${record.type} texts must be non-empty`);
+			validateRun(record, texts.length, record.type);
+			return record;
+		}
+		case "tool-call-chunks": {
+			exactKeys(record, Object.hasOwn(record, "name") ? [
+				"type",
+				"time0",
+				"index",
+				"dt",
+				"id",
+				"name",
+				"args"
+			] : [
+				"type",
+				"time0",
+				"index",
+				"dt",
+				"id",
+				"args"
+			], record.type);
+			const args = stringArray(record.args, "tool-call-chunks args");
+			if (args.length === 0) throw new TypeError("tool-call-chunks args must be non-empty");
+			if (typeof record.id !== "string" || record.id.length === 0) throw new TypeError("tool-call-chunks id must be a non-empty string");
+			if (record.name !== void 0 && (typeof record.name !== "string" || record.name.length === 0)) throw new TypeError("tool-call-chunks name must be a non-empty string");
+			validateRun(record, args.length, record.type);
+			return record;
+		}
+		case "chunk": {
+			exactKeys(record, [
+				"type",
+				"time",
+				"chunk"
+			], "chunk");
+			const time = safeTime(record.time);
+			if (typeof record.chunk !== "object" || record.chunk === null || Array.isArray(record.chunk)) throw new TypeError("Assistant stream raw chunk must be a lossless JSON object");
+			let chunk;
+			try {
+				chunk = snapshotChunk(record.chunk);
+			} catch (error) {
+				throw new TypeError("Assistant stream raw chunk must be a lossless JSON object", { cause: error });
+			}
+			return deepFreeze({
+				type: "chunk",
+				time,
+				chunk
+			});
+		}
+		default: throw new TypeError(`Unsupported Assistant stream record ${JSON.stringify(record.type)}`);
+	}
+}
+function validateRun(record, members, label) {
+	safeTime(record.time0);
+	safeIndex(record.index, label);
+	if (!Array.isArray(record.dt) || record.dt.some((value) => !Number.isSafeInteger(value))) throw new TypeError(`${label} dt must contain safe integers`);
+	if (record.dt.length !== members - 1) throw new TypeError(`${label} dt length must be one less than its members`);
+	let time = record.time0;
+	for (const gap of record.dt) {
+		time += gap;
+		if (!Number.isSafeInteger(time)) throw new TypeError(`${label} member times must stay safe integers`);
+	}
+}
+function stringArray(value, label) {
+	if (!Array.isArray(value) || value.some((member) => typeof member !== "string")) throw new TypeError(`${label} must be a string array`);
+	return value;
+}
+function exactKeys(record, keys, label) {
+	if (Object.keys(record).length !== keys.length || !keys.every((key) => Object.hasOwn(record, key))) throw new TypeError(`${label} Assistant stream record must contain exactly ${keys.join(", ")}`);
+}
+//#endregion
 //#region lib/types/index.js
 /**
 * LLM service: adapter registry with a waterfall-interceptable streaming call
@@ -1458,6 +1974,15 @@ let LlmRuntime = (() => {
 		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];
@@ -1651,6 +2176,20 @@ let LlmRuntime = (() => {
 			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.
@@ -1681,13 +2220,16 @@ let LlmRuntime = (() => {
 					...options,
 					...resolvedConfig
 				};
-				const projectedOptions = modelInfo.inputModalities !== void 0 && !modelInfo.inputModalities.includes("image") && resolvedOptions.messages.some((message) => contentHasImage(message.content)) ? Object.isFrozen(resolvedOptions) ? deepFreeze({
+				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: projectImagesForTextModel(resolvedOptions.messages)
+					messages: projectedMessages
 				}) : {
 					...resolvedOptions,
-					messages: projectImagesForTextModel(resolvedOptions.messages)
-				} : resolvedOptions;
+					messages: projectedMessages
+				};
 				iterator = dispatch(this.forAdapter(projectedOptions, adapter))[Symbol.asyncIterator]();
 			} catch (error) {
 				yield adapterFailureChunk(error, options.signal);
@@ -1755,4 +2297,4 @@ function adapterFailureChunk(error, signal) {
 	};
 }
 //#endregion
-export { APP_IDENTITY, BlockAssembler, CONTEXT_SUMMARY_MAX_CHARS, CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, HarnessError, INVALID_CREDENTIAL_CODE, LlmAdapter, LlmError, LlmRuntime, LlmRuntime as default, MessageId, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, RetryPolicySchema, ToolCallId, assertUsableApiKey, attributionHeaders, boundContextSummary, callConfigEquals, contentHasImage, createAssistantMessage, createMessage, createToolResultMessage, createUserMessage, errorChain, freezeMessage, isAgentLoopRequest, isContextWindowExceededError, isHarnessError, isQuotaExceededError, markAgentLoopRequest, normalizeApiKey, offloadRequestImagesWithPolicy, offloadedImagePrefixCount, offloadedImageText, projectImagesForTextModel, requestImageHandleText, resolveImageAttachmentAccess, resolveRetryPolicy, textOnlyImageText, userAgent };
+export { APP_IDENTITY, AssistantStreamAccumulator, BlockAssembler, CONTEXT_SUMMARY_MAX_CHARS, CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, HarnessError, INVALID_CREDENTIAL_CODE, LlmAdapter, LlmAttemptId, LlmError, LlmRuntime, LlmRuntime as default, MessageId, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, RetryPolicySchema, ToolCallId, assembleAssistantStream, assertUsableApiKey, assistantStreamChunks, assistantStreamFirstTokenTime, assistantStreamHasVisibleContent, assistantStreamHasVisibleText, attributionHeaders, boundContextSummary, callConfigEquals, chunkHasVisibleText, contentHasFile, contentHasImage, createAssistantMessage, createMessage, createToolResultMessage, createUserMessage, errorChain, expandAssistantStream, fileHandleText, freezeMessage, isAgentLoopRequest, isContextWindowExceededError, isHarnessError, isQuotaExceededError, isTokenDelta, isVisibleChunk, joinAssistantStreamText, lastAssistantStreamChunk, markAgentLoopRequest, normalizeApiKey, offloadRequestImagesWithPolicy, offloadedImagePrefixCount, offloadedImageText, projectFilesToText, projectImagesForTextModel, requestImageHandleText, resolveImageAttachmentAccess, resolveRetryPolicy, runFirstTokenTime, runFirstVisibleTime, textOnlyImageText, userAgent };

package/lib/typert.host.js

@@ -67,7 +67,7 @@ export const TYPERT = {
         typeSymbol: '@deepseek-ai/dsh-llm#llm/discoverModels:result',
         schema: _deepseek_ai_dsh_llm_llm_discoverModels_result$schema,
       },
-      sourceLocation: {"file":"packages/llm/llm/src/index.ts","line":621,"column":9},
+      sourceLocation: {"file":"packages/llm/llm/src/index.ts","line":625,"column":9},
     },
     {
       id: '@deepseek-ai/dsh-llm#llm/listConfigurableProviders',
@@ -82,7 +82,7 @@ export const TYPERT = {
         typeSymbol: '@deepseek-ai/dsh-llm#llm/listConfigurableProviders:result',
         schema: _deepseek_ai_dsh_llm_llm_listConfigurableProviders_result$schema,
       },
-      sourceLocation: {"file":"packages/llm/llm/src/index.ts","line":534,"column":3},
+      sourceLocation: {"file":"packages/llm/llm/src/index.ts","line":538,"column":3},
     },
     {
       id: '@deepseek-ai/dsh-llm#llm/listProviders',
@@ -97,7 +97,7 @@ export const TYPERT = {
         typeSymbol: '@deepseek-ai/dsh-llm#llm/listProviders:result',
         schema: _deepseek_ai_dsh_llm_llm_listProviders_result$schema,
       },
-      sourceLocation: {"file":"packages/llm/llm/src/index.ts","line":462,"column":3},
+      sourceLocation: {"file":"packages/llm/llm/src/index.ts","line":466,"column":3},
     },
   ],
   model: {
@@ -173,6 +173,13 @@ export const TYPERT = {
             "summary": "Resolve provider-side request-image pricing for one exact route, or `undefined` when the provider is unregistered or declares none.",
             "jsDoc": "/**\n * Resolve provider-side request-image pricing for one exact route, or\n * `undefined` when the provider is unregistered or declares none. Unknown\n * providers degrade to `undefined` rather than throwing because callers\n * price durable history whose route may no longer be mounted.\n * @param provider - provider route named by a request header.\n * @param model - exact model id named by the same header.\n * @returns the owning adapter's image pricing for the route, when declared.\n */"
           },
+          {
+            "kind": "method",
+            "name": "fileRequestText",
+            "signature": "fileRequestText(ref: FileAttachmentRef): string",
+            "summary": "Resolve the exact text one durable file occurrence contributes to every provider request in the current execution environment.",
+            "jsDoc": "/**\n * Resolve the exact text one durable file occurrence contributes to every\n * provider request in the current execution environment.\n * @param ref - durable verbatim file reference from model history.\n * @returns the same deterministic handle text used at adapter dispatch.\n */"
+          },
           {
             "kind": "method",
             "name": "listModels",
@@ -240,7 +247,7 @@ export const TYPERT = {
           },
           {
             "name": "ContentBlockMap",
-            "declaration": "export interface ContentBlockMap {\n    text: TextBlock;\n    reasoning: ReasoningBlock;\n    image: ImageBlock;\n    'tool-call': ToolCallBlock;\n    'tool-result': ToolResultBlock;\n}"
+            "declaration": "export interface ContentBlockMap {\n    text: TextBlock;\n    reasoning: ReasoningBlock;\n    image: ImageBlock;\n    file: FileBlock;\n    'tool-call': ToolCallBlock;\n    'tool-result': ToolResultBlock;\n}"
           },
           {
             "name": "ContentBlockType",
@@ -258,6 +265,14 @@ export const TYPERT = {
             "name": "DirectoryRegistrationHandle",
             "declaration": "export interface DirectoryRegistrationHandle {\n    (): void;\n    replace(entries: readonly LlmConfigurableProvider[]): void;\n}"
           },
+          {
+            "name": "FileAttachmentRef",
+            "declaration": "export interface FileAttachmentRef {\n    attachmentId: AttachmentId;\n    name: string;\n    bytes: number;\n}"
+          },
+          {
+            "name": "FileBlock",
+            "declaration": "export interface FileBlock {\n    type: 'file';\n    attachment: FileAttachmentRef;\n}"
+          },
           {
             "name": "FinishReason",
             "declaration": "export type FinishReason = FinishReasonMap[keyof FinishReasonMap];"
@@ -428,7 +443,7 @@ export const TYPERT = {
           },
           {
             "name": "SessionReferenceSource",
-            "declaration": "export interface SessionReferenceSource {\n    kind: 'session-reference';\n    form: 'recall';\n    version: 1;\n    references: { sessionId: string; label: string; capturedThroughSeq: OptionalSessionSeq; compacted: boolean; originalMessages: number; retainedMessages: number; omittedMessages: number; omittedBytes: number; truncated: boolean; inputIndex: number; }[];\n}"
+            "declaration": "export interface SessionReferenceSource {\n    kind: 'session-reference';\n    form: 'recall';\n    version: 1;\n    references: { sessionId: string; label: string; capturedFormatVersion?: number; capturedThroughSeq: OptionalSessionSeq; compacted: boolean; originalMessages: number; retainedMessages: number; omittedMessages: number; omittedBytes: number; truncated: boolean; inputIndex: number; }[];\n}"
           },
           {
             "name": "SessionRequestId",