@nextclaw/nextclaw-ncp-runtime-stdio-client 0.1.2 → 0.1.4

package/dist/stdio-runtime-error.utils.js

@@ -0,0 +1,25 @@
+//#region src/stdio-runtime-error.utils.ts
+function buildSpawnFailureMessage(params) {
+	const cwdSuffix = params.cwd ? ` (cwd: ${params.cwd})` : "";
+	return `[narp-stdio] failed to start stdio runtime command "${params.command}"${cwdSuffix}: ${params.error.message}`;
+}
+function normalizeRuntimeError(error) {
+	if (isNcpError(error)) return error;
+	const message = error instanceof Error ? error.message : String(error);
+	const lowered = message.toLowerCase();
+	return {
+		code: lowered.includes("abort") || lowered.includes("cancel") ? "abort-error" : "runtime-error",
+		message
+	};
+}
+function isAbortLikeRuntimeError(error) {
+	if (isNcpError(error)) return error.code === "abort-error";
+	const lowered = (error instanceof Error ? error.message : String(error)).toLowerCase();
+	return lowered.includes("abort") || lowered.includes("cancel");
+}
+function isNcpError(value) {
+	if (!value || typeof value !== "object") return false;
+	return typeof value.code === "string" && typeof value.message === "string";
+}
+//#endregion
+export { buildSpawnFailureMessage, isAbortLikeRuntimeError, normalizeRuntimeError };

package/dist/stdio-runtime-tool-name.utils.js

@@ -0,0 +1,26 @@
+import { readString } from "./stdio-runtime-config.utils.js";
+//#region src/stdio-runtime-tool-name.utils.ts
+function resolveToolNameFromAcpUpdate(update) {
+	return resolveToolNameFromRawInput(update.rawInput) ?? resolveHermesAcpToolNameFromTitle(update.title) ?? readString(update.title) ?? "unknown";
+}
+function resolveToolNameFromRawInput(rawInput) {
+	if (typeof rawInput !== "object" || !rawInput || Array.isArray(rawInput)) return;
+	const input = rawInput;
+	return readString(input.toolName) ?? readString(input.tool);
+}
+function resolveHermesAcpToolNameFromTitle(title) {
+	const normalizedTitle = readString(title)?.toLowerCase();
+	if (!normalizedTitle) return;
+	if (normalizedTitle.startsWith("terminal:")) return "terminal";
+	if (normalizedTitle.startsWith("read:")) return "read_file";
+	if (normalizedTitle.startsWith("write:")) return "write_file";
+	if (normalizedTitle.startsWith("patch (") || normalizedTitle.startsWith("patch:")) return "patch";
+	if (normalizedTitle.startsWith("search:")) return "search_files";
+	if (normalizedTitle.startsWith("web search:")) return "web_search";
+	if (normalizedTitle === "web extract" || normalizedTitle.startsWith("extract:")) return "web_extract";
+	if (normalizedTitle === "delegate task" || normalizedTitle.startsWith("delegate:")) return "delegate_task";
+	if (normalizedTitle === "execute code") return "execute_code";
+	if (normalizedTitle.startsWith("analyze image:")) return "vision_analyze";
+}
+//#endregion
+export { resolveToolNameFromAcpUpdate };

package/dist/stdio-runtime.service.js

@@ -1,10 +1,13 @@
 import { NARP_STDIO_PROMPT_META_KEY, buildStdioRuntimeLaunchEnv, readString } from "./stdio-runtime-config.utils.js";
+import { buildSpawnFailureMessage, isAbortLikeRuntimeError, normalizeRuntimeError } from "./stdio-runtime-error.utils.js";
+import { resolveToolNameFromAcpUpdate } from "./stdio-runtime-tool-name.utils.js";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import * as acp from "@agentclientprotocol/sdk";
 import { NcpEventType } from "@nextclaw/ncp";
 //#region src/stdio-runtime.service.ts
+const HERMES_ACP_ROUTE_BRIDGE_ENV = "NEXTCLAW_HERMES_ACP_ROUTE_BRIDGE";
 var UpdateBuffer = class {
 	updates = [];
 	waiters = /* @__PURE__ */ new Set();
@@ -205,7 +208,7 @@ var StdioRuntimeSession = class {
 		});
 		const releaseAbort = this.bindAbortSignal(signal);
 		try {
-			if (modelId) try {
+			if (modelId && this.config.env?.[HERMES_ACP_ROUTE_BRIDGE_ENV] !== "1") try {
 				await this.connection.unstable_setSessionModel({
 					sessionId: this.remoteSessionId,
 					modelId
@@ -247,10 +250,6 @@ var StdioRuntimeSession = class {
 	};
 	readStderr = () => this.stderr;
 };
-function buildSpawnFailureMessage(params) {
-	const cwdSuffix = params.cwd ? ` (cwd: ${params.cwd})` : "";
-	return `[narp-stdio] failed to start stdio runtime command "${params.command}"${cwdSuffix}: ${params.error.message}`;
-}
 var StdioRuntimeRunController = class {
 	buffer = new UpdateBuffer();
 	collector = new PromptUpdateCollector();
@@ -287,16 +286,33 @@ var StdioRuntimeRunController = class {
 			signal: options?.signal,
 			onUpdate: (update) => this.buffer.push(update)
 		});
-		let promptSettled = false;
-		let promptError = null;
+		const promptState = this.trackPromptState(promptPromise);
+		yield* this.emitRunStartedEvents(assistantMessageId);
+		try {
+			yield* this.drainPromptUpdates(assistantMessageId, promptState);
+			if (this.shouldExitForAbort(options, promptState.error)) return;
+			yield* this.emitCompletionEvents(assistantMessageId);
+		} catch (error) {
+			if (this.shouldExitForAbort(options, error)) return;
+			yield* this.emitFailureEvents(assistantMessageId, error);
+		}
+	};
+	trackPromptState = (promptPromise) => {
+		const promptState = {
+			settled: false,
+			error: null
+		};
 		promptPromise.then(() => {
-			promptSettled = true;
+			promptState.settled = true;
 			this.buffer.notify();
 		}).catch((error) => {
-			promptSettled = true;
-			promptError = error;
+			promptState.settled = true;
+			promptState.error = error;
 			this.buffer.notify();
 		});
+		return promptState;
+	};
+	emitRunStartedEvents = async function* (assistantMessageId) {
 		yield* this.emitEvent({
 			type: NcpEventType.MessageAccepted,
 			payload: {
@@ -312,63 +328,65 @@ var StdioRuntimeRunController = class {
 				runId: `narp-stdio:${this.input.sessionId}:${Date.now()}`
 			}
 		});
-		try {
-			while (!promptSettled || this.buffer.hasItems()) {
-				const update = this.buffer.shift();
-				if (!update) {
-					await this.buffer.waitForChange();
-					continue;
-				}
-				for (const event of this.translateUpdate(update, assistantMessageId)) yield* this.emitEvent(event);
+	};
+	drainPromptUpdates = async function* (assistantMessageId, promptState) {
+		while (!promptState.settled || this.buffer.hasItems()) {
+			const update = this.buffer.shift();
+			if (!update) {
+				await this.buffer.waitForChange();
+				continue;
 			}
-			if (promptError) throw promptError;
-			if (options?.signal?.aborted) throw createNcpError("abort-error", "ACP prompt cancelled");
-			for (const terminalEvent of this.createTerminalEvents(assistantMessageId)) yield* this.emitEvent(terminalEvent);
-			if (!this.collector.hasParts()) throw new Error(`[narp-stdio] ACP prompt completed without any assistant content for session ${this.input.sessionId}. stderr=${this.session.readStderr()}`);
-			yield* this.emitEvent({
-				type: NcpEventType.MessageCompleted,
-				payload: {
-					sessionId: this.input.sessionId,
-					correlationId: this.input.correlationId,
-					message: {
-						id: assistantMessageId,
-						sessionId: this.input.sessionId,
-						role: "assistant",
-						status: "final",
-						parts: this.collector.buildParts(),
-						timestamp: (/* @__PURE__ */ new Date()).toISOString()
-					}
-				}
-			});
-			yield* this.emitEvent({
-				type: NcpEventType.RunFinished,
-				payload: {
-					sessionId: this.input.sessionId,
-					messageId: assistantMessageId,
-					runId: `narp-stdio:${this.input.sessionId}`
-				}
-			});
-		} catch (error) {
-			const ncpError = normalizeRuntimeError(error);
-			yield* this.emitEvent({
-				type: NcpEventType.MessageFailed,
-				payload: {
-					sessionId: this.input.sessionId,
-					messageId: assistantMessageId,
-					correlationId: this.input.correlationId,
-					error: ncpError
-				}
-			});
-			yield* this.emitEvent({
-				type: NcpEventType.RunError,
-				payload: {
+			for (const event of this.translateUpdate(update, assistantMessageId)) yield* this.emitEvent(event);
+		}
+	};
+	shouldExitForAbort = (options, error) => options?.signal?.aborted === true || isAbortLikeRuntimeError(error);
+	emitCompletionEvents = async function* (assistantMessageId) {
+		for (const terminalEvent of this.createTerminalEvents(assistantMessageId)) yield* this.emitEvent(terminalEvent);
+		if (!this.collector.hasParts()) throw new Error(`[narp-stdio] ACP prompt completed without any assistant content for session ${this.input.sessionId}. stderr=${this.session.readStderr()}`);
+		yield* this.emitEvent({
+			type: NcpEventType.MessageCompleted,
+			payload: {
+				sessionId: this.input.sessionId,
+				correlationId: this.input.correlationId,
+				message: {
+					id: assistantMessageId,
 					sessionId: this.input.sessionId,
-					messageId: assistantMessageId,
-					runId: `narp-stdio:${this.input.sessionId}`,
-					error: ncpError.message
+					role: "assistant",
+					status: "final",
+					parts: this.collector.buildParts(),
+					timestamp: (/* @__PURE__ */ new Date()).toISOString()
 				}
-			});
-		}
+			}
+		});
+		yield* this.emitEvent({
+			type: NcpEventType.RunFinished,
+			payload: {
+				sessionId: this.input.sessionId,
+				messageId: assistantMessageId,
+				runId: `narp-stdio:${this.input.sessionId}`
+			}
+		});
+	};
+	emitFailureEvents = async function* (assistantMessageId, error) {
+		const ncpError = normalizeRuntimeError(error);
+		yield* this.emitEvent({
+			type: NcpEventType.MessageFailed,
+			payload: {
+				sessionId: this.input.sessionId,
+				messageId: assistantMessageId,
+				correlationId: this.input.correlationId,
+				error: ncpError
+			}
+		});
+		yield* this.emitEvent({
+			type: NcpEventType.RunError,
+			payload: {
+				sessionId: this.input.sessionId,
+				messageId: assistantMessageId,
+				runId: `narp-stdio:${this.input.sessionId}`,
+				error: ncpError.message
+			}
+		});
 	};
 	emitEvent = async function* (event) {
 		this.collector.apply(event);
@@ -553,11 +571,7 @@ function resolveModelId(params) {
 	return providerRoute?.model ?? readString(metadata?.preferred_model) ?? readString(metadata?.preferredModel) ?? readString(metadata?.model);
 }
 function resolveToolName(update) {
-	if (typeof update.rawInput === "object" && update.rawInput && !Array.isArray(update.rawInput)) {
-		const candidate = readString(update.rawInput.toolName) ?? readString(update.rawInput.tool);
-		if (candidate) return candidate;
-	}
-	return readString(update.title) ?? "unknown";
+	return resolveToolNameFromAcpUpdate(update);
 }
 function createAssistantMessageId(requestMessageId) {
 	return `assistant:${requestMessageId.trim() || "request"}:${randomUUID()}`;
@@ -567,25 +581,6 @@ function serializeToolArgs(value) {
 	if (typeof value === "undefined") return "{}";
 	return JSON.stringify(value);
 }
-function normalizeRuntimeError(error) {
-	if (isNcpError(error)) return error;
-	const message = error instanceof Error ? error.message : String(error);
-	const lowered = message.toLowerCase();
-	return {
-		code: lowered.includes("abort") || lowered.includes("cancel") ? "abort-error" : "runtime-error",
-		message
-	};
-}
-function createNcpError(code, message) {
-	return {
-		code,
-		message
-	};
-}
-function isNcpError(value) {
-	if (!value || typeof value !== "object") return false;
-	return typeof value.code === "string" && typeof value.message === "string";
-}
 async function withTimeout(promise, timeoutMs, message) {
 	let timeoutHandle = null;
 	try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/nextclaw-ncp-runtime-stdio-client",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "description": "Optional NCP runtime adapter backed by a protocol-aware stdio agent command.",
   "type": "module",
@@ -17,7 +17,7 @@
   ],
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.19.0",
-    "@nextclaw/ncp": "0.5.2"
+    "@nextclaw/ncp": "0.5.4"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",