@xopcai/xopc 0.0.368 → 0.0.370

package/dist/packages/browser-control-contract/src/automation.js

@@ -0,0 +1,213 @@
+//#region packages/browser-control-contract/src/automation.ts
+/** Runs in the page. Keep all helpers inside this function for serialization. */
+async function browserDom(input) {
+	const root = globalThis;
+	const doc = root.document;
+	const normalize = (value) => String(value || "").trim().replace(/\s+/g, " ").slice(0, 240);
+	const sensitive = (element) => element.type === "password" || element.type === "file" || /cc-|one-time-code|transaction-|password|token|secret|otp|cvv|cvc|card.?number|验证码|密码|银行卡|卡号/i.test([
+		element.autocomplete,
+		element.name,
+		element.id,
+		element.getAttribute("aria-label"),
+		name(element)
+	].join(" "));
+	const role = (element) => element.getAttribute("role") || {
+		A: "link",
+		BUTTON: "button",
+		SUMMARY: "button",
+		SELECT: "combobox",
+		TEXTAREA: "textbox",
+		FORM: "form",
+		FIELDSET: "group",
+		SECTION: "region"
+	}[element.tagName] || (element.tagName === "INPUT" ? element.type === "checkbox" ? "checkbox" : element.type === "radio" ? "radio" : [
+		"submit",
+		"button",
+		"reset"
+	].includes(element.type) ? "button" : "textbox" : "text");
+	const name = (element) => normalize((element.getAttribute("aria-labelledby") || "").split(/\s+/).map((id) => doc.getElementById(id)?.textContent || "").join(" ") || element.getAttribute("aria-label") || element.labels?.[0]?.textContent || (element.tagName === "FIELDSET" ? element.querySelector("legend")?.textContent : "") || element.getAttribute("alt") || element.getAttribute("placeholder") || ([
+		"submit",
+		"button",
+		"reset"
+	].includes(element.type) ? element.value : "") || element.innerText || element.getAttribute("title") || "");
+	const describe = (element) => {
+		const container = element.parentElement?.closest("form,fieldset,section,[role=\"region\"],[role=\"group\"],[role=\"dialog\"]");
+		return {
+			role: role(element),
+			name: name(element),
+			...element.getAttribute("data-testid") ? { testId: element.getAttribute("data-testid") } : {},
+			...container && name(container) ? { scope: {
+				role: role(container),
+				name: name(container)
+			} } : {}
+		};
+	};
+	const selector = "a[href],button,input:not([type=\"hidden\"]),textarea,select,summary,[role],[data-testid],label,p,span,h1,h2,h3,td,output";
+	if (input.operation === "resolve") {
+		const target = input.target;
+		const matches = Array.from(doc.querySelectorAll(selector)).filter((element) => {
+			const rect = element.getBoundingClientRect();
+			const style = root.getComputedStyle(element);
+			if (!rect.width || !rect.height || style.display === "none" || style.visibility === "hidden") return false;
+			const descriptor = describe(element);
+			return descriptor.role === target.role && (!target.name || descriptor.name === target.name) && (!target.nameIncludes || descriptor.name?.includes(target.nameIncludes)) && (!target.testId || descriptor.testId === target.testId) && (!target.scope || descriptor.scope?.role === target.scope.role && descriptor.scope?.name === target.scope.name);
+		});
+		if (matches.length !== 1) return { matches: matches.length };
+		const element = matches[0];
+		const ref = `xopc-e${++root.__xopcRefCounter || (root.__xopcRefCounter = 1)}`;
+		element.setAttribute("data-xopc-ref", ref);
+		return {
+			matches: 1,
+			node: {
+				ref,
+				role: role(element),
+				name: name(element),
+				value: !sensitive(element) && "value" in element ? String(element.value).slice(0, 4096) : void 0,
+				description: !sensitive(element) ? normalize(element.textContent) : void 0,
+				href: element.tagName === "A" ? element.href : void 0,
+				states: [
+					sensitive(element) ? "sensitive" : "",
+					element.disabled ? "disabled" : "",
+					element.checked ? "checked" : "",
+					["BUTTON", "INPUT"].includes(element.tagName) && element.type === "submit" ? "submit" : ""
+				].filter(Boolean)
+			}
+		};
+	}
+	const prior = root.__xopcRecorder;
+	if (input.operation === "record" && prior?.recordingId === input.recordingId && prior?.generation === input.generation) return { recording: true };
+	if (prior) {
+		await prior.stop();
+		delete root.__xopcRecorder;
+	}
+	if (input.operation === "stop") return { stopped: true };
+	let sourceSeq = 0;
+	const pending = /* @__PURE__ */ new Set();
+	const dirty = /* @__PURE__ */ new Set();
+	const lastValues = /* @__PURE__ */ new WeakMap();
+	const listeners = [];
+	const cleanUrl = () => {
+		const url = new URL(root.location.href);
+		url.username = "";
+		url.password = "";
+		url.hash = "";
+		for (const key of [...url.searchParams.keys()]) if (/token|secret|password|key|code/i.test(key)) url.searchParams.delete(key);
+		return url.toString();
+	};
+	const documentId = `${root.performance.timeOrigin}:${input.generation}`;
+	let failed = false;
+	let ended = false;
+	let enterTarget;
+	let enterAt = 0;
+	const emit = (event) => {
+		const task = root.chrome.runtime.sendMessage({
+			type: "browser/recording-event",
+			recordingId: input.recordingId,
+			generation: input.generation,
+			event: {
+				...event,
+				id: root.crypto.randomUUID(),
+				sourceSeq: ++sourceSeq,
+				documentId,
+				url: cleanUrl()
+			}
+		}).then((ack) => {
+			if (!ack?.ok) failed = true;
+		}).catch(() => {
+			failed = true;
+		});
+		pending.add(task);
+		task.finally(() => pending.delete(task));
+	};
+	const flush = (element) => {
+		if (!dirty.delete(element) || sensitive(element)) return;
+		const value = String(element.value || "").slice(0, 4096);
+		if (lastValues.get(element) === value) return;
+		lastValues.set(element, value);
+		emit({
+			action: element.tagName === "SELECT" ? "select" : "fill",
+			target: describe(element),
+			value
+		});
+	};
+	const listen = (type, handler) => {
+		listeners.push([type, handler]);
+		(type === "pagehide" ? root : doc).addEventListener(type, handler, true);
+	};
+	listen("input", (event) => {
+		if (event.isTrusted && !sensitive(event.target) && !["checkbox", "radio"].includes(event.target.type) && "value" in event.target) dirty.add(event.target);
+	});
+	listen("dragstart", (event) => {
+		if (event.isTrusted) emit({
+			action: "unsupported",
+			value: "Drag actions are not supported by the recorder."
+		});
+	});
+	listen("change", (event) => {
+		if (!event.isTrusted || sensitive(event.target)) return;
+		if (["checkbox", "radio"].includes(event.target.type)) emit({
+			action: "check",
+			target: describe(event.target),
+			checked: !!event.target.checked
+		});
+		else {
+			dirty.add(event.target);
+			flush(event.target);
+		}
+	});
+	listen("focusout", (event) => flush(event.target));
+	listen("click", (event) => {
+		if (!event.isTrusted) return;
+		for (const element of dirty) flush(element);
+		const element = event.target.closest("a[href],button,summary,[role=\"button\"],input[type=\"submit\"],input[type=\"button\"]");
+		if (element && event.detail === 0 && Date.now() - enterAt < 500 && (element === enterTarget || element.form && element.form === enterTarget?.form)) return;
+		if (element && !sensitive(element)) emit({
+			action: "click",
+			target: describe(element)
+		});
+		else if (event.target.closest("canvas,[contenteditable=\"true\"],input[type=\"file\"]")) emit({
+			action: "unsupported",
+			value: "Canvas, rich text and file actions require an assistant to complete the workflow."
+		});
+	});
+	listen("pagehide", () => {
+		for (const element of dirty) flush(element);
+		emit({ action: "checkpoint" });
+		ended = true;
+		for (const [type, handler] of listeners) (type === "pagehide" ? root : doc).removeEventListener(type, handler, true);
+	});
+	listen("keydown", (event) => {
+		if (!event.isTrusted || event.isComposing || sensitive(event.target) || !["Enter", "Escape"].includes(event.key)) return;
+		flush(event.target);
+		if (event.key === "Enter") {
+			enterTarget = event.target;
+			enterAt = Date.now();
+		}
+		emit({
+			action: "press",
+			target: describe(event.target),
+			key: event.key
+		});
+	});
+	root.__xopcRecorder = {
+		recordingId: input.recordingId,
+		generation: input.generation,
+		stop: async () => {
+			for (const [type, handler] of listeners) (type === "pagehide" ? root : doc).removeEventListener(type, handler, true);
+			for (const element of dirty) flush(element);
+			if (!ended) {
+				emit({ action: "checkpoint" });
+				ended = true;
+			}
+			await Promise.all([...pending]);
+			if (failed) throw new Error("Recording events could not be saved.");
+		}
+	};
+	emit({ action: "navigate" });
+	return {
+		recording: true,
+		documentId
+	};
+}
+//#endregion
+export { browserDom };

package/dist/packages/browser-control-contract/src/index.js

@@ -1,3 +1,4 @@
+import "./automation.js";
 //#region packages/browser-control-contract/src/index.ts
 const BROWSER_CONTROL_ENDPOINT_TOOL_NAME = "browser.control";
 const BROWSER_CONTROL_ENDPOINT_INPUT_SCHEMA = {
@@ -28,16 +29,46 @@ const BROWSER_CONTROL_ENDPOINT_OUTPUT_SCHEMA = {
 		}
 	}
 };
-function browserWireAuthenticationPayload(input) {
-	return [
-		"xopc-browser-extension-v4",
-		input.connectionId,
-		input.challenge,
-		String(input.issuedAt),
-		input.principalId,
-		input.extensionId,
-		input.extensionVersion
-	].join("\n");
-}
+const BROWSER_CONTROL_ENDPOINT_DESCRIPTOR = {
+	name: BROWSER_CONTROL_ENDPOINT_TOOL_NAME,
+	title: "Browser control transport",
+	description: "Internal authenticated transport for xopc browser-control actions.",
+	inputSchema: BROWSER_CONTROL_ENDPOINT_INPUT_SCHEMA,
+	outputSchema: BROWSER_CONTROL_ENDPOINT_OUTPUT_SCHEMA,
+	policyId: "browser.control",
+	sensitivity: "personal",
+	effect: "write",
+	confirmation: "never",
+	requiresForeground: false,
+	requiredPermissions: ["browser-control"],
+	timeoutMs: 12e4,
+	maxConcurrency: 4,
+	supportsCancellation: true,
+	idempotent: false,
+	resultKinds: ["json"]
+};
+const BROWSER_RECORDING_ENDPOINT_INPUT_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["operation"],
+	properties: { operation: {
+		type: "string",
+		enum: [
+			"start",
+			"pause",
+			"resume",
+			"finish",
+			"status"
+		]
+	} }
+};
+const BROWSER_RECORDING_ENDPOINT_DESCRIPTOR = {
+	...BROWSER_CONTROL_ENDPOINT_DESCRIPTOR,
+	name: "browser.recording",
+	title: "Browser workflow recording",
+	description: "Record a workflow in the active browser tab and save it as an automation.",
+	inputSchema: BROWSER_RECORDING_ENDPOINT_INPUT_SCHEMA,
+	maxConcurrency: 1
+};
 //#endregion
-export { BROWSER_CONTROL_ENDPOINT_INPUT_SCHEMA, BROWSER_CONTROL_ENDPOINT_OUTPUT_SCHEMA, BROWSER_CONTROL_ENDPOINT_TOOL_NAME, browserWireAuthenticationPayload };
+export { BROWSER_CONTROL_ENDPOINT_DESCRIPTOR, BROWSER_CONTROL_ENDPOINT_INPUT_SCHEMA, BROWSER_CONTROL_ENDPOINT_OUTPUT_SCHEMA, BROWSER_CONTROL_ENDPOINT_TOOL_NAME, BROWSER_RECORDING_ENDPOINT_DESCRIPTOR, BROWSER_RECORDING_ENDPOINT_INPUT_SCHEMA };

package/dist/packages/endpoint-tools-client/src/index.js

@@ -0,0 +1,189 @@
+import { canonicalJson, endpointToolContentSchema, init_src } from "../../endpoint-tools-protocol/src/index.js";
+import { sha256 } from "../../../.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js";
+//#region packages/endpoint-tools-client/src/index.ts
+init_src();
+var EndpointToolClientError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "EndpointToolClientError";
+	}
+};
+function endpointToolRevision(descriptor) {
+	return [...sha256(new TextEncoder().encode(canonicalJson(descriptor)))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+var EndpointToolRegistry = class {
+	tools = /* @__PURE__ */ new Map();
+	constructor(definitions) {
+		for (const definition of definitions) {
+			const name = definition.descriptor.name;
+			if (this.tools.has(name)) throw new Error(`Duplicate endpoint tool: ${name}`);
+			this.tools.set(name, {
+				definition,
+				revision: endpointToolRevision(definition.descriptor)
+			});
+		}
+	}
+	descriptors() {
+		return [...this.tools.values()].map(({ definition }) => definition.descriptor);
+	}
+	get(name) {
+		return this.tools.get(name);
+	}
+};
+var EndpointToolHostController = class {
+	active = /* @__PURE__ */ new Map();
+	now;
+	sendMessage;
+	generation = 0;
+	constructor(options) {
+		this.options = options;
+		this.now = options.now ?? Date.now;
+	}
+	connect(sendMessage) {
+		this.disconnect();
+		this.sendMessage = sendMessage;
+	}
+	disconnect() {
+		this.generation += 1;
+		this.sendMessage = void 0;
+		for (const invocation of this.active.values()) invocation.controller.abort();
+		this.active.clear();
+	}
+	publishAvailability() {
+		this.send("endpoint.availability_changed", { availability: this.options.getAvailability() });
+	}
+	async handleMessage(message) {
+		if (message.type === "tool.cancel") {
+			this.cancel(message.payload.invocationId);
+			return;
+		}
+		await this.invoke(message);
+	}
+	async invoke(message) {
+		const { invocationId, toolName, arguments: args, descriptorRevision, confirmationRequired, deadlineAt, uploadGrant } = message.payload;
+		if (this.active.has(invocationId)) {
+			this.sendError(invocationId, "PROTOCOL_ERROR", "Endpoint invocation is already running");
+			return;
+		}
+		this.send("tool.received", { invocationId });
+		const registered = this.options.registry.get(toolName);
+		if (!registered) {
+			this.sendError(invocationId, "TOOL_NOT_FOUND", "Endpoint tool is not registered");
+			return;
+		}
+		if (registered.revision !== descriptorRevision) {
+			this.sendError(invocationId, "TOOL_REVISION_MISMATCH", "Endpoint tool contract changed");
+			return;
+		}
+		const descriptor = registered.definition.descriptor;
+		const localConfirmationRequired = descriptor.confirmation === "always";
+		if (confirmationRequired !== localConfirmationRequired) {
+			this.sendError(invocationId, "PROTOCOL_ERROR", "Endpoint confirmation policy mismatch");
+			return;
+		}
+		const invocation = {
+			controller: new AbortController(),
+			generation: this.generation
+		};
+		this.active.set(invocationId, invocation);
+		try {
+			this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+			const authorizationRequest = {
+				invocationId,
+				descriptor,
+				arguments: args,
+				deadlineAt,
+				signal: invocation.controller.signal
+			};
+			await this.options.authorize?.(authorizationRequest);
+			this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+			if (localConfirmationRequired) {
+				this.send("tool.progress", {
+					invocationId,
+					message: "Waiting for approval"
+				});
+				const allowed = await this.options.confirm(authorizationRequest);
+				this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+				if (!allowed) throw new EndpointToolClientError("USER_DENIED", "User denied the endpoint tool call");
+			}
+			const result = await registered.definition.execute(args, {
+				invocationId,
+				signal: invocation.controller.signal,
+				reportProgress: (progress) => {
+					if (this.isCurrent(invocationId, invocation)) this.send("tool.progress", {
+						invocationId,
+						...progress
+					});
+				},
+				uploadFile: (file) => {
+					this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+					return this.options.uploadFile(uploadGrant, file, {
+						signal: invocation.controller.signal,
+						invocationId
+					});
+				}
+			});
+			this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+			const content = endpointToolContentSchema.array().min(1).max(20).parse(result.content);
+			this.send("tool.result", {
+				invocationId,
+				content,
+				...result.details ? { details: result.details } : {}
+			});
+			this.active.delete(invocationId);
+			if (result.afterSend) {
+				const generation = invocation.generation;
+				setTimeout(() => {
+					if (this.generation === generation && this.now() < deadlineAt && (!descriptor.requiresForeground || this.options.getAvailability() === "foreground")) result.afterSend?.();
+				}, this.options.afterSendDelayMs ?? 50);
+			}
+		} catch (error) {
+			if (!this.isCurrent(invocationId, invocation)) return;
+			this.active.delete(invocationId);
+			const normalized = this.normalizeError(error);
+			this.sendError(invocationId, normalized.code, normalized.message);
+		}
+	}
+	cancel(invocationId) {
+		const invocation = this.active.get(invocationId);
+		if (!invocation) return;
+		this.active.delete(invocationId);
+		invocation.controller.abort();
+		this.send("tool.cancelled", { invocationId });
+	}
+	assertExecutable(invocationId, invocation, descriptor, deadlineAt) {
+		if (!this.isCurrent(invocationId, invocation) || invocation.controller.signal.aborted) throw new EndpointToolClientError("TOOL_CANCELLED", "Endpoint tool call was cancelled");
+		if (this.now() >= deadlineAt) throw new EndpointToolClientError("TOOL_TIMEOUT", "Endpoint tool deadline expired");
+		if (descriptor.requiresForeground && this.options.getAvailability() !== "foreground") throw new EndpointToolClientError("ENDPOINT_NOT_FOREGROUND", "Endpoint is not foreground");
+	}
+	isCurrent(invocationId, invocation) {
+		return this.active.get(invocationId) === invocation && invocation.generation === this.generation && this.sendMessage !== void 0;
+	}
+	normalizeError(error) {
+		if (error instanceof EndpointToolClientError) return error;
+		if (error instanceof Error && error.name === "RealtimeFrameTooLargeError") return new EndpointToolClientError("RESULT_TOO_LARGE", error.message);
+		if (error instanceof TypeError) return new EndpointToolClientError("INVALID_ARGUMENTS", error.message);
+		if (error instanceof Error && error.name === "AbortError") return new EndpointToolClientError("USER_DENIED", error.message);
+		if (error instanceof Error && error.name === "NotAllowedError") return new EndpointToolClientError("PERMISSION_DENIED", error.message);
+		return new EndpointToolClientError("PROTOCOL_ERROR", error instanceof Error ? error.message : String(error));
+	}
+	sendError(invocationId, code, message) {
+		this.send("tool.error", {
+			invocationId,
+			code,
+			message
+		});
+	}
+	send(type, payload) {
+		this.sendMessage?.({
+			protocolVersion: 2,
+			messageId: this.options.createMessageId(),
+			type,
+			sentAt: this.now(),
+			payload
+		});
+	}
+};
+//#endregion
+export { EndpointToolHostController, EndpointToolRegistry };

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

@@ -0,0 +1,105 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+//#region packages/endpoint-tools-protocol/src/bridge.ts
+function jsonOutput(value) {
+	return {
+		type: "array",
+		minItems: 1,
+		maxItems: 1,
+		items: {
+			type: "object",
+			additionalProperties: false,
+			required: ["type", "value"],
+			properties: {
+				type: { const: "json" },
+				value
+			}
+		}
+	};
+}
+/** A Bridge uses the existing desktop host transport; each sensor retains its own resource ID. */
+function bridgeDescriptor(operation) {
+	return {
+		name: `desktop.bridge.${operation}`,
+		title: operation === "list_resources" ? "Discover Bridge sensors" : "Read a Bridge sensor",
+		description: operation === "list_resources" ? "List bounded temperature and humidity resources on the explicitly selected Bridge. Each resource declares whether it is simulated." : "Read one fresh temperature or humidity sample by resourceId on the explicitly selected Bridge. Simulated samples are marked; unavailable values are null.",
+		inputSchema: operation === "list_resources" ? {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		} : BRIDGE_READ_INPUT_SCHEMA,
+		outputSchema: operation === "list_resources" ? BRIDGE_LIST_OUTPUT_SCHEMA : BRIDGE_READ_OUTPUT_SCHEMA,
+		policyId: "public.background-read",
+		sensitivity: "public",
+		effect: "read",
+		confirmation: "never",
+		requiresForeground: false,
+		requiredPermissions: [],
+		timeoutMs: 1e4,
+		maxConcurrency: 1,
+		supportsCancellation: true,
+		idempotent: true,
+		resultKinds: ["json"]
+	};
+}
+var BRIDGE_RESOURCE_SCHEMA, BRIDGE_READ_INPUT_SCHEMA, BRIDGE_LIST_OUTPUT_SCHEMA, BRIDGE_READ_OUTPUT_SCHEMA;
+var init_bridge = __esmMin((() => {
+	BRIDGE_RESOURCE_SCHEMA = {
+		type: "object",
+		additionalProperties: false,
+		required: [
+			"resourceId",
+			"name",
+			"measurement",
+			"unit",
+			"simulated"
+		],
+		properties: {
+			resourceId: {
+				type: "string",
+				pattern: "^[a-zA-Z0-9._:-]{1,128}$"
+			},
+			name: {
+				type: "string",
+				minLength: 1,
+				maxLength: 80
+			},
+			measurement: { enum: ["temperature", "humidity"] },
+			unit: { enum: ["celsius", "percent"] },
+			simulated: { type: "boolean" }
+		}
+	};
+	BRIDGE_READ_INPUT_SCHEMA = {
+		type: "object",
+		additionalProperties: false,
+		required: ["resourceId"],
+		properties: { resourceId: BRIDGE_RESOURCE_SCHEMA.properties.resourceId }
+	};
+	BRIDGE_LIST_OUTPUT_SCHEMA = jsonOutput({
+		type: "array",
+		maxItems: 100,
+		items: BRIDGE_RESOURCE_SCHEMA
+	});
+	BRIDGE_READ_OUTPUT_SCHEMA = jsonOutput({
+		...BRIDGE_RESOURCE_SCHEMA,
+		required: [
+			...BRIDGE_RESOURCE_SCHEMA.required,
+			"capturedAt",
+			"value"
+		],
+		properties: {
+			...BRIDGE_RESOURCE_SCHEMA.properties,
+			capturedAt: {
+				type: "integer",
+				minimum: 0
+			},
+			value: {
+				type: ["number", "null"],
+				minimum: -100,
+				maximum: 200
+			}
+		}
+	});
+}));
+//#endregion
+init_bridge();
+export { BRIDGE_LIST_OUTPUT_SCHEMA, BRIDGE_READ_INPUT_SCHEMA, BRIDGE_READ_OUTPUT_SCHEMA, BRIDGE_RESOURCE_SCHEMA, bridgeDescriptor, init_bridge };

package/dist/packages/endpoint-tools-protocol/src/index.js

@@ -1,4 +1,6 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { init_bridge } from "./bridge.js";
+import { init_location } from "./location.js";
 import { z } from "zod";
 //#region packages/endpoint-tools-protocol/src/index.ts
 function contactOutputSchema(multiple) {
@@ -39,8 +41,10 @@ function endpointHelloSigningPayload(payload) {
 	const { signature: _signature, ...unsigned } = payload;
 	return canonicalJson(unsigned);
 }
-var ENDPOINT_MAX_FILE_BYTES, ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS, endpointKindSchema, endpointAvailabilitySchema, endpointEffectSchema, endpointConfirmationSchema, endpointResultKindSchema, endpointSensitivitySchema, identifierSchema, turnTokenSchema, turnOriginSchema, endpointTurnOriginSchema, endpointTurnClaimSchema, messageIdSchema, timestampSchema, jsonObjectSchema, endpointToolDescriptorSchema, endpointPrincipalRegistrationSchema, endpointSessionBindingRequestSchema, backgroundCapabilitySchema, endpointHelloPayloadSchema, toolInvokePayloadSchema, toolCancelPayloadSchema, invocationPayloadSchema, endpointToolContentSchema, endpointToolErrorCodeSchema, envelope, clientEndpointMessageSchema, serverEndpointMessageSchema, ENDPOINT_TEXT_OUTPUT_SCHEMA, ENDPOINT_FILE_OUTPUT_SCHEMA, ENDPOINT_CONTACT_RECORD_SCHEMA, ENDPOINT_CONTACT_OUTPUT_SCHEMA, ENDPOINT_CONTACT_LIST_OUTPUT_SCHEMA;
+var ENDPOINT_MAX_FILE_BYTES, ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS, endpointKindSchema, endpointAvailabilitySchema, endpointEffectSchema, endpointConfirmationSchema, endpointResultKindSchema, endpointSensitivitySchema, identifierSchema, turnTokenSchema, turnOriginSchema, endpointTurnOriginSchema, endpointTurnClaimSchema, messageIdSchema, timestampSchema, jsonObjectSchema, endpointToolDescriptorSchema, endpointPrincipalRegistrationSchema, endpointSessionBindingRequestSchema, backgroundCapabilitySchema, endpointHelloPayloadSchema, toolInvokePayloadSchema, toolCancelPayloadSchema, invocationPayloadSchema, endpointToolContentSchema, endpointToolErrorCodeSchema, envelope, clientEndpointMessageSchema, serverEndpointMessageSchema, ENDPOINT_TEXT_OUTPUT_SCHEMA, ENDPOINT_FILE_OUTPUT_SCHEMA, ENDPOINT_CONTACT_RECORD_SCHEMA, ENDPOINT_CONTACT_OUTPUT_SCHEMA, ENDPOINT_CONTACT_LIST_OUTPUT_SCHEMA, DEVICE_EMPTY_INPUT_SCHEMA, DEVICE_STATE_OUTPUT_SCHEMA, DEVICE_POWER_OUTPUT_SCHEMA;
 var init_src = __esmMin((() => {
+	init_bridge();
+	init_location();
 	ENDPOINT_MAX_FILE_BYTES = 25 * 1024 * 1024;
 	ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS = 3e3;
 	endpointKindSchema = z.enum([
@@ -347,7 +351,94 @@ var init_src = __esmMin((() => {
 	};
 	ENDPOINT_CONTACT_OUTPUT_SCHEMA = contactOutputSchema(false);
 	ENDPOINT_CONTACT_LIST_OUTPUT_SCHEMA = contactOutputSchema(true);
+	DEVICE_EMPTY_INPUT_SCHEMA = {
+		type: "object",
+		properties: {},
+		additionalProperties: false
+	};
+	DEVICE_STATE_OUTPUT_SCHEMA = {
+		type: "array",
+		minItems: 1,
+		maxItems: 1,
+		items: {
+			type: "object",
+			additionalProperties: false,
+			required: ["type", "value"],
+			properties: {
+				type: { const: "json" },
+				value: {
+					type: "object",
+					additionalProperties: false,
+					required: [
+						"capturedAt",
+						"platform",
+						"systemVersion",
+						"locale",
+						"timezone"
+					],
+					properties: {
+						capturedAt: {
+							type: "integer",
+							minimum: 0
+						},
+						platform: {
+							type: "string",
+							minLength: 1,
+							maxLength: 40
+						},
+						systemVersion: {
+							type: "string",
+							maxLength: 80
+						},
+						locale: {
+							type: "string",
+							maxLength: 80
+						},
+						timezone: {
+							type: "string",
+							maxLength: 80
+						},
+						online: { type: "boolean" }
+					}
+				}
+			}
+		}
+	};
+	DEVICE_POWER_OUTPUT_SCHEMA = {
+		type: "array",
+		minItems: 1,
+		maxItems: 1,
+		items: {
+			type: "object",
+			additionalProperties: false,
+			required: ["type", "value"],
+			properties: {
+				type: { const: "json" },
+				value: {
+					type: "object",
+					additionalProperties: false,
+					required: [
+						"capturedAt",
+						"levelPercent",
+						"charging"
+					],
+					properties: {
+						capturedAt: {
+							type: "integer",
+							minimum: 0
+						},
+						levelPercent: {
+							type: ["number", "null"],
+							minimum: 0,
+							maximum: 100
+						},
+						charging: { type: ["boolean", "null"] }
+					}
+				}
+			}
+		}
+	};
 }));
 //#endregion
 init_src();
-export { ENDPOINT_CONTACT_LIST_OUTPUT_SCHEMA, ENDPOINT_CONTACT_OUTPUT_SCHEMA, ENDPOINT_FILE_OUTPUT_SCHEMA, ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS, ENDPOINT_MAX_FILE_BYTES, ENDPOINT_TEXT_OUTPUT_SCHEMA, canonicalJson, clientEndpointMessageSchema, endpointHelloPayloadSchema, endpointHelloSigningPayload, endpointPrincipalRegistrationSchema, endpointSessionBindingRequestSchema, endpointTurnClaimSchema, init_src, serverEndpointMessageSchema, turnOriginSchema };
+export { DEVICE_EMPTY_INPUT_SCHEMA, DEVICE_POWER_OUTPUT_SCHEMA, DEVICE_STATE_OUTPUT_SCHEMA, ENDPOINT_CONTACT_LIST_OUTPUT_SCHEMA, ENDPOINT_CONTACT_OUTPUT_SCHEMA, ENDPOINT_FILE_OUTPUT_SCHEMA, ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS, ENDPOINT_MAX_FILE_BYTES, ENDPOINT_TEXT_OUTPUT_SCHEMA, canonicalJson, clientEndpointMessageSchema, endpointHelloPayloadSchema, endpointHelloSigningPayload, endpointPrincipalRegistrationSchema, endpointSessionBindingRequestSchema, endpointToolContentSchema, endpointTurnClaimSchema, init_src, serverEndpointMessageSchema, turnOriginSchema };