@nextclaw/ncp-agent-runtime 0.3.7 → 0.3.9

package/dist/index.js

@@ -1,1205 +1,1201 @@
-// src/user-content.ts
-function readOptionalString(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
+import { copyFileSync, existsSync, readFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { NcpAssistantTextStreamNormalizer, NcpEventType, isHiddenNcpMessage, normalizeAssistantText } from "@nextclaw/ncp";
+import AjvPkg from "ajv";
+//#region src/user-content.ts
+function readOptionalString$1(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
 }
 function formatAssetReferenceBlock(params) {
-  const fileName = readOptionalString(params.fileName) ?? "asset";
-  const mimeType = readOptionalString(params.mimeType) ?? "application/octet-stream";
-  const assetUri = readOptionalString(params.assetUri);
-  const url = readOptionalString(params.url);
-  const sizeText = typeof params.sizeBytes === "number" && Number.isFinite(params.sizeBytes) ? String(params.sizeBytes) : null;
-  const lines = [
-    `[Asset: ${fileName}]`,
-    `[MIME: ${mimeType}]`,
-    ...assetUri ? [`[Asset URI: ${assetUri}]`] : [],
-    ...sizeText ? [`[Size Bytes: ${sizeText}]`] : [],
-    ...url ? [`[Preview URL: ${url}]`] : [],
-    "[Instruction: This file is not embedded in the prompt. If you need to inspect or transform it, use asset_export to copy it to a normal file path first.]"
-  ];
-  return lines.join("\n");
+	const fileName = readOptionalString$1(params.fileName) ?? "asset";
+	const mimeType = readOptionalString$1(params.mimeType) ?? "application/octet-stream";
+	const assetUri = readOptionalString$1(params.assetUri);
+	const url = readOptionalString$1(params.url);
+	const sizeText = typeof params.sizeBytes === "number" && Number.isFinite(params.sizeBytes) ? String(params.sizeBytes) : null;
+	return [
+		`[Asset: ${fileName}]`,
+		`[MIME: ${mimeType}]`,
+		...assetUri ? [`[Asset URI: ${assetUri}]`] : [],
+		...sizeText ? [`[Size Bytes: ${sizeText}]`] : [],
+		...url ? [`[Preview URL: ${url}]`] : [],
+		"[Instruction: This file is not embedded in the prompt. If you need to inspect or transform it, use asset_export to copy it to a normal file path first.]"
+	].join("\n");
+}
+function resolveFilePart(part, assetStore) {
+	const assetUri = readOptionalString$1(part.assetUri);
+	const stored = assetUri ? assetStore?.getByUri(assetUri) : null;
+	return {
+		fileName: readOptionalString$1(stored?.fileName) ?? readOptionalString$1(part.name) ?? "asset",
+		mimeType: readOptionalString$1(stored?.mimeType) ?? readOptionalString$1(part.mimeType) ?? "application/octet-stream",
+		assetUri,
+		url: readOptionalString$1(part.url),
+		contentBase64: readOptionalString$1(part.contentBase64),
+		sizeBytes: stored?.sizeBytes ?? (typeof part.sizeBytes === "number" ? part.sizeBytes : void 0),
+		contentPath: assetUri ? assetStore?.resolveContentPath(assetUri) ?? null : null
+	};
+}
+function formatImageAttachmentHint(params) {
+	const { fileName: rawFileName, mimeType: rawMimeType, assetUri: rawAssetUri, sizeBytes } = params;
+	const fileName = readOptionalString$1(rawFileName) ?? "asset";
+	const mimeType = readOptionalString$1(rawMimeType) ?? "application/octet-stream";
+	const assetUri = readOptionalString$1(rawAssetUri);
+	const sizeText = typeof sizeBytes === "number" && Number.isFinite(sizeBytes) ? String(sizeBytes) : null;
+	return [
+		`[Attached Image: ${fileName}]`,
+		`[MIME: ${mimeType}]`,
+		...assetUri ? [`[Asset URI: ${assetUri}]`] : [],
+		...sizeText ? [`[Size Bytes: ${sizeText}]`] : [],
+		assetUri ? "[Instruction: This image is embedded in the prompt. If you need to transform or process the original file with tools, use the asset URI.]" : "[Instruction: This image is embedded in the prompt.]"
+	].join("\n");
+}
+function isImageMimeType(value) {
+	return value?.startsWith("image/") ?? false;
+}
+function isModelReachableImageUrl(value) {
+	return value !== null && (/^https?:\/\//i.test(value) || /^data:/i.test(value));
+}
+function buildImageDataUrl(mimeType, bytes) {
+	return `data:${mimeType};base64,${Buffer.from(bytes).toString("base64")}`;
+}
+function resolveImageContentPart(part, assetStore) {
+	const resolved = resolveFilePart(part, assetStore);
+	if (!isImageMimeType(resolved.mimeType)) return null;
+	if (resolved.contentBase64) return {
+		type: "image_url",
+		image_url: {
+			url: `data:${resolved.mimeType};base64,${resolved.contentBase64}`,
+			detail: "auto"
+		}
+	};
+	if (resolved.contentPath) return {
+		type: "image_url",
+		image_url: {
+			url: buildImageDataUrl(resolved.mimeType, readFileSync(resolved.contentPath)),
+			detail: "auto"
+		}
+	};
+	const reachableImageUrl = resolved.url;
+	if (isModelReachableImageUrl(reachableImageUrl)) return {
+		type: "image_url",
+		image_url: {
+			url: reachableImageUrl,
+			detail: "auto"
+		}
+	};
+	return null;
+}
+function resolveImageAttachmentHint(part, assetStore) {
+	const resolved = resolveFilePart(part, assetStore);
+	if (!isImageMimeType(resolved.mimeType)) return null;
+	return formatImageAttachmentHint({
+		fileName: resolved.fileName,
+		mimeType: resolved.mimeType,
+		assetUri: resolved.assetUri,
+		sizeBytes: resolved.sizeBytes
+	});
 }
 function resolveAssetReferenceBlock(part, assetStore) {
-  const fileName = readOptionalString(part.name);
-  const mimeType = readOptionalString(part.mimeType);
-  const assetUri = readOptionalString(part.assetUri);
-  const url = readOptionalString(part.url);
-  const sizeBytes = typeof part.sizeBytes === "number" ? part.sizeBytes : void 0;
-  if (assetUri) {
-    const stored = assetStore?.getByUri(assetUri);
-    return formatAssetReferenceBlock({
-      fileName: stored?.fileName ?? fileName,
-      mimeType: stored?.mimeType ?? mimeType,
-      assetUri,
-      url,
-      sizeBytes: stored?.sizeBytes ?? sizeBytes
-    });
-  }
-  if (url || part.contentBase64) {
-    return formatAssetReferenceBlock({
-      fileName,
-      mimeType,
-      url,
-      sizeBytes
-    });
-  }
-  return null;
+	const resolved = resolveFilePart(part, assetStore);
+	if (resolved.assetUri) return formatAssetReferenceBlock({
+		fileName: resolved.fileName,
+		mimeType: resolved.mimeType,
+		assetUri: resolved.assetUri,
+		url: resolved.url,
+		sizeBytes: resolved.sizeBytes
+	});
+	if (resolved.url || resolved.contentBase64) return formatAssetReferenceBlock({
+		fileName: resolved.fileName,
+		mimeType: resolved.mimeType,
+		url: resolved.url,
+		sizeBytes: resolved.sizeBytes
+	});
+	return null;
 }
 function buildNcpUserContent(parts, options = {}) {
-  const content = [];
-  for (const part of parts) {
-    if ((part.type === "text" || part.type === "rich-text") && part.text.trim().length > 0) {
-      content.push({ type: "text", text: part.text });
-      continue;
-    }
-    if (part.type !== "file") {
-      continue;
-    }
-    const assetReferenceBlock = resolveAssetReferenceBlock(part, options.assetStore);
-    if (assetReferenceBlock) {
-      content.push({ type: "text", text: assetReferenceBlock });
-    }
-  }
-  if (content.length === 0) {
-    return "";
-  }
-  if (content.length === 1 && content[0]?.type === "text") {
-    return content[0].text;
-  }
-  return content;
+	const content = [];
+	for (const part of parts) {
+		if ((part.type === "text" || part.type === "rich-text") && part.text.trim().length > 0) {
+			content.push({
+				type: "text",
+				text: part.text
+			});
+			continue;
+		}
+		if (part.type !== "file") continue;
+		const imageContentPart = resolveImageContentPart(part, options.assetStore);
+		if (imageContentPart) {
+			content.push(imageContentPart);
+			const imageAttachmentHint = resolveImageAttachmentHint(part, options.assetStore);
+			if (imageAttachmentHint) content.push({
+				type: "text",
+				text: imageAttachmentHint
+			});
+			continue;
+		}
+		const assetReferenceBlock = resolveAssetReferenceBlock(part, options.assetStore);
+		if (assetReferenceBlock) content.push({
+			type: "text",
+			text: assetReferenceBlock
+		});
+	}
+	if (content.length === 0) return "";
+	if (content.length === 1 && content[0]?.type === "text") return content[0].text;
+	return content;
 }
-
-// src/context-builder.ts
+//#endregion
+//#region src/context-builder.ts
 function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function readOptionalString2(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
+function readOptionalString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
 }
 function isTextLikePart(part) {
-  return part.type === "text" || part.type === "rich-text";
+	return part.type === "text" || part.type === "rich-text";
 }
 function mergeMessageAndRequestMetadata(input) {
-  const messageMetadata = input.messages.slice().reverse().find((message) => isRecord(message.metadata))?.metadata;
-  return {
-    ...isRecord(messageMetadata) ? messageMetadata : {},
-    ...isRecord(input.metadata) ? input.metadata : {}
-  };
+	const messageMetadata = input.messages.slice().reverse().find((message) => isRecord(message.metadata))?.metadata;
+	return {
+		...isRecord(messageMetadata) ? messageMetadata : {},
+		...isRecord(input.metadata) ? input.metadata : {}
+	};
 }
 function readRequestedToolNames(metadata) {
-  const raw = metadata.requested_tools ?? metadata.requestedTools ?? metadata.requested_skills ?? metadata.requestedSkills;
-  if (!Array.isArray(raw)) {
-    return [];
-  }
-  const deduped = /* @__PURE__ */ new Set();
-  for (const item of raw) {
-    const value = readOptionalString2(item);
-    if (value) {
-      deduped.add(value);
-    }
-  }
-  return [...deduped];
+	const raw = metadata.requested_tools ?? metadata.requestedTools ?? metadata.requested_skills ?? metadata.requestedSkills;
+	if (!Array.isArray(raw)) return [];
+	const deduped = /* @__PURE__ */ new Set();
+	for (const item of raw) {
+		const value = readOptionalString(item);
+		if (value) deduped.add(value);
+	}
+	return [...deduped];
 }
 function isDefaultNcpContextBuilderOptions(value) {
-  return Boolean(value) && typeof value === "object" && !("getToolDefinitions" in value);
+	return Boolean(value) && typeof value === "object" && !("getToolDefinitions" in value);
 }
 function messageToOpenAI(msg, options) {
-  const role = msg.role;
-  const parts = msg.parts ?? [];
-  if (role === "user" || role === "system") {
-    if (role === "user") {
-      return [
-        {
-          role,
-          content: buildNcpUserContent(parts, {
-            assetStore: options.assetStore
-          })
-        }
-      ];
-    }
-    const text = parts.filter(isTextLikePart).map((part) => part.text).join("");
-    return [{ role, content: text }];
-  }
-  if (role === "assistant") {
-    const texts = [];
-    const reasonings = [];
-    const toolInvocations = [];
-    for (const p of parts) {
-      if (p.type === "reasoning") {
-        reasonings.push(p.text);
-      }
-      if (p.type === "text") {
-        texts.push(p.text);
-      }
-      if (p.type === "tool-invocation" && p.state === "result" && p.result !== void 0) {
-        toolInvocations.push({
-          toolCallId: p.toolCallId ?? "",
-          toolName: p.toolName,
-          args: p.args ?? {},
-          result: p.result
-        });
-      }
-    }
-    const text = texts.join("");
-    const reasoning = reasonings.join("");
-    const out = [];
-    if (toolInvocations.length > 0) {
-      out.push({
-        role: "assistant",
-        content: text || null,
-        ...reasoning ? { reasoning_content: reasoning } : {},
-        tool_calls: toolInvocations.map((t) => ({
-          id: t.toolCallId,
-          type: "function",
-          function: {
-            name: t.toolName,
-            arguments: typeof t.args === "string" ? t.args : JSON.stringify(t.args ?? {})
-          }
-        }))
-      });
-      for (const t of toolInvocations) {
-        out.push({
-          role: "tool",
-          content: typeof t.result === "string" ? t.result : JSON.stringify(t.result),
-          tool_call_id: t.toolCallId
-        });
-      }
-    } else {
-      out.push({
-        role: "assistant",
-        content: text,
-        ...reasoning ? { reasoning_content: reasoning } : {}
-      });
-    }
-    return out;
-  }
-  return [];
+	const role = msg.role;
+	const parts = msg.parts ?? [];
+	if (role === "user" || role === "system") {
+		if (role === "user") return [{
+			role,
+			content: buildNcpUserContent(parts, { assetStore: options.assetStore })
+		}];
+		return [{
+			role,
+			content: parts.filter(isTextLikePart).map((part) => part.text).join("")
+		}];
+	}
+	if (role === "assistant") {
+		const texts = [];
+		const reasonings = [];
+		const toolInvocations = [];
+		for (const p of parts) {
+			if (p.type === "reasoning") reasonings.push(p.text);
+			if (p.type === "text") texts.push(p.text);
+			if (p.type === "tool-invocation" && p.state === "result" && p.result !== void 0) toolInvocations.push({
+				toolCallId: p.toolCallId ?? "",
+				toolName: p.toolName,
+				args: p.args ?? {},
+				result: p.result
+			});
+		}
+		const text = texts.join("");
+		const reasoning = reasonings.join("");
+		const out = [];
+		if (toolInvocations.length > 0) {
+			out.push({
+				role: "assistant",
+				content: text || null,
+				...reasoning ? { reasoning_content: reasoning } : {},
+				tool_calls: toolInvocations.map((t) => ({
+					id: t.toolCallId,
+					type: "function",
+					function: {
+						name: t.toolName,
+						arguments: typeof t.args === "string" ? t.args : JSON.stringify(t.args ?? {})
+					}
+				}))
+			});
+			for (const t of toolInvocations) out.push({
+				role: "tool",
+				content: typeof t.result === "string" ? t.result : JSON.stringify(t.result),
+				tool_call_id: t.toolCallId
+			});
+		} else out.push({
+			role: "assistant",
+			content: text,
+			...reasoning ? { reasoning_content: reasoning } : {}
+		});
+		return out;
+	}
+	return [];
 }
 var DefaultNcpContextBuilder = class {
-  toolRegistry;
-  assetStore;
-  constructor(toolRegistryOrOptions) {
-    if (isDefaultNcpContextBuilderOptions(toolRegistryOrOptions)) {
-      this.toolRegistry = toolRegistryOrOptions.toolRegistry;
-      this.assetStore = toolRegistryOrOptions.assetStore;
-      return;
-    }
-    this.toolRegistry = toolRegistryOrOptions;
-  }
-  prepare = (input, options) => {
-    const maxMessages = options?.maxMessages ?? 50;
-    const sessionMessages = options?.sessionMessages ?? [];
-    const systemPrompt = options?.systemPrompt;
-    const requestMetadata = mergeMessageAndRequestMetadata(input);
-    const requestedToolNames = readRequestedToolNames(requestMetadata);
-    const messages = [];
-    if (systemPrompt) {
-      messages.push({ role: "system", content: systemPrompt });
-    }
-    for (const msg of sessionMessages.slice(-maxMessages)) {
-      messages.push(
-        ...messageToOpenAI(msg, {
-          assetStore: this.assetStore
-        })
-      );
-    }
-    for (const msg of input.messages) {
-      messages.push(
-        ...messageToOpenAI(msg, {
-          assetStore: this.assetStore
-        })
-      );
-    }
-    const toolDefinitions = this.toolRegistry?.getToolDefinitions() ?? [];
-    const filteredToolDefinitions = requestedToolNames.length > 0 ? toolDefinitions.filter((definition) => requestedToolNames.includes(definition.name)) : toolDefinitions;
-    const tools = filteredToolDefinitions.map((definition) => ({
-      type: "function",
-      function: {
-        name: definition.name,
-        description: definition.description,
-        parameters: definition.parameters
-      }
-    }));
-    return {
-      messages,
-      tools: tools && tools.length > 0 ? tools : void 0,
-      model: readOptionalString2(requestMetadata.model) ?? readOptionalString2(requestMetadata.llm_model) ?? readOptionalString2(requestMetadata.agent_model) ?? void 0,
-      thinkingLevel: readOptionalString2(requestMetadata.thinking) ?? readOptionalString2(requestMetadata.thinking_level) ?? readOptionalString2(requestMetadata.thinkingLevel) ?? readOptionalString2(requestMetadata.thinking_effort) ?? readOptionalString2(requestMetadata.thinkingEffort) ?? null
-    };
-  };
+	toolRegistry;
+	assetStore;
+	constructor(toolRegistryOrOptions) {
+		if (isDefaultNcpContextBuilderOptions(toolRegistryOrOptions)) {
+			this.toolRegistry = toolRegistryOrOptions.toolRegistry;
+			this.assetStore = toolRegistryOrOptions.assetStore;
+			return;
+		}
+		this.toolRegistry = toolRegistryOrOptions;
+	}
+	prepare = (input, options) => {
+		const maxMessages = options?.maxMessages ?? 50;
+		const sessionMessages = options?.sessionMessages ?? [];
+		const systemPrompt = options?.systemPrompt;
+		const requestMetadata = mergeMessageAndRequestMetadata(input);
+		const requestedToolNames = readRequestedToolNames(requestMetadata);
+		const messages = [];
+		if (systemPrompt) messages.push({
+			role: "system",
+			content: systemPrompt
+		});
+		for (const msg of sessionMessages.slice(-maxMessages)) messages.push(...messageToOpenAI(msg, { assetStore: this.assetStore }));
+		for (const msg of input.messages) messages.push(...messageToOpenAI(msg, { assetStore: this.assetStore }));
+		const toolDefinitions = this.toolRegistry?.getToolDefinitions() ?? [];
+		const tools = (requestedToolNames.length > 0 ? toolDefinitions.filter((definition) => requestedToolNames.includes(definition.name)) : toolDefinitions).map((definition) => ({
+			type: "function",
+			function: {
+				name: definition.name,
+				description: definition.description,
+				parameters: definition.parameters
+			}
+		}));
+		return {
+			messages,
+			tools: tools && tools.length > 0 ? tools : void 0,
+			model: readOptionalString(requestMetadata.model) ?? readOptionalString(requestMetadata.llm_model) ?? readOptionalString(requestMetadata.agent_model) ?? void 0,
+			thinkingLevel: readOptionalString(requestMetadata.thinking) ?? readOptionalString(requestMetadata.thinking_level) ?? readOptionalString(requestMetadata.thinkingLevel) ?? readOptionalString(requestMetadata.thinking_effort) ?? readOptionalString(requestMetadata.thinkingEffort) ?? null
+		};
+	};
 };
-
-// src/asset-store.ts
-import { createHash, randomUUID } from "crypto";
-import { copyFileSync, existsSync, readFileSync } from "fs";
-import { copyFile, mkdir, readFile, stat, writeFile } from "fs/promises";
-import { basename, dirname, join, resolve } from "path";
-var ASSET_URI_SCHEME = "asset://store/";
+//#endregion
+//#region src/asset-store.ts
+const ASSET_URI_SCHEME = "asset://store/";
 function normalizeSegment(value) {
-  return value.replace(/[^\w.-]+/g, "_").replace(/^_+|_+$/g, "") || "asset.bin";
+	return value.replace(/[^\w.-]+/g, "_").replace(/^_+|_+$/g, "") || "asset.bin";
 }
 function normalizeFileName(value) {
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : "asset.bin";
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : "asset.bin";
 }
 function normalizeMimeType(value) {
-  const normalized = value?.trim().toLowerCase() ?? "";
-  return normalized.length > 0 ? normalized : "application/octet-stream";
+	const normalized = value?.trim().toLowerCase() ?? "";
+	return normalized.length > 0 ? normalized : "application/octet-stream";
 }
 function buildAssetId() {
-  return `asset_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+	return `asset_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
 }
 function ensureAssetRoot(rootDir) {
-  const normalized = rootDir.trim();
-  if (!normalized) {
-    throw new Error("LocalAssetStore requires a non-empty rootDir.");
-  }
-  return resolve(normalized);
+	const normalized = rootDir.trim();
+	if (!normalized) throw new Error("LocalAssetStore requires a non-empty rootDir.");
+	return resolve(normalized);
 }
 function buildStorageKey(timestamp, assetId) {
-  const year = String(timestamp.getFullYear());
-  const month = String(timestamp.getMonth() + 1).padStart(2, "0");
-  const day = String(timestamp.getDate()).padStart(2, "0");
-  return `${year}/${month}/${day}/${assetId}`;
+	return `${String(timestamp.getFullYear())}/${String(timestamp.getMonth() + 1).padStart(2, "0")}/${String(timestamp.getDate()).padStart(2, "0")}/${assetId}`;
 }
 function buildAssetUri(storageKey) {
-  return `${ASSET_URI_SCHEME}${storageKey}`;
+	return `${ASSET_URI_SCHEME}${storageKey}`;
 }
 function parseAssetUri(uri) {
-  const normalized = uri.trim();
-  if (!normalized.startsWith(ASSET_URI_SCHEME)) {
-    return null;
-  }
-  const storageKey = normalized.slice(ASSET_URI_SCHEME.length).replace(/^\/+/, "").trim();
-  return storageKey.length > 0 ? storageKey : null;
+	const normalized = uri.trim();
+	if (!normalized.startsWith(ASSET_URI_SCHEME)) return null;
+	const storageKey = normalized.slice(14).replace(/^\/+/, "").trim();
+	return storageKey.length > 0 ? storageKey : null;
 }
 function ensureStorageKey(storageKey) {
-  const normalized = storageKey.trim().replace(/^\/+|\/+$/g, "");
-  if (!normalized) {
-    throw new Error("Asset storage key must not be empty.");
-  }
-  const segments = normalized.split("/");
-  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
-    throw new Error(`Invalid asset storage key: ${storageKey}`);
-  }
-  return segments.join("/");
+	const normalized = storageKey.trim().replace(/^\/+|\/+$/g, "");
+	if (!normalized) throw new Error("Asset storage key must not be empty.");
+	const segments = normalized.split("/");
+	if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) throw new Error(`Invalid asset storage key: ${storageKey}`);
+	return segments.join("/");
 }
 function hydrateStoredAssetRecord(value) {
-  const fileName = normalizeFileName(value.fileName);
-  return {
-    ...value,
-    fileName,
-    storedName: normalizeSegment(value.storedName || fileName),
-    mimeType: normalizeMimeType(value.mimeType)
-  };
+	const fileName = normalizeFileName(value.fileName);
+	return {
+		...value,
+		fileName,
+		storedName: normalizeSegment(value.storedName || fileName),
+		mimeType: normalizeMimeType(value.mimeType)
+	};
 }
 function toAssetMeta(record) {
-  return {
-    uri: record.uri,
-    fileName: record.fileName,
-    mimeType: record.mimeType,
-    sizeBytes: record.sizeBytes,
-    createdAt: record.createdAt
-  };
+	return {
+		uri: record.uri,
+		fileName: record.fileName,
+		mimeType: record.mimeType,
+		sizeBytes: record.sizeBytes,
+		createdAt: record.createdAt
+	};
 }
 function isTextLikeAsset(params) {
-  const mimeType = normalizeMimeType(params.mimeType);
-  if (mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "text/xml" || mimeType === "application/yaml" || mimeType === "text/yaml" || mimeType === "application/x-yaml" || mimeType === "text/csv") {
-    return true;
-  }
-  const normalizedName = (params.fileName ?? "").trim().toLowerCase();
-  return [
-    ".json",
-    ".md",
-    ".txt",
-    ".csv",
-    ".xml",
-    ".yaml",
-    ".yml",
-    ".js",
-    ".mjs",
-    ".cjs",
-    ".ts",
-    ".tsx",
-    ".jsx",
-    ".py",
-    ".rb",
-    ".go",
-    ".rs",
-    ".java",
-    ".kt",
-    ".swift",
-    ".php",
-    ".css",
-    ".scss",
-    ".html",
-    ".sql",
-    ".sh"
-  ].some((suffix) => normalizedName.endsWith(suffix));
+	const mimeType = normalizeMimeType(params.mimeType);
+	if (mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "text/xml" || mimeType === "application/yaml" || mimeType === "text/yaml" || mimeType === "application/x-yaml" || mimeType === "text/csv") return true;
+	const normalizedName = (params.fileName ?? "").trim().toLowerCase();
+	return [
+		".json",
+		".md",
+		".txt",
+		".csv",
+		".xml",
+		".yaml",
+		".yml",
+		".js",
+		".mjs",
+		".cjs",
+		".ts",
+		".tsx",
+		".jsx",
+		".py",
+		".rb",
+		".go",
+		".rs",
+		".java",
+		".kt",
+		".swift",
+		".php",
+		".css",
+		".scss",
+		".html",
+		".sql",
+		".sh"
+	].some((suffix) => normalizedName.endsWith(suffix));
 }
 var LocalAssetStore = class {
-  rootDir;
-  constructor(options) {
-    this.rootDir = ensureAssetRoot(options.rootDir);
-  }
-  async put(input) {
-    const record = input.kind === "path" ? await this.putFromPath(input) : await this.putFromBytes({
-      fileName: input.fileName,
-      mimeType: input.mimeType,
-      bytes: input.bytes,
-      createdAt: input.createdAt
-    });
-    return { uri: record.uri };
-  }
-  async putBytes(params) {
-    return this.putFromBytes(params);
-  }
-  async putPath(params) {
-    return this.putFromPath({
-      kind: "path",
-      ...params
-    });
-  }
-  async export(ref, targetPath) {
-    const record = await this.statRecord(ref.uri);
-    if (!record) {
-      throw new Error(`Asset not found: ${ref.uri}`);
-    }
-    const outputPath = resolve(targetPath);
-    await ensureParentDirectory(outputPath);
-    await copyFile(this.resolveContentPathOrThrow(record), outputPath);
-    return outputPath;
-  }
-  async stat(ref) {
-    const record = await this.statRecord(ref.uri);
-    return record ? toAssetMeta(record) : null;
-  }
-  getByUri(uri) {
-    const storageKey = parseAssetUri(uri);
-    if (!storageKey) {
-      return null;
-    }
-    const metaPath = join(this.resolveStorageKeyDirectory(storageKey), "meta.json");
-    if (!existsSync(metaPath)) {
-      return null;
-    }
-    const text = readFileSync(metaPath, "utf8");
-    return hydrateStoredAssetRecord(JSON.parse(text));
-  }
-  async statRecord(uri) {
-    const record = this.getByUri(uri);
-    if (!record) {
-      return null;
-    }
-    try {
-      await stat(this.resolveContentPathOrThrow(record));
-      return record;
-    } catch {
-      return null;
-    }
-  }
-  async readAssetBytes(uri) {
-    const record = await this.statRecord(uri);
-    if (!record) {
-      return null;
-    }
-    try {
-      return await readFile(this.resolveContentPathOrThrow(record));
-    } catch {
-      return null;
-    }
-  }
-  resolveContentPath(uri) {
-    const record = this.getByUri(uri);
-    return record ? this.resolveContentPathOrThrow(record) : null;
-  }
-  async putFromPath(input) {
-    const sourcePath = resolve(input.path);
-    const sourceStats = await stat(sourcePath);
-    if (!sourceStats.isFile()) {
-      throw new Error(`Asset source path is not a file: ${sourcePath}`);
-    }
-    const bytes = readFileSync(sourcePath);
-    const record = this.buildRecord({
-      fileName: input.fileName ?? basename(sourcePath),
-      mimeType: input.mimeType,
-      bytes,
-      createdAt: input.createdAt
-    });
-    const assetDir = this.resolveStorageKeyDirectory(record.storageKey);
-    await mkdir(assetDir, { recursive: true });
-    copyFileSync(sourcePath, join(assetDir, record.storedName));
-    await this.writeMeta(assetDir, record);
-    return record;
-  }
-  async putFromBytes(params) {
-    const bytes = Buffer.from(params.bytes);
-    const record = this.buildRecord({
-      fileName: params.fileName,
-      mimeType: params.mimeType,
-      bytes,
-      createdAt: params.createdAt
-    });
-    const assetDir = this.resolveStorageKeyDirectory(record.storageKey);
-    await mkdir(assetDir, { recursive: true });
-    await writeFile(join(assetDir, record.storedName), bytes);
-    await this.writeMeta(assetDir, record);
-    return record;
-  }
-  buildRecord(params) {
-    const createdAt = params.createdAt ?? /* @__PURE__ */ new Date();
-    const id = buildAssetId();
-    const storageKey = buildStorageKey(createdAt, id);
-    const fileName = normalizeFileName(params.fileName);
-    return {
-      id,
-      uri: buildAssetUri(storageKey),
-      storageKey,
-      fileName,
-      storedName: normalizeSegment(fileName),
-      mimeType: normalizeMimeType(params.mimeType),
-      sizeBytes: params.bytes.length,
-      createdAt: createdAt.toISOString(),
-      sha256: createHash("sha256").update(params.bytes).digest("hex")
-    };
-  }
-  async writeMeta(assetDir, record) {
-    await writeFile(join(assetDir, "meta.json"), `${JSON.stringify(record)}
-`, "utf8");
-  }
-  resolveContentPathOrThrow(record) {
-    return join(this.resolveStorageKeyDirectory(record.storageKey), record.storedName);
-  }
-  resolveStorageKeyDirectory(storageKey) {
-    return join(this.rootDir, ensureStorageKey(storageKey));
-  }
+	rootDir;
+	constructor(options) {
+		this.rootDir = ensureAssetRoot(options.rootDir);
+	}
+	async put(input) {
+		return { uri: (input.kind === "path" ? await this.putFromPath(input) : await this.putFromBytes({
+			fileName: input.fileName,
+			mimeType: input.mimeType,
+			bytes: input.bytes,
+			createdAt: input.createdAt
+		})).uri };
+	}
+	async putBytes(params) {
+		return this.putFromBytes(params);
+	}
+	async putPath(params) {
+		return this.putFromPath({
+			kind: "path",
+			...params
+		});
+	}
+	async export(ref, targetPath) {
+		const record = await this.statRecord(ref.uri);
+		if (!record) throw new Error(`Asset not found: ${ref.uri}`);
+		const outputPath = resolve(targetPath);
+		await ensureParentDirectory(outputPath);
+		await copyFile(this.resolveContentPathOrThrow(record), outputPath);
+		return outputPath;
+	}
+	async stat(ref) {
+		const record = await this.statRecord(ref.uri);
+		return record ? toAssetMeta(record) : null;
+	}
+	getByUri(uri) {
+		const storageKey = parseAssetUri(uri);
+		if (!storageKey) return null;
+		const metaPath = join(this.resolveStorageKeyDirectory(storageKey), "meta.json");
+		if (!existsSync(metaPath)) return null;
+		const text = readFileSync(metaPath, "utf8");
+		return hydrateStoredAssetRecord(JSON.parse(text));
+	}
+	async statRecord(uri) {
+		const record = this.getByUri(uri);
+		if (!record) return null;
+		try {
+			await stat(this.resolveContentPathOrThrow(record));
+			return record;
+		} catch {
+			return null;
+		}
+	}
+	async readAssetBytes(uri) {
+		const record = await this.statRecord(uri);
+		if (!record) return null;
+		try {
+			return await readFile(this.resolveContentPathOrThrow(record));
+		} catch {
+			return null;
+		}
+	}
+	resolveContentPath(uri) {
+		const record = this.getByUri(uri);
+		return record ? this.resolveContentPathOrThrow(record) : null;
+	}
+	async putFromPath(input) {
+		const sourcePath = resolve(input.path);
+		if (!(await stat(sourcePath)).isFile()) throw new Error(`Asset source path is not a file: ${sourcePath}`);
+		const bytes = readFileSync(sourcePath);
+		const record = this.buildRecord({
+			fileName: input.fileName ?? basename(sourcePath),
+			mimeType: input.mimeType,
+			bytes,
+			createdAt: input.createdAt
+		});
+		const assetDir = this.resolveStorageKeyDirectory(record.storageKey);
+		await mkdir(assetDir, { recursive: true });
+		copyFileSync(sourcePath, join(assetDir, record.storedName));
+		await this.writeMeta(assetDir, record);
+		return record;
+	}
+	async putFromBytes(params) {
+		const bytes = Buffer.from(params.bytes);
+		const record = this.buildRecord({
+			fileName: params.fileName,
+			mimeType: params.mimeType,
+			bytes,
+			createdAt: params.createdAt
+		});
+		const assetDir = this.resolveStorageKeyDirectory(record.storageKey);
+		await mkdir(assetDir, { recursive: true });
+		await writeFile(join(assetDir, record.storedName), bytes);
+		await this.writeMeta(assetDir, record);
+		return record;
+	}
+	buildRecord(params) {
+		const createdAt = params.createdAt ?? /* @__PURE__ */ new Date();
+		const id = buildAssetId();
+		const storageKey = buildStorageKey(createdAt, id);
+		const fileName = normalizeFileName(params.fileName);
+		return {
+			id,
+			uri: buildAssetUri(storageKey),
+			storageKey,
+			fileName,
+			storedName: normalizeSegment(fileName),
+			mimeType: normalizeMimeType(params.mimeType),
+			sizeBytes: params.bytes.length,
+			createdAt: createdAt.toISOString(),
+			sha256: createHash("sha256").update(params.bytes).digest("hex")
+		};
+	}
+	async writeMeta(assetDir, record) {
+		await writeFile(join(assetDir, "meta.json"), `${JSON.stringify(record)}\n`, "utf8");
+	}
+	resolveContentPathOrThrow(record) {
+		return join(this.resolveStorageKeyDirectory(record.storageKey), record.storedName);
+	}
+	resolveStorageKeyDirectory(storageKey) {
+		return join(this.rootDir, ensureStorageKey(storageKey));
+	}
 };
 function buildAssetContentPath(params) {
-  const query = new URLSearchParams({ uri: params.assetUri });
-  return `${params.basePath}?${query.toString()}`;
+	const query = new URLSearchParams({ uri: params.assetUri });
+	return `${params.basePath}?${query.toString()}`;
 }
 async function ensureParentDirectory(filePath) {
-  await mkdir(dirname(filePath), { recursive: true });
+	await mkdir(dirname(filePath), { recursive: true });
 }
-
-// src/round-buffer.ts
+//#endregion
+//#region src/round-buffer.ts
 var DefaultNcpRoundBuffer = class {
-  text = "";
-  toolCalls = [];
-  pending = null;
-  appendText = (delta) => {
-    this.text += delta;
-  };
-  getText = () => {
-    return this.text;
-  };
-  appendToolCall = (result) => {
-    this.toolCalls.push(result);
-  };
-  getToolCalls = () => {
-    return [...this.toolCalls];
-  };
-  startToolCall = (toolCallId, toolName) => {
-    this.pending = { toolCallId, toolName, args: void 0 };
-  };
-  appendToolCallArgs = (args) => {
-    if (this.pending) this.pending.args = args;
-  };
-  consumePendingToolCall = () => {
-    const p = this.pending;
-    this.pending = null;
-    return p;
-  };
-  clear = () => {
-    this.text = "";
-    this.toolCalls.length = 0;
-    this.pending = null;
-  };
+	text = "";
+	toolCalls = [];
+	pending = null;
+	appendText = (delta) => {
+		this.text += delta;
+	};
+	getText = () => {
+		return this.text;
+	};
+	appendToolCall = (result) => {
+		this.toolCalls.push(result);
+	};
+	getToolCalls = () => {
+		return [...this.toolCalls];
+	};
+	startToolCall = (toolCallId, toolName) => {
+		this.pending = {
+			toolCallId,
+			toolName,
+			args: void 0
+		};
+	};
+	appendToolCallArgs = (args) => {
+		if (this.pending) this.pending.args = args;
+	};
+	consumePendingToolCall = () => {
+		const p = this.pending;
+		this.pending = null;
+		return p;
+	};
+	clear = () => {
+		this.text = "";
+		this.toolCalls.length = 0;
+		this.pending = null;
+	};
 };
-
-// src/stream-encoder.ts
-import {
-  NcpEventType as NcpEventType2
-} from "@nextclaw/ncp";
-
-// src/stream-encoder.utils.ts
-import {
-  NcpAssistantTextStreamNormalizer
-} from "@nextclaw/ncp";
-import { NcpEventType } from "@nextclaw/ncp";
+//#endregion
+//#region src/stream-encoder.utils.ts
 function getToolCallIndex(toolDelta, fallback) {
-  const idx = toolDelta.index;
-  return typeof idx === "number" && Number.isFinite(idx) ? idx : fallback;
+	const idx = toolDelta.index;
+	return typeof idx === "number" && Number.isFinite(idx) ? idx : fallback;
 }
 function applyToolDelta(current, toolDelta) {
-  const next = { ...current, argumentsText: current.argumentsText };
-  if (typeof toolDelta.id === "string" && toolDelta.id.trim()) {
-    next.id = toolDelta.id;
-  }
-  const fn = toolDelta.function;
-  if (fn && typeof fn === "object" && !Array.isArray(fn)) {
-    if (typeof fn.name === "string" && fn.name.trim()) {
-      next.name = fn.name.trim();
-    }
-    if (typeof fn.arguments === "string" && fn.arguments.length > 0) {
-      next.argumentsText += fn.arguments;
-    }
-  }
-  return next;
+	const next = {
+		...current,
+		argumentsText: current.argumentsText
+	};
+	if (typeof toolDelta.id === "string" && toolDelta.id.trim()) next.id = toolDelta.id;
+	const fn = toolDelta.function;
+	if (fn && typeof fn === "object" && !Array.isArray(fn)) {
+		if (typeof fn.name === "string" && fn.name.trim()) next.name = fn.name.trim();
+		if (typeof fn.arguments === "string" && fn.arguments.length > 0) next.argumentsText += fn.arguments;
+	}
+	return next;
 }
 function* emitTextDeltas(delta, ctx, state) {
-  const content = delta.content;
-  if (typeof content !== "string" || content.length === 0) return state;
-  if (state.normalizer) {
-    let textStarted = state.textStarted;
-    for (const segment of state.normalizer.push(content)) {
-      if (segment.type === "reasoning") {
-        yield {
-          type: NcpEventType.MessageReasoningDelta,
-          payload: { ...ctx, delta: segment.text }
-        };
-        continue;
-      }
-      if (!textStarted) {
-        yield { type: NcpEventType.MessageTextStart, payload: ctx };
-        textStarted = true;
-      }
-      yield {
-        type: NcpEventType.MessageTextDelta,
-        payload: { ...ctx, delta: segment.text }
-      };
-    }
-    return {
-      ...state,
-      textStarted
-    };
-  }
-  if (!state.textStarted) {
-    yield { type: NcpEventType.MessageTextStart, payload: ctx };
-    yield { type: NcpEventType.MessageTextDelta, payload: { ...ctx, delta: content } };
-    return {
-      ...state,
-      textStarted: true
-    };
-  }
-  yield { type: NcpEventType.MessageTextDelta, payload: { ...ctx, delta: content } };
-  return state;
+	const content = delta.content;
+	if (typeof content !== "string" || content.length === 0) return state;
+	if (state.normalizer) {
+		let textStarted = state.textStarted;
+		for (const segment of state.normalizer.push(content)) {
+			if (segment.type === "reasoning") {
+				yield {
+					type: NcpEventType.MessageReasoningDelta,
+					payload: {
+						...ctx,
+						delta: segment.text
+					}
+				};
+				continue;
+			}
+			if (!textStarted) {
+				yield {
+					type: NcpEventType.MessageTextStart,
+					payload: ctx
+				};
+				textStarted = true;
+			}
+			yield {
+				type: NcpEventType.MessageTextDelta,
+				payload: {
+					...ctx,
+					delta: segment.text
+				}
+			};
+		}
+		return {
+			...state,
+			textStarted
+		};
+	}
+	if (!state.textStarted) {
+		yield {
+			type: NcpEventType.MessageTextStart,
+			payload: ctx
+		};
+		yield {
+			type: NcpEventType.MessageTextDelta,
+			payload: {
+				...ctx,
+				delta: content
+			}
+		};
+		return {
+			...state,
+			textStarted: true
+		};
+	}
+	yield {
+		type: NcpEventType.MessageTextDelta,
+		payload: {
+			...ctx,
+			delta: content
+		}
+	};
+	return state;
 }
 function* flushTextDeltas(ctx, state) {
-  if (!state.normalizer) {
-    return state;
-  }
-  let textStarted = state.textStarted;
-  for (const segment of state.normalizer.finish()) {
-    if (segment.type === "reasoning") {
-      yield {
-        type: NcpEventType.MessageReasoningDelta,
-        payload: { ...ctx, delta: segment.text }
-      };
-      continue;
-    }
-    if (!textStarted) {
-      yield { type: NcpEventType.MessageTextStart, payload: ctx };
-      textStarted = true;
-    }
-    yield {
-      type: NcpEventType.MessageTextDelta,
-      payload: { ...ctx, delta: segment.text }
-    };
-  }
-  return {
-    ...state,
-    textStarted
-  };
+	if (!state.normalizer) return state;
+	let textStarted = state.textStarted;
+	for (const segment of state.normalizer.finish()) {
+		if (segment.type === "reasoning") {
+			yield {
+				type: NcpEventType.MessageReasoningDelta,
+				payload: {
+					...ctx,
+					delta: segment.text
+				}
+			};
+			continue;
+		}
+		if (!textStarted) {
+			yield {
+				type: NcpEventType.MessageTextStart,
+				payload: ctx
+			};
+			textStarted = true;
+		}
+		yield {
+			type: NcpEventType.MessageTextDelta,
+			payload: {
+				...ctx,
+				delta: segment.text
+			}
+		};
+	}
+	return {
+		...state,
+		textStarted
+	};
 }
 function* emitReasoningDelta(delta, ctx) {
-  const reasoning = delta.reasoning_content ?? delta.reasoning;
-  if (typeof reasoning !== "string" || !reasoning) return;
-  yield { type: NcpEventType.MessageReasoningDelta, payload: { ...ctx, delta: reasoning } };
+	const reasoning = delta.reasoning_content ?? delta.reasoning;
+	if (typeof reasoning !== "string" || !reasoning) return;
+	yield {
+		type: NcpEventType.MessageReasoningDelta,
+		payload: {
+			...ctx,
+			delta: reasoning
+		}
+	};
 }
 function* emitToolCallDeltas(delta, buffers, ctx) {
-  const toolDeltas = delta.tool_calls;
-  if (!Array.isArray(toolDeltas)) return;
-  for (const toolDelta of toolDeltas) {
-    const index = getToolCallIndex(toolDelta, buffers.size);
-    const prev = buffers.get(index) ?? {
-      argumentsText: "",
-      pendingArgumentDeltas: []
-    };
-    const current = applyToolDelta(prev, toolDelta);
-    const argsDelta = typeof toolDelta.function?.arguments === "string" && toolDelta.function.arguments.length > 0 ? toolDelta.function.arguments : null;
-    const toolCallId = current.id;
-    const toolName = current.name;
-    if (toolCallId && toolName && !current.emittedStart) {
-      yield {
-        type: NcpEventType.MessageToolCallStart,
-        payload: { ...ctx, toolCallId, toolName }
-      };
-      current.emittedStart = true;
-    }
-    if (argsDelta) {
-      if (current.emittedStart && current.id) {
-        yield {
-          type: NcpEventType.MessageToolCallArgsDelta,
-          payload: {
-            ...ctx,
-            toolCallId: current.id,
-            delta: argsDelta
-          }
-        };
-        current.emittedArgsDelta = true;
-      } else {
-        current.pendingArgumentDeltas = [
-          ...current.pendingArgumentDeltas ?? [],
-          argsDelta
-        ];
-      }
-    }
-    if (current.emittedStart && current.id && (current.pendingArgumentDeltas?.length ?? 0) > 0) {
-      for (const pendingDelta of current.pendingArgumentDeltas ?? []) {
-        yield {
-          type: NcpEventType.MessageToolCallArgsDelta,
-          payload: {
-            ...ctx,
-            toolCallId: current.id,
-            delta: pendingDelta
-          }
-        };
-      }
-      current.emittedArgsDelta = true;
-      current.pendingArgumentDeltas = [];
-    }
-    buffers.set(index, current);
-  }
+	const toolDeltas = delta.tool_calls;
+	if (!Array.isArray(toolDeltas)) return;
+	for (const toolDelta of toolDeltas) {
+		const index = getToolCallIndex(toolDelta, buffers.size);
+		const current = applyToolDelta(buffers.get(index) ?? {
+			argumentsText: "",
+			pendingArgumentDeltas: []
+		}, toolDelta);
+		const argsDelta = typeof toolDelta.function?.arguments === "string" && toolDelta.function.arguments.length > 0 ? toolDelta.function.arguments : null;
+		const toolCallId = current.id;
+		const toolName = current.name;
+		if (toolCallId && toolName && !current.emittedStart) {
+			yield {
+				type: NcpEventType.MessageToolCallStart,
+				payload: {
+					...ctx,
+					toolCallId,
+					toolName
+				}
+			};
+			current.emittedStart = true;
+		}
+		if (argsDelta) if (current.emittedStart && current.id) {
+			yield {
+				type: NcpEventType.MessageToolCallArgsDelta,
+				payload: {
+					...ctx,
+					toolCallId: current.id,
+					delta: argsDelta
+				}
+			};
+			current.emittedArgsDelta = true;
+		} else current.pendingArgumentDeltas = [...current.pendingArgumentDeltas ?? [], argsDelta];
+		if (current.emittedStart && current.id && (current.pendingArgumentDeltas?.length ?? 0) > 0) {
+			for (const pendingDelta of current.pendingArgumentDeltas ?? []) yield {
+				type: NcpEventType.MessageToolCallArgsDelta,
+				payload: {
+					...ctx,
+					toolCallId: current.id,
+					delta: pendingDelta
+				}
+			};
+			current.emittedArgsDelta = true;
+			current.pendingArgumentDeltas = [];
+		}
+		buffers.set(index, current);
+	}
 }
 function* flushToolCalls(buffers, ctx) {
-  const ordered = Array.from(buffers.entries()).sort(([a], [b]) => a - b);
-  for (const [, buf] of ordered) {
-    if (!buf.id || !buf.name) continue;
-    if (!buf.emittedArgsDelta) {
-      yield {
-        type: NcpEventType.MessageToolCallArgs,
-        payload: { ...ctx, toolCallId: buf.id, args: buf.argumentsText }
-      };
-    }
-    yield {
-      type: NcpEventType.MessageToolCallEnd,
-      payload: { ...ctx, toolCallId: buf.id }
-    };
-  }
+	const ordered = Array.from(buffers.entries()).sort(([a], [b]) => a - b);
+	for (const [, buf] of ordered) {
+		if (!buf.id || !buf.name) continue;
+		if (!buf.emittedArgsDelta) yield {
+			type: NcpEventType.MessageToolCallArgs,
+			payload: {
+				...ctx,
+				toolCallId: buf.id,
+				args: buf.argumentsText
+			}
+		};
+		yield {
+			type: NcpEventType.MessageToolCallEnd,
+			payload: {
+				...ctx,
+				toolCallId: buf.id
+			}
+		};
+	}
 }
 function createStreamContentState(reasoningNormalizationMode) {
-  return {
-    textStarted: false,
-    normalizer: reasoningNormalizationMode === "think-tags" ? new NcpAssistantTextStreamNormalizer(reasoningNormalizationMode) : null
-  };
+	return {
+		textStarted: false,
+		normalizer: reasoningNormalizationMode === "think-tags" ? new NcpAssistantTextStreamNormalizer(reasoningNormalizationMode) : null
+	};
 }
-
-// src/stream-encoder.ts
+//#endregion
+//#region src/stream-encoder.ts
+/**
+* Converts LLM stream chunks to NCP events (text, reasoning, tool calls).
+* Does not emit RunFinished; that is the runtime's responsibility after the loop completes.
+*/
 var DefaultNcpStreamEncoder = class {
-  reasoningNormalizationMode;
-  constructor(config = {}) {
-    this.reasoningNormalizationMode = config.reasoningNormalizationMode ?? "off";
-  }
-  async *encode(stream, context) {
-    const { sessionId, messageId } = context;
-    let state = createStreamContentState(this.reasoningNormalizationMode);
-    const toolCallBuffers = /* @__PURE__ */ new Map();
-    for await (const chunk of stream) {
-      const choice = chunk.choices?.[0];
-      if (!choice) continue;
-      const delta = choice.delta;
-      if (delta) {
-        yield* emitReasoningDelta(delta, { sessionId, messageId });
-        const nextState = yield* emitTextDeltas(delta, { sessionId, messageId }, state);
-        state = nextState;
-        yield* emitToolCallDeltas(delta, toolCallBuffers, { sessionId, messageId });
-      }
-      const finishReason = choice.finish_reason;
-      if (typeof finishReason === "string" && finishReason.trim().length > 0) {
-        state = yield* flushTextDeltas({ sessionId, messageId }, state);
-        yield* flushToolCalls(toolCallBuffers, { sessionId, messageId });
-        if (state.textStarted) {
-          yield { type: NcpEventType2.MessageTextEnd, payload: { sessionId, messageId } };
-        }
-      }
-    }
-  }
+	reasoningNormalizationMode;
+	constructor(config = {}) {
+		this.reasoningNormalizationMode = config.reasoningNormalizationMode ?? "off";
+	}
+	async *encode(stream, context) {
+		const { sessionId, messageId } = context;
+		let state = createStreamContentState(this.reasoningNormalizationMode);
+		const toolCallBuffers = /* @__PURE__ */ new Map();
+		for await (const chunk of stream) {
+			const choice = chunk.choices?.[0];
+			if (!choice) continue;
+			const delta = choice.delta;
+			if (delta) {
+				yield* emitReasoningDelta(delta, {
+					sessionId,
+					messageId
+				});
+				state = yield* emitTextDeltas(delta, {
+					sessionId,
+					messageId
+				}, state);
+				yield* emitToolCallDeltas(delta, toolCallBuffers, {
+					sessionId,
+					messageId
+				});
+			}
+			const finishReason = choice.finish_reason;
+			if (typeof finishReason === "string" && finishReason.trim().length > 0) {
+				state = yield* flushTextDeltas({
+					sessionId,
+					messageId
+				}, state);
+				yield* flushToolCalls(toolCallBuffers, {
+					sessionId,
+					messageId
+				});
+				if (state.textStarted) yield {
+					type: NcpEventType.MessageTextEnd,
+					payload: {
+						sessionId,
+						messageId
+					}
+				};
+			}
+		}
+	}
 };
-
-// src/tool-registry.ts
+//#endregion
+//#region src/tool-registry.ts
 var DefaultNcpToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  constructor(tools = []) {
-    for (const t of tools) {
-      this.tools.set(t.name, t);
-    }
-  }
-  register = (tool) => {
-    this.tools.set(tool.name, tool);
-  };
-  listTools = () => {
-    return [...this.tools.values()];
-  };
-  getTool = (name) => {
-    return this.tools.get(name);
-  };
-  getToolDefinitions = () => {
-    return this.listTools().map((t) => ({
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters
-    }));
-  };
-  execute = async (_toolCallId, toolName, args) => {
-    const tool = this.tools.get(toolName);
-    return tool ? await tool.execute(args) : void 0;
-  };
+	tools = /* @__PURE__ */ new Map();
+	constructor(tools = []) {
+		for (const t of tools) this.tools.set(t.name, t);
+	}
+	register = (tool) => {
+		this.tools.set(tool.name, tool);
+	};
+	listTools = () => {
+		return [...this.tools.values()];
+	};
+	getTool = (name) => {
+		return this.tools.get(name);
+	};
+	getToolDefinitions = () => {
+		return this.listTools().map((t) => ({
+			name: t.name,
+			description: t.description,
+			parameters: t.parameters
+		}));
+	};
+	execute = async (_toolCallId, toolName, args) => {
+		const tool = this.tools.get(toolName);
+		return tool ? await tool.execute(args) : void 0;
+	};
 };
-
-// src/llm-api-echo.ts
+//#endregion
+//#region src/llm-api-echo.ts
 function getLastUserContent(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const m = messages[i];
-    if (m.role !== "user") continue;
-    if (typeof m.content === "string") return m.content;
-    if (Array.isArray(m.content)) {
-      return m.content.map((p) => p.type === "text" ? p.text : "").join("");
-    }
-  }
-  return "";
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const m = messages[i];
+		if (m.role !== "user") continue;
+		if (typeof m.content === "string") return m.content;
+		if (Array.isArray(m.content)) return m.content.map((p) => p.type === "text" ? p.text : "").join("");
+	}
+	return "";
 }
 var EchoNcpLLMApi = class {
-  generate = async function* (input, options) {
-    const text = getLastUserContent(input.messages);
-    const signal = options?.signal;
-    for (const char of text) {
-      if (signal?.aborted) break;
-      yield {
-        choices: [{ index: 0, delta: { content: char } }]
-      };
-    }
-    yield {
-      choices: [
-        {
-          index: 0,
-          delta: {},
-          finish_reason: "stop"
-        }
-      ],
-      usage: { prompt_tokens: 0, completion_tokens: text.length, total_tokens: text.length }
-    };
-  };
+	generate = async function* (input, options) {
+		const text = getLastUserContent(input.messages);
+		const signal = options?.signal;
+		for (const char of text) {
+			if (signal?.aborted) break;
+			yield { choices: [{
+				index: 0,
+				delta: { content: char }
+			}] };
+		}
+		yield {
+			choices: [{
+				index: 0,
+				delta: {},
+				finish_reason: "stop"
+			}],
+			usage: {
+				prompt_tokens: 0,
+				completion_tokens: text.length,
+				total_tokens: text.length
+			}
+		};
+	};
 };
-
-// src/runtime.ts
-import {
-  isHiddenNcpMessage,
-  NcpEventType as NcpEventType3
-} from "@nextclaw/ncp";
-
-// src/utils.ts
+//#endregion
+//#region src/utils.ts
+const toolSchemaValidator = new AjvPkg({
+	allErrors: true,
+	strict: false,
+	removeAdditional: false
+});
+const validatorCache = /* @__PURE__ */ new WeakMap();
 function genId() {
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
 }
 function stringifyRawArgs(args) {
-  if (typeof args === "string") {
-    return args;
-  }
-  if (args && typeof args === "object" && !Array.isArray(args)) {
-    try {
-      return JSON.stringify(args);
-    } catch {
-      return "[unserializable-object]";
-    }
-  }
-  return String(args ?? "");
+	if (typeof args === "string") return args;
+	if (args && typeof args === "object" && !Array.isArray(args)) try {
+		return JSON.stringify(args);
+	} catch {
+		return "[unserializable-object]";
+	}
+	return String(args ?? "");
 }
 function parseToolArgs(args) {
-  if (args && typeof args === "object" && !Array.isArray(args)) {
-    return {
-      ok: true,
-      rawText: stringifyRawArgs(args),
-      value: args
-    };
-  }
-  const rawText = stringifyRawArgs(args);
-  if (typeof args !== "string") {
-    return {
-      ok: false,
-      rawText,
-      issues: ["Tool arguments must be a JSON object string."]
-    };
-  }
-  const trimmed = args.trim();
-  if (!trimmed) {
-    return {
-      ok: false,
-      rawText,
-      issues: ["Tool arguments are empty."]
-    };
-  }
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return {
-        ok: false,
-        rawText,
-        issues: ["Tool arguments JSON must decode to an object."]
-      };
-    }
-    return {
-      ok: true,
-      rawText,
-      value: parsed
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      rawText,
-      issues: [error instanceof Error ? error.message : "Failed to parse tool arguments JSON."]
-    };
-  }
+	if (args && typeof args === "object" && !Array.isArray(args)) return {
+		ok: true,
+		rawText: stringifyRawArgs(args),
+		value: args
+	};
+	const rawText = stringifyRawArgs(args);
+	if (typeof args !== "string") return {
+		ok: false,
+		rawText,
+		issues: ["Tool arguments must be a JSON object string."]
+	};
+	const trimmed = args.trim();
+	if (!trimmed) return {
+		ok: false,
+		rawText,
+		issues: ["Tool arguments are empty."]
+	};
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {
+			ok: false,
+			rawText,
+			issues: ["Tool arguments JSON must decode to an object."]
+		};
+		return {
+			ok: true,
+			rawText,
+			value: parsed
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			rawText,
+			issues: [error instanceof Error ? error.message : "Failed to parse tool arguments JSON."]
+		};
+	}
 }
 function validateToolArgs(args, schema) {
-  if (!schema) {
-    return [];
-  }
-  return validateToolValue(args, schema, "");
+	if (!schema) return [];
+	const validate = getOrCreateValidator(schema);
+	if (validate(args)) return [];
+	return formatSchemaIssues(validate.errors);
 }
-function validateToolValue(value, schema, path) {
-  const label = path || "parameter";
-  const type = typeof schema.type === "string" ? schema.type : void 0;
-  if (type && !matchesSchemaType(value, type)) {
-    return [`${label} should be ${type}`];
-  }
-  const errors = [];
-  if (schema.enum && !schema.enum.includes(value)) {
-    errors.push(`${label} must be one of ${JSON.stringify(schema.enum)}`);
-  }
-  if (typeof value === "number") {
-    if (schema.minimum !== void 0 && value < schema.minimum) {
-      errors.push(`${label} must be >= ${schema.minimum}`);
-    }
-    if (schema.maximum !== void 0 && value > schema.maximum) {
-      errors.push(`${label} must be <= ${schema.maximum}`);
-    }
-  }
-  if (typeof value === "string") {
-    if (schema.minLength !== void 0 && value.length < schema.minLength) {
-      errors.push(`${label} must be at least ${schema.minLength} chars`);
-    }
-    if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
-      errors.push(`${label} must be at most ${schema.maxLength} chars`);
-    }
-  }
-  if (type === "object") {
-    const objectValue = value;
-    for (const key of schema.required ?? []) {
-      if (!(key in objectValue)) {
-        errors.push(`missing required ${path ? `${path}.${key}` : key}`);
-      }
-    }
-    const properties = schema.properties ?? {};
-    for (const [key, childValue] of Object.entries(objectValue)) {
-      const childSchema = properties[key];
-      if (!childSchema) {
-        continue;
-      }
-      errors.push(...validateToolValue(childValue, childSchema, path ? `${path}.${key}` : key));
-    }
-  }
-  if (type === "array" && schema.items && Array.isArray(value)) {
-    value.forEach((item, index) => {
-      errors.push(...validateToolValue(item, schema.items, `${label}[${index}]`));
-    });
-  }
-  return errors;
+function getOrCreateValidator(schema) {
+	const cached = validatorCache.get(schema);
+	if (cached) return cached;
+	const validate = toolSchemaValidator.compile(schema);
+	validatorCache.set(schema, validate);
+	return validate;
 }
-function matchesSchemaType(value, type) {
-  switch (type) {
-    case "string":
-      return typeof value === "string";
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "number":
-      return typeof value === "number";
-    case "boolean":
-      return typeof value === "boolean";
-    case "array":
-      return Array.isArray(value);
-    case "object":
-      return typeof value === "object" && value !== null && !Array.isArray(value);
-    default:
-      return true;
-  }
+function formatSchemaIssues(errors) {
+	if (!errors || errors.length === 0) return ["Tool arguments do not match the declared schema."];
+	return errors.map((error) => {
+		const instancePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+		if (error.keyword === "required" && "missingProperty" in error.params && typeof error.params.missingProperty === "string") return `${instancePath ? `${instancePath}.${error.params.missingProperty}` : error.params.missingProperty} is required`;
+		if (error.keyword === "additionalProperties" && "additionalProperty" in error.params && typeof error.params.additionalProperty === "string") return `${instancePath ? `${instancePath}.${error.params.additionalProperty}` : error.params.additionalProperty} is not allowed`;
+		return `${instancePath || "parameter"}: ${error.message ?? "invalid"}`;
+	});
 }
 function createInvalidToolArgumentsResult(params) {
-  return {
-    ok: false,
-    error: {
-      code: "invalid_tool_arguments",
-      message: "Tool arguments are invalid.",
-      toolCallId: params.toolCallId,
-      toolName: params.toolName,
-      rawArgumentsText: params.rawArgumentsText,
-      issues: params.issues
-    }
-  };
+	return {
+		ok: false,
+		error: {
+			code: "invalid_tool_arguments",
+			message: "Tool arguments are invalid.",
+			toolCallId: params.toolCallId,
+			toolName: params.toolName,
+			rawArgumentsText: params.rawArgumentsText,
+			issues: params.issues
+		}
+	};
+}
+function createToolExecutionFailedResult(params) {
+	const { toolCallId, toolName, error } = params;
+	return {
+		ok: false,
+		error: {
+			code: "tool_execution_failed",
+			message: error instanceof Error ? error.message : String(error),
+			toolCallId,
+			toolName
+		}
+	};
 }
 function appendToolRoundToInput(input, reasoning, text, toolResults) {
-  const assistantMsg = {
-    role: "assistant",
-    content: text || null,
-    ...reasoning ? { reasoning_content: reasoning } : {},
-    tool_calls: toolResults.map((tr) => ({
-      id: tr.toolCallId,
-      type: "function",
-      function: {
-        name: tr.toolName,
-        arguments: tr.rawArgsText
-      }
-    }))
-  };
-  const toolMsgs = toolResults.map((tr) => ({
-    role: "tool",
-    content: typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result ?? {}),
-    tool_call_id: tr.toolCallId
-  }));
-  return {
-    ...input,
-    messages: [...input.messages, assistantMsg, ...toolMsgs]
-  };
+	const assistantMsg = {
+		role: "assistant",
+		content: text || null,
+		...reasoning ? { reasoning_content: reasoning } : {},
+		tool_calls: toolResults.map((tr) => ({
+			id: tr.toolCallId,
+			type: "function",
+			function: {
+				name: tr.toolName,
+				arguments: tr.rawArgsText
+			}
+		}))
+	};
+	const toolMsgs = toolResults.map((tr) => ({
+		role: "tool",
+		content: typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result ?? {}),
+		tool_call_id: tr.toolCallId
+	}));
+	return {
+		...input,
+		messages: [
+			...input.messages,
+			assistantMsg,
+			...toolMsgs
+		]
+	};
 }
-
-// src/round-collector.ts
-import {
-  normalizeAssistantText
-} from "@nextclaw/ncp";
+//#endregion
+//#region src/round-collector.ts
 var DefaultNcpRoundCollector = class {
-  constructor(reasoningNormalizationMode = "off") {
-    this.reasoningNormalizationMode = reasoningNormalizationMode;
-  }
-  rawText = "";
-  explicitReasoning = "";
-  toolCallBuffers = /* @__PURE__ */ new Map();
-  clear() {
-    this.rawText = "";
-    this.explicitReasoning = "";
-    this.toolCallBuffers.clear();
-  }
-  consumeChunk(chunk) {
-    const choice = chunk.choices?.[0];
-    if (!choice) {
-      return;
-    }
-    const delta = choice.delta;
-    if (!delta) {
-      return;
-    }
-    if (typeof delta.content === "string" && delta.content.length > 0) {
-      this.rawText += delta.content;
-    }
-    const reasoning = delta.reasoning_content ?? delta.reasoning;
-    if (typeof reasoning === "string" && reasoning.length > 0) {
-      this.explicitReasoning += reasoning;
-    }
-    const toolDeltas = delta.tool_calls;
-    if (!Array.isArray(toolDeltas)) {
-      return;
-    }
-    for (const toolDelta of toolDeltas) {
-      const index = getToolCallIndex(toolDelta, this.toolCallBuffers.size);
-      const previous = this.toolCallBuffers.get(index) ?? { argumentsText: "" };
-      const current = applyToolDelta(previous, toolDelta);
-      this.toolCallBuffers.set(index, current);
-    }
-  }
-  getText() {
-    if (this.reasoningNormalizationMode !== "think-tags") {
-      return this.rawText;
-    }
-    return normalizeAssistantText(this.rawText, this.reasoningNormalizationMode).text;
-  }
-  getReasoning() {
-    if (this.explicitReasoning.length > 0) {
-      return this.explicitReasoning;
-    }
-    if (this.reasoningNormalizationMode !== "think-tags") {
-      return "";
-    }
-    return normalizeAssistantText(this.rawText, this.reasoningNormalizationMode).reasoning;
-  }
-  getToolCalls() {
-    const orderedEntries = Array.from(this.toolCallBuffers.entries()).sort(([left], [right]) => left - right);
-    const toolCalls = [];
-    for (const [, buffer] of orderedEntries) {
-      if (!buffer.id || !buffer.name) {
-        continue;
-      }
-      toolCalls.push({
-        toolCallId: buffer.id,
-        toolName: buffer.name,
-        args: buffer.argumentsText
-      });
-    }
-    return toolCalls;
-  }
+	rawText = "";
+	explicitReasoning = "";
+	toolCallBuffers = /* @__PURE__ */ new Map();
+	constructor(reasoningNormalizationMode = "off") {
+		this.reasoningNormalizationMode = reasoningNormalizationMode;
+	}
+	clear() {
+		this.rawText = "";
+		this.explicitReasoning = "";
+		this.toolCallBuffers.clear();
+	}
+	consumeChunk(chunk) {
+		const choice = chunk.choices?.[0];
+		if (!choice) return;
+		const delta = choice.delta;
+		if (!delta) return;
+		if (typeof delta.content === "string" && delta.content.length > 0) this.rawText += delta.content;
+		const reasoning = delta.reasoning_content ?? delta.reasoning;
+		if (typeof reasoning === "string" && reasoning.length > 0) this.explicitReasoning += reasoning;
+		const toolDeltas = delta.tool_calls;
+		if (!Array.isArray(toolDeltas)) return;
+		for (const toolDelta of toolDeltas) {
+			const index = getToolCallIndex(toolDelta, this.toolCallBuffers.size);
+			const current = applyToolDelta(this.toolCallBuffers.get(index) ?? { argumentsText: "" }, toolDelta);
+			this.toolCallBuffers.set(index, current);
+		}
+	}
+	getText() {
+		if (this.reasoningNormalizationMode !== "think-tags") return this.rawText;
+		return normalizeAssistantText(this.rawText, this.reasoningNormalizationMode).text;
+	}
+	getReasoning() {
+		if (this.explicitReasoning.length > 0) return this.explicitReasoning;
+		if (this.reasoningNormalizationMode !== "think-tags") return "";
+		return normalizeAssistantText(this.rawText, this.reasoningNormalizationMode).reasoning;
+	}
+	getToolCalls() {
+		const orderedEntries = Array.from(this.toolCallBuffers.entries()).sort(([left], [right]) => left - right);
+		const toolCalls = [];
+		for (const [, buffer] of orderedEntries) {
+			if (!buffer.id || !buffer.name) continue;
+			toolCalls.push({
+				toolCallId: buffer.id,
+				toolName: buffer.name,
+				args: buffer.argumentsText
+			});
+		}
+		return toolCalls;
+	}
 };
-
-// src/runtime.ts
+//#endregion
+//#region src/runtime.ts
 var DefaultNcpAgentRuntime = class {
-  contextBuilder;
-  llmApi;
-  toolRegistry;
-  stateManager;
-  streamEncoder;
-  reasoningNormalizationMode;
-  constructor(config) {
-    this.contextBuilder = config.contextBuilder;
-    this.llmApi = config.llmApi;
-    this.toolRegistry = config.toolRegistry;
-    this.stateManager = config.stateManager;
-    this.reasoningNormalizationMode = config.reasoningNormalizationMode ?? "off";
-    this.streamEncoder = config.streamEncoder ?? new DefaultNcpStreamEncoder({
-      reasoningNormalizationMode: this.reasoningNormalizationMode
-    });
-  }
-  run = async function* (input, options) {
-    const ctx = {
-      messageId: genId(),
-      runId: genId(),
-      sessionId: input.sessionId,
-      correlationId: input.correlationId
-    };
-    const sessionMessages = this.stateManager.getSnapshot().messages;
-    const modelInput = this.contextBuilder.prepare(input, {
-      sessionMessages
-    });
-    for (const msg of input.messages) {
-      if (isHiddenNcpMessage(msg)) {
-        continue;
-      }
-      const messageSent = {
-        type: NcpEventType3.MessageSent,
-        payload: { sessionId: input.sessionId, message: msg }
-      };
-      await this.stateManager.dispatch(messageSent);
-    }
-    const runStarted = {
-      type: NcpEventType3.RunStarted,
-      payload: { sessionId: ctx.sessionId, messageId: ctx.messageId, runId: ctx.runId }
-    };
-    await this.stateManager.dispatch(runStarted);
-    yield runStarted;
-    for await (const event of this.runLoop(modelInput, ctx, options)) {
-      await this.stateManager.dispatch(event);
-      yield event;
-    }
-  };
-  /**
-   * Agent loop: LLM stream → encoder events → tool execution (if any) → next round or finish.
-   * RunFinished is emitted only when the entire loop completes (no more tool calls).
-   * The stream encoder does not emit RunFinished; it only converts chunks to NCP events.
-   */
-  runLoop = async function* (llmInput, ctx, options) {
-    const roundCollector = new DefaultNcpRoundCollector(this.reasoningNormalizationMode);
-    let currentInput = llmInput;
-    let done = false;
-    while (!done && !options?.signal?.aborted) {
-      roundCollector.clear();
-      const stream = this.llmApi.generate(currentInput, { signal: options?.signal });
-      const tappedStream = this.tapStream(stream, (chunk) => roundCollector.consumeChunk(chunk));
-      for await (const event of this.streamEncoder.encode(tappedStream, ctx)) {
-        yield event;
-      }
-      const toolResults = [];
-      for (const toolCall of roundCollector.getToolCalls()) {
-        const tool = this.toolRegistry.getTool(toolCall.toolName);
-        const parsedArgs = parseToolArgs(toolCall.args);
-        let result;
-        let args = null;
-        if (!parsedArgs.ok) {
-          result = createInvalidToolArgumentsResult({
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            rawArgumentsText: parsedArgs.rawText,
-            issues: parsedArgs.issues
-          });
-        } else {
-          const schemaIssues = validateToolArgs(parsedArgs.value, tool?.parameters);
-          const validationIssues = schemaIssues.length > 0 ? schemaIssues : typeof tool?.validateArgs === "function" ? tool.validateArgs(parsedArgs.value) : [];
-          if (validationIssues.length > 0) {
-            result = createInvalidToolArgumentsResult({
-              toolCallId: toolCall.toolCallId,
-              toolName: toolCall.toolName,
-              rawArgumentsText: parsedArgs.rawText,
-              issues: validationIssues
-            });
-          } else {
-            args = parsedArgs.value;
-            result = await this.toolRegistry.execute(
-              toolCall.toolCallId,
-              toolCall.toolName,
-              parsedArgs.value
-            );
-          }
-        }
-        toolResults.push({
-          toolCallId: toolCall.toolCallId,
-          toolName: toolCall.toolName,
-          args,
-          rawArgsText: parsedArgs.rawText,
-          result
-        });
-        yield {
-          type: NcpEventType3.MessageToolCallResult,
-          payload: {
-            sessionId: ctx.sessionId,
-            toolCallId: toolCall.toolCallId,
-            content: result
-          }
-        };
-      }
-      if (toolResults.length === 0) {
-        yield {
-          type: NcpEventType3.RunFinished,
-          payload: { sessionId: ctx.sessionId, messageId: ctx.messageId, runId: ctx.runId }
-        };
-        done = true;
-        break;
-      }
-      currentInput = appendToolRoundToInput(
-        currentInput,
-        roundCollector.getReasoning(),
-        roundCollector.getText(),
-        toolResults
-      );
-    }
-  };
-  tapStream = async function* (stream, onChunk) {
-    for await (const chunk of stream) {
-      onChunk(chunk);
-      yield chunk;
-    }
-  };
-};
-export {
-  DefaultNcpAgentRuntime,
-  DefaultNcpContextBuilder,
-  DefaultNcpRoundBuffer,
-  DefaultNcpStreamEncoder,
-  DefaultNcpToolRegistry,
-  EchoNcpLLMApi,
-  LocalAssetStore,
-  buildAssetContentPath,
-  buildNcpUserContent,
-  isTextLikeAsset
+	contextBuilder;
+	llmApi;
+	toolRegistry;
+	stateManager;
+	streamEncoder;
+	reasoningNormalizationMode;
+	constructor(config) {
+		this.contextBuilder = config.contextBuilder;
+		this.llmApi = config.llmApi;
+		this.toolRegistry = config.toolRegistry;
+		this.stateManager = config.stateManager;
+		this.reasoningNormalizationMode = config.reasoningNormalizationMode ?? "off";
+		this.streamEncoder = config.streamEncoder ?? new DefaultNcpStreamEncoder({ reasoningNormalizationMode: this.reasoningNormalizationMode });
+	}
+	run = async function* (input, options) {
+		const ctx = {
+			messageId: genId(),
+			runId: genId(),
+			sessionId: input.sessionId,
+			correlationId: input.correlationId
+		};
+		const sessionMessages = this.stateManager.getSnapshot().messages;
+		const modelInput = this.contextBuilder.prepare(input, { sessionMessages });
+		for (const msg of input.messages) {
+			if (isHiddenNcpMessage(msg)) continue;
+			const messageSent = {
+				type: NcpEventType.MessageSent,
+				payload: {
+					sessionId: input.sessionId,
+					message: msg
+				}
+			};
+			await this.stateManager.dispatch(messageSent);
+		}
+		const runStarted = {
+			type: NcpEventType.RunStarted,
+			payload: {
+				sessionId: ctx.sessionId,
+				messageId: ctx.messageId,
+				runId: ctx.runId
+			}
+		};
+		await this.stateManager.dispatch(runStarted);
+		yield runStarted;
+		for await (const event of this.runLoop(modelInput, ctx, options)) {
+			await this.stateManager.dispatch(event);
+			yield event;
+		}
+	};
+	/**
+	* Agent loop: LLM stream → encoder events → tool execution (if any) → next round or finish.
+	* RunFinished is emitted only when the entire loop completes (no more tool calls).
+	* The stream encoder does not emit RunFinished; it only converts chunks to NCP events.
+	*/
+	runLoop = async function* (llmInput, ctx, options) {
+		const roundCollector = new DefaultNcpRoundCollector(this.reasoningNormalizationMode);
+		let currentInput = llmInput;
+		let done = false;
+		while (!done && !options?.signal?.aborted) {
+			roundCollector.clear();
+			const stream = this.llmApi.generate(currentInput, { signal: options?.signal });
+			const tappedStream = this.tapStream(stream, (chunk) => roundCollector.consumeChunk(chunk));
+			for await (const event of this.streamEncoder.encode(tappedStream, ctx)) yield event;
+			const toolResults = [];
+			for (const toolCall of roundCollector.getToolCalls()) {
+				const toolResult = await this.executeToolCall(toolCall);
+				toolResults.push(toolResult);
+				yield {
+					type: NcpEventType.MessageToolCallResult,
+					payload: {
+						sessionId: ctx.sessionId,
+						toolCallId: toolCall.toolCallId,
+						content: toolResult.result
+					}
+				};
+			}
+			if (toolResults.length === 0) {
+				yield {
+					type: NcpEventType.RunFinished,
+					payload: {
+						sessionId: ctx.sessionId,
+						messageId: ctx.messageId,
+						runId: ctx.runId
+					}
+				};
+				done = true;
+				break;
+			}
+			currentInput = appendToolRoundToInput(currentInput, roundCollector.getReasoning(), roundCollector.getText(), toolResults);
+		}
+	};
+	executeToolCall = async function(toolCall) {
+		const tool = this.toolRegistry.getTool(toolCall.toolName);
+		const parsedArgs = parseToolArgs(toolCall.args);
+		if (!parsedArgs.ok) return {
+			toolCallId: toolCall.toolCallId,
+			toolName: toolCall.toolName,
+			args: null,
+			rawArgsText: parsedArgs.rawText,
+			result: createInvalidToolArgumentsResult({
+				toolCallId: toolCall.toolCallId,
+				toolName: toolCall.toolName,
+				rawArgumentsText: parsedArgs.rawText,
+				issues: parsedArgs.issues
+			})
+		};
+		const validationIssues = this.resolveValidationIssues(parsedArgs.value, tool);
+		if (validationIssues.length > 0) return {
+			toolCallId: toolCall.toolCallId,
+			toolName: toolCall.toolName,
+			args: null,
+			rawArgsText: parsedArgs.rawText,
+			result: createInvalidToolArgumentsResult({
+				toolCallId: toolCall.toolCallId,
+				toolName: toolCall.toolName,
+				rawArgumentsText: parsedArgs.rawText,
+				issues: validationIssues
+			})
+		};
+		return {
+			toolCallId: toolCall.toolCallId,
+			toolName: toolCall.toolName,
+			args: parsedArgs.value,
+			rawArgsText: parsedArgs.rawText,
+			result: await this.executeValidatedToolCall(toolCall, parsedArgs.value)
+		};
+	};
+	resolveValidationIssues = function(args, tool) {
+		const schemaIssues = validateToolArgs(args, tool?.parameters);
+		if (schemaIssues.length > 0) return schemaIssues;
+		return typeof tool?.validateArgs === "function" ? tool.validateArgs(args) : [];
+	};
+	executeValidatedToolCall = async function(toolCall, args) {
+		try {
+			return await this.toolRegistry.execute(toolCall.toolCallId, toolCall.toolName, args);
+		} catch (error) {
+			return createToolExecutionFailedResult({
+				toolCallId: toolCall.toolCallId,
+				toolName: toolCall.toolName,
+				error
+			});
+		}
+	};
+	tapStream = async function* (stream, onChunk) {
+		for await (const chunk of stream) {
+			onChunk(chunk);
+			yield chunk;
+		}
+	};
 };
+//#endregion
+export { DefaultNcpAgentRuntime, DefaultNcpContextBuilder, DefaultNcpRoundBuffer, DefaultNcpStreamEncoder, DefaultNcpToolRegistry, EchoNcpLLMApi, LocalAssetStore, buildAssetContentPath, buildNcpUserContent, isTextLikeAsset };