@nextclaw/ncp-agent-runtime 0.3.13 → 0.3.15

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { NcpAgentConversationStateManager, NcpAgentRunInput, NcpAgentRunOptions, NcpAgentRuntime, NcpAssistantReasoningNormalizationMode, NcpContextBuilder, NcpContextPrepareOptions, NcpEncodeContext, NcpEndpointEvent, NcpInvalidToolArgumentsResult, NcpLLMApi, NcpLLMApiInput, NcpLLMApiOptions, NcpMessagePart, NcpRoundBuffer, NcpStreamEncoder, NcpTool, NcpToolCallResult, NcpToolDefinition, NcpToolRegistry, OpenAIChatChunk, OpenAIContentPart, OpenAITool } from "@nextclaw/ncp";
+import { NcpAgentConversationStateManager, NcpAgentRunInput, NcpAgentRunOptions, NcpAgentRuntime, NcpAssistantReasoningNormalizationMode, NcpContextBuilder, NcpContextPrepareOptions, NcpEncodeContext, NcpEndpointEvent, NcpInvalidToolArgumentsResult, NcpLLMApi, NcpLLMApiInput, NcpLLMApiOptions, NcpMessagePart, NcpRoundBuffer, NcpStreamEncoder, NcpTool, NcpToolCallResult, NcpToolDefinition, NcpToolRegistry, OpenAIChatChunk, OpenAIChatMessage, OpenAIContentPart, OpenAITool } from "@nextclaw/ncp";
 
 //#region src/asset-store.d.ts
 type StoredAssetRecord = {
@@ -142,7 +142,55 @@ declare class EchoNcpLLMApi implements NcpLLMApi {
   generate: (input: NcpLLMApiInput, options?: NcpLLMApiOptions) => AsyncGenerator<OpenAIChatChunk>;
 }
 //#endregion
-//#region src/runtime.d.ts
+//#region src/tool-result-content.manager.d.ts
+type ToolResultContentContext = {
+  toolCallId?: string;
+  toolName?: string;
+};
+type ToolResultContentManagerOptions = {
+  maxModelVisibleChars?: number;
+  maxToolMessagesChars?: number;
+  maxStringValueChars?: number;
+  maxModelVisibleImages?: number;
+  maxArrayItems?: number;
+  maxObjectKeys?: number;
+  maxDepth?: number;
+};
+declare class ToolResultContentManager {
+  private readonly maxModelVisibleChars;
+  private readonly maxToolMessagesChars;
+  private readonly maxStringValueChars;
+  private readonly maxModelVisibleImages;
+  private readonly maxArrayItems;
+  private readonly maxObjectKeys;
+  private readonly maxDepth;
+  private readonly imageService;
+  constructor(options?: ToolResultContentManagerOptions);
+  normalizeToolCallResult: (result: NcpToolCallResult) => NcpToolCallResult;
+  compactInput: (input: NcpLLMApiInput) => NcpLLMApiInput;
+  toModelContent: (result: unknown, context?: ToolResultContentContext) => string;
+  toVisualObservationMessages: (toolResults: ReadonlyArray<NcpToolCallResult>) => OpenAIChatMessage[];
+  private readonly normalizeResult;
+  private readonly buildContentItems;
+  private readonly readVisibleImages;
+  private readonly buildVisualObservationMessage;
+  private readonly compactToolMessages;
+  private readonly compactToolMessage;
+  private readonly normalizeStringResult;
+  private readonly redactValue;
+  private readonly redactArray;
+  private readonly redactObject;
+  private readonly redactString;
+  private readonly attachNotice;
+  private readonly buildEnvelope;
+  private readonly buildStringNotice;
+  private readonly buildNotice;
+  private readonly buildOmittedHistoricalToolResult;
+  private readonly boundModelContentText;
+}
+declare const defaultToolResultContentManager: ToolResultContentManager;
+//#endregion
+//#region src/agent-runtime.service.d.ts
 type DefaultNcpAgentRuntimeConfig = {
   contextBuilder: NcpContextBuilder;
   llmApi: NcpLLMApi;
@@ -150,6 +198,7 @@ type DefaultNcpAgentRuntimeConfig = {
   stateManager: NcpAgentConversationStateManager;
   streamEncoder?: NcpStreamEncoder;
   reasoningNormalizationMode?: NcpAssistantReasoningNormalizationMode;
+  toolResultContentManager?: ToolResultContentManager;
 };
 declare class DefaultNcpAgentRuntime implements NcpAgentRuntime {
   private readonly contextBuilder;
@@ -158,6 +207,7 @@ declare class DefaultNcpAgentRuntime implements NcpAgentRuntime {
   private readonly stateManager;
   private readonly streamEncoder;
   private readonly reasoningNormalizationMode;
+  private readonly toolResultContentManager;
   constructor(config: DefaultNcpAgentRuntimeConfig);
   run: (this: DefaultNcpAgentRuntime, input: NcpAgentRunInput, options?: NcpAgentRunOptions) => AsyncGenerator<NcpEndpointEvent>;
   /**
@@ -210,6 +260,6 @@ declare function createToolExecutionFailedResult(params: {
     toolName: string;
   };
 };
-declare function appendToolRoundToInput(input: NcpLLMApiInput, reasoning: string, text: string, toolResults: ReadonlyArray<NcpToolCallResult>): NcpLLMApiInput;
+declare function appendToolRoundToInput(input: NcpLLMApiInput, reasoning: string, text: string, toolResults: ReadonlyArray<NcpToolCallResult>, toolResultContentManager?: ToolResultContentManager): NcpLLMApiInput;
 //#endregion
-export { type AssetMeta, type AssetPutInput, type AssetRef, DefaultNcpAgentRuntime, type DefaultNcpAgentRuntimeConfig, DefaultNcpContextBuilder, DefaultNcpRoundBuffer, DefaultNcpStreamEncoder, DefaultNcpToolRegistry, EchoNcpLLMApi, LocalAssetStore, type StoredAssetRecord, appendToolRoundToInput, assertOpenAiFunctionParametersSchema, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool, createInvalidToolArgumentsResult, createToolExecutionFailedResult, genId, getOpenAiFunctionParametersSchemaIssues, isTextLikeAsset, parseToolArgs, validateToolArgs };
+export { type AssetMeta, type AssetPutInput, type AssetRef, DefaultNcpAgentRuntime, type DefaultNcpAgentRuntimeConfig, DefaultNcpContextBuilder, DefaultNcpRoundBuffer, DefaultNcpStreamEncoder, DefaultNcpToolRegistry, EchoNcpLLMApi, LocalAssetStore, type StoredAssetRecord, ToolResultContentManager, type ToolResultContentManagerOptions, appendToolRoundToInput, assertOpenAiFunctionParametersSchema, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool, createInvalidToolArgumentsResult, createToolExecutionFailedResult, defaultToolResultContentManager, genId, getOpenAiFunctionParametersSchemaIssues, isTextLikeAsset, parseToolArgs, validateToolArgs };

package/dist/index.js

@@ -147,6 +147,423 @@ function buildNcpUserContent(parts, options = {}) {
 	return content;
 }
 //#endregion
+//#region src/tool-result-content.utils.ts
+const LARGE_INLINE_PAYLOAD_CHARS$1 = 2048;
+function sanitizePositiveInt(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	const normalized = Math.floor(value);
+	return normalized > 0 ? normalized : fallback;
+}
+function serializeValue(value) {
+	if (typeof value === "string") return {
+		text: value,
+		ok: true
+	};
+	try {
+		return {
+			text: JSON.stringify(value ?? null),
+			ok: true
+		};
+	} catch (error) {
+		return {
+			text: `[unserializable tool result: ${error instanceof Error ? error.message : String(error)}]`,
+			ok: false
+		};
+	}
+}
+function truncateMiddle(value, maxChars) {
+	if (value.length <= maxChars) return value;
+	if (maxChars <= 0) return "";
+	const marker = "\n... [truncated] ...\n";
+	if (maxChars <= 21) return value.slice(0, maxChars);
+	const keepChars = maxChars - 21;
+	const headChars = Math.ceil(keepChars / 2);
+	const tailChars = Math.floor(keepChars / 2);
+	return `${value.slice(0, headChars)}${marker}${value.slice(value.length - tailChars)}`;
+}
+function isLargeDataUrl(value) {
+	return value.length > LARGE_INLINE_PAYLOAD_CHARS$1 && /^data:[^,]+;base64,/i.test(value);
+}
+function readDataUrlMime(value) {
+	return /^data:([^;,]+)/i.exec(value)?.[1] ?? "application/octet-stream";
+}
+function isLargeBase64LikeString(value) {
+	if (value.length <= LARGE_INLINE_PAYLOAD_CHARS$1) return false;
+	const compact = value.replace(/\s+/g, "");
+	return compact.length > LARGE_INLINE_PAYLOAD_CHARS$1 && /^[A-Za-z0-9+/=_-]+$/.test(compact);
+}
+function isBinaryLike(value) {
+	return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+function getBinaryByteLength(value) {
+	if (value instanceof ArrayBuffer) return value.byteLength;
+	if (ArrayBuffer.isView(value)) return value.byteLength;
+	return 0;
+}
+function readStringField(value, key) {
+	const field = value[key];
+	return typeof field === "string" && field.length > 0 ? field : null;
+}
+//#endregion
+//#region src/tool-result-image.service.ts
+const LARGE_INLINE_PAYLOAD_CHARS = 2048;
+const DEFAULT_MAX_MODEL_VISIBLE_IMAGES$1 = 4;
+const DEFAULT_MAX_ARRAY_ITEMS$1 = 50;
+const DEFAULT_MAX_OBJECT_KEYS$1 = 80;
+const DEFAULT_MAX_DEPTH$1 = 8;
+var ToolResultImageService = class {
+	maxModelVisibleImages;
+	maxArrayItems;
+	maxObjectKeys;
+	maxDepth;
+	constructor(options = {}) {
+		this.maxModelVisibleImages = sanitizePositiveInt(options.maxModelVisibleImages, DEFAULT_MAX_MODEL_VISIBLE_IMAGES$1);
+		this.maxArrayItems = sanitizePositiveInt(options.maxArrayItems, DEFAULT_MAX_ARRAY_ITEMS$1);
+		this.maxObjectKeys = sanitizePositiveInt(options.maxObjectKeys, DEFAULT_MAX_OBJECT_KEYS$1);
+		this.maxDepth = sanitizePositiveInt(options.maxDepth, DEFAULT_MAX_DEPTH$1);
+	}
+	extractImageItems = (value) => {
+		const images = [];
+		this.collectImageItems(value, images, { depth: 0 });
+		return images;
+	};
+	readVisibleImages = (contentItems) => {
+		if (!contentItems) return [];
+		return contentItems.filter((item) => item.type === "input_image").slice(0, this.maxModelVisibleImages);
+	};
+	toOpenAiImagePart = (item) => ({
+		type: "image_url",
+		image_url: {
+			url: item.imageUrl,
+			...item.detail ? { detail: toOpenAiImageDetail(item.detail) } : {}
+		}
+	});
+	summarizeImageContentItem = (value) => {
+		const type = readStringField(value, "type");
+		if (type === "image") return {
+			type: "image",
+			mimeType: readStringField(value, "mimeType") ?? readStringField(value, "mime_type"),
+			detail: readImageDetail(value),
+			dataOmitted: true,
+			originalDataChars: readStringField(value, "data")?.length ?? 0
+		};
+		if (type === "input_image" || type === "image_url") {
+			const imageUrl = readImageUrl(value);
+			return {
+				type,
+				imageUrl: imageUrl ? redactImageUrl(imageUrl) : void 0,
+				detail: readImageDetail(value)
+			};
+		}
+		return null;
+	};
+	collectImageItems = (value, output, context) => {
+		if (output.length >= this.maxModelVisibleImages || context.depth > this.maxDepth) return;
+		if (typeof value === "string") {
+			const image = imageDataUrlToContentItem(value);
+			if (image) output.push(image);
+			return;
+		}
+		if (!value || typeof value !== "object" || isBinaryLike(value)) return;
+		if (Array.isArray(value)) {
+			value.slice(0, this.maxArrayItems).forEach((item) => this.collectImageItems(item, output, { depth: context.depth + 1 }));
+			return;
+		}
+		const image = readImageContentItem(value);
+		if (image) {
+			output.push(image);
+			return;
+		}
+		Object.values(value).slice(0, this.maxObjectKeys).forEach((item) => this.collectImageItems(item, output, { depth: context.depth + 1 }));
+	};
+};
+function imageDataUrlToContentItem(value) {
+	if (!/^data:image\/[^,]+;base64,/i.test(value)) return null;
+	return {
+		type: "input_image",
+		imageUrl: value,
+		mimeType: readDataUrlMime(value),
+		originalDataChars: value.length
+	};
+}
+function readImageContentItem(value) {
+	const type = readStringField(value, "type");
+	if (type === "image") {
+		const data = readStringField(value, "data");
+		const mimeType = readStringField(value, "mimeType") ?? readStringField(value, "mime_type") ?? "image/png";
+		if (!data) return null;
+		return {
+			type: "input_image",
+			imageUrl: `data:${mimeType};base64,${data}`,
+			mimeType,
+			detail: readImageDetail(value),
+			originalDataChars: data.length
+		};
+	}
+	if (type === "input_image" || type === "image_url") {
+		const imageUrl = readImageUrl(value);
+		if (!imageUrl) return null;
+		return {
+			type: "input_image",
+			imageUrl,
+			detail: readImageDetail(value)
+		};
+	}
+	return null;
+}
+function toOpenAiImageDetail(detail) {
+	if (detail === "low" || detail === "high" || detail === "auto") return detail;
+	if (detail === "original") return "high";
+}
+function readImageDetail(value) {
+	const direct = readStringField(value, "detail");
+	if (isImageDetail(direct)) return direct;
+	const meta = value._meta;
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
+	const codexDetail = readStringField(meta, "codex/imageDetail");
+	return isImageDetail(codexDetail) ? codexDetail : void 0;
+}
+function isImageDetail(value) {
+	return value === "low" || value === "high" || value === "auto" || value === "original";
+}
+function readImageUrl(value) {
+	const direct = readStringField(value, "image_url");
+	if (direct) return direct;
+	const nested = value.image_url;
+	if (!nested || typeof nested !== "object" || Array.isArray(nested)) return null;
+	return readStringField(nested, "url");
+}
+function redactImageUrl(value) {
+	if (isLargeDataUrl(value)) return `[omitted data URL payload: mime=${readDataUrlMime(value)}, originalChars=${value.length}]`;
+	return value.length > LARGE_INLINE_PAYLOAD_CHARS ? truncateMiddle(value, LARGE_INLINE_PAYLOAD_CHARS) : value;
+}
+//#endregion
+//#region src/tool-result-content.manager.ts
+const DEFAULT_MAX_MODEL_VISIBLE_CHARS = 1e4;
+const DEFAULT_MAX_TOOL_MESSAGES_CHARS = 6e4;
+const DEFAULT_MAX_STRING_VALUE_CHARS = 4e3;
+const DEFAULT_MAX_MODEL_VISIBLE_IMAGES = 4;
+const DEFAULT_MAX_ARRAY_ITEMS = 50;
+const DEFAULT_MAX_OBJECT_KEYS = 80;
+const DEFAULT_MAX_DEPTH = 8;
+const TRUNCATION_MARKER = "[NextClaw tool result truncated]";
+var ToolResultContentManager = class {
+	maxModelVisibleChars;
+	maxToolMessagesChars;
+	maxStringValueChars;
+	maxModelVisibleImages;
+	maxArrayItems;
+	maxObjectKeys;
+	maxDepth;
+	imageService;
+	constructor(options = {}) {
+		this.maxModelVisibleChars = sanitizePositiveInt(options.maxModelVisibleChars, DEFAULT_MAX_MODEL_VISIBLE_CHARS);
+		this.maxToolMessagesChars = sanitizePositiveInt(options.maxToolMessagesChars, DEFAULT_MAX_TOOL_MESSAGES_CHARS);
+		this.maxStringValueChars = sanitizePositiveInt(options.maxStringValueChars, DEFAULT_MAX_STRING_VALUE_CHARS);
+		this.maxModelVisibleImages = sanitizePositiveInt(options.maxModelVisibleImages, DEFAULT_MAX_MODEL_VISIBLE_IMAGES);
+		this.maxArrayItems = sanitizePositiveInt(options.maxArrayItems, DEFAULT_MAX_ARRAY_ITEMS);
+		this.maxObjectKeys = sanitizePositiveInt(options.maxObjectKeys, DEFAULT_MAX_OBJECT_KEYS);
+		this.maxDepth = sanitizePositiveInt(options.maxDepth, DEFAULT_MAX_DEPTH);
+		this.imageService = new ToolResultImageService({
+			maxModelVisibleImages: this.maxModelVisibleImages,
+			maxArrayItems: this.maxArrayItems,
+			maxObjectKeys: this.maxObjectKeys,
+			maxDepth: this.maxDepth
+		});
+	}
+	normalizeToolCallResult = (result) => {
+		const context = {
+			toolCallId: result.toolCallId,
+			toolName: result.toolName
+		};
+		const normalized = this.normalizeResult(result.result, {
+			toolCallId: result.toolCallId,
+			toolName: result.toolName
+		});
+		const contentItems = this.buildContentItems(result.result, normalized.value, context);
+		return {
+			...result,
+			...normalized.changed ? { result: normalized.value } : {},
+			contentItems
+		};
+	};
+	compactInput = (input) => ({
+		...input,
+		messages: this.compactToolMessages(input.messages)
+	});
+	toModelContent = (result, context = {}) => {
+		const serialized = serializeValue(this.normalizeResult(result, context).value);
+		if (serialized.text.length <= this.maxModelVisibleChars) return serialized.text;
+		return this.boundModelContentText(JSON.stringify(this.buildEnvelope({
+			context,
+			originalSerializedChars: serialized.text.length,
+			previewSource: serialized.text
+		})));
+	};
+	toVisualObservationMessages = (toolResults) => {
+		return toolResults.flatMap((result) => {
+			const images = this.readVisibleImages(result.contentItems);
+			if (images.length === 0) return [];
+			return [this.buildVisualObservationMessage(result, images)];
+		});
+	};
+	normalizeResult = (result, context) => {
+		if (typeof result === "string") return this.normalizeStringResult(result, context);
+		const serialized = serializeValue(result);
+		if (serialized.ok && serialized.text.length <= this.maxModelVisibleChars) return {
+			value: result,
+			changed: false
+		};
+		const redacted = this.redactValue(result, { depth: 0 });
+		const redactedSerialized = serializeValue(redacted);
+		if (redactedSerialized.text.length <= this.maxModelVisibleChars) return {
+			value: this.attachNotice(redacted, {
+				context,
+				originalSerializedChars: serialized.text.length
+			}),
+			changed: true
+		};
+		return {
+			value: this.buildEnvelope({
+				context,
+				originalSerializedChars: serialized.text.length,
+				previewSource: redactedSerialized.text
+			}),
+			changed: true
+		};
+	};
+	buildContentItems = (rawResult, normalizedResult, context) => {
+		return [{
+			type: "input_text",
+			text: this.toModelContent(normalizedResult, context)
+		}, ...this.imageService.extractImageItems(rawResult).slice(0, this.maxModelVisibleImages)];
+	};
+	readVisibleImages = (contentItems) => this.imageService.readVisibleImages(contentItems);
+	buildVisualObservationMessage = (toolResult, images) => {
+		const imageParts = images.map(this.imageService.toOpenAiImagePart);
+		const omittedCount = Math.max(0, (toolResult.contentItems ?? []).filter((item) => item.type === "input_image").length - imageParts.length);
+		return {
+			role: "user",
+			content: [{
+				type: "text",
+				text: [
+					`Tool "${toolResult.toolName}" returned ${imageParts.length} image(s).`,
+					"Use the attached image content as the visual observation for the preceding tool result.",
+					omittedCount > 0 ? `${omittedCount} additional image(s) were omitted by budget.` : ""
+				].filter(Boolean).join(" ")
+			}, ...imageParts]
+		};
+	};
+	compactToolMessages = (messages) => {
+		let remainingChars = this.maxToolMessagesChars;
+		const output = messages.slice();
+		for (let index = output.length - 1; index >= 0; index -= 1) {
+			const message = output[index];
+			if (message.role !== "tool") continue;
+			const compacted = this.compactToolMessage(message, remainingChars);
+			output[index] = compacted.message;
+			remainingChars = compacted.remainingChars;
+		}
+		return output;
+	};
+	compactToolMessage = (message, remainingChars) => {
+		if (message.content.length <= remainingChars) return {
+			message,
+			remainingChars: remainingChars - message.content.length
+		};
+		const content = remainingChars >= 1e3 ? truncateMiddle(message.content, remainingChars) : this.buildOmittedHistoricalToolResult(message.content.length);
+		return {
+			message: {
+				...message,
+				content
+			},
+			remainingChars: Math.max(0, remainingChars - content.length)
+		};
+	};
+	normalizeStringResult = (result, context) => {
+		const redacted = this.redactString(result);
+		if (redacted.length <= this.maxModelVisibleChars && redacted === result) return {
+			value: result,
+			changed: false
+		};
+		if (redacted.length <= this.maxModelVisibleChars) return {
+			value: this.buildStringNotice(context, result.length, redacted),
+			changed: true
+		};
+		return {
+			value: this.buildStringNotice(context, result.length, truncateMiddle(redacted, this.maxModelVisibleChars)),
+			changed: true
+		};
+	};
+	redactValue = (value, context) => {
+		if (typeof value === "string") return this.redactString(value);
+		if (!value || typeof value !== "object") return value;
+		if (value instanceof Date) return value.toISOString();
+		const imageSummary = this.imageService.summarizeImageContentItem(value);
+		if (imageSummary) return imageSummary;
+		if (isBinaryLike(value)) return `[omitted binary payload: bytes=${getBinaryByteLength(value)}]`;
+		if (context.depth >= this.maxDepth) return `[omitted nested ${Array.isArray(value) ? "array" : "object"} beyond depth ${this.maxDepth}]`;
+		if (Array.isArray(value)) return this.redactArray(value, context);
+		return this.redactObject(value, context);
+	};
+	redactArray = (value, context) => {
+		const visibleItems = value.slice(0, this.maxArrayItems).map((item) => this.redactValue(item, { depth: context.depth + 1 }));
+		if (value.length <= this.maxArrayItems) return visibleItems;
+		return [...visibleItems, `[omitted ${value.length - this.maxArrayItems} array items from tool result]`];
+	};
+	redactObject = (value, context) => {
+		const entries = Object.entries(value);
+		const visibleEntries = entries.slice(0, this.maxObjectKeys);
+		const output = Object.fromEntries(visibleEntries.map(([key, item]) => [key, this.redactValue(item, { depth: context.depth + 1 })]));
+		if (entries.length > this.maxObjectKeys) output._nextclawOmittedKeys = entries.length - this.maxObjectKeys;
+		return output;
+	};
+	redactString = (value) => {
+		if (isLargeDataUrl(value)) return `[omitted data URL payload: mime=${readDataUrlMime(value)}, originalChars=${value.length}]`;
+		if (isLargeBase64LikeString(value)) return `[omitted base64-like payload: originalChars=${value.length}]`;
+		if (value.length <= this.maxStringValueChars) return value;
+		return truncateMiddle(value, this.maxStringValueChars);
+	};
+	attachNotice = (value, params) => {
+		const notice = this.buildNotice(params.context, params.originalSerializedChars);
+		if (value && typeof value === "object" && !Array.isArray(value)) return {
+			...value,
+			_nextclawToolResultNotice: notice
+		};
+		return {
+			type: "nextclaw.tool_result_sanitized",
+			notice,
+			result: value
+		};
+	};
+	buildEnvelope = (params) => {
+		const { context, originalSerializedChars, previewSource } = params;
+		return {
+			type: "nextclaw.tool_result_truncated",
+			notice: this.buildNotice(context, originalSerializedChars),
+			originalSerializedChars,
+			visibleLimitChars: this.maxModelVisibleChars,
+			preview: truncateMiddle(previewSource, Math.max(1e3, this.maxModelVisibleChars - 1e3))
+		};
+	};
+	buildStringNotice = (context, originalChars, preview) => [
+		TRUNCATION_MARKER,
+		this.buildNotice(context, originalChars),
+		"",
+		preview
+	].join("\n");
+	buildNotice = (context, originalSerializedChars) => {
+		const { toolCallId: rawToolCallId, toolName: rawToolName } = context;
+		return `${TRUNCATION_MARKER}${rawToolName ? ` tool=${rawToolName}` : ""}${rawToolCallId ? ` toolCallId=${rawToolCallId}` : ""} originalSerializedChars=${originalSerializedChars} visibleLimitChars=${this.maxModelVisibleChars}`;
+	};
+	buildOmittedHistoricalToolResult = (originalChars) => `${TRUNCATION_MARKER} older tool result omitted from active model context originalChars=${originalChars}`;
+	boundModelContentText = (value) => {
+		if (value.length <= this.maxModelVisibleChars) return value;
+		return truncateMiddle(value, this.maxModelVisibleChars);
+	};
+};
+const defaultToolResultContentManager = new ToolResultContentManager();
+//#endregion
 //#region src/utils.ts
 const toolSchemaValidator = new AjvPkg({
 	allErrors: true,
@@ -289,7 +706,7 @@ function createToolExecutionFailedResult(params) {
 		}
 	};
 }
-function appendToolRoundToInput(input, reasoning, text, toolResults) {
+function appendToolRoundToInput(input, reasoning, text, toolResults, toolResultContentManager = defaultToolResultContentManager) {
 	const assistantMsg = {
 		role: "assistant",
 		content: text || null,
@@ -305,17 +722,22 @@ function appendToolRoundToInput(input, reasoning, text, toolResults) {
 	};
 	const toolMsgs = toolResults.map((tr) => ({
 		role: "tool",
-		content: typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result ?? {}),
+		content: toolResultContentManager.toModelContent(tr.result, {
+			toolCallId: tr.toolCallId,
+			toolName: tr.toolName
+		}),
 		tool_call_id: tr.toolCallId
 	}));
-	return {
+	const visualMessages = toolResultContentManager.toVisualObservationMessages(toolResults);
+	return toolResultContentManager.compactInput({
 		...input,
 		messages: [
 			...input.messages,
 			assistantMsg,
-			...toolMsgs
+			...toolMsgs,
+			...visualMessages
 		]
-	};
+	});
 }
 //#endregion
 //#region src/context-builder.ts
@@ -374,7 +796,8 @@ function messageToOpenAI(msg, options) {
 				toolCallId: p.toolCallId ?? "",
 				toolName: p.toolName,
 				args: p.args ?? {},
-				result: p.result
+				result: p.result,
+				resultContentItems: p.resultContentItems
 			});
 		}
 		const text = texts.join("");
@@ -399,6 +822,14 @@ function messageToOpenAI(msg, options) {
 				content: typeof t.result === "string" ? t.result : JSON.stringify(t.result),
 				tool_call_id: t.toolCallId
 			});
+			out.push(...defaultToolResultContentManager.toVisualObservationMessages(toolInvocations.map((toolInvocation) => ({
+				toolCallId: toolInvocation.toolCallId,
+				toolName: toolInvocation.toolName,
+				args: isRecord(toolInvocation.args) ? toolInvocation.args : null,
+				rawArgsText: typeof toolInvocation.args === "string" ? toolInvocation.args : JSON.stringify(toolInvocation.args ?? {}),
+				result: toolInvocation.result,
+				contentItems: toolInvocation.resultContentItems
+			}))));
 		} else out.push({
 			role: "assistant",
 			content: text,
@@ -456,6 +887,37 @@ function normalizeMimeType(value) {
 	const normalized = value?.trim().toLowerCase() ?? "";
 	return normalized.length > 0 ? normalized : "application/octet-stream";
 }
+function inferMimeTypeFromFileName(fileName) {
+	const normalized = fileName.trim().toLowerCase();
+	if (normalized.endsWith(".mp3")) return "audio/mpeg";
+	if (normalized.endsWith(".m4a")) return "audio/mp4";
+	if (normalized.endsWith(".wav")) return "audio/wav";
+	if (normalized.endsWith(".ogg")) return "audio/ogg";
+	if (normalized.endsWith(".opus")) return "audio/opus";
+	if (normalized.endsWith(".flac")) return "audio/flac";
+	if (normalized.endsWith(".aac")) return "audio/aac";
+	if (normalized.endsWith(".weba")) return "audio/webm";
+	if (normalized.endsWith(".mp4") || normalized.endsWith(".m4v")) return "video/mp4";
+	if (normalized.endsWith(".mov")) return "video/quicktime";
+	if (normalized.endsWith(".webm")) return "video/webm";
+	if (normalized.endsWith(".mkv")) return "video/x-matroska";
+	if (normalized.endsWith(".avi")) return "video/x-msvideo";
+	if (normalized.endsWith(".wmv")) return "video/x-ms-wmv";
+	if (normalized.endsWith(".png")) return "image/png";
+	if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
+	if (normalized.endsWith(".gif")) return "image/gif";
+	if (normalized.endsWith(".webp")) return "image/webp";
+	if (normalized.endsWith(".svg")) return "image/svg+xml";
+	if (normalized.endsWith(".pdf")) return "application/pdf";
+	if (normalized.endsWith(".json")) return "application/json";
+	if (normalized.endsWith(".txt")) return "text/plain";
+	return null;
+}
+function resolveStoredMimeType(fileName, mimeType) {
+	const normalized = normalizeMimeType(mimeType);
+	if (normalized !== "application/octet-stream") return normalized;
+	return inferMimeTypeFromFileName(fileName) ?? normalized;
+}
 function buildAssetId() {
 	return `asset_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
 }
@@ -616,12 +1078,13 @@ var LocalAssetStore = class {
 		return record;
 	}
 	async putFromBytes(params) {
-		const bytes = Buffer.from(params.bytes);
+		const { bytes: rawBytes, createdAt, fileName, mimeType } = params;
+		const bytes = Buffer.from(rawBytes);
 		const record = this.buildRecord({
-			fileName: params.fileName,
-			mimeType: params.mimeType,
+			fileName,
+			mimeType,
 			bytes,
-			createdAt: params.createdAt
+			createdAt
 		});
 		const assetDir = this.resolveStorageKeyDirectory(record.storageKey);
 		await mkdir(assetDir, { recursive: true });
@@ -630,20 +1093,21 @@ var LocalAssetStore = class {
 		return record;
 	}
 	buildRecord(params) {
-		const createdAt = params.createdAt ?? /* @__PURE__ */ new Date();
+		const { bytes, createdAt: rawCreatedAt, fileName: rawFileName, mimeType } = params;
+		const createdAt = rawCreatedAt ?? /* @__PURE__ */ new Date();
 		const id = buildAssetId();
 		const storageKey = buildStorageKey(createdAt, id);
-		const fileName = normalizeFileName(params.fileName);
+		const fileName = normalizeFileName(rawFileName);
 		return {
 			id,
 			uri: buildAssetUri(storageKey),
 			storageKey,
 			fileName,
 			storedName: normalizeSegment(fileName),
-			mimeType: normalizeMimeType(params.mimeType),
-			sizeBytes: params.bytes.length,
+			mimeType: resolveStoredMimeType(fileName, mimeType),
+			sizeBytes: bytes.length,
 			createdAt: createdAt.toISOString(),
-			sha256: createHash("sha256").update(params.bytes).digest("hex")
+			sha256: createHash("sha256").update(bytes).digest("hex")
 		};
 	}
 	async writeMeta(assetDir, record) {
@@ -1094,7 +1558,7 @@ var DefaultNcpRoundCollector = class {
 	}
 };
 //#endregion
-//#region src/runtime.ts
+//#region src/agent-runtime.service.ts
 var DefaultNcpAgentRuntime = class {
 	contextBuilder;
 	llmApi;
@@ -1102,12 +1566,14 @@ var DefaultNcpAgentRuntime = class {
 	stateManager;
 	streamEncoder;
 	reasoningNormalizationMode;
+	toolResultContentManager;
 	constructor(config) {
 		this.contextBuilder = config.contextBuilder;
 		this.llmApi = config.llmApi;
 		this.toolRegistry = config.toolRegistry;
 		this.stateManager = config.stateManager;
 		this.reasoningNormalizationMode = config.reasoningNormalizationMode ?? "off";
+		this.toolResultContentManager = config.toolResultContentManager ?? defaultToolResultContentManager;
 		this.streamEncoder = config.streamEncoder ?? new DefaultNcpStreamEncoder({ reasoningNormalizationMode: this.reasoningNormalizationMode });
 	}
 	run = async function* (input, options) {
@@ -1161,14 +1627,15 @@ var DefaultNcpAgentRuntime = class {
 			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);
+				const toolResult = this.toolResultContentManager.normalizeToolCallResult(await this.executeToolCall(toolCall));
 				toolResults.push(toolResult);
 				yield {
 					type: NcpEventType.MessageToolCallResult,
 					payload: {
 						sessionId: ctx.sessionId,
 						toolCallId: toolCall.toolCallId,
-						content: toolResult.result
+						content: toolResult.result,
+						contentItems: toolResult.contentItems
 					}
 				};
 			}
@@ -1184,7 +1651,7 @@ var DefaultNcpAgentRuntime = class {
 				done = true;
 				break;
 			}
-			currentInput = appendToolRoundToInput(currentInput, roundCollector.getReasoning(), roundCollector.getText(), toolResults);
+			currentInput = appendToolRoundToInput(currentInput, roundCollector.getReasoning(), roundCollector.getText(), toolResults, this.toolResultContentManager);
 		}
 	};
 	executeToolCall = async function(toolCall) {
@@ -1247,4 +1714,4 @@ var DefaultNcpAgentRuntime = class {
 	};
 };
 //#endregion
-export { DefaultNcpAgentRuntime, DefaultNcpContextBuilder, DefaultNcpRoundBuffer, DefaultNcpStreamEncoder, DefaultNcpToolRegistry, EchoNcpLLMApi, LocalAssetStore, appendToolRoundToInput, assertOpenAiFunctionParametersSchema, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool, createInvalidToolArgumentsResult, createToolExecutionFailedResult, genId, getOpenAiFunctionParametersSchemaIssues, isTextLikeAsset, parseToolArgs, validateToolArgs };
+export { DefaultNcpAgentRuntime, DefaultNcpContextBuilder, DefaultNcpRoundBuffer, DefaultNcpStreamEncoder, DefaultNcpToolRegistry, EchoNcpLLMApi, LocalAssetStore, ToolResultContentManager, appendToolRoundToInput, assertOpenAiFunctionParametersSchema, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool, createInvalidToolArgumentsResult, createToolExecutionFailedResult, defaultToolResultContentManager, genId, getOpenAiFunctionParametersSchemaIssues, isTextLikeAsset, parseToolArgs, validateToolArgs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-agent-runtime",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "private": false,
   "description": "Default agent runtime implementation built on NCP interfaces.",
   "type": "module",
@@ -16,7 +16,7 @@
   ],
   "dependencies": {
     "ajv": "^8.17.1",
-    "@nextclaw/ncp": "0.5.3"
+    "@nextclaw/ncp": "0.5.5"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",