@nextclaw/ncp-agent-runtime 0.3.8 → 0.3.9

package/dist/index.d.ts

@@ -166,6 +166,9 @@ declare class DefaultNcpAgentRuntime implements NcpAgentRuntime {
    * The stream encoder does not emit RunFinished; it only converts chunks to NCP events.
    */
   private runLoop;
+  private executeToolCall;
+  private resolveValidationIssues;
+  private executeValidatedToolCall;
   private tapStream;
 }
 //#endregion

package/dist/index.js

@@ -3,6 +3,7 @@ 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;
@@ -859,6 +860,12 @@ var EchoNcpLLMApi = class {
 };
 //#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)}`;
 }
@@ -911,47 +918,25 @@ function parseToolArgs(args) {
 }
 function validateToolArgs(args, schema) {
 	if (!schema) return [];
-	return validateToolValue(args, schema, "");
+	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 {
@@ -966,6 +951,18 @@ function createInvalidToolArgumentsResult(params) {
 		}
 	};
 }
+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",
@@ -1115,43 +1112,14 @@ var DefaultNcpAgentRuntime = class {
 			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
-				});
+				const toolResult = await this.executeToolCall(toolCall);
+				toolResults.push(toolResult);
 				yield {
 					type: NcpEventType.MessageToolCallResult,
 					payload: {
 						sessionId: ctx.sessionId,
 						toolCallId: toolCall.toolCallId,
-						content: result
+						content: toolResult.result
 					}
 				};
 			}
@@ -1170,6 +1138,58 @@ var DefaultNcpAgentRuntime = class {
 			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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-agent-runtime",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "private": false,
   "description": "Default agent runtime implementation built on NCP interfaces.",
   "type": "module",
@@ -15,6 +15,7 @@
     "dist"
   ],
   "dependencies": {
+    "ajv": "^8.17.1",
     "@nextclaw/ncp": "0.5.0"
   },
   "devDependencies": {