@rulvar/core 1.169.0 → 1.170.0

package/dist/index.d.ts

@@ -10839,6 +10839,28 @@ interface McpConfig {
     listMs?: number;
     callMs?: number;
   };
+  /**
+  * streamable-http only (RV1516): headers injected into EVERY wire
+  * request through a wrapped fetch. The hook form is awaited before
+  * each send, so it IS the refresh point: rotate a token in the hook
+  * and the next request carries it, with no reconnect and no
+  * library-invented 401 retry (transport failures surface exactly as
+  * before; the engine's RetryPolicy owns retries).
+  */
+  http?: {
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+  };
+  /**
+  * What a listChanged notification means for THIS source (RV1516).
+  * 'rekey' is the documented default: the session cache invalidates
+  * and subsequently spawned agents import the changed list under a new
+  * toolsetHash. 'refuse' fails closed instead: the notification
+  * poisons the source, every later tools() call refuses typed, and
+  * only close() (a deliberate host reset) clears it. In-flight spawn
+  * snapshots are untouched either way. Composes with the toolset
+  * attestation: refuse at the source vs refuse at the spawn.
+  */
+  drift?: "rekey" | "refuse";
 }
 /**
 * The ToolSource returned by {@link mcp}: the frozen ToolSource seam

package/dist/index.js

@@ -3894,6 +3894,9 @@ function validateBounds(cfg) {
 		const value = cfg.timeouts?.[key];
 		if (value !== void 0 && (!Number.isFinite(value) || value <= 0)) throw new ConfigError(`mcp: 'timeouts.${key}' must be a positive finite number of milliseconds, got ${String(value)}`);
 	}
+	if (cfg.drift !== void 0 && cfg.drift !== "rekey" && cfg.drift !== "refuse") throw new ConfigError(`mcp: 'drift' must be 'rekey' or 'refuse', got '${String(cfg.drift)}'`);
+	const headers = cfg.http?.headers;
+	if (headers !== void 0 && typeof headers !== "function" && typeof headers !== "object") throw new ConfigError("mcp: 'http.headers' must be a record of header values or a (possibly async) function returning one");
 }
 function validateConfig(cfg) {
 	validateBounds(cfg);
@@ -3905,6 +3908,7 @@ function validateConfig(cfg) {
 			if (cfg.command === void 0) throw new ConfigError("mcp: the stdio transport requires 'command'");
 			forbid("url");
 			forbid("server");
+			forbid("http");
 			return;
 		case "streamable-http":
 			if (cfg.url === void 0) throw new ConfigError("mcp: the streamable-http transport requires 'url'");
@@ -3917,6 +3921,7 @@ function validateConfig(cfg) {
 			forbid("command");
 			forbid("args");
 			forbid("url");
+			forbid("http");
 			return;
 		default: throw new ConfigError(`mcp: unknown transport '${String(cfg.transport)}'`);
 	}
@@ -3937,6 +3942,23 @@ function mapContent(result) {
 		text: block.text ?? ""
 	} : block);
 }
+/**
+* Wraps fetch so EVERY wire request of the streamable-http transport
+* consults the declared headers before send (RV1516): the hook form is
+* the per-request refresh point for rotating tokens, so no reconnect
+* and no library-invented 401 retry exists or is needed.
+*/
+function perRequestHeaders(headersOption) {
+	return async (url, init) => {
+		const extra = typeof headersOption === "function" ? await headersOption() : headersOption;
+		const headers = new Headers(init?.headers);
+		for (const [name, value] of Object.entries(extra ?? {})) headers.set(name, value);
+		return fetch(url, {
+			...init,
+			headers
+		});
+	};
+}
 function errorText(result) {
 	const text = (result.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
 	return text === "" ? "MCP tool reported an error" : text;
@@ -3959,6 +3981,7 @@ function mcp(cfg) {
 	let cache;
 	let generation = 0;
 	let inFlight;
+	let poisoned = false;
 	const connect = async () => {
 		const client = new Client({
 			name: "rulvar",
@@ -3972,7 +3995,8 @@ function mcp(cfg) {
 				});
 				await client.connect(transport);
 			} else if (cfg.transport === "streamable-http") {
-				const transport = new StreamableHTTPClientTransport(new URL(cfg.url ?? ""));
+				const declaredHeaders = cfg.http?.headers;
+				const transport = new StreamableHTTPClientTransport(new URL(cfg.url ?? ""), declaredHeaders === void 0 ? void 0 : { fetch: perRequestHeaders(declaredHeaders) });
 				await client.connect(transport);
 			} else {
 				const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
@@ -4003,6 +4027,7 @@ function mcp(cfg) {
 		client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
 			generation += 1;
 			cache = void 0;
+			if (cfg.drift === "refuse") poisoned = true;
 		});
 		return client;
 	};
@@ -4058,6 +4083,7 @@ function mcp(cfg) {
 	return {
 		id: sourceIdOf(cfg),
 		tools: async () => {
+			if (poisoned) throw new ConfigError(`mcp: the tool list of '${sourceIdOf(cfg)}' changed after import (listChanged) and drift policy 'refuse' holds the source closed; close() and re-create the source (and re-record any toolset attestation) to import the changed list deliberately`);
 			if (cache !== void 0) return cache;
 			if (inFlight !== void 0) return inFlight;
 			const fetch = (async () => {
@@ -4084,6 +4110,7 @@ function mcp(cfg) {
 			const pending = clientPromise;
 			clientPromise = void 0;
 			cache = void 0;
+			poisoned = false;
 			if (pending === void 0) return;
 			let client;
 			try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/core",
-  "version": "1.169.0",
+  "version": "1.170.0",
   "description": "Rulvar core: L0 contracts, journal kernel, ctx primitives, agent runtime, model router, tool system, dynamic orchestrator, InMemory and JSONL stores, event stream.",
   "type": "module",
   "license": "Apache-2.0",