@nhtio/adk 0.1.0-master-f0aa531d

package/tool_call-BKyyxGaZ.mjs

@@ -0,0 +1,578 @@
+import { a as validateOrThrow, i as passesSchema } from "./exceptions-NrzIHw_R.mjs";
+import { a as Tokenizable, c as isObject, o as isError, r as Registry, s as isInstanceOf } from "./tool_registry-DqLOyGyG.mjs";
+import { S as E_NOT_A_MEDIA_READER, i as E_INVALID_INITIAL_MEDIA_VALUE, u as E_INVALID_INITIAL_TOOL_CALL_VALUE } from "./runtime-CrEPIFgr.mjs";
+import { t as SpooledArtifact } from "./spooled_artifact-C5ZtGxuJ.mjs";
+import { validator } from "@nhtio/validation";
+import { v6 } from "uuid";
+//#region src/lib/contracts/media_reader.ts
+/**
+* Validator schema used to validate a MediaReader value.
+*
+* @remarks
+* Because MediaReader is a structural interface with no associated constructor, validation is
+* duck-typed: the value must be an object, class instance, or function with `stream` and
+* `byteLength` present as callable properties. Arity is not enforced.
+*/
+var mediaReaderSchema = validator.any().required().custom((value, helpers) => {
+	if (value !== null && value !== void 0 && typeof value.stream === "function" && typeof value.byteLength === "function") return value;
+	return helpers.error("any.invalid");
+});
+/**
+* Returns `true` if `value` implements the MediaReader interface.
+*
+* @remarks
+* Duck-typed: checks that `value` is non-null with `stream` and `byteLength` as callable
+* functions. Does not use `instanceof` — there is no MediaReader constructor.
+*
+* @param value - The value to test.
+* @returns `true` when `value` conforms to the MediaReader interface.
+*/
+var implementsMediaReader = (value) => {
+	return passesSchema(mediaReaderSchema, value);
+};
+//#endregion
+//#region src/lib/classes/media.ts
+/**
+* The set of supported media kinds.
+*
+* @remarks
+* Modality coverage is asymmetric across providers. The framework defines no
+* `supportedModalities` field — how a battery handles a modality it cannot natively render is
+* the battery author's call (see `unsupportedMediaPolicy` on the OpenAI Chat Completions
+* battery).
+*/
+var MediaKind = [
+	"image",
+	"audio",
+	"video",
+	"document"
+];
+/**
+* Provenance axis. *Who is the framework willing to vouch for as the source of these bytes?*
+*
+* @remarks
+* Mirrors `RetrievableTrustTier` deliberately — same vocabulary, same question:
+* *did this content come from a place the agent should treat as authoritative?*
+*
+* - `'first-party'` — deployer-vetted bytes (tool output the operator authored, signed
+*   internal assets).
+* - `'third-party-public'` — open-web fetches, public APIs, public corpora.
+* - `'third-party-private'` — user uploads, partner APIs, private corpora.
+*/
+var MediaTrustTier = [
+	"first-party",
+	"third-party-public",
+	"third-party-private"
+];
+/**
+* Modality-hazard axis. *How dangerous is it to let the model decode these bytes?*
+*
+* @remarks
+* Orthogonal to provenance — a first-party trusted PDF can still carry hidden text layers; a
+* third-party-public raw image can still be encoded as opaque pixels with adversarial
+* perturbations.
+*
+* - `'inert'` — bytes the model never decodes as instructions (e.g. a handle that is never
+*   inlined into the prompt).
+* - `'extractable-instructions'` — text-bearing media: PDFs, screenshots with UI text, documents.
+*   Hazard is OCR / embedded-text-layer reads.
+* - `'opaque-perceptual'` — raw vision/audio/video the model encodes directly. Hazard is
+*   steganographic LSB prompts, adversarial perturbations, ultrasonic audio — invisible to any
+*   pre-screen.
+*
+* See `/the-loop/trust-tiers/media` and its research sub-page `/the-loop/trust-tiers/media/research`.
+*/
+var MediaModalityHazard = [
+	"inert",
+	"extractable-instructions",
+	"opaque-perceptual"
+];
+var stashEntrySchema = validator.object({
+	value: validator.any().required(),
+	trustTier: validator.string().valid(...MediaTrustTier).required(),
+	derivedFromMedia: validator.string().optional()
+}).unknown(false);
+/**
+* Validator schema used to validate a {@link RawMedia} before constructing a {@link Media}.
+*/
+var rawMediaSchema = validator.object({
+	id: validator.string().optional(),
+	kind: validator.string().valid(...MediaKind).required(),
+	mimeType: validator.string().required(),
+	filename: validator.string().required(),
+	reader: mediaReaderSchema.required(),
+	trustTier: validator.string().valid(...MediaTrustTier).required(),
+	modalityHazard: validator.string().valid(...MediaModalityHazard).required(),
+	source: validator.string().optional(),
+	stash: validator.object().pattern(validator.string(), stashEntrySchema).optional()
+});
+var conservativeHazardForKind = (kind) => {
+	return kind === "document" ? "extractable-instructions" : "opaque-perceptual";
+};
+/**
+* Cross-environment base64 encoder for a `Uint8Array`.
+*
+* @remarks
+* Prefers Node's `Buffer.from(buf).toString('base64')` when `globalThis.Buffer` exists; otherwise
+* chunk-encodes through `btoa` with a 0x8000-byte window to avoid `Maximum call stack size
+* exceeded` on large buffers.
+*/
+var encodeBase64 = (bytes) => {
+	const maybeBuffer = globalThis.Buffer;
+	if (maybeBuffer && typeof maybeBuffer.from === "function") return maybeBuffer.from(bytes).toString("base64");
+	const chunkSize = 32768;
+	let binary = "";
+	for (let i = 0; i < bytes.length; i += chunkSize) {
+		const chunk = bytes.subarray(i, i + chunkSize);
+		binary += String.fromCharCode.apply(null, Array.from(chunk));
+	}
+	return btoa(binary);
+};
+/**
+* Lazy, re-openable view over a binary asset (image, audio, video, document).
+*
+* @remarks
+* Dual-peer to {@link @nhtio/adk!Tokenizable} (silo) and {@link @nhtio/adk!SpooledArtifact}
+* (handle). Wraps a {@link @nhtio/adk!MediaReader} contract — the framework owns the contract, the
+* implementor owns the storage backend. Bytes are reached only through the reader; the primitive
+* itself never inlines bytes.
+*
+* Construction requires `trustTier` and `modalityHazard` — the framework refuses to guess
+* provenance or decoding hazard. Ergonomic factories ({@link Media.userAttachment},
+* {@link Media.toolGenerated}, {@link Media.retrievedPublic}, {@link Media.retrievedPrivate})
+* force the labelling decision at the call site without becoming defaults on the bare
+* constructor.
+*/
+var Media = class Media {
+	/**
+	* Validator schema that accepts a {@link RawMedia} object.
+	*/
+	static schema = rawMediaSchema;
+	/**
+	* The set of recognised media kinds. Exposed for downstream schemas that need to discriminate
+	* on `kind`.
+	*/
+	static MediaKind = MediaKind;
+	/**
+	* The set of recognised trust tiers.
+	*/
+	static MediaTrustTier = MediaTrustTier;
+	/**
+	* The set of recognised modality hazards.
+	*/
+	static MediaModalityHazard = MediaModalityHazard;
+	/**
+	* Returns `true` if `value` is a {@link Media} instance.
+	*
+	* @remarks
+	* Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety.
+	*
+	* @param value - The value to test.
+	* @returns `true` when `value` is a {@link Media} instance.
+	*/
+	static isMedia(value) {
+		return isInstanceOf(value, "Media", Media);
+	}
+	#id;
+	#kind;
+	#mimeType;
+	#filename;
+	#source;
+	#trustTier;
+	#modalityHazard;
+	#reader;
+	#stash;
+	/**
+	* @param raw - The raw media input validated against `rawMediaSchema`.
+	* @throws {@link @nhtio/adk/exceptions!E_INVALID_INITIAL_MEDIA_VALUE} when `raw` does not satisfy the schema.
+	* @throws {@link @nhtio/adk/exceptions!E_NOT_A_MEDIA_READER} when `raw.reader` does not implement {@link @nhtio/adk!MediaReader}.
+	*/
+	constructor(raw) {
+		let resolved;
+		try {
+			resolved = validateOrThrow(rawMediaSchema, raw, true);
+		} catch (err) {
+			throw new E_INVALID_INITIAL_MEDIA_VALUE({ cause: isError(err) ? err : void 0 });
+		}
+		if (!implementsMediaReader(resolved.reader)) throw new E_NOT_A_MEDIA_READER();
+		this.#id = resolved.id ?? v6();
+		this.#kind = resolved.kind;
+		this.#mimeType = resolved.mimeType;
+		this.#filename = resolved.filename;
+		this.#source = resolved.source;
+		this.#trustTier = resolved.trustTier;
+		this.#modalityHazard = resolved.modalityHazard;
+		this.#reader = resolved.reader;
+		this.#stash = new Registry(resolved.stash);
+		Object.defineProperties(this, {
+			id: {
+				get: () => this.#id,
+				enumerable: true,
+				configurable: false
+			},
+			kind: {
+				get: () => this.#kind,
+				enumerable: true,
+				configurable: false
+			},
+			mimeType: {
+				get: () => this.#mimeType,
+				enumerable: true,
+				configurable: false
+			},
+			filename: {
+				get: () => this.#filename,
+				enumerable: true,
+				configurable: false
+			},
+			source: {
+				get: () => this.#source,
+				enumerable: true,
+				configurable: false
+			},
+			trustTier: {
+				get: () => this.#trustTier,
+				enumerable: true,
+				configurable: false
+			},
+			modalityHazard: {
+				get: () => this.#modalityHazard,
+				enumerable: true,
+				configurable: false
+			},
+			stash: {
+				get: () => this.#stash,
+				enumerable: true,
+				configurable: false
+			}
+		});
+	}
+	/**
+	* Re-opens the underlying byte source and returns a fresh ReadableStream.
+	*
+	* @returns A drainable `ReadableStream` over the underlying bytes.
+	*/
+	async stream() {
+		return this.#reader.stream();
+	}
+	/**
+	* Returns the total number of bytes in the underlying data, or `undefined` if unknown.
+	*
+	* @returns The byte length, or `undefined` when the underlying source cannot report it.
+	*/
+	async byteLength() {
+		return this.#reader.byteLength();
+	}
+	/**
+	* Drains the reader's stream and returns the underlying bytes as a single `Uint8Array`.
+	*
+	* @remarks
+	* Convenience for callers that need the full buffer (e.g. inline base64 encoding). Forces
+	* full materialisation — large assets should be piped through {@link Media.stream} instead.
+	*/
+	async asBytes() {
+		const reader = (await this.stream()).getReader();
+		const chunks = [];
+		let total = 0;
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			if (value) {
+				chunks.push(value);
+				total += value.byteLength;
+			}
+		}
+		const out = new Uint8Array(total);
+		let offset = 0;
+		for (const chunk of chunks) {
+			out.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return out;
+	}
+	/**
+	* Drains the reader's stream and returns the underlying bytes as a base64 string.
+	*
+	* @remarks
+	* Cross-environment: prefers Node's `Buffer.from(buf).toString('base64')` when available;
+	* otherwise chunk-encodes through `btoa` with a 0x8000-byte window to avoid stack overflow
+	* on large buffers.
+	*/
+	async asBase64() {
+		return encodeBase64(await this.asBytes());
+	}
+	/**
+	* Returns the metadata-only serialisation of this Media. Bytes and the reader are stripped
+	* so naive event/log serialisation never materialises bytes.
+	*
+	* @remarks
+	* Implementations that have cheap, already-cached `byteLength` may opt to include it; this
+	* default implementation omits it to preserve the "lazy by default" invariant. Consumers that
+	* need byteLength on the serialised payload should call `await media.byteLength()` and merge
+	* the result.
+	*/
+	toJSON() {
+		return {
+			id: this.#id,
+			kind: this.#kind,
+			mimeType: this.#mimeType,
+			filename: this.#filename,
+			source: this.#source,
+			trustTier: this.#trustTier,
+			modalityHazard: this.#modalityHazard,
+			stash: this.#stash.all()
+		};
+	}
+	/**
+	* Factory: constructs a {@link Media} representing a user-supplied attachment.
+	*
+	* @remarks
+	* Pre-fills `trustTier: 'third-party-private'` and derives `modalityHazard` from `kind`
+	* (`document` → `'extractable-instructions'`; everything else → `'opaque-perceptual'`).
+	* Use the bare constructor when the conservative kind→hazard mapping is wrong for your case.
+	*/
+	static userAttachment(args) {
+		return new Media({
+			...args,
+			trustTier: "third-party-private",
+			modalityHazard: conservativeHazardForKind(args.kind)
+		});
+	}
+	/**
+	* Factory: constructs a {@link Media} produced by a first-party tool.
+	*
+	* @remarks
+	* Pre-fills `trustTier: 'first-party'` and derives `modalityHazard` from `kind`.
+	*/
+	static toolGenerated(args) {
+		return new Media({
+			...args,
+			trustTier: "first-party",
+			modalityHazard: conservativeHazardForKind(args.kind)
+		});
+	}
+	/**
+	* Factory: constructs a {@link Media} retrieved from a public third-party source.
+	*
+	* @remarks
+	* Pre-fills `trustTier: 'third-party-public'` and derives `modalityHazard` from `kind`.
+	*/
+	static retrievedPublic(args) {
+		return new Media({
+			...args,
+			trustTier: "third-party-public",
+			modalityHazard: conservativeHazardForKind(args.kind)
+		});
+	}
+	/**
+	* Factory: constructs a {@link Media} retrieved from a private third-party source.
+	*
+	* @remarks
+	* Pre-fills `trustTier: 'third-party-private'` and derives `modalityHazard` from `kind`.
+	*/
+	static retrievedPrivate(args) {
+		return new Media({
+			...args,
+			trustTier: "third-party-private",
+			modalityHazard: conservativeHazardForKind(args.kind)
+		});
+	}
+};
+/**
+* Returns `true` if `value` is a {@link Media} instance.
+*
+* @remarks
+* Module-level convenience alias for {@link Media.isMedia}. Uses {@link @nhtio/adk!isInstanceOf} for
+* cross-realm safety.
+*/
+var isMedia = (value) => {
+	return isInstanceOf(value, "Media", Media);
+};
+//#endregion
+//#region src/lib/classes/tool_call.ts
+var isToolCallResults = (value) => {
+	if (Tokenizable.isTokenizable(value)) return true;
+	if (SpooledArtifact.isSpooledArtifact(value)) return true;
+	if (Media.isMedia(value)) return true;
+	if (Array.isArray(value) && value.length > 0) {
+		if (value.every((entry) => Media.isMedia(entry))) return true;
+		if (value.every((entry) => SpooledArtifact.isSpooledArtifact(entry))) return true;
+	}
+	return false;
+};
+/**
+* Validator schema used to validate a {@link RawToolCall} before constructing a {@link ToolCall}.
+*
+* @remarks
+* Validates all fields of {@link RawToolCall}:
+* - `id` — required non-empty string.
+* - `tool` — required non-empty string.
+* - `args` — required; either a plain object or a JSON string that deserialises to an object.
+*   Strings are parsed and the resulting object is stored.
+* - `checksum` — required string.
+* - `isComplete` — required boolean.
+* - `isError` — required boolean.
+* - `results` — required; one of {@link @nhtio/adk!Tokenizable}, {@link @nhtio/adk!SpooledArtifact}, a non-empty
+*   `SpooledArtifact[]`, {@link @nhtio/adk!Media}, or a non-empty `Media[]`. Arrays must be homogeneous.
+* - `createdAt` / `updatedAt` / `completedAt` — required datetime-parseable values, normalised to `DateTime`.
+*
+* Throws {@link @nhtio/adk!E_INVALID_INITIAL_TOOL_CALL_VALUE} (via the {@link ToolCall} constructor) when
+* validation fails.
+*/
+var rawToolCallSchema = validator.object({
+	id: validator.string().required(),
+	tool: validator.string().required(),
+	args: validator.alternatives(validator.object().unknown(true), validator.string().custom((value, helpers) => {
+		try {
+			const parsed = JSON.parse(value);
+			if (!isObject(parsed)) return helpers.error("any.invalid");
+			return parsed;
+		} catch {
+			return helpers.error("any.invalid");
+		}
+	})).required(),
+	checksum: validator.string().required(),
+	isComplete: validator.boolean().required(),
+	isError: validator.boolean().required(),
+	results: validator.any().custom((value, helpers) => {
+		if (isToolCallResults(value)) return value;
+		return helpers.error("any.invalid");
+	}).required(),
+	fromArtifactTool: validator.boolean().default(false),
+	inline: validator.boolean().default(true),
+	createdAt: validator.datetime().required(),
+	updatedAt: validator.datetime().required(),
+	completedAt: validator.datetime().required()
+});
+/**
+* An immutable, validated tool call record associated with a turn.
+*
+* @remarks
+* Represents a completed tool invocation from the conversation history — `results`,
+* `completedAt`, `isComplete`, and `isError` are all present and required.
+* Temporal fields are normalised to Luxon `DateTime` instances at construction time.
+*/
+var ToolCall = class ToolCall {
+	/**
+	* Validator schema that accepts a {@link RawToolCall} object.
+	*
+	* @remarks
+	* Reusable fragment for any schema that needs to validate or nest a tool call entry.
+	*/
+	static schema = rawToolCallSchema;
+	/**
+	* Returns `true` if `value` is a {@link ToolCall} instance.
+	*
+	* @remarks
+	* Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety — `instanceof` would fail for instances
+	* created in a different module copy or VM context.
+	*
+	* @param value - The value to test.
+	* @returns `true` when `value` is a {@link ToolCall} instance.
+	*/
+	static isToolCall(value) {
+		return isInstanceOf(value, "ToolCall", ToolCall);
+	}
+	#id;
+	#tool;
+	#args;
+	#checksum;
+	#isComplete;
+	#isError;
+	#results;
+	#fromArtifactTool;
+	#inline;
+	#createdAt;
+	#updatedAt;
+	#completedAt;
+	/**
+	* @param raw - The raw tool call input validated against `rawToolCallSchema`.
+	* @throws {@link @nhtio/adk!E_INVALID_INITIAL_TOOL_CALL_VALUE} when `raw` does not satisfy the schema.
+	*/
+	constructor(raw) {
+		let resolved;
+		try {
+			resolved = validateOrThrow(rawToolCallSchema, raw, true);
+		} catch (err) {
+			throw new E_INVALID_INITIAL_TOOL_CALL_VALUE({ cause: isError(err) ? err : void 0 });
+		}
+		this.#id = resolved.id;
+		this.#tool = resolved.tool;
+		this.#args = resolved.args;
+		this.#checksum = resolved.checksum;
+		this.#isComplete = resolved.isComplete;
+		this.#isError = resolved.isError;
+		this.#results = resolved.results;
+		this.#fromArtifactTool = resolved.fromArtifactTool;
+		this.#inline = resolved.inline;
+		this.#createdAt = resolved.createdAt;
+		this.#updatedAt = resolved.updatedAt;
+		this.#completedAt = resolved.completedAt;
+		Object.defineProperties(this, {
+			id: {
+				get: () => this.#id,
+				enumerable: true,
+				configurable: false
+			},
+			tool: {
+				get: () => this.#tool,
+				enumerable: true,
+				configurable: false
+			},
+			args: {
+				get: () => this.#args,
+				enumerable: true,
+				configurable: false
+			},
+			checksum: {
+				get: () => this.#checksum,
+				enumerable: true,
+				configurable: false
+			},
+			isComplete: {
+				get: () => this.#isComplete,
+				enumerable: true,
+				configurable: false
+			},
+			isError: {
+				get: () => this.#isError,
+				enumerable: true,
+				configurable: false
+			},
+			results: {
+				get: () => this.#results,
+				enumerable: true,
+				configurable: false
+			},
+			fromArtifactTool: {
+				get: () => this.#fromArtifactTool,
+				enumerable: true,
+				configurable: false
+			},
+			inline: {
+				get: () => this.#inline,
+				enumerable: true,
+				configurable: false
+			},
+			createdAt: {
+				get: () => this.#createdAt,
+				enumerable: true,
+				configurable: false
+			},
+			updatedAt: {
+				get: () => this.#updatedAt,
+				enumerable: true,
+				configurable: false
+			},
+			completedAt: {
+				get: () => this.#completedAt,
+				enumerable: true,
+				configurable: false
+			}
+		});
+	}
+};
+//#endregion
+export { mediaReaderSchema as a, implementsMediaReader as i, Media as n, isMedia as r, ToolCall as t };
+
+//# sourceMappingURL=tool_call-BKyyxGaZ.mjs.map

package/tool_call-BKyyxGaZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_call-BKyyxGaZ.mjs","names":["#id","#kind","#mimeType","#filename","#source","#trustTier","#modalityHazard","#reader","#stash","#id","#tool","#args","#checksum","#isComplete","#isError","#results","#fromArtifactTool","#inline","#createdAt","#updatedAt","#completedAt"],"sources":["../src/lib/contracts/media_reader.ts","../src/lib/classes/media.ts","../src/lib/classes/tool_call.ts"],"sourcesContent":["import { validator } from '@nhtio/validation'\nimport { passesSchema } from '../utils/validation'\n\n/**\n * Re-openable byte source contract for a Media instance.\n *\n * @remarks\n * Peer to {@link @nhtio/adk!SpoolReader} but tuned for binary streaming rather than line-indexed text.\n * Each `stream()` call must return a fresh, drainable `ReadableStream` over the same underlying\n * bytes — implementations model replay: in-memory readers reconstitute the stream from the\n * buffer, file-backed readers reopen the file handle, HTTP-backed readers re-issue the fetch,\n * cloud blob readers re-issue the GET. The implementor owns the storage and the cost of keeping\n * the underlying source addressable. Implementors whose underlying source is genuinely\n * non-replayable (a raw HTTP body they were handed once) are responsible for caching locally\n * before constructing the Media.\n *\n * Both methods may be synchronous or asynchronous to accommodate both in-memory and I/O-backed\n * implementations without forcing unnecessary promise overhead on simple cases.\n */\nexport interface MediaReader {\n  /**\n   * Re-opens the underlying byte source and returns a fresh ReadableStream.\n   *\n   * @remarks\n   * Each call yields a new, drainable stream over the same bytes. Render code that needs the\n   * full buffer (e.g. base64-encoding an inline image_url) drains the stream; render code that\n   * can forward the stream (e.g. multipart upload) passes the stream through without buffering.\n   *\n   * @returns A drainable ReadableStream of Uint8Array chunks over the underlying bytes.\n   */\n  stream(): ReadableStream<Uint8Array> | Promise<ReadableStream<Uint8Array>>\n\n  /**\n   * Returns the total number of bytes in the underlying data, or `undefined` if unknown.\n   *\n   * @remarks\n   * Used for telemetry, budget checks, and pre-flight provider size validation without forcing\n   * a stream drain. Sources of unknown length may return `undefined` — absence is treated as\n   * \"unknown\", not \"zero\".\n   *\n   * @returns The byte length of the underlying data, or `undefined` when unknown.\n   */\n  byteLength(): number | undefined | Promise<number | undefined>\n}\n\n/**\n * Validator schema used to validate a MediaReader value.\n *\n * @remarks\n * Because MediaReader is a structural interface with no associated constructor, validation is\n * duck-typed: the value must be an object, class instance, or function with `stream` and\n * `byteLength` present as callable properties. Arity is not enforced.\n */\nexport const mediaReaderSchema = validator\n  .any()\n  .required()\n  .custom((value, helpers) => {\n    if (\n      value !== null &&\n      value !== undefined &&\n      typeof (value as any).stream === 'function' &&\n      typeof (value as any).byteLength === 'function'\n    ) {\n      return value as MediaReader\n    }\n    return helpers.error('any.invalid')\n  })\n\n/**\n * Returns `true` if `value` implements the MediaReader interface.\n *\n * @remarks\n * Duck-typed: checks that `value` is non-null with `stream` and `byteLength` as callable\n * functions. Does not use `instanceof` — there is no MediaReader constructor.\n *\n * @param value - The value to test.\n * @returns `true` when `value` conforms to the MediaReader interface.\n */\nexport const implementsMediaReader = (value: unknown): value is MediaReader => {\n  return passesSchema(mediaReaderSchema, value)\n}\n","import { v6 as uuidv6 } from 'uuid'\nimport { Registry } from './registry'\nimport { isError } from '../utils/guards'\nimport { validator } from '@nhtio/validation'\nimport { isInstanceOf } from '../utils/guards'\nimport { validateOrThrow } from '../utils/validation'\nimport { implementsMediaReader, mediaReaderSchema } from '../contracts/media_reader'\nimport { E_INVALID_INITIAL_MEDIA_VALUE, E_NOT_A_MEDIA_READER } from '../exceptions/runtime'\nimport type { MediaReader } from '../contracts/media_reader'\n\n/**\n * The set of supported media kinds.\n *\n * @remarks\n * Modality coverage is asymmetric across providers. The framework defines no\n * `supportedModalities` field — how a battery handles a modality it cannot natively render is\n * the battery author's call (see `unsupportedMediaPolicy` on the OpenAI Chat Completions\n * battery).\n */\nexport const MediaKind = ['image', 'audio', 'video', 'document'] as const\n\n/**\n * Union of all recognised media kind identifier strings.\n */\nexport type MediaKind = (typeof MediaKind)[number]\n\n/**\n * Provenance axis. *Who is the framework willing to vouch for as the source of these bytes?*\n *\n * @remarks\n * Mirrors `RetrievableTrustTier` deliberately — same vocabulary, same question:\n * *did this content come from a place the agent should treat as authoritative?*\n *\n * - `'first-party'` — deployer-vetted bytes (tool output the operator authored, signed\n *   internal assets).\n * - `'third-party-public'` — open-web fetches, public APIs, public corpora.\n * - `'third-party-private'` — user uploads, partner APIs, private corpora.\n */\nexport const MediaTrustTier = ['first-party', 'third-party-public', 'third-party-private'] as const\nexport type MediaTrustTier = (typeof MediaTrustTier)[number]\n\n/**\n * Modality-hazard axis. *How dangerous is it to let the model decode these bytes?*\n *\n * @remarks\n * Orthogonal to provenance — a first-party trusted PDF can still carry hidden text layers; a\n * third-party-public raw image can still be encoded as opaque pixels with adversarial\n * perturbations.\n *\n * - `'inert'` — bytes the model never decodes as instructions (e.g. a handle that is never\n *   inlined into the prompt).\n * - `'extractable-instructions'` — text-bearing media: PDFs, screenshots with UI text, documents.\n *   Hazard is OCR / embedded-text-layer reads.\n * - `'opaque-perceptual'` — raw vision/audio/video the model encodes directly. Hazard is\n *   steganographic LSB prompts, adversarial perturbations, ultrasonic audio — invisible to any\n *   pre-screen.\n *\n * See `/the-loop/trust-tiers/media` and its research sub-page `/the-loop/trust-tiers/media/research`.\n */\nexport const MediaModalityHazard = [\n  'inert',\n  'extractable-instructions',\n  'opaque-perceptual',\n] as const\nexport type MediaModalityHazard = (typeof MediaModalityHazard)[number]\n\n/**\n * Per-entry shape stored in a {@link Media}'s `stash` register.\n *\n * @remarks\n * Each entry carries its own trust tier so render code can route derived text (OCR, captions,\n * transcripts) through its own envelope independent of the parent media. How a battery or\n * middleware assigns those entry-level tiers is the implementor's call — the primitive contract\n * does not enforce a \"downgrade derived interpretation from possibly-adversarial bytes\" policy.\n */\nexport interface MediaStashEntry {\n  /** The value of the entry — any serialisable shape the consumer wants to store. */\n  value: unknown\n  /** Trust tier for this specific entry; routed independently of the parent media. */\n  trustTier: MediaTrustTier\n  /** Optional pointer to the parent Media id this entry was derived from. */\n  derivedFromMedia?: string\n}\n\n/**\n * Plain input object supplied to {@link Media} at construction time.\n *\n * @remarks\n * Validated against `rawMediaSchema` before the `Media` instance is created.\n */\nexport interface RawMedia {\n  /**\n   * Stable unique identifier for this media instance. Required for strict symmetry with\n   * `Message.id` and `ToolCall.id`. When omitted, a fresh UUIDv6 is assigned at construction\n   * time.\n   */\n  id?: string\n  /** The media kind. See {@link MediaKind}. */\n  kind: MediaKind\n  /** The MIME type of the underlying bytes. */\n  mimeType: string\n  /** Filename used by providers that key on it (e.g. OpenAI `file.filename`). */\n  filename: string\n  /** Re-openable byte source. See {@link @nhtio/adk!MediaReader}. */\n  reader: MediaReader\n  /**\n   * Trust tier declared at construction time. Required — there is NO default.\n   * See {@link MediaTrustTier}.\n   */\n  trustTier: MediaTrustTier\n  /**\n   * Modality hazard declared at construction time. Required — there is NO default.\n   * See {@link MediaModalityHazard}.\n   */\n  modalityHazard: MediaModalityHazard\n  /** Optional provenance pointer (URL, tool name, etc.) for audit / events. */\n  source?: string\n  /**\n   * Free-form per-instance metadata register. Middleware pipelines append to this — typically\n   * with a text description, transcript, caption, or alt-text — so downstream code that cannot\n   * consume the media natively has a model-readable fallback. No keys are reserved by the\n   * framework. Defaults to `{}`.\n   */\n  stash?: Record<string, MediaStashEntry>\n}\n\nconst stashEntrySchema = validator\n  .object<MediaStashEntry>({\n    value: validator.any().required(),\n    trustTier: validator\n      .string()\n      .valid(...MediaTrustTier)\n      .required(),\n    derivedFromMedia: validator.string().optional(),\n  })\n  .unknown(false)\n\n/**\n * Validator schema used to validate a {@link RawMedia} before constructing a {@link Media}.\n */\nconst rawMediaSchema = validator.object<RawMedia>({\n  id: validator.string().optional(),\n  kind: validator\n    .string()\n    .valid(...MediaKind)\n    .required(),\n  mimeType: validator.string().required(),\n  filename: validator.string().required(),\n  reader: mediaReaderSchema.required(),\n  trustTier: validator\n    .string()\n    .valid(...MediaTrustTier)\n    .required(),\n  modalityHazard: validator\n    .string()\n    .valid(...MediaModalityHazard)\n    .required(),\n  source: validator.string().optional(),\n  stash: validator.object().pattern(validator.string(), stashEntrySchema).optional(),\n})\n\ninterface ResolvedMedia {\n  id?: string\n  kind: MediaKind\n  mimeType: string\n  filename: string\n  reader: MediaReader\n  trustTier: MediaTrustTier\n  modalityHazard: MediaModalityHazard\n  source?: string\n  stash?: Record<string, MediaStashEntry>\n}\n\nconst conservativeHazardForKind = (kind: MediaKind): MediaModalityHazard => {\n  return kind === 'document' ? 'extractable-instructions' : 'opaque-perceptual'\n}\n\n/**\n * Shape returned by {@link Media.toJSON}. Metadata-only — bytes and the reader are stripped so\n * naive event/log serialisation never materialises bytes.\n */\nexport interface SerializedMedia {\n  id: string\n  kind: MediaKind\n  mimeType: string\n  filename: string\n  source?: string\n  trustTier: MediaTrustTier\n  modalityHazard: MediaModalityHazard\n  stash: Record<string, MediaStashEntry>\n  byteLength?: number\n}\n\n/**\n * Cross-environment base64 encoder for a `Uint8Array`.\n *\n * @remarks\n * Prefers Node's `Buffer.from(buf).toString('base64')` when `globalThis.Buffer` exists; otherwise\n * chunk-encodes through `btoa` with a 0x8000-byte window to avoid `Maximum call stack size\n * exceeded` on large buffers.\n */\nconst encodeBase64 = (bytes: Uint8Array): string => {\n  const maybeBuffer = (\n    globalThis as { Buffer?: { from(b: Uint8Array): { toString(enc: string): string } } }\n  ).Buffer\n  if (maybeBuffer && typeof maybeBuffer.from === 'function') {\n    return maybeBuffer.from(bytes).toString('base64')\n  }\n  const chunkSize = 0x8000\n  let binary = ''\n  for (let i = 0; i < bytes.length; i += chunkSize) {\n    const chunk = bytes.subarray(i, i + chunkSize)\n    binary += String.fromCharCode.apply(null, Array.from(chunk) as number[])\n  }\n  return btoa(binary)\n}\n\n/**\n * Lazy, re-openable view over a binary asset (image, audio, video, document).\n *\n * @remarks\n * Dual-peer to {@link @nhtio/adk!Tokenizable} (silo) and {@link @nhtio/adk!SpooledArtifact}\n * (handle). Wraps a {@link @nhtio/adk!MediaReader} contract — the framework owns the contract, the\n * implementor owns the storage backend. Bytes are reached only through the reader; the primitive\n * itself never inlines bytes.\n *\n * Construction requires `trustTier` and `modalityHazard` — the framework refuses to guess\n * provenance or decoding hazard. Ergonomic factories ({@link Media.userAttachment},\n * {@link Media.toolGenerated}, {@link Media.retrievedPublic}, {@link Media.retrievedPrivate})\n * force the labelling decision at the call site without becoming defaults on the bare\n * constructor.\n */\nexport class Media {\n  /**\n   * Validator schema that accepts a {@link RawMedia} object.\n   */\n  public static schema = rawMediaSchema\n\n  /**\n   * The set of recognised media kinds. Exposed for downstream schemas that need to discriminate\n   * on `kind`.\n   */\n  public static MediaKind = MediaKind\n\n  /**\n   * The set of recognised trust tiers.\n   */\n  public static MediaTrustTier = MediaTrustTier\n\n  /**\n   * The set of recognised modality hazards.\n   */\n  public static MediaModalityHazard = MediaModalityHazard\n\n  /**\n   * Returns `true` if `value` is a {@link Media} instance.\n   *\n   * @remarks\n   * Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety.\n   *\n   * @param value - The value to test.\n   * @returns `true` when `value` is a {@link Media} instance.\n   */\n  public static isMedia(value: unknown): value is Media {\n    return isInstanceOf(value, 'Media', Media)\n  }\n\n  /** Stable unique identifier. */\n  declare readonly id: string\n  /** Media kind. */\n  declare readonly kind: MediaKind\n  /** MIME type of the underlying bytes. */\n  declare readonly mimeType: string\n  /** Filename surfaced to providers that key on it. */\n  declare readonly filename: string\n  /** Optional provenance pointer. */\n  declare readonly source: string | undefined\n  /** Trust tier declared at construction time. */\n  declare readonly trustTier: MediaTrustTier\n  /** Modality hazard declared at construction time. */\n  declare readonly modalityHazard: MediaModalityHazard\n  /** Mutable per-instance metadata register; middleware pipelines append to this. */\n  declare readonly stash: Registry\n\n  #id: string\n  #kind: MediaKind\n  #mimeType: string\n  #filename: string\n  #source?: string\n  #trustTier: MediaTrustTier\n  #modalityHazard: MediaModalityHazard\n  #reader: MediaReader\n  #stash: Registry\n\n  /**\n   * @param raw - The raw media input validated against `rawMediaSchema`.\n   * @throws {@link @nhtio/adk/exceptions!E_INVALID_INITIAL_MEDIA_VALUE} when `raw` does not satisfy the schema.\n   * @throws {@link @nhtio/adk/exceptions!E_NOT_A_MEDIA_READER} when `raw.reader` does not implement {@link @nhtio/adk!MediaReader}.\n   */\n  constructor(raw: RawMedia) {\n    let resolved: ResolvedMedia\n    try {\n      resolved = validateOrThrow<ResolvedMedia>(rawMediaSchema, raw, true)\n    } catch (err) {\n      throw new E_INVALID_INITIAL_MEDIA_VALUE({ cause: isError(err) ? err : undefined })\n    }\n    if (!implementsMediaReader(resolved.reader)) {\n      throw new E_NOT_A_MEDIA_READER()\n    }\n    this.#id = resolved.id ?? uuidv6()\n    this.#kind = resolved.kind\n    this.#mimeType = resolved.mimeType\n    this.#filename = resolved.filename\n    this.#source = resolved.source\n    this.#trustTier = resolved.trustTier\n    this.#modalityHazard = resolved.modalityHazard\n    this.#reader = resolved.reader\n    this.#stash = new Registry(resolved.stash as Record<string, unknown> | undefined)\n\n    Object.defineProperties(this, {\n      id: {\n        get: () => this.#id,\n        enumerable: true,\n        configurable: false,\n      },\n      kind: {\n        get: () => this.#kind,\n        enumerable: true,\n        configurable: false,\n      },\n      mimeType: {\n        get: () => this.#mimeType,\n        enumerable: true,\n        configurable: false,\n      },\n      filename: {\n        get: () => this.#filename,\n        enumerable: true,\n        configurable: false,\n      },\n      source: {\n        get: () => this.#source,\n        enumerable: true,\n        configurable: false,\n      },\n      trustTier: {\n        get: () => this.#trustTier,\n        enumerable: true,\n        configurable: false,\n      },\n      modalityHazard: {\n        get: () => this.#modalityHazard,\n        enumerable: true,\n        configurable: false,\n      },\n      stash: {\n        get: () => this.#stash,\n        enumerable: true,\n        configurable: false,\n      },\n    })\n  }\n\n  /**\n   * Re-opens the underlying byte source and returns a fresh ReadableStream.\n   *\n   * @returns A drainable `ReadableStream` over the underlying bytes.\n   */\n  async stream(): Promise<ReadableStream<Uint8Array>> {\n    return this.#reader.stream()\n  }\n\n  /**\n   * Returns the total number of bytes in the underlying data, or `undefined` if unknown.\n   *\n   * @returns The byte length, or `undefined` when the underlying source cannot report it.\n   */\n  async byteLength(): Promise<number | undefined> {\n    return this.#reader.byteLength()\n  }\n\n  /**\n   * Drains the reader's stream and returns the underlying bytes as a single `Uint8Array`.\n   *\n   * @remarks\n   * Convenience for callers that need the full buffer (e.g. inline base64 encoding). Forces\n   * full materialisation — large assets should be piped through {@link Media.stream} instead.\n   */\n  async asBytes(): Promise<Uint8Array> {\n    const stream = await this.stream()\n    const reader = stream.getReader()\n    const chunks: Uint8Array[] = []\n    let total = 0\n    while (true) {\n      const { value, done } = await reader.read()\n      if (done) break\n      if (value) {\n        chunks.push(value)\n        total += value.byteLength\n      }\n    }\n    const out = new Uint8Array(total)\n    let offset = 0\n    for (const chunk of chunks) {\n      out.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n    return out\n  }\n\n  /**\n   * Drains the reader's stream and returns the underlying bytes as a base64 string.\n   *\n   * @remarks\n   * Cross-environment: prefers Node's `Buffer.from(buf).toString('base64')` when available;\n   * otherwise chunk-encodes through `btoa` with a 0x8000-byte window to avoid stack overflow\n   * on large buffers.\n   */\n  async asBase64(): Promise<string> {\n    const bytes = await this.asBytes()\n    return encodeBase64(bytes)\n  }\n\n  /**\n   * Returns the metadata-only serialisation of this Media. Bytes and the reader are stripped\n   * so naive event/log serialisation never materialises bytes.\n   *\n   * @remarks\n   * Implementations that have cheap, already-cached `byteLength` may opt to include it; this\n   * default implementation omits it to preserve the \"lazy by default\" invariant. Consumers that\n   * need byteLength on the serialised payload should call `await media.byteLength()` and merge\n   * the result.\n   */\n  toJSON(): SerializedMedia {\n    return {\n      id: this.#id,\n      kind: this.#kind,\n      mimeType: this.#mimeType,\n      filename: this.#filename,\n      source: this.#source,\n      trustTier: this.#trustTier,\n      modalityHazard: this.#modalityHazard,\n      stash: this.#stash.all() as Record<string, MediaStashEntry>,\n    }\n  }\n\n  /**\n   * Factory: constructs a {@link Media} representing a user-supplied attachment.\n   *\n   * @remarks\n   * Pre-fills `trustTier: 'third-party-private'` and derives `modalityHazard` from `kind`\n   * (`document` → `'extractable-instructions'`; everything else → `'opaque-perceptual'`).\n   * Use the bare constructor when the conservative kind→hazard mapping is wrong for your case.\n   */\n  public static userAttachment(args: {\n    id?: string\n    kind: MediaKind\n    mimeType: string\n    filename: string\n    reader: MediaReader\n    source?: string\n    stash?: Record<string, MediaStashEntry>\n  }): Media {\n    return new Media({\n      ...args,\n      trustTier: 'third-party-private',\n      modalityHazard: conservativeHazardForKind(args.kind),\n    })\n  }\n\n  /**\n   * Factory: constructs a {@link Media} produced by a first-party tool.\n   *\n   * @remarks\n   * Pre-fills `trustTier: 'first-party'` and derives `modalityHazard` from `kind`.\n   */\n  public static toolGenerated(args: {\n    id?: string\n    kind: MediaKind\n    mimeType: string\n    filename: string\n    reader: MediaReader\n    source?: string\n    stash?: Record<string, MediaStashEntry>\n  }): Media {\n    return new Media({\n      ...args,\n      trustTier: 'first-party',\n      modalityHazard: conservativeHazardForKind(args.kind),\n    })\n  }\n\n  /**\n   * Factory: constructs a {@link Media} retrieved from a public third-party source.\n   *\n   * @remarks\n   * Pre-fills `trustTier: 'third-party-public'` and derives `modalityHazard` from `kind`.\n   */\n  public static retrievedPublic(args: {\n    id?: string\n    kind: MediaKind\n    mimeType: string\n    filename: string\n    reader: MediaReader\n    source?: string\n    stash?: Record<string, MediaStashEntry>\n  }): Media {\n    return new Media({\n      ...args,\n      trustTier: 'third-party-public',\n      modalityHazard: conservativeHazardForKind(args.kind),\n    })\n  }\n\n  /**\n   * Factory: constructs a {@link Media} retrieved from a private third-party source.\n   *\n   * @remarks\n   * Pre-fills `trustTier: 'third-party-private'` and derives `modalityHazard` from `kind`.\n   */\n  public static retrievedPrivate(args: {\n    id?: string\n    kind: MediaKind\n    mimeType: string\n    filename: string\n    reader: MediaReader\n    source?: string\n    stash?: Record<string, MediaStashEntry>\n  }): Media {\n    return new Media({\n      ...args,\n      trustTier: 'third-party-private',\n      modalityHazard: conservativeHazardForKind(args.kind),\n    })\n  }\n}\n\n/**\n * Returns `true` if `value` is a {@link Media} instance.\n *\n * @remarks\n * Module-level convenience alias for {@link Media.isMedia}. Uses {@link @nhtio/adk!isInstanceOf} for\n * cross-realm safety.\n */\nexport const isMedia = (value: unknown): value is Media => {\n  return isInstanceOf(value, 'Media', Media)\n}\n","import { Media } from './media'\nimport { Tokenizable } from './tokenizable'\nimport { validator } from '@nhtio/validation'\nimport { SpooledArtifact } from './spooled_artifact'\nimport { validateOrThrow } from '../utils/validation'\nimport { isObject, isInstanceOf, isError } from '../utils/guards'\nimport { E_INVALID_INITIAL_TOOL_CALL_VALUE } from '../exceptions/runtime'\nimport type { DateTime } from 'luxon'\n\n/**\n * Union of every shape a {@link ToolCall.results} field may carry.\n *\n * @remarks\n * Three silos with distinct render-time semantics:\n *\n * - {@link @nhtio/adk!Tokenizable} — always singular. The {@link @nhtio/adk!ArtifactTool}\n *   carve-out: a model-visible text answer that explicitly opts out of artifact wrapping to\n *   break the recursive grep-on-the-grep-result loop.\n * - {@link @nhtio/adk!SpooledArtifact} or `SpooledArtifact[]` — bounded text output spooled to durable\n *   storage. A single tool call may legitimately produce multiple artifacts (e.g. one tool\n *   that returns N PR bodies). LLM adapters render either inline (full body in trust envelope)\n *   or as a handle reference (forged artifact-query tools).\n * - {@link @nhtio/adk!Media} or `Media[]` — binary modality output (image, audio, video, document).\n *   Adapters render as provider-specific content blocks (`image_url`, `input_audio`, `file`,\n *   etc.). Bytes are lazy — reached only through {@link @nhtio/adk!Media.stream}.\n */\nexport type ToolCallResults = Tokenizable | SpooledArtifact | SpooledArtifact[] | Media | Media[]\n\nconst isToolCallResults = (value: unknown): value is ToolCallResults => {\n  if (Tokenizable.isTokenizable(value)) return true\n  if (SpooledArtifact.isSpooledArtifact(value)) return true\n  if (Media.isMedia(value)) return true\n  if (Array.isArray(value) && value.length > 0) {\n    const allMedia = value.every((entry) => Media.isMedia(entry))\n    if (allMedia) return true\n    const allSpooled = value.every((entry) => SpooledArtifact.isSpooledArtifact(entry))\n    if (allSpooled) return true\n  }\n  return false\n}\n\n/**\n * Plain input object supplied to {@link ToolCall} at construction time.\n *\n * @remarks\n * Validated against `rawToolCallSchema` before the `ToolCall` instance is created.\n * Temporal fields accept any value that Luxon can parse — ISO strings, Unix timestamps,\n * `Date` objects, or existing `DateTime` instances.\n */\nexport interface RawToolCall {\n  /** Stable unique identifier for this tool call; correlates the request with its result. */\n  id: string\n  /** Name of the tool the model has requested. */\n  tool: string\n  /**\n   * Arguments the model supplied for this tool call.\n   *\n   * @remarks\n   * Accepts either a plain object or a JSON-encoded string that deserialises to an object.\n   * Always exposed as a plain object on the constructed {@link ToolCall} instance.\n   */\n  args: string | Record<string, unknown>\n  /** Integrity checksum over `tool` and `args`; can be used to detect tampering before execution. */\n  checksum: string\n  /** `true` once the tool call has finished (successfully or not). */\n  isComplete: boolean\n  /** `true` when the tool execution produced an error; inspect `results` for detail. */\n  isError: boolean\n  /**\n   * Result returned by the tool, or error detail when `isError` is `true`.\n   *\n   * @remarks\n   * Three silos with distinct render-time semantics — see {@link ToolCallResults}:\n   *\n   * - For a normal {@link @nhtio/adk!Tool} call whose handler returned `string` or\n   *   `Uint8Array`, this is a {@link @nhtio/adk!SpooledArtifact} (or one of its subclasses) wrapping the\n   *   spooled bytes. Tools that legitimately produce multiple bounded artifacts may return\n   *   a `SpooledArtifact[]`.\n   * - For a `Tool` call whose handler returned a {@link @nhtio/adk!Media} or `Media[]`, this is the same\n   *   media handle(s) — the explicit-modality silo bypasses `SpooledArtifact` wrapping because\n   *   the bytes are binary and rendered as provider-specific content blocks, not text.\n   * - For an {@link @nhtio/adk!ArtifactTool} call (a forged artifact-query tool),\n   *   this is a {@link @nhtio/adk!Tokenizable} holding the raw model-visible answer — `ArtifactTool`\n   *   explicitly opts out of wrapping to break the recursive grep-on-the-grep-result loop.\n   *\n   * The ADK sets {@link RawToolCall.fromArtifactTool} on calls produced by an\n   * `ArtifactTool` so subsequent `forgeTools(ctx)` invocations can filter them out of the\n   * `callId` enum.\n   */\n  results: ToolCallResults\n  /**\n   * `true` when this tool call originated from an {@link @nhtio/adk!ArtifactTool}\n   * invocation. Defaults to `false`.\n   *\n   * @remarks\n   * Set by the ADK's result-wrapping touch sites when `ArtifactTool.isArtifactTool(tool)`\n   * holds. Read by `SpooledArtifact.forgeTools(ctx)` when building each descriptor's `callId`\n   * enum — calls with this flag set are excluded so the model can't `artifact_grep` on a\n   * previous `artifact_grep` result. Optional in the raw shape (defaults to `false`); always\n   * defined on the constructed {@link ToolCall}.\n   *\n   * @defaultValue `false`\n   */\n  fromArtifactTool?: boolean\n  /**\n   * When `true` (default), LLM adapters render this tool call's result inline — the full\n   * stringified body is wrapped in the adapter's trust envelope and sent to the model as the\n   * `tool` role content. When `false`, the adapter surfaces the result as a \"handle\" — a\n   * directions-bearing envelope that tells the model which forged artifact-query tools to call\n   * against this `tc.id` to read the content incrementally.\n   *\n   * @remarks\n   * Policy is the producer's or middleware's call:\n   *   - A normal tool returns its result with `inline: true` by default so its output is shown\n   *     verbatim.\n   *   - Middleware that wants to keep large results out of the model's prompt sets `inline: false`\n   *     (typically via `ctx.mutateToolCall(tc.id, { inline: false })`) before yielding.\n   *   - LLM adapters do not override the flag, do not size-check the result, and do not silently\n   *     switch to the handle pattern.\n   *\n   * For {@link @nhtio/adk!Tokenizable} results, the flag is effectively informational — handles only make\n   * sense for {@link @nhtio/adk!SpooledArtifact} (which is the only result kind the forged artifact-query\n   * tools can read). When `inline: false` is set on a call whose `results` is a `Tokenizable`,\n   * the adapter renders inline anyway and may log a warning.\n   *\n   * @defaultValue `true`\n   */\n  inline?: boolean\n  /** When this tool call was first created. */\n  createdAt: string | number | Date | DateTime\n  /** When this tool call was last modified. */\n  updatedAt: string | number | Date | DateTime\n  /** When the tool call completed. */\n  completedAt: string | number | Date | DateTime\n}\n\n/**\n * A fully-resolved {@link RawToolCall} where temporal fields have been normalised to Luxon\n * `DateTime` instances.\n *\n * @remarks\n * Used internally by the {@link ToolCall} constructor to assign private fields with\n * guaranteed types.\n */\ninterface ResolvedToolCall {\n  id: string\n  tool: string\n  args: Record<string, unknown>\n  checksum: string\n  isComplete: boolean\n  isError: boolean\n  results: ToolCallResults\n  fromArtifactTool: boolean\n  inline: boolean\n  createdAt: DateTime\n  updatedAt: DateTime\n  completedAt: DateTime\n}\n\n/**\n * Validator schema used to validate a {@link RawToolCall} before constructing a {@link ToolCall}.\n *\n * @remarks\n * Validates all fields of {@link RawToolCall}:\n * - `id` — required non-empty string.\n * - `tool` — required non-empty string.\n * - `args` — required; either a plain object or a JSON string that deserialises to an object.\n *   Strings are parsed and the resulting object is stored.\n * - `checksum` — required string.\n * - `isComplete` — required boolean.\n * - `isError` — required boolean.\n * - `results` — required; one of {@link @nhtio/adk!Tokenizable}, {@link @nhtio/adk!SpooledArtifact}, a non-empty\n *   `SpooledArtifact[]`, {@link @nhtio/adk!Media}, or a non-empty `Media[]`. Arrays must be homogeneous.\n * - `createdAt` / `updatedAt` / `completedAt` — required datetime-parseable values, normalised to `DateTime`.\n *\n * Throws {@link @nhtio/adk!E_INVALID_INITIAL_TOOL_CALL_VALUE} (via the {@link ToolCall} constructor) when\n * validation fails.\n */\nconst rawToolCallSchema = validator.object<RawToolCall>({\n  id: validator.string().required(),\n  tool: validator.string().required(),\n  args: validator\n    .alternatives(\n      validator.object().unknown(true),\n      validator.string().custom((value, helpers) => {\n        try {\n          const parsed = JSON.parse(value)\n          if (!isObject(parsed)) {\n            return helpers.error('any.invalid')\n          }\n          return parsed\n        } catch {\n          return helpers.error('any.invalid')\n        }\n      })\n    )\n    .required(),\n  checksum: validator.string().required(),\n  isComplete: validator.boolean().required(),\n  isError: validator.boolean().required(),\n  results: validator\n    .any()\n    .custom((value, helpers) => {\n      if (isToolCallResults(value)) {\n        return value\n      }\n      return helpers.error('any.invalid')\n    })\n    .required(),\n  fromArtifactTool: validator.boolean().default(false),\n  inline: validator.boolean().default(true),\n  createdAt: validator.datetime().required(),\n  updatedAt: validator.datetime().required(),\n  completedAt: validator.datetime().required(),\n})\n\n/**\n * An immutable, validated tool call record associated with a turn.\n *\n * @remarks\n * Represents a completed tool invocation from the conversation history — `results`,\n * `completedAt`, `isComplete`, and `isError` are all present and required.\n * Temporal fields are normalised to Luxon `DateTime` instances at construction time.\n */\nexport class ToolCall {\n  /**\n   * Validator schema that accepts a {@link RawToolCall} object.\n   *\n   * @remarks\n   * Reusable fragment for any schema that needs to validate or nest a tool call entry.\n   */\n  public static schema = rawToolCallSchema\n\n  /**\n   * Returns `true` if `value` is a {@link ToolCall} instance.\n   *\n   * @remarks\n   * Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety — `instanceof` would fail for instances\n   * created in a different module copy or VM context.\n   *\n   * @param value - The value to test.\n   * @returns `true` when `value` is a {@link ToolCall} instance.\n   */\n  public static isToolCall(value: unknown): value is ToolCall {\n    return isInstanceOf(value, 'ToolCall', ToolCall)\n  }\n\n  /** Stable unique identifier for this tool call; correlates the request with its result. */\n  declare readonly id: string\n  /** Name of the tool the model has requested. */\n  declare readonly tool: string\n  /** Arguments the model supplied for this tool call, always as a plain object. */\n  declare readonly args: Record<string, unknown>\n  /** Integrity checksum over `tool` and `args`. */\n  declare readonly checksum: string\n  /** `true` once the tool call has finished (successfully or not). */\n  declare readonly isComplete: boolean\n  /** `true` when the tool execution produced an error; inspect `results` for detail. */\n  declare readonly isError: boolean\n  /**\n   * Result returned by the tool, or error detail when `isError` is `true`.\n   *\n   * @remarks\n   * One of three silos — see {@link ToolCallResults}. {@link @nhtio/adk!SpooledArtifact} or\n   * `SpooledArtifact[]` for normal text-output {@link @nhtio/adk!Tool} calls;\n   * {@link @nhtio/adk!Media} or `Media[]` for tool calls whose handler returned binary modality output;\n   * {@link @nhtio/adk!Tokenizable} for {@link @nhtio/adk!ArtifactTool} calls\n   * (see {@link ToolCall.fromArtifactTool}).\n   */\n  declare readonly results: ToolCallResults\n  /**\n   * `true` when this tool call originated from an {@link @nhtio/adk!ArtifactTool}\n   * invocation. Used by `SpooledArtifact.forgeTools(ctx)` to filter out forged-tool results from\n   * the `callId` enum it builds.\n   */\n  declare readonly fromArtifactTool: boolean\n  /**\n   * `true` (default) renders this tool call's result inline in the prompt; `false` instructs LLM\n   * adapters to surface the result as a handle reference. See {@link RawToolCall.inline}.\n   */\n  declare readonly inline: boolean\n  /** When this tool call was first created. */\n  declare readonly createdAt: DateTime\n  /** When this tool call was last modified. */\n  declare readonly updatedAt: DateTime\n  /** When the tool call completed. */\n  declare readonly completedAt: DateTime\n\n  #id: string\n  #tool: string\n  #args: Record<string, unknown>\n  #checksum: string\n  #isComplete: boolean\n  #isError: boolean\n  #results: ToolCallResults\n  #fromArtifactTool: boolean\n  #inline: boolean\n  #createdAt: DateTime\n  #updatedAt: DateTime\n  #completedAt: DateTime\n\n  /**\n   * @param raw - The raw tool call input validated against `rawToolCallSchema`.\n   * @throws {@link @nhtio/adk!E_INVALID_INITIAL_TOOL_CALL_VALUE} when `raw` does not satisfy the schema.\n   */\n  constructor(raw: RawToolCall) {\n    let resolved: ResolvedToolCall\n    try {\n      resolved = validateOrThrow<ResolvedToolCall>(rawToolCallSchema, raw, true)\n    } catch (err) {\n      throw new E_INVALID_INITIAL_TOOL_CALL_VALUE({ cause: isError(err) ? err : undefined })\n    }\n    this.#id = resolved.id\n    this.#tool = resolved.tool\n    this.#args = resolved.args\n    this.#checksum = resolved.checksum\n    this.#isComplete = resolved.isComplete\n    this.#isError = resolved.isError\n    this.#results = resolved.results\n    this.#fromArtifactTool = resolved.fromArtifactTool\n    this.#inline = resolved.inline\n    this.#createdAt = resolved.createdAt\n    this.#updatedAt = resolved.updatedAt\n    this.#completedAt = resolved.completedAt\n\n    Object.defineProperties(this, {\n      id: {\n        get: () => this.#id,\n        enumerable: true,\n        configurable: false,\n      },\n      tool: {\n        get: () => this.#tool,\n        enumerable: true,\n        configurable: false,\n      },\n      args: {\n        get: () => this.#args,\n        enumerable: true,\n        configurable: false,\n      },\n      checksum: {\n        get: () => this.#checksum,\n        enumerable: true,\n        configurable: false,\n      },\n      isComplete: {\n        get: () => this.#isComplete,\n        enumerable: true,\n        configurable: false,\n      },\n      isError: {\n        get: () => this.#isError,\n        enumerable: true,\n        configurable: false,\n      },\n      results: {\n        get: () => this.#results,\n        enumerable: true,\n        configurable: false,\n      },\n      fromArtifactTool: {\n        get: () => this.#fromArtifactTool,\n        enumerable: true,\n        configurable: false,\n      },\n      inline: {\n        get: () => this.#inline,\n        enumerable: true,\n        configurable: false,\n      },\n      createdAt: {\n        get: () => this.#createdAt,\n        enumerable: true,\n        configurable: false,\n      },\n      updatedAt: {\n        get: () => this.#updatedAt,\n        enumerable: true,\n        configurable: false,\n      },\n      completedAt: {\n        get: () => this.#completedAt,\n        enumerable: true,\n        configurable: false,\n      },\n    })\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAqDA,IAAa,oBAAoB,UAC9B,IAAI,EACJ,SAAS,EACT,QAAQ,OAAO,YAAY;CAC1B,IACE,UAAU,QACV,UAAU,KAAA,KACV,OAAQ,MAAc,WAAW,cACjC,OAAQ,MAAc,eAAe,YAErC,OAAO;CAET,OAAO,QAAQ,MAAM,aAAa;AACpC,CAAC;;;;;;;;;;;AAYH,IAAa,yBAAyB,UAAyC;CAC7E,OAAO,aAAa,mBAAmB,KAAK;AAC9C;;;;;;;;;;;;AC7DA,IAAa,YAAY;CAAC;CAAS;CAAS;CAAS;AAAU;;;;;;;;;;;;;AAmB/D,IAAa,iBAAiB;CAAC;CAAe;CAAsB;AAAqB;;;;;;;;;;;;;;;;;;;AAqBzF,IAAa,sBAAsB;CACjC;CACA;CACA;AACF;AA+DA,IAAM,mBAAmB,UACtB,OAAwB;CACvB,OAAO,UAAU,IAAI,EAAE,SAAS;CAChC,WAAW,UACR,OAAO,EACP,MAAM,GAAG,cAAc,EACvB,SAAS;CACZ,kBAAkB,UAAU,OAAO,EAAE,SAAS;AAChD,CAAC,EACA,QAAQ,KAAK;;;;AAKhB,IAAM,iBAAiB,UAAU,OAAiB;CAChD,IAAI,UAAU,OAAO,EAAE,SAAS;CAChC,MAAM,UACH,OAAO,EACP,MAAM,GAAG,SAAS,EAClB,SAAS;CACZ,UAAU,UAAU,OAAO,EAAE,SAAS;CACtC,UAAU,UAAU,OAAO,EAAE,SAAS;CACtC,QAAQ,kBAAkB,SAAS;CACnC,WAAW,UACR,OAAO,EACP,MAAM,GAAG,cAAc,EACvB,SAAS;CACZ,gBAAgB,UACb,OAAO,EACP,MAAM,GAAG,mBAAmB,EAC5B,SAAS;CACZ,QAAQ,UAAU,OAAO,EAAE,SAAS;CACpC,OAAO,UAAU,OAAO,EAAE,QAAQ,UAAU,OAAO,GAAG,gBAAgB,EAAE,SAAS;AACnF,CAAC;AAcD,IAAM,6BAA6B,SAAyC;CAC1E,OAAO,SAAS,aAAa,6BAA6B;AAC5D;;;;;;;;;AA0BA,IAAM,gBAAgB,UAA8B;CAClD,MAAM,cACJ,WACA;CACF,IAAI,eAAe,OAAO,YAAY,SAAS,YAC7C,OAAO,YAAY,KAAK,KAAK,EAAE,SAAS,QAAQ;CAElD,MAAM,YAAY;CAClB,IAAI,SAAS;CACb,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;EAChD,MAAM,QAAQ,MAAM,SAAS,GAAG,IAAI,SAAS;EAC7C,UAAU,OAAO,aAAa,MAAM,MAAM,MAAM,KAAK,KAAK,CAAa;CACzE;CACA,OAAO,KAAK,MAAM;AACpB;;;;;;;;;;;;;;;;AAiBA,IAAa,QAAb,MAAa,MAAM;;;;CAIjB,OAAc,SAAS;;;;;CAMvB,OAAc,YAAY;;;;CAK1B,OAAc,iBAAiB;;;;CAK/B,OAAc,sBAAsB;;;;;;;;;;CAWpC,OAAc,QAAQ,OAAgC;EACpD,OAAO,aAAa,OAAO,SAAS,KAAK;CAC3C;CAmBA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;;;;;CAOA,YAAY,KAAe;EACzB,IAAI;EACJ,IAAI;GACF,WAAW,gBAA+B,gBAAgB,KAAK,IAAI;EACrE,SAAS,KAAK;GACZ,MAAM,IAAI,8BAA8B,EAAE,OAAO,QAAQ,GAAG,IAAI,MAAM,KAAA,EAAU,CAAC;EACnF;EACA,IAAI,CAAC,sBAAsB,SAAS,MAAM,GACxC,MAAM,IAAI,qBAAqB;EAEjC,KAAKA,MAAM,SAAS,MAAM,GAAO;EACjC,KAAKC,QAAQ,SAAS;EACtB,KAAKC,YAAY,SAAS;EAC1B,KAAKC,YAAY,SAAS;EAC1B,KAAKC,UAAU,SAAS;EACxB,KAAKC,aAAa,SAAS;EAC3B,KAAKC,kBAAkB,SAAS;EAChC,KAAKC,UAAU,SAAS;EACxB,KAAKC,SAAS,IAAI,SAAS,SAAS,KAA4C;EAEhF,OAAO,iBAAiB,MAAM;GAC5B,IAAI;IACF,WAAW,KAAKR;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,MAAM;IACJ,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,UAAU;IACR,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,UAAU;IACR,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,QAAQ;IACN,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,WAAW;IACT,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,gBAAgB;IACd,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,OAAO;IACL,WAAW,KAAKE;IAChB,YAAY;IACZ,cAAc;GAChB;EACF,CAAC;CACH;;;;;;CAOA,MAAM,SAA8C;EAClD,OAAO,KAAKD,QAAQ,OAAO;CAC7B;;;;;;CAOA,MAAM,aAA0C;EAC9C,OAAO,KAAKA,QAAQ,WAAW;CACjC;;;;;;;;CASA,MAAM,UAA+B;EAEnC,MAAM,UAAS,MADM,KAAK,OAAO,GACX,UAAU;EAChC,MAAM,SAAuB,CAAC;EAC9B,IAAI,QAAQ;EACZ,OAAO,MAAM;GACX,MAAM,EAAE,OAAO,SAAS,MAAM,OAAO,KAAK;GAC1C,IAAI,MAAM;GACV,IAAI,OAAO;IACT,OAAO,KAAK,KAAK;IACjB,SAAS,MAAM;GACjB;EACF;EACA,MAAM,MAAM,IAAI,WAAW,KAAK;EAChC,IAAI,SAAS;EACb,KAAK,MAAM,SAAS,QAAQ;GAC1B,IAAI,IAAI,OAAO,MAAM;GACrB,UAAU,MAAM;EAClB;EACA,OAAO;CACT;;;;;;;;;CAUA,MAAM,WAA4B;EAEhC,OAAO,aAAa,MADA,KAAK,QAAQ,CACR;CAC3B;;;;;;;;;;;CAYA,SAA0B;EACxB,OAAO;GACL,IAAI,KAAKP;GACT,MAAM,KAAKC;GACX,UAAU,KAAKC;GACf,UAAU,KAAKC;GACf,QAAQ,KAAKC;GACb,WAAW,KAAKC;GAChB,gBAAgB,KAAKC;GACrB,OAAO,KAAKE,OAAO,IAAI;EACzB;CACF;;;;;;;;;CAUA,OAAc,eAAe,MAQnB;EACR,OAAO,IAAI,MAAM;GACf,GAAG;GACH,WAAW;GACX,gBAAgB,0BAA0B,KAAK,IAAI;EACrD,CAAC;CACH;;;;;;;CAQA,OAAc,cAAc,MAQlB;EACR,OAAO,IAAI,MAAM;GACf,GAAG;GACH,WAAW;GACX,gBAAgB,0BAA0B,KAAK,IAAI;EACrD,CAAC;CACH;;;;;;;CAQA,OAAc,gBAAgB,MAQpB;EACR,OAAO,IAAI,MAAM;GACf,GAAG;GACH,WAAW;GACX,gBAAgB,0BAA0B,KAAK,IAAI;EACrD,CAAC;CACH;;;;;;;CAQA,OAAc,iBAAiB,MAQrB;EACR,OAAO,IAAI,MAAM;GACf,GAAG;GACH,WAAW;GACX,gBAAgB,0BAA0B,KAAK,IAAI;EACrD,CAAC;CACH;AACF;;;;;;;;AASA,IAAa,WAAW,UAAmC;CACzD,OAAO,aAAa,OAAO,SAAS,KAAK;AAC3C;;;ACtgBA,IAAM,qBAAqB,UAA6C;CACtE,IAAI,YAAY,cAAc,KAAK,GAAG,OAAO;CAC7C,IAAI,gBAAgB,kBAAkB,KAAK,GAAG,OAAO;CACrD,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO;CACjC,IAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS,GAAG;EAE5C,IADiB,MAAM,OAAO,UAAU,MAAM,QAAQ,KAAK,CACvD,GAAU,OAAO;EAErB,IADmB,MAAM,OAAO,UAAU,gBAAgB,kBAAkB,KAAK,CAC7E,GAAY,OAAO;CACzB;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;AA2IA,IAAM,oBAAoB,UAAU,OAAoB;CACtD,IAAI,UAAU,OAAO,EAAE,SAAS;CAChC,MAAM,UAAU,OAAO,EAAE,SAAS;CAClC,MAAM,UACH,aACC,UAAU,OAAO,EAAE,QAAQ,IAAI,GAC/B,UAAU,OAAO,EAAE,QAAQ,OAAO,YAAY;EAC5C,IAAI;GACF,MAAM,SAAS,KAAK,MAAM,KAAK;GAC/B,IAAI,CAAC,SAAS,MAAM,GAClB,OAAO,QAAQ,MAAM,aAAa;GAEpC,OAAO;EACT,QAAQ;GACN,OAAO,QAAQ,MAAM,aAAa;EACpC;CACF,CAAC,CACH,EACC,SAAS;CACZ,UAAU,UAAU,OAAO,EAAE,SAAS;CACtC,YAAY,UAAU,QAAQ,EAAE,SAAS;CACzC,SAAS,UAAU,QAAQ,EAAE,SAAS;CACtC,SAAS,UACN,IAAI,EACJ,QAAQ,OAAO,YAAY;EAC1B,IAAI,kBAAkB,KAAK,GACzB,OAAO;EAET,OAAO,QAAQ,MAAM,aAAa;CACpC,CAAC,EACA,SAAS;CACZ,kBAAkB,UAAU,QAAQ,EAAE,QAAQ,KAAK;CACnD,QAAQ,UAAU,QAAQ,EAAE,QAAQ,IAAI;CACxC,WAAW,UAAU,SAAS,EAAE,SAAS;CACzC,WAAW,UAAU,SAAS,EAAE,SAAS;CACzC,aAAa,UAAU,SAAS,EAAE,SAAS;AAC7C,CAAC;;;;;;;;;AAUD,IAAa,WAAb,MAAa,SAAS;;;;;;;CAOpB,OAAc,SAAS;;;;;;;;;;;CAYvB,OAAc,WAAW,OAAmC;EAC1D,OAAO,aAAa,OAAO,YAAY,QAAQ;CACjD;CA2CA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;;;;CAMA,YAAY,KAAkB;EAC5B,IAAI;EACJ,IAAI;GACF,WAAW,gBAAkC,mBAAmB,KAAK,IAAI;EAC3E,SAAS,KAAK;GACZ,MAAM,IAAI,kCAAkC,EAAE,OAAO,QAAQ,GAAG,IAAI,MAAM,KAAA,EAAU,CAAC;EACvF;EACA,KAAKC,MAAM,SAAS;EACpB,KAAKC,QAAQ,SAAS;EACtB,KAAKC,QAAQ,SAAS;EACtB,KAAKC,YAAY,SAAS;EAC1B,KAAKC,cAAc,SAAS;EAC5B,KAAKC,WAAW,SAAS;EACzB,KAAKC,WAAW,SAAS;EACzB,KAAKC,oBAAoB,SAAS;EAClC,KAAKC,UAAU,SAAS;EACxB,KAAKC,aAAa,SAAS;EAC3B,KAAKC,aAAa,SAAS;EAC3B,KAAKC,eAAe,SAAS;EAE7B,OAAO,iBAAiB,MAAM;GAC5B,IAAI;IACF,WAAW,KAAKX;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,MAAM;IACJ,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,MAAM;IACJ,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,UAAU;IACR,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,YAAY;IACV,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,SAAS;IACP,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,SAAS;IACP,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,kBAAkB;IAChB,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,QAAQ;IACN,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,WAAW;IACT,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,WAAW;IACT,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;GACA,aAAa;IACX,WAAW,KAAKC;IAChB,YAAY;IACZ,cAAc;GAChB;EACF,CAAC;CACH;AACF"}