@xopcai/xopc 0.0.369 → 0.0.370

package/dist/src/connectors/connection-recovery-service.js

@@ -22,7 +22,6 @@ import { resolveConnectionCandidate } from "./connection-candidates.js";
 import { cancelPersonalRequest, resolvePersonalRequestConnection } from "../personal-agent/request-service.js";
 import { persistConfigMutation } from "../config/config-mutation.js";
 import { drainPersonalRequestContinuations, drainPersonalRequestResults } from "../personal-agent/request-delivery.js";
-import { HostPluginMcpRecovery } from "./plugin-mcp-recovery.js";
 import { randomUUID } from "node:crypto";
 //#region src/connectors/connection-recovery-service.ts
 init_transaction();
@@ -95,9 +94,6 @@ var ConnectionRecoveryService = class {
 	get adapter() {
 		return this.deps.adapter ?? new ComposioSessionsAdapter();
 	}
-	get pluginMcp() {
-		return this.deps.pluginMcp ?? new HostPluginMcpRecovery(this.deps.getConfig);
-	}
 	snapshot(conversationId) {
 		if (!connectorPrincipalForSession(conversationId).isLocalOwner) throw new Error("This connection belongs to another principal.");
 		const transcriptId = readCurrentTranscriptId(getSqliteDatabase(), conversationId);
@@ -111,18 +107,6 @@ var ConnectionRecoveryService = class {
 	}
 	view(wait, verifiedIds) {
 		const needs = wait.needs.map((need) => {
-			if (need.target.type === "plugin-mcp") {
-				const availability = this.pluginMcp.availability(need.target);
-				const phase = !availability.available || need.connectionId && need.capabilityError ? "blocked" : need.connectionId === need.target.serverId ? "ready" : need.attempt && need.attempt.expiresAt > Date.now() ? "authorizing" : need.unavailable ? "reconnect" : "connect";
-				return {
-					...need,
-					authorizationMode: "desktop",
-					phase,
-					accounts: [],
-					alternatives: [],
-					...availability.reason || need.capabilityError ? { reason: availability.reason ?? need.capabilityError } : {}
-				};
-			}
 			if (need.target.type === "store-connector") {
 				const target = need.target;
 				const instance = listConnectorInstances(this.deps.getConfig()).find((item) => item.connectorId === target.connectorId);
@@ -238,7 +222,7 @@ var ConnectionRecoveryService = class {
 			}))
 		}, verified).needs;
 		return Promise.all(wait.needs.map(async (need) => {
-			if (need.target.type === "plugin-mcp" || need.target.type === "store-connector") return need;
+			if (need.target.type === "store-connector") return need;
 			if (views.find((view) => view.key === need.key)?.phase !== "ready") return {
 				...need,
 				capabilityError: void 0
@@ -314,38 +298,6 @@ var ConnectionRecoveryService = class {
 		}
 		return fresh;
 	}
-	async syncPluginMcpNeeds(wait) {
-		return Promise.all(wait.needs.map(async (need) => {
-			if (need.target.type !== "plugin-mcp") return need;
-			const status = await this.pluginMcp.status(need.target);
-			if (status.status === "connected") {
-				const verified = await this.pluginMcp.verify(need.target);
-				return {
-					...need,
-					connectionId: need.target.serverId,
-					unavailable: false,
-					attempt: void 0,
-					capabilityError: verified.ready ? void 0 : verified.error ?? "The connected MCP tools are unavailable."
-				};
-			}
-			if (status.status === "authorizing") return {
-				...need,
-				connectionId: void 0,
-				unavailable: false,
-				attempt: {
-					id: status.session?.id ?? need.attempt?.id ?? randomUUID(),
-					expiresAt: status.session?.expiresAt ?? Date.now() + ATTEMPT_TTL
-				}
-			};
-			return {
-				...need,
-				connectionId: void 0,
-				unavailable: true,
-				attempt: void 0,
-				capabilityError: status.status === "error" ? status.session?.error : void 0
-			};
-		}));
-	}
 	async preflight(input) {
 		if (input.kind !== "connection_resume") return true;
 		const wait = input.payload ? getConnectionWait(input.payload.waitId) : void 0;
@@ -354,11 +306,10 @@ var ConnectionRecoveryService = class {
 		try {
 			const fresh = await this.syncConnections(wait);
 			const verified = new Set(fresh.filter((item) => item.status === "active").map((item) => item.id));
-			wait.needs = await this.syncPluginMcpNeeds(wait);
-			wait.needs = wait.needs.map((need) => need.target.type === "plugin-mcp" ? need : {
+			wait.needs = wait.needs.map((need) => ({
 				...need,
 				unavailable: !fresh.some((item) => item.id === need.connectionId && item.status === "active")
-			});
+			}));
 			wait.needs = await this.checkCapabilities(wait, verified);
 			const ready = this.view(wait, verified).needs.every((need) => need.phase === "ready");
 			if (getConnectionWait(wait.id)?.version !== wait.version) return false;
@@ -466,48 +417,6 @@ var ConnectionRecoveryService = class {
 				const need = wait.needs.find((need) => need.key === action.needKey);
 				if (!need) throw new Error("Unknown connection requirement.");
 				if (this.view(wait).needs.find((item) => item.key === need.key)?.phase === "blocked") throw new Error("Connector policy blocks this connection.");
-				if (need.target.type === "plugin-mcp") {
-					const serverId = need.target.serverId;
-					const attemptId = randomUUID();
-					wait = updateConnectionWait({
-						...wait,
-						intent: {
-							objectiveRevision: wait.objectiveRevision,
-							validUntil: Date.now() + INTENT_TTL
-						},
-						needs: wait.needs.map((item) => item.key === need.key ? {
-							...item,
-							unavailable: false,
-							capabilityError: void 0,
-							attempt: {
-								id: attemptId,
-								expiresAt: Date.now() + ATTEMPT_TTL
-							}
-						} : item)
-					}, wait.version);
-					publishConnectionWait(conversationId);
-					const auth = await this.pluginMcp.start(need.target);
-					const latest = getConnectionWait(wait.id);
-					if (!latest || latest.version !== wait.version || latest.status !== "open") throw new Error("WAIT_CHANGED");
-					wait = updateConnectionWait({
-						...wait,
-						needs: wait.needs.map((item) => item.key === need.key ? {
-							...item,
-							attempt: auth.status === "authorizing" ? {
-								id: auth.session?.id ?? attemptId,
-								expiresAt: auth.session?.expiresAt ?? Date.now() + ATTEMPT_TTL
-							} : void 0,
-							connectionId: auth.status === "connected" ? serverId : void 0,
-							unavailable: auth.status === "error",
-							capabilityError: auth.status === "error" ? auth.session?.error : void 0
-						} : item)
-					}, wait.version);
-					publishConnectionWait(conversationId);
-					return {
-						snapshot: this.snapshot(conversationId),
-						authorizationUrl: auth.session?.authorizationUrl
-					};
-				}
 				const id = need.target.connectorId;
 				const instance = listConnectorInstances(this.deps.getConfig()).find((item) => item.connectorId === id);
 				const definition = (instance ? getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) : void 0) ?? getConnectorDefinition(id);
@@ -578,18 +487,11 @@ var ConnectionRecoveryService = class {
 					authorizationUrl: auth.connectUrl
 				};
 			} else {
-				if (action.action === "submit_callback") {
-					const need = wait.needs.find((need) => need.key === action.needKey);
-					if (!need || need.target.type !== "plugin-mcp") throw new Error("OAuth callback is unavailable.");
-					if (!action.callbackUrl || action.callbackUrl.length > 16384) throw new Error("Expected the complete OAuth callback URL.");
-					await this.pluginMcp.submitCallback(need.target, action.callbackUrl);
-				}
 				const fresh = await this.syncConnections(wait);
 				const verified = new Set(fresh.filter((item) => item.status === "active").map((item) => item.id));
 				const latest = getConnectionWait(wait.id);
 				if (!latest || latest.version !== wait.version || latest.status !== "open") throw new Error("WAIT_CHANGED");
 				let needs = wait.needs.map((need) => {
-					if (need.target.type === "plugin-mcp") return need;
 					if (need.target.type === "store-connector") {
 						const selected = this.view({
 							...wait,
@@ -617,10 +519,6 @@ var ConnectionRecoveryService = class {
 						unavailable: !fresh.some((item) => item.connectorId === id && item.status === "active" && (!need.connectionId || item.id === need.connectionId) && (!need.accountId || item.accountId === need.accountId))
 					};
 				});
-				needs = await this.syncPluginMcpNeeds({
-					...wait,
-					needs
-				});
 				if (action.action === "select_account") {
 					const need = needs.find((item) => item.key === action.needKey);
 					if (!need || need.target.type !== "connector") throw new Error("Account selection is unavailable.");

package/dist/src/connectors/health.d.ts

@@ -1,4 +1,3 @@
 import type { Config } from '../config/schema.js';
-import type { ConnectorDefinition, ConnectorHealthResult, ConnectorInstallInput } from './types.js';
+import type { ConnectorHealthResult } from './types.js';
 export declare function testConnectorInstance(config: Config, serverId: string): Promise<ConnectorHealthResult>;
-export declare function previewConnectorDefinition(config: Config, definition: ConnectorDefinition, input?: ConnectorInstallInput): Promise<ConnectorHealthResult>;

package/dist/src/connectors/health.js

@@ -1,10 +1,7 @@
 import { init_connector_repository, listConnectorConnections } from "../storage/sqlite/connector-repository.js";
 import { currentAccountConnections } from "./account-access.js";
-import { materializeConnectorMcpServer } from "./materialize.js";
 import { getConnectorInstance } from "./instances.js";
 import { describeCliAction, verifyCliConnection } from "./cli/runtime.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
-import { listBundleMcpServerCapabilitiesForGateway } from "../agent/mcp/bundle-mcp-gateway.js";
 //#region src/connectors/health.ts
 init_connector_repository();
 function classifyConnectorHealthError(error) {
@@ -17,12 +14,6 @@ function classifyConnectorHealthError(error) {
 	if (/spawn|command|start|connect/i.test(message)) return "startup_failed";
 	return "unknown_error";
 }
-function healthActionForStatus(status) {
-	if (status === "missing_secret") return "Reconnect the connector and provide the required secret.";
-	if (status === "timeout" || status === "network_failed") return "Check network access and retry the connector health check.";
-	if (status === "startup_failed") return "Verify the connector runtime dependency is installed and reachable.";
-	if (status === "unauthorized") return "Reconnect the connector or refresh its credentials.";
-}
 async function testConnectorInstance(config, serverId) {
 	const instance = getConnectorInstance(config, serverId);
 	if (!instance) return {
@@ -97,97 +88,7 @@ async function testConnectorInstance(config, serverId) {
 			};
 		}
 	}
-	const workspaceDir = getWorkspacePath(config) || "./workspace";
-	try {
-		const capabilities = await listBundleMcpServerCapabilitiesForGateway({
-			workspaceDir,
-			cfg: config,
-			serverId
-		});
-		return {
-			serverId,
-			ok: true,
-			status: "ok",
-			toolCount: capabilities.toolCount,
-			resourceCount: capabilities.resourceCount,
-			promptCount: capabilities.promptCount,
-			tools: capabilities.tools,
-			resources: capabilities.resources,
-			prompts: capabilities.prompts
-		};
-	} catch (error) {
-		const status = classifyConnectorHealthError(error);
-		return {
-			serverId,
-			ok: false,
-			status,
-			toolCount: 0,
-			resourceCount: 0,
-			promptCount: 0,
-			tools: [],
-			resources: [],
-			prompts: [],
-			error: error instanceof Error ? error.message : String(error),
-			action: healthActionForStatus(status)
-		};
-	}
-}
-async function previewConnectorDefinition(config, definition, input = {}) {
-	if (definition.runtime.type !== "mcp") return {
-		serverId: definition.id,
-		ok: false,
-		status: "unknown_error",
-		toolCount: 0,
-		resourceCount: 0,
-		promptCount: 0,
-		tools: [],
-		resources: [],
-		prompts: [],
-		error: `Connector type "${definition.runtime.type}" does not support MCP capability preview.`
-	};
-	try {
-		const { serverId, server } = materializeConnectorMcpServer(definition, input);
-		const capabilities = await listBundleMcpServerCapabilitiesForGateway({
-			workspaceDir: getWorkspacePath(config) || "./workspace",
-			cfg: {
-				...config,
-				mcp: {
-					...config.mcp ?? {},
-					servers: {
-						...config.mcp?.servers ?? {},
-						[serverId]: server
-					}
-				}
-			},
-			serverId
-		});
-		return {
-			serverId,
-			ok: true,
-			status: "ok",
-			toolCount: capabilities.toolCount,
-			resourceCount: capabilities.resourceCount,
-			promptCount: capabilities.promptCount,
-			tools: capabilities.tools,
-			resources: capabilities.resources,
-			prompts: capabilities.prompts
-		};
-	} catch (error) {
-		const status = classifyConnectorHealthError(error);
-		return {
-			serverId: definition.id,
-			ok: false,
-			status,
-			toolCount: 0,
-			resourceCount: 0,
-			promptCount: 0,
-			tools: [],
-			resources: [],
-			prompts: [],
-			error: error instanceof Error ? error.message : String(error),
-			action: healthActionForStatus(status)
-		};
-	}
+	throw new Error("MCP diagnostics are provided by xopc mcp list.");
 }
 //#endregion
-export { previewConnectorDefinition, testConnectorInstance };
+export { testConnectorInstance };

package/dist/src/connectors/types.d.ts

@@ -1,6 +1,6 @@
 export type ConnectorKind = 'mcp' | 'cli' | 'http' | 'browser' | 'extension' | 'builtin' | 'composio' | 'memorySource';
 export type ConnectorCategory = 'code' | 'docs' | 'browser' | 'data' | 'automation' | 'custom';
-export type ConnectorCapability = 'tools' | 'resources' | 'prompts' | 'context' | 'channel' | 'events' | 'ui' | 'memory_source' | 'workflows' | 'auth.apiKey' | 'auth.oauth' | 'runtime.mcp.stdio' | 'runtime.mcp.sse' | 'runtime.mcp.streamableHttp';
+export type ConnectorCapability = 'tools' | 'resources' | 'prompts' | 'context' | 'channel' | 'events' | 'ui' | 'memory_source' | 'workflows' | 'auth.apiKey' | 'auth.oauth' | 'runtime.mcp.stdio' | 'runtime.mcp.streamableHttp';
 export type ConnectorAuthMode = 'none' | 'apiKey' | 'oauth' | 'cli';
 export type ConnectorAuthDefinition = {
     mode: 'cli';

package/dist/src/endpoint-tools/binding-service.d.ts

@@ -13,6 +13,8 @@ export interface EndpointSessionBindingStore {
 export declare class EndpointBindingService {
     private readonly registry;
     private readonly store;
+    private readonly changeListeners;
+    onChange(listener: (conversationId: string) => void): () => void;
     constructor(registry: EndpointRegistry, store?: EndpointSessionBindingStore);
     bind(conversationId: string, endpointId: string, now?: number): EndpointSessionBinding;
     get(conversationId: string): EndpointSessionBinding | undefined;

package/dist/src/endpoint-tools/binding-service.js

@@ -11,6 +11,13 @@ function memoryStore() {
 	};
 }
 var EndpointBindingService = class {
+	changeListeners = /* @__PURE__ */ new Set();
+	onChange(listener) {
+		this.changeListeners.add(listener);
+		return () => {
+			this.changeListeners.delete(listener);
+		};
+	}
 	constructor(registry, store = memoryStore()) {
 		this.registry = registry;
 		this.store = store;
@@ -23,7 +30,9 @@ var EndpointBindingService = class {
 			endpointId,
 			boundAt: now
 		};
-		return this.store.set(binding);
+		const stored = this.store.set(binding);
+		for (const listener of this.changeListeners) listener(normalizedConversationId);
+		return stored;
 	}
 	get(conversationId) {
 		return this.store.get(this.normalizeConversationId(conversationId));
@@ -33,7 +42,10 @@ var EndpointBindingService = class {
 		return binding ? this.registry.get(binding.endpointId) : void 0;
 	}
 	unbind(conversationId) {
-		return this.store.delete(this.normalizeConversationId(conversationId));
+		const normalized = this.normalizeConversationId(conversationId);
+		const removed = this.store.delete(normalized);
+		if (removed) for (const listener of this.changeListeners) listener(normalized);
+		return removed;
 	}
 	normalizeConversationId(conversationId) {
 		const normalized = conversationId.trim();

package/dist/src/endpoint-tools/bridge-host.d.ts

@@ -0,0 +1,15 @@
+import { type EndpointToolRegistry } from '@xopcai/endpoint-tools-client';
+export interface DeviceBridgeHostOptions {
+    gatewayUrl: string;
+    token: string;
+    identityPath: string;
+    registry: EndpointToolRegistry;
+    displayName?: string;
+    onStateChange?: (state: string) => void;
+}
+/** Connects a Node hardware adapter through the existing signed Endpoint v2 transport. */
+export declare function connectDeviceBridge(options: DeviceBridgeHostOptions): Promise<{
+    endpointId: string;
+    principalId: string;
+    close: () => void;
+}>;

package/dist/src/endpoint-tools/bridge-host.js

@@ -0,0 +1,166 @@
+import { endpointHelloSigningPayload, init_src } from "../../packages/endpoint-tools-protocol/src/index.js";
+import { EndpointToolHostController } from "../../packages/endpoint-tools-client/src/index.js";
+import { RealtimeClient } from "../../packages/realtime-client/src/index.js";
+import { dirname } from "node:path";
+import { generateKeyPairSync, randomUUID, sign } from "node:crypto";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import WebSocket from "ws";
+//#region src/endpoint-tools/bridge-host.ts
+init_src();
+async function loadIdentity(path) {
+	try {
+		const info = await stat(path);
+		if (!info.isFile() || process.platform !== "win32" && (info.mode & 63) !== 0) throw new Error("Bridge identity must be a private file (mode 0600)");
+		const identity = JSON.parse(await readFile(path, "utf8"));
+		if (!identity.principalId || !identity.publicKey || !identity.privateKey) throw new Error("Invalid Bridge identity file");
+		return identity;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		const pair = generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+		const identity = {
+			principalId: randomUUID(),
+			publicKey: pair.publicKey.export({
+				type: "spki",
+				format: "der"
+			}).toString("base64url"),
+			privateKey: pair.privateKey.export({
+				type: "pkcs8",
+				format: "pem"
+			}).toString()
+		};
+		await mkdir(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		await writeFile(path, JSON.stringify(identity), {
+			mode: 384,
+			flag: "wx"
+		});
+		return identity;
+	}
+}
+/** Connects a Node hardware adapter through the existing signed Endpoint v2 transport. */
+async function connectDeviceBridge(options) {
+	const url = new URL(options.gatewayUrl);
+	if (url.username || url.password || url.search || url.hash || url.pathname !== "/") throw new Error("Use a Gateway origin URL without credentials or path");
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname))) throw new Error("Remote Bridge connections require HTTPS");
+	const lifetime = new AbortController();
+	const request = async (path, body, signal) => {
+		const response = await fetch(new URL(path, url), {
+			method: body === void 0 ? "GET" : "POST",
+			headers: {
+				Authorization: `Bearer ${options.token}`,
+				"Content-Type": "application/json"
+			},
+			...body === void 0 ? {} : { body: JSON.stringify(body) },
+			redirect: "error",
+			signal: AbortSignal.any([lifetime.signal, signal ?? AbortSignal.timeout(1e4)])
+		});
+		if (!response.ok) throw new Error(`Bridge Gateway request failed: HTTP ${response.status}`);
+		const result = await response.json();
+		if (!result.ok) throw new Error("Bridge Gateway request was rejected");
+		return result.payload;
+	};
+	if ((await request("/api/endpoint-tools/compatibility")).hardwareBridgeV1 !== true) throw new Error("Gateway does not support hardwareBridgeV1");
+	const identity = await loadIdentity(options.identityPath);
+	const endpointId = `${identity.principalId}:bridge`;
+	const displayName = options.displayName ?? "xopc Device Bridge";
+	if (!displayName.trim() || displayName.length > 80) throw new Error("Bridge name must contain 1–80 characters");
+	const register = () => request("/api/endpoint-tools/principals", {
+		principalId: identity.principalId,
+		publicKey: identity.publicKey,
+		kind: "desktop",
+		platform: process.platform,
+		displayName
+	});
+	await register();
+	const controller = new EndpointToolHostController({
+		registry: options.registry,
+		getAvailability: () => "background",
+		createMessageId: randomUUID,
+		confirm: async () => false,
+		uploadFile: async () => {
+			throw new Error("Bridge sensors cannot upload files");
+		}
+	});
+	const clientId = randomUUID();
+	const websocketUrl = new URL("/api/realtime/v1/ws", url);
+	websocketUrl.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	const client = new RealtimeClient({
+		clientId,
+		clientKind: "desktop",
+		createMessageId: randomUUID,
+		getWebSocketUrl: () => websocketUrl.href,
+		issueTicket: (signal) => request("/api/realtime/tickets", {
+			clientId,
+			clientKind: "desktop",
+			protocolVersion: 2
+		}, signal),
+		createWebSocket: (address) => new WebSocket(address),
+		onStateChange: (state) => options.onStateChange?.(state)
+	});
+	const close = () => {
+		lifetime.abort();
+		client.disconnect();
+		controller.disconnect();
+	};
+	let resolveReady;
+	const ready = new Promise((resolve) => {
+		resolveReady = resolve;
+	});
+	client.setEndpoint({
+		createHello: async () => {
+			await register();
+			const hello = {
+				principalId: identity.principalId,
+				endpointId,
+				connectionInstanceId: randomUUID(),
+				displayName,
+				kind: "desktop",
+				platform: process.platform,
+				appVersion: "1",
+				availability: "background",
+				nonce: randomUUID(),
+				signedAt: Date.now(),
+				signature: "pending",
+				tools: options.registry.descriptors()
+			};
+			hello.signature = sign("sha256", Buffer.from(endpointHelloSigningPayload(hello)), {
+				key: identity.privateKey,
+				dsaEncoding: "ieee-p1363"
+			}).toString("base64url");
+			return hello;
+		},
+		onReady: () => {
+			controller.connect((message) => client.sendEndpointMessage(message));
+			resolveReady();
+		},
+		onMessage: (message) => {
+			controller.handleMessage(message);
+		},
+		onDisconnected: () => controller.disconnect()
+	});
+	client.connect();
+	let timeout;
+	try {
+		await Promise.race([ready, new Promise((_resolve, reject) => {
+			timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("Bridge endpoint did not become ready")), 15e3);
+		})]);
+	} catch (error) {
+		close();
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+	return {
+		endpointId,
+		principalId: identity.principalId,
+		close
+	};
+}
+//#endregion
+export { connectDeviceBridge };

package/dist/src/endpoint-tools/bridge.d.ts

@@ -0,0 +1,27 @@
+import { EndpointToolRegistry } from '@xopcai/endpoint-tools-client';
+import { z } from 'zod';
+declare const resourceSchema: z.ZodObject<{
+    resourceId: z.ZodString;
+    name: z.ZodString;
+    measurement: z.ZodEnum<{
+        temperature: "temperature";
+        humidity: "humidity";
+    }>;
+    unit: z.ZodEnum<{
+        celsius: "celsius";
+        percent: "percent";
+    }>;
+    simulated: z.ZodBoolean;
+}, z.core.$strict>;
+export type BridgeResource = z.infer<typeof resourceSchema>;
+export interface BridgeSensorAdapter {
+    resource: BridgeResource;
+    read(signal: AbortSignal): Promise<{
+        value: number | null;
+        capturedAt: number;
+    }>;
+}
+/** Drivers return one sample; transport, identity, cancellation and policy remain host-owned. */
+export declare function createDeviceBridge(adapters: readonly BridgeSensorAdapter[], now?: () => number): EndpointToolRegistry;
+export declare function simulatedEnvironmentSensors(now?: () => number): BridgeSensorAdapter[];
+export {};

package/dist/src/endpoint-tools/bridge.js

@@ -0,0 +1,88 @@
+import { bridgeDescriptor } from "../../packages/endpoint-tools-protocol/src/bridge.js";
+import { init_src } from "../../packages/endpoint-tools-protocol/src/index.js";
+import { EndpointToolRegistry } from "../../packages/endpoint-tools-client/src/index.js";
+import { z } from "zod";
+//#region src/endpoint-tools/bridge.ts
+init_src();
+const resourceSchema = z.object({
+	resourceId: z.string().regex(/^[a-zA-Z0-9._:-]{1,128}$/),
+	name: z.string().min(1).max(80),
+	measurement: z.enum(["temperature", "humidity"]),
+	unit: z.enum(["celsius", "percent"]),
+	simulated: z.boolean()
+}).strict().refine((item) => item.unit === (item.measurement === "temperature" ? "celsius" : "percent"), "Unit does not match measurement");
+/** Drivers return one sample; transport, identity, cancellation and policy remain host-owned. */
+function createDeviceBridge(adapters, now = Date.now) {
+	if (adapters.length > 100) throw new Error("Bridge supports at most 100 resources");
+	const resources = /* @__PURE__ */ new Map();
+	for (const adapter of adapters) {
+		const resource = resourceSchema.parse(adapter.resource);
+		if (resources.has(resource.resourceId)) throw new Error("Duplicate Bridge resource ID");
+		resources.set(resource.resourceId, {
+			resource,
+			read: adapter.read.bind(adapter)
+		});
+	}
+	return new EndpointToolRegistry([{
+		descriptor: bridgeDescriptor("list_resources"),
+		execute: async (args) => {
+			z.object({}).strict().parse(args);
+			return { content: [{
+				type: "json",
+				value: [...resources.values()].map((item) => ({ ...item.resource }))
+			}] };
+		}
+	}, {
+		descriptor: bridgeDescriptor("read_sensor"),
+		execute: async (args, context) => {
+			const { resourceId } = z.object({ resourceId: z.string() }).strict().parse(args);
+			const adapter = resources.get(resourceId);
+			if (!adapter) throw new TypeError("Unknown Bridge resource");
+			context.signal.throwIfAborted();
+			const sample = await adapter.read(context.signal);
+			context.signal.throwIfAborted();
+			const time = now();
+			if (!Number.isSafeInteger(sample.capturedAt) || sample.capturedAt > time + 6e4 || sample.capturedAt < time - 3e4) throw new TypeError("Bridge sample has an invalid or stale timestamp");
+			const { value } = sample;
+			const range = adapter.resource.measurement === "humidity" ? [0, 100] : [-100, 200];
+			if (value !== null && (!Number.isFinite(value) || value < range[0] || value > range[1])) throw new TypeError("Invalid Bridge sample value");
+			return { content: [{
+				type: "json",
+				value: {
+					...adapter.resource,
+					value,
+					capturedAt: sample.capturedAt
+				}
+			}] };
+		}
+	}]);
+}
+function simulatedEnvironmentSensors(now = Date.now) {
+	return [{
+		resource: {
+			resourceId: "sim.room.temperature",
+			name: "Simulated room temperature",
+			measurement: "temperature",
+			unit: "celsius",
+			simulated: true
+		},
+		read: async () => ({
+			value: 23.5,
+			capturedAt: now()
+		})
+	}, {
+		resource: {
+			resourceId: "sim.room.humidity",
+			name: "Simulated room humidity",
+			measurement: "humidity",
+			unit: "percent",
+			simulated: true
+		},
+		read: async () => ({
+			value: 45,
+			capturedAt: now()
+		})
+	}];
+}
+//#endregion
+export { createDeviceBridge, simulatedEnvironmentSensors };

package/dist/src/endpoint-tools/capability-catalog.d.ts

@@ -0,0 +1,2 @@
+/** Server-owned targeting rules; device descriptors cannot change these defaults. */
+export declare function deviceCapabilityTarget(toolName: string): 'turn_origin' | 'session_bound';

package/dist/src/endpoint-tools/capability-catalog.js

@@ -0,0 +1,8 @@
+//#region src/endpoint-tools/capability-catalog.ts
+/** Server-owned targeting rules; device descriptors cannot change these defaults. */
+function deviceCapabilityTarget(toolName) {
+	if (/^(mobile|desktop|web|browser)\.device\./.test(toolName) || toolName === "web.page.get_selection") return "turn_origin";
+	return "session_bound";
+}
+//#endregion
+export { deviceCapabilityTarget };