@nextclaw/nextclaw-ncp-runtime-adapter-hermes-http 0.1.1

package/dist/hermes-http-adapter-message.utils.js

@@ -0,0 +1,458 @@
+import { NcpAssistantTextStreamNormalizer, NcpEventType } from "@nextclaw/ncp";
+//#region src/hermes-http-adapter-message.utils.ts
+const HERMES_INLINE_TOOL_TRACE_PATTERNS = [{
+	icon: "🔎",
+	toolName: "search_files",
+	buildArgs: (rawArgs) => JSON.stringify({ pattern: rawArgs })
+}, {
+	icon: "💻",
+	toolName: "terminal",
+	buildArgs: (rawArgs) => JSON.stringify({ command: rawArgs })
+}];
+function readMetadataString(metadata, key) {
+	const value = metadata?.[key];
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function readStringRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const out = {};
+	for (const [entryKey, entryValue] of Object.entries(value)) {
+		if (typeof entryValue !== "string") continue;
+		const normalized = entryValue.trim();
+		if (!normalized) continue;
+		out[entryKey] = normalized;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+const NARP_API_MODE_HEADER = "x-nextclaw-narp-api-mode";
+function readHermesProviderRoute(envelope) {
+	const route = envelope.providerRoute;
+	if (!route || typeof route !== "object" || Array.isArray(route)) return;
+	const routeRecord = route;
+	const model = readMetadataString(routeRecord, "model") ?? readMetadataString(routeRecord, "providerLocalModel");
+	if (!model) return;
+	return {
+		model,
+		apiKey: readMetadataString(routeRecord, "apiKey"),
+		apiBase: readMetadataString(routeRecord, "apiBase"),
+		...extractRuntimeHeaders(readStringRecord(routeRecord.headers) ?? readStringRecord(routeRecord.extraHeaders) ?? {})
+	};
+}
+function buildHermesMessages(params) {
+	const { envelope, systemPrompt } = params;
+	const messages = [];
+	if (systemPrompt) messages.push({
+		role: "system",
+		content: systemPrompt
+	});
+	const content = extractMessageText(envelope.message);
+	messages.push({
+		role: normalizeRole(envelope.message.role),
+		content
+	});
+	return messages;
+}
+function createAssistantMessage(params) {
+	const { sessionId, messageId, text, timestamp, metadata } = params;
+	return {
+		id: messageId,
+		sessionId,
+		role: "assistant",
+		status: "final",
+		parts: [{
+			type: "text",
+			text
+		}],
+		timestamp,
+		...metadata ? { metadata } : {}
+	};
+}
+function createAssistantMessageFromParts(params) {
+	const { sessionId, messageId, parts, timestamp, metadata } = params;
+	return {
+		id: messageId,
+		sessionId,
+		role: "assistant",
+		status: "final",
+		parts: structuredClone(parts),
+		timestamp,
+		...metadata ? { metadata } : {}
+	};
+}
+var HermesAssistantEventCollector = class {
+	parts = [];
+	toolPartIndexByCallId = /* @__PURE__ */ new Map();
+	applyEvent = (event) => {
+		switch (event.type) {
+			case NcpEventType.MessageTextDelta:
+				this.appendTextPart(event.payload.delta);
+				return;
+			case NcpEventType.MessageReasoningDelta:
+				this.appendReasoningPart(event.payload.delta);
+				return;
+			case NcpEventType.MessageToolCallStart:
+				this.upsertToolInvocationPart({
+					type: "tool-invocation",
+					toolCallId: event.payload.toolCallId,
+					toolName: event.payload.toolName,
+					state: "partial-call",
+					args: ""
+				});
+				return;
+			case NcpEventType.MessageToolCallArgsDelta:
+				this.applyToolCallArgsDelta(event.payload.toolCallId, event.payload.delta);
+				return;
+			case NcpEventType.MessageToolCallArgs:
+				this.upsertToolInvocationPart({
+					type: "tool-invocation",
+					toolCallId: event.payload.toolCallId,
+					toolName: this.readToolName(event.payload.toolCallId),
+					state: "partial-call",
+					args: event.payload.args
+				});
+				return;
+			case NcpEventType.MessageToolCallEnd:
+				this.upsertToolInvocationPart({
+					type: "tool-invocation",
+					toolCallId: event.payload.toolCallId,
+					toolName: this.readToolName(event.payload.toolCallId),
+					state: "call",
+					args: this.readToolArgs(event.payload.toolCallId)
+				});
+				return;
+			default: return;
+		}
+	};
+	hasParts = () => this.parts.length > 0;
+	buildParts = () => structuredClone(this.parts);
+	appendTextPart = (delta) => {
+		if (!delta) return;
+		const lastPart = this.parts.at(-1);
+		if (lastPart?.type === "text") {
+			lastPart.text = `${lastPart.text}${delta}`;
+			return;
+		}
+		this.parts.push({
+			type: "text",
+			text: delta
+		});
+	};
+	appendReasoningPart = (delta) => {
+		if (!delta) return;
+		const lastPart = this.parts.at(-1);
+		if (lastPart?.type === "reasoning") {
+			lastPart.text = `${lastPart.text}${delta}`;
+			return;
+		}
+		this.parts.push({
+			type: "reasoning",
+			text: delta
+		});
+	};
+	applyToolCallArgsDelta = (toolCallId, delta) => {
+		const currentArgs = this.readToolArgs(toolCallId);
+		this.upsertToolInvocationPart({
+			type: "tool-invocation",
+			toolCallId,
+			toolName: this.readToolName(toolCallId),
+			state: "partial-call",
+			args: `${currentArgs}${delta}`
+		});
+	};
+	upsertToolInvocationPart = (nextPart) => {
+		const normalizedToolCallId = nextPart.toolCallId?.trim();
+		if (!normalizedToolCallId) {
+			this.parts.push({ ...nextPart });
+			return;
+		}
+		const existingIndex = this.toolPartIndexByCallId.get(normalizedToolCallId);
+		if (typeof existingIndex === "number") {
+			const existingPart = this.parts[existingIndex];
+			if (existingPart?.type !== "tool-invocation") return;
+			this.parts[existingIndex] = {
+				...existingPart,
+				...nextPart,
+				toolCallId: normalizedToolCallId,
+				toolName: nextPart.toolName || existingPart.toolName,
+				args: nextPart.args ?? existingPart.args
+			};
+			return;
+		}
+		this.toolPartIndexByCallId.set(normalizedToolCallId, this.parts.length);
+		this.parts.push({
+			...nextPart,
+			toolCallId: normalizedToolCallId
+		});
+	};
+	readToolArgs = (toolCallId) => {
+		const part = this.findToolPart(toolCallId);
+		if (!part) return "";
+		return typeof part.args === "string" ? part.args : JSON.stringify(part.args ?? "");
+	};
+	readToolName = (toolCallId) => {
+		return this.findToolPart(toolCallId)?.toolName ?? "unknown";
+	};
+	findToolPart = (toolCallId) => {
+		const existingIndex = this.toolPartIndexByCallId.get(toolCallId);
+		if (typeof existingIndex !== "number") return null;
+		const part = this.parts[existingIndex];
+		return part?.type === "tool-invocation" ? part : null;
+	};
+};
+var HermesInlineToolTraceTranslator = class {
+	pendingTextBuffer = "";
+	sawStructuredToolCall = false;
+	toolCallCount = 0;
+	translate = async function* (events) {
+		for await (const event of events) {
+			if (this.isStructuredToolCallEvent(event)) {
+				this.sawStructuredToolCall = true;
+				yield* this.flushPendingText({
+					sessionId: this.readEventSessionId(event),
+					messageId: this.readEventMessageId(event),
+					flush: true
+				});
+				yield event;
+				continue;
+			}
+			if (!this.sawStructuredToolCall && event.type === NcpEventType.MessageTextDelta) {
+				this.pendingTextBuffer += event.payload.delta;
+				yield* this.flushPendingText({
+					sessionId: event.payload.sessionId,
+					messageId: event.payload.messageId,
+					flush: false
+				});
+				continue;
+			}
+			if (!this.sawStructuredToolCall && this.shouldFlushPendingText(event)) yield* this.flushPendingText({
+				sessionId: this.readEventSessionId(event),
+				messageId: this.readEventMessageId(event),
+				flush: true
+			});
+			yield event;
+		}
+	};
+	flushPendingText = function* (params) {
+		if (!this.pendingTextBuffer) return;
+		const lastNewlineIndex = this.pendingTextBuffer.lastIndexOf("\n");
+		const flushableText = params.flush ? this.pendingTextBuffer : lastNewlineIndex >= 0 ? this.pendingTextBuffer.slice(0, lastNewlineIndex + 1) : this.pendingTextBuffer.includes("`") ? "" : this.pendingTextBuffer;
+		if (!flushableText) return;
+		this.pendingTextBuffer = this.pendingTextBuffer.slice(flushableText.length);
+		for (const segment of splitIntoLineSegments(flushableText)) {
+			const inlineToolTrace = matchHermesInlineToolTrace(segment);
+			if (inlineToolTrace && params.sessionId) {
+				const toolCallId = `hermes-inline-tool-${++this.toolCallCount}`;
+				yield {
+					type: NcpEventType.MessageToolCallStart,
+					payload: {
+						sessionId: params.sessionId,
+						...params.messageId ? { messageId: params.messageId } : {},
+						toolCallId,
+						toolName: inlineToolTrace.toolName
+					}
+				};
+				yield {
+					type: NcpEventType.MessageToolCallArgs,
+					payload: {
+						sessionId: params.sessionId,
+						toolCallId,
+						args: inlineToolTrace.args
+					}
+				};
+				yield {
+					type: NcpEventType.MessageToolCallEnd,
+					payload: {
+						sessionId: params.sessionId,
+						toolCallId
+					}
+				};
+				continue;
+			}
+			if (!segment || !params.sessionId || !params.messageId) continue;
+			yield {
+				type: NcpEventType.MessageTextDelta,
+				payload: {
+					sessionId: params.sessionId,
+					messageId: params.messageId,
+					delta: segment
+				}
+			};
+		}
+	};
+	shouldFlushPendingText = (event) => event.type === NcpEventType.MessageTextEnd || event.type === NcpEventType.MessageCompleted || event.type === NcpEventType.MessageFailed || event.type === NcpEventType.RunFinished || event.type === NcpEventType.RunError;
+	isStructuredToolCallEvent = (event) => event.type === NcpEventType.MessageToolCallStart || event.type === NcpEventType.MessageToolCallArgs || event.type === NcpEventType.MessageToolCallArgsDelta || event.type === NcpEventType.MessageToolCallEnd || event.type === NcpEventType.MessageToolCallResult;
+	readEventSessionId = (event) => {
+		if (!("payload" in event) || !event.payload || typeof event.payload !== "object") return;
+		return "sessionId" in event.payload && typeof event.payload.sessionId === "string" ? event.payload.sessionId : void 0;
+	};
+	readEventMessageId = (event) => {
+		if (!("payload" in event) || !event.payload || typeof event.payload !== "object") return;
+		return "messageId" in event.payload && typeof event.payload.messageId === "string" ? event.payload.messageId : void 0;
+	};
+};
+var HermesReasoningDeltaTranslator = class {
+	normalizer = new NcpAssistantTextStreamNormalizer("think-tags");
+	translate = async function* (events) {
+		for await (const event of events) {
+			if (event.type === NcpEventType.MessageTextDelta) {
+				yield* this.emitNormalizedTextDelta(event);
+				continue;
+			}
+			if (this.shouldFlushPendingText(event)) yield* this.flushPendingText(event);
+			yield event;
+		}
+		yield* this.flushSegments();
+	};
+	emitNormalizedTextDelta = function* (event) {
+		const segments = this.normalizer.push(event.payload.delta);
+		for (const segment of segments) {
+			if (!segment.text) continue;
+			if (segment.type === "reasoning") {
+				yield {
+					type: NcpEventType.MessageReasoningDelta,
+					payload: {
+						sessionId: event.payload.sessionId,
+						messageId: event.payload.messageId,
+						delta: segment.text
+					}
+				};
+				continue;
+			}
+			yield {
+				type: NcpEventType.MessageTextDelta,
+				payload: {
+					sessionId: event.payload.sessionId,
+					messageId: event.payload.messageId,
+					delta: segment.text
+				}
+			};
+		}
+	};
+	flushPendingText = function* (event) {
+		const sessionId = this.readEventSessionId(event);
+		const messageId = this.readEventMessageId(event);
+		if (!sessionId || !messageId) {
+			yield* this.flushSegments();
+			return;
+		}
+		const segments = this.normalizer.finish();
+		for (const segment of segments) {
+			if (!segment.text) continue;
+			if (segment.type === "reasoning") {
+				yield {
+					type: NcpEventType.MessageReasoningDelta,
+					payload: {
+						sessionId,
+						messageId,
+						delta: segment.text
+					}
+				};
+				continue;
+			}
+			yield {
+				type: NcpEventType.MessageTextDelta,
+				payload: {
+					sessionId,
+					messageId,
+					delta: segment.text
+				}
+			};
+		}
+	};
+	flushSegments = function* () {
+		this.normalizer.finish();
+	};
+	shouldFlushPendingText = (event) => event.type === NcpEventType.MessageTextEnd || event.type === NcpEventType.MessageCompleted || event.type === NcpEventType.MessageFailed || event.type === NcpEventType.RunFinished || event.type === NcpEventType.RunError;
+	readEventSessionId = (event) => {
+		if (!("payload" in event) || !event.payload || typeof event.payload !== "object") return;
+		return "sessionId" in event.payload && typeof event.payload.sessionId === "string" ? event.payload.sessionId : void 0;
+	};
+	readEventMessageId = (event) => {
+		if (!("payload" in event) || !event.payload || typeof event.payload !== "object") return;
+		return "messageId" in event.payload && typeof event.payload.messageId === "string" ? event.payload.messageId : void 0;
+	};
+};
+function resolveHermesModel(params) {
+	const { envelope, fallbackModel } = params;
+	const providerRoute = readHermesProviderRoute(envelope);
+	const metadata = envelope.metadata && typeof envelope.metadata === "object" && !Array.isArray(envelope.metadata) ? envelope.metadata : void 0;
+	return providerRoute?.model ?? readMetadataString(metadata, "preferred_model") ?? readMetadataString(metadata, "preferredModel") ?? readMetadataString(metadata, "model") ?? fallbackModel;
+}
+function normalizeHermesRequestedModel(model) {
+	const trimmed = model.trim();
+	if (!trimmed) return trimmed;
+	const slashIndex = trimmed.indexOf("/");
+	if (slashIndex <= 0) return trimmed;
+	const suffix = trimmed.slice(slashIndex + 1).trim();
+	if (!suffix) return trimmed;
+	if (suffix.includes(":")) return suffix;
+	return trimmed;
+}
+function inferHermesProvider(params) {
+	if (params.apiMode === "anthropic_messages") return "anthropic";
+	const model = params.model.trim().toLowerCase();
+	if (readHostname(params.apiBase).includes("anthropic.com") || model.startsWith("claude")) return "anthropic";
+	return "openai";
+}
+function toNcpError(error, code) {
+	return {
+		code,
+		message: error instanceof Error ? error.message : String(error)
+	};
+}
+function toNcpSseFrame(event) {
+	return `event: ncp-event\ndata: ${JSON.stringify(event)}\n\n`;
+}
+function toErrorSseFrame(error) {
+	return `event: error\ndata: ${JSON.stringify(error)}\n\n`;
+}
+function readHostname(value) {
+	if (!value) return "";
+	try {
+		return new URL(value).hostname.trim().toLowerCase();
+	} catch {
+		return "";
+	}
+}
+function extractRuntimeHeaders(headers) {
+	const nextHeaders = { ...headers };
+	const apiMode = nextHeaders[NARP_API_MODE_HEADER];
+	delete nextHeaders[NARP_API_MODE_HEADER];
+	return {
+		headers: nextHeaders,
+		...apiMode ? { apiMode } : {}
+	};
+}
+function extractMessageText(message) {
+	const text = message.parts.map((part) => {
+		if (part.type === "text" || part.type === "reasoning" || part.type === "rich-text") return part.text;
+		return "";
+	}).join("\n").trim();
+	return text.length > 0 ? text : "[empty message]";
+}
+function splitIntoLineSegments(text) {
+	return text.match(/[^\n]*\n|[^\n]+$/gu) ?? [];
+}
+function matchHermesInlineToolTrace(segment) {
+	const trimmed = segment.trim();
+	if (!trimmed.startsWith("`") || !trimmed.endsWith("`")) return null;
+	const body = trimmed.slice(1, -1).trim();
+	for (const candidate of HERMES_INLINE_TOOL_TRACE_PATTERNS) {
+		if (!body.startsWith(candidate.icon)) continue;
+		const rawArgs = body.slice(candidate.icon.length).trim();
+		if (!rawArgs) return null;
+		return {
+			toolName: candidate.toolName,
+			args: candidate.buildArgs(rawArgs)
+		};
+	}
+	return null;
+}
+function normalizeRole(role) {
+	if (role === "assistant" || role === "system") return role;
+	return "user";
+}
+//#endregion
+export { HermesAssistantEventCollector, HermesInlineToolTraceTranslator, HermesReasoningDeltaTranslator, buildHermesMessages, createAssistantMessage, createAssistantMessageFromParts, inferHermesProvider, normalizeHermesRequestedModel, readHermesProviderRoute, resolveHermesModel, toErrorSseFrame, toNcpError, toNcpSseFrame };

package/dist/hermes-http-adapter-session-store.service.js

@@ -0,0 +1,105 @@
+//#region src/hermes-http-adapter-session-store.service.ts
+var HermesHttpAdapterSessionStore = class {
+	sessions = /* @__PURE__ */ new Map();
+	setPendingRun = (run) => {
+		const session = this.getOrCreateEntry(run.envelope.sessionId);
+		if (session.pendingRun || session.activeAbortController) throw new Error(`[hermes-http-adapter] session ${run.envelope.sessionId} already has an active or pending run.`);
+		session.pendingRun = run;
+		this.flushWaiters(run.envelope.sessionId, session);
+	};
+	waitForPendingRun = async (sessionId, signal, timeoutMs) => {
+		const entry = this.getOrCreateEntry(sessionId);
+		if (entry.pendingRun) {
+			const run = entry.pendingRun;
+			entry.pendingRun = void 0;
+			return run;
+		}
+		return await new Promise((resolve, reject) => {
+			const waiter = {
+				resolve: (run) => {
+					cleanup();
+					resolve(run);
+				},
+				reject: (error) => {
+					cleanup();
+					reject(error);
+				}
+			};
+			const cleanup = () => {
+				clearTimeout(timeout);
+				signal.removeEventListener("abort", handleAbort);
+				entry.waiters.delete(waiter);
+			};
+			const handleAbort = () => {
+				waiter.reject(createAbortError("stream request aborted before send arrived"));
+			};
+			const timeout = setTimeout(() => {
+				waiter.reject(/* @__PURE__ */ new Error(`[hermes-http-adapter] timed out waiting for /send for session ${sessionId}.`));
+			}, timeoutMs);
+			signal.addEventListener("abort", handleAbort, { once: true });
+			entry.waiters.add(waiter);
+		});
+	};
+	setActiveAbortController = (sessionId, controller) => {
+		const session = this.getOrCreateEntry(sessionId);
+		session.activeAbortController = controller;
+	};
+	clearActiveAbortController = (sessionId) => {
+		const session = this.sessions.get(sessionId);
+		if (!session) return;
+		session.activeAbortController = void 0;
+		this.cleanupSession(sessionId, session);
+	};
+	abortSession = (sessionId) => {
+		const session = this.sessions.get(sessionId);
+		if (!session?.activeAbortController) return false;
+		session.activeAbortController.abort("session aborted");
+		return true;
+	};
+	setHermesSessionId = (sessionId, hermesSessionId) => {
+		const session = this.getOrCreateEntry(sessionId);
+		session.hermesSessionId = hermesSessionId;
+	};
+	readHermesSessionId = (sessionId) => this.sessions.get(sessionId)?.hermesSessionId;
+	setSelectedModel = (sessionId, model) => {
+		const session = this.getOrCreateEntry(sessionId);
+		session.selectedModel = model;
+	};
+	readSelectedModel = (sessionId) => this.sessions.get(sessionId)?.selectedModel;
+	dispose = () => {
+		for (const [sessionId, session] of this.sessions.entries()) {
+			session.activeAbortController?.abort("adapter disposed");
+			for (const waiter of session.waiters) waiter.reject(/* @__PURE__ */ new Error(`[hermes-http-adapter] adapter disposed for ${sessionId}.`));
+			session.waiters.clear();
+		}
+		this.sessions.clear();
+	};
+	flushWaiters = (sessionId, session) => {
+		if (!session.pendingRun || session.waiters.size === 0) return;
+		const run = session.pendingRun;
+		session.pendingRun = void 0;
+		const waiters = [...session.waiters];
+		session.waiters.clear();
+		for (const waiter of waiters) waiter.resolve(run);
+		this.cleanupSession(sessionId, session);
+	};
+	cleanupSession = (sessionId, session) => {
+		if (session.pendingRun || session.activeAbortController || session.waiters.size > 0) return;
+		if (session.hermesSessionId || session.selectedModel) return;
+		this.sessions.delete(sessionId);
+	};
+	getOrCreateEntry = (sessionId) => {
+		const existing = this.sessions.get(sessionId);
+		if (existing) return existing;
+		const created = { waiters: /* @__PURE__ */ new Set() };
+		this.sessions.set(sessionId, created);
+		return created;
+	};
+};
+function createAbortError(message) {
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
+}
+//#endregion
+export { HermesHttpAdapterSessionStore };

package/dist/hermes-http-adapter.service.d.ts

@@ -0,0 +1,14 @@
+import { HermesHttpAdapterResolvedConfig } from "./hermes-http-adapter.types.js";
+import { HermesHttpAdapterConfigInput } from "./hermes-http-adapter-config.utils.js";
+
+//#region src/hermes-http-adapter.service.d.ts
+declare class HermesHttpAdapterServer {
+  readonly config: HermesHttpAdapterResolvedConfig;
+  private readonly routeService;
+  private server;
+  constructor(configInput?: HermesHttpAdapterConfigInput);
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+}
+//#endregion
+export { HermesHttpAdapterServer };