@nextclaw/nextclaw-ncp-runtime-stdio-client 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { NARP_STDIO_PROMPT_META_KEY, NarpStdioPromptMeta, StdioRuntimeConfigResolver, StdioRuntimeEnv, StdioRuntimeProcessScope, StdioRuntimeResolvedConfig, StdioRuntimeWireDialect, buildRuntimeRouteBridgeEnv } from "./stdio-runtime-config.utils.js";
+import { NARP_STDIO_PROMPT_META_KEY, NarpStdioPromptMeta, StdioRuntimeConfigResolver, StdioRuntimeEnv, StdioRuntimeProcessScope, StdioRuntimeResolvedConfig, StdioRuntimeWireDialect, buildRuntimeRouteBridgeEnv, buildStdioRuntimeLaunchEnv } from "./stdio-runtime-config.utils.js";
 import { StdioRuntimeNcpAgentRuntime, StdioRuntimeNcpAgentRuntimeConfig } from "./stdio-runtime.service.js";
 import { probeStdioRuntime } from "./stdio-runtime-probe.utils.js";
-export { NARP_STDIO_PROMPT_META_KEY, type NarpStdioPromptMeta, StdioRuntimeConfigResolver, type StdioRuntimeEnv, StdioRuntimeNcpAgentRuntime, type StdioRuntimeNcpAgentRuntimeConfig, type StdioRuntimeProcessScope, type StdioRuntimeResolvedConfig, type StdioRuntimeWireDialect, buildRuntimeRouteBridgeEnv, probeStdioRuntime };
+export { NARP_STDIO_PROMPT_META_KEY, type NarpStdioPromptMeta, StdioRuntimeConfigResolver, type StdioRuntimeEnv, StdioRuntimeNcpAgentRuntime, type StdioRuntimeNcpAgentRuntimeConfig, type StdioRuntimeProcessScope, type StdioRuntimeResolvedConfig, type StdioRuntimeWireDialect, buildRuntimeRouteBridgeEnv, buildStdioRuntimeLaunchEnv, probeStdioRuntime };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { NARP_STDIO_PROMPT_META_KEY, StdioRuntimeConfigResolver, buildRuntimeRouteBridgeEnv } from "./stdio-runtime-config.utils.js";
+import { NARP_STDIO_PROMPT_META_KEY, StdioRuntimeConfigResolver, buildRuntimeRouteBridgeEnv, buildStdioRuntimeLaunchEnv } from "./stdio-runtime-config.utils.js";
 import { StdioRuntimeNcpAgentRuntime } from "./stdio-runtime.service.js";
 import { probeStdioRuntime } from "./stdio-runtime-probe.utils.js";
-export { NARP_STDIO_PROMPT_META_KEY, StdioRuntimeConfigResolver, StdioRuntimeNcpAgentRuntime, buildRuntimeRouteBridgeEnv, probeStdioRuntime };
+export { NARP_STDIO_PROMPT_META_KEY, StdioRuntimeConfigResolver, StdioRuntimeNcpAgentRuntime, buildRuntimeRouteBridgeEnv, buildStdioRuntimeLaunchEnv, probeStdioRuntime };

package/dist/stdio-runtime-config.utils.d.ts

@@ -32,5 +32,10 @@ declare class StdioRuntimeConfigResolver {
 declare function buildRuntimeRouteBridgeEnv(params: {
   providerRoute?: NcpProviderRuntimeRoute;
 }): Record<string, string>;
+declare function buildStdioRuntimeLaunchEnv(params: {
+  baseEnv?: Record<string, string | undefined>;
+  configEnv?: StdioRuntimeEnv;
+  providerRoute?: NcpProviderRuntimeRoute;
+}): Record<string, string>;
 //#endregion
-export { NARP_STDIO_PROMPT_META_KEY, NarpStdioPromptMeta, StdioRuntimeConfigResolver, StdioRuntimeEnv, StdioRuntimeProcessScope, StdioRuntimeResolvedConfig, StdioRuntimeWireDialect, buildRuntimeRouteBridgeEnv };
+export { NARP_STDIO_PROMPT_META_KEY, NarpStdioPromptMeta, StdioRuntimeConfigResolver, StdioRuntimeEnv, StdioRuntimeProcessScope, StdioRuntimeResolvedConfig, StdioRuntimeWireDialect, buildRuntimeRouteBridgeEnv, buildStdioRuntimeLaunchEnv };

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

@@ -82,6 +82,15 @@ function buildRuntimeRouteBridgeEnv(params) {
 		[DEFAULT_RUNTIME_ROUTE_BRIDGE_FIELDS.headers]: JSON.stringify(providerRoute.headers ?? {})
 	};
 }
+function buildStdioRuntimeLaunchEnv(params) {
+	const baseEnv = {};
+	for (const [key, value] of Object.entries(params.baseEnv ?? process.env)) if (typeof value === "string") baseEnv[key] = value;
+	return {
+		...baseEnv,
+		...params.configEnv ?? {},
+		...buildRuntimeRouteBridgeEnv({ providerRoute: params.providerRoute })
+	};
+}
 function parseJsonArray(value) {
 	if (typeof value !== "string" || !value.trim()) return;
 	try {
@@ -99,4 +108,4 @@ function parseJsonObject(value) {
 	}
 }
 //#endregion
-export { NARP_STDIO_PROMPT_META_KEY, StdioRuntimeConfigResolver, buildRuntimeRouteBridgeEnv, readString };
+export { NARP_STDIO_PROMPT_META_KEY, StdioRuntimeConfigResolver, buildRuntimeRouteBridgeEnv, buildStdioRuntimeLaunchEnv, readString };

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-probe.utils.js

@@ -1,4 +1,4 @@
-import { buildStdioLaunchEnv } from "./hermes-acp-route-bridge.utils.js";
+import { buildStdioRuntimeLaunchEnv } from "./stdio-runtime-config.utils.js";
 import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import * as acp from "@agentclientprotocol/sdk";
@@ -12,10 +12,7 @@ const createProbeClientBridge = () => ({
 async function probeStdioRuntime(config) {
 	const child = spawn(config.command, config.args, {
 		cwd: config.cwd,
-		env: buildStdioLaunchEnv({
-			config,
-			useProbeRoute: true
-		}),
+		env: buildStdioRuntimeLaunchEnv({ configEnv: config.env }),
 		stdio: [
 			"pipe",
 			"pipe",

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,11 +1,13 @@
-import { NARP_STDIO_PROMPT_META_KEY, readString } from "./stdio-runtime-config.utils.js";
-import { buildStdioLaunchEnv } from "./hermes-acp-route-bridge.utils.js";
+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();
@@ -156,8 +158,8 @@ var StdioRuntimeSession = class {
 	ensureStarted = async (params) => {
 		this.pendingProviderRoute = params?.providerRoute;
 		if (this.connection && this.remoteSessionId) return;
-		const env = buildStdioLaunchEnv({
-			config: this.config,
+		const env = buildStdioRuntimeLaunchEnv({
+			configEnv: this.config.env,
 			providerRoute: this.pendingProviderRoute
 		});
 		this.child = spawn(this.config.command, this.config.args, {
@@ -206,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
@@ -248,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();
@@ -288,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: {
@@ -313,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);
@@ -554,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()}`;
@@ -568,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.1",
+  "version": "0.1.3",
   "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.3"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
@@ -25,7 +25,7 @@
     "vitest": "^4.1.2"
   },
   "scripts": {
-    "build": "tsdown src/index.ts --dts --clean --target es2022 --no-fixedExtension --unbundle && node ./scripts/copy-hermes-acp-route-bridge.mjs",
+    "build": "tsdown src/index.ts --dts --clean --target es2022 --no-fixedExtension --unbundle",
     "lint": "eslint .",
     "tsc": "tsc -p tsconfig.json",
     "test": "vitest run"

package/dist/hermes-acp-route-bridge/sitecustomize.py

@@ -1,225 +0,0 @@
-"""NextClaw bridge for Hermes ACP RuntimeRoute passthrough.
-
-This module is auto-imported by Python when PYTHONPATH points at this
-directory. It patches Hermes ACP so `hermes acp` consumes the active
-NextClaw RuntimeRoute instead of resolving its own provider config first.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-from typing import Any, Dict, Optional
-
-LOGGER = logging.getLogger("nextclaw.hermes_acp_route_bridge")
-ROUTE_ENABLE_ENV = "NEXTCLAW_HERMES_ACP_ROUTE_BRIDGE"
-API_MODE_HEADER = "x-nextclaw-narp-api-mode"
-
-
-def _read_text_env(name: str) -> Optional[str]:
-    value = os.environ.get(name)
-    if not isinstance(value, str):
-        return None
-    trimmed = value.strip()
-    return trimmed or None
-
-
-def _read_headers_env() -> Dict[str, str]:
-    raw = _read_text_env("NEXTCLAW_HEADERS_JSON")
-    if not raw:
-        return {}
-    try:
-        parsed = json.loads(raw)
-    except Exception:
-        LOGGER.debug("Failed to parse NEXTCLAW_HEADERS_JSON", exc_info=True)
-        return {}
-    if not isinstance(parsed, dict):
-        return {}
-    normalized: Dict[str, str] = {}
-    for key, value in parsed.items():
-        if isinstance(key, str) and isinstance(value, str) and key.strip() and value.strip():
-            normalized[key] = value
-    return normalized
-
-
-def _read_nextclaw_route(explicit_model: Optional[str] = None) -> Optional[Dict[str, Any]]:
-    model = explicit_model or _read_text_env("NEXTCLAW_MODEL")
-    api_base = _read_text_env("NEXTCLAW_API_BASE")
-    api_key = _read_text_env("NEXTCLAW_API_KEY")
-    headers = _read_headers_env()
-    api_mode = headers.pop(API_MODE_HEADER, None) or "chat_completions"
-    if not any([model, api_base, api_key, headers]):
-        return None
-    return {
-      "model": model,
-      "api_base": api_base,
-      "api_key": api_key or "",
-      "headers": headers,
-      "api_mode": api_mode,
-    }
-
-
-def _merge_openai_headers(agent: Any, headers: Dict[str, str]) -> None:
-    if not headers:
-        return
-    client_kwargs = getattr(agent, "_client_kwargs", None)
-    if not isinstance(client_kwargs, dict):
-        return
-    merged = dict(client_kwargs.get("default_headers") or {})
-    merged.update(headers)
-    client_kwargs["default_headers"] = merged
-    replace_client = getattr(agent, "_replace_primary_openai_client", None)
-    if callable(replace_client):
-        replace_client(reason="nextclaw_runtime_route_bridge")
-
-
-def _merge_anthropic_headers(agent: Any, headers: Dict[str, str]) -> None:
-    if not headers:
-        return
-    client = getattr(agent, "_anthropic_client", None)
-    if client is None:
-        return
-    merged = dict(getattr(client, "_default_headers", {}) or {})
-    merged.update(headers)
-    if hasattr(client, "_default_headers"):
-        client._default_headers = merged
-    inner_client = getattr(client, "_client", None)
-    if inner_client is not None:
-        if hasattr(inner_client, "_default_headers"):
-            inner_client._default_headers = merged
-        transport_headers = getattr(inner_client, "headers", None)
-        if hasattr(transport_headers, "update"):
-            transport_headers.update(merged)
-
-
-def _patch_acp_auth() -> None:
-    try:
-        from acp_adapter import auth as auth_module
-    except Exception:
-        LOGGER.debug("Failed to import acp_adapter.auth", exc_info=True)
-        return
-
-    original_detect_provider = auth_module.detect_provider
-
-    def detect_provider():
-        route = _read_nextclaw_route()
-        if route is not None:
-            return "nextclaw"
-        return original_detect_provider()
-
-    def has_provider():
-        return detect_provider() is not None
-
-    auth_module.detect_provider = detect_provider
-    auth_module.has_provider = has_provider
-
-
-def _patch_session_manager() -> None:
-    try:
-        from acp_adapter import session as session_module
-    except Exception:
-        LOGGER.debug("Failed to import acp_adapter.session", exc_info=True)
-        return
-
-    original_make_agent = session_module.SessionManager._make_agent
-
-    def bridged_make_agent(
-        self,
-        *,
-        session_id: str,
-        cwd: str,
-        model: str | None = None,
-        requested_provider: str | None = None,
-        base_url: str | None = None,
-        api_mode: str | None = None,
-    ):
-        route = _read_nextclaw_route(explicit_model=model)
-        if route is None:
-            return original_make_agent(
-                self,
-                session_id=session_id,
-                cwd=cwd,
-                model=model,
-                requested_provider=requested_provider,
-                base_url=base_url,
-                api_mode=api_mode,
-            )
-
-        if self._agent_factory is not None:
-            return self._agent_factory()
-
-        from run_agent import AIAgent
-
-        kwargs = {
-            "platform": "acp",
-            "enabled_toolsets": ["hermes-acp"],
-            "quiet_mode": True,
-            "session_id": session_id,
-            "model": route["model"] or "",
-            "provider": requested_provider or "custom",
-            "api_mode": api_mode or route["api_mode"],
-            "base_url": base_url or route["api_base"] or "",
-            "api_key": route["api_key"],
-        }
-
-        session_module._register_task_cwd(session_id, cwd)
-        agent = AIAgent(**kwargs)
-        agent._print_fn = session_module._acp_stderr_print
-        _merge_openai_headers(agent, route["headers"])
-        _merge_anthropic_headers(agent, route["headers"])
-        return agent
-
-    session_module.SessionManager._make_agent = bridged_make_agent
-
-
-def _patch_acp_reasoning_mapping() -> None:
-    try:
-        from run_agent import AIAgent
-    except Exception:
-        LOGGER.debug("Failed to import run_agent.AIAgent", exc_info=True)
-        return
-
-    original_run_conversation = getattr(AIAgent, "run_conversation", None)
-    if not callable(original_run_conversation):
-        return
-    if getattr(original_run_conversation, "__nextclaw_reasoning_bridge__", False):
-        return
-
-    def bridged_run_conversation(self, *args, **kwargs):
-        original_thinking = getattr(self, "thinking_callback", None)
-        original_reasoning = getattr(self, "reasoning_callback", None)
-        remapped = (
-            getattr(self, "platform", None) == "acp"
-            and callable(original_thinking)
-            and original_reasoning is None
-        )
-
-        if remapped:
-            # Hermes ACP currently wires its transient spinner/status callback
-            # into ACP thought events. For ACP sessions, remap that callback to
-            # the real reasoning channel so downstream clients receive model
-            # reasoning instead of strings like "(⌐■_■) computing...".
-            self.reasoning_callback = original_thinking
-            self.thinking_callback = None
-
-        try:
-            return original_run_conversation(self, *args, **kwargs)
-        finally:
-            if remapped:
-                self.thinking_callback = original_thinking
-                self.reasoning_callback = original_reasoning
-
-    bridged_run_conversation.__nextclaw_reasoning_bridge__ = True
-    AIAgent.run_conversation = bridged_run_conversation
-
-
-def _activate() -> None:
-    if _read_text_env(ROUTE_ENABLE_ENV) != "1":
-        return
-    _patch_acp_auth()
-    _patch_session_manager()
-    _patch_acp_reasoning_mapping()
-
-
-_activate()

package/dist/hermes-acp-route-bridge.utils.js

@@ -1,61 +0,0 @@
-import { buildRuntimeRouteBridgeEnv } from "./stdio-runtime-config.utils.js";
-import { existsSync } from "node:fs";
-import { basename, delimiter } from "node:path";
-import { fileURLToPath } from "node:url";
-//#region src/hermes-acp-route-bridge.utils.ts
-const HERMES_ACP_BRIDGE_ENABLE_ENV = "NEXTCLAW_HERMES_ACP_ROUTE_BRIDGE";
-const HERMES_ACP_BRIDGE_DIR_ENV = "NEXTCLAW_HERMES_ACP_ROUTE_BRIDGE_DIR";
-const HERMES_ACP_PROBE_ROUTE = {
-	model: "nextclaw-hermes-acp-probe",
-	apiBase: "http://127.0.0.1:1/v1",
-	apiKey: "nextclaw-hermes-acp-probe-key",
-	headers: { "x-nextclaw-narp-api-mode": "chat_completions" }
-};
-function normalizeCommandBasename(command) {
-	return basename(command).trim().toLowerCase();
-}
-function isPythonCommand(command) {
-	const normalized = normalizeCommandBasename(command);
-	return normalized === "python" || normalized === "python3" || normalized.startsWith("python3.");
-}
-function targetsHermesAcpModule(args) {
-	for (let index = 0; index < args.length - 1; index += 1) if (args[index] === "-m" && args[index + 1]?.trim().toLowerCase() === "acp_adapter.entry") return true;
-	return false;
-}
-function isHermesAcpRuntimeConfig(config) {
-	const command = normalizeCommandBasename(config.command);
-	if (command === "hermes-acp") return true;
-	if (command === "hermes") return config.args[0]?.trim().toLowerCase() === "acp";
-	if (isPythonCommand(config.command)) return targetsHermesAcpModule(config.args);
-	return false;
-}
-function resolveHermesAcpBridgeDir() {
-	const bridgeDir = fileURLToPath(new URL("./hermes-acp-route-bridge", import.meta.url));
-	return existsSync(bridgeDir) ? bridgeDir : null;
-}
-function mergePathList(existingValue, injectedPath) {
-	const parts = (existingValue ?? "").split(delimiter).map((entry) => entry.trim()).filter(Boolean);
-	if (!parts.includes(injectedPath)) parts.unshift(injectedPath);
-	return parts.join(delimiter);
-}
-function buildStdioLaunchEnv(params) {
-	const providerRoute = params.providerRoute ?? (params.useProbeRoute && isHermesAcpRuntimeConfig(params.config) ? HERMES_ACP_PROBE_ROUTE : void 0);
-	const baseEnv = {};
-	for (const [key, value] of Object.entries(params.baseEnv ?? process.env)) if (typeof value === "string") baseEnv[key] = value;
-	const env = {
-		...baseEnv,
-		...params.config.env ?? {},
-		...buildRuntimeRouteBridgeEnv({ providerRoute })
-	};
-	if (!isHermesAcpRuntimeConfig(params.config)) return env;
-	const bridgeDir = resolveHermesAcpBridgeDir();
-	if (!bridgeDir) return env;
-	return {
-		...env,
-		[HERMES_ACP_BRIDGE_ENABLE_ENV]: "1",
-		[HERMES_ACP_BRIDGE_DIR_ENV]: bridgeDir,
-		PYTHONPATH: mergePathList(env.PYTHONPATH, bridgeDir)
-	};
-}
-//#endregion
-export { buildStdioLaunchEnv };