@xopcai/xopc 0.0.369 → 0.0.371

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,7 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { init_bridge } from "./bridge.js";
+import { init_location } from "./location.js";
+import { init_personal } from "./personal.js";
 import { z } from "zod";
 //#region packages/endpoint-tools-protocol/src/index.ts
 function contactOutputSchema(multiple) {
@@ -39,8 +42,11 @@ 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();
+	init_personal();
 	ENDPOINT_MAX_FILE_BYTES = 25 * 1024 * 1024;
 	ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS = 3e3;
 	endpointKindSchema = z.enum([
@@ -347,7 +353,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 };

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

@@ -0,0 +1,109 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region packages/endpoint-tools-protocol/src/location.ts
+var locationRequestSchema, LOCATION_INPUT_SCHEMA, locationSampleSchema, LOCATION_OUTPUT_SCHEMA;
+var init_location = __esmMin((() => {
+	locationRequestSchema = z.object({
+		purpose: z.enum(["weather", "nearby"]),
+		precision: z.enum(["approximate", "precise"]),
+		category: z.enum([
+			"restaurant",
+			"cafe",
+			"pharmacy",
+			"park"
+		]).optional()
+	}).strict().superRefine((value, ctx) => {
+		if (value.purpose === "nearby" !== (value.category !== void 0)) ctx.addIssue({
+			code: "custom",
+			message: "Category is required only for nearby queries"
+		});
+	});
+	LOCATION_INPUT_SCHEMA = {
+		type: "object",
+		additionalProperties: false,
+		required: ["purpose", "precision"],
+		properties: {
+			purpose: { enum: ["weather", "nearby"] },
+			precision: { enum: ["approximate", "precise"] },
+			category: { enum: [
+				"restaurant",
+				"cafe",
+				"pharmacy",
+				"park"
+			] }
+		},
+		allOf: [{
+			if: {
+				properties: { purpose: { const: "nearby" } },
+				required: ["purpose"]
+			},
+			then: {
+				properties: { category: {} },
+				required: ["category"]
+			},
+			else: { not: {
+				properties: { category: {} },
+				required: ["category"]
+			} }
+		}]
+	};
+	locationSampleSchema = z.object({
+		latitude: z.number().min(-90).max(90),
+		longitude: z.number().min(-180).max(180),
+		accuracyMeters: z.number().min(0).max(1e5),
+		capturedAt: z.number().int().nonnegative(),
+		precision: z.enum(["approximate", "precise"]),
+		coordinateSystem: z.literal("WGS84")
+	}).strict();
+	LOCATION_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: [
+						"latitude",
+						"longitude",
+						"accuracyMeters",
+						"capturedAt",
+						"precision",
+						"coordinateSystem"
+					],
+					properties: {
+						latitude: {
+							type: "number",
+							minimum: -90,
+							maximum: 90
+						},
+						longitude: {
+							type: "number",
+							minimum: -180,
+							maximum: 180
+						},
+						accuracyMeters: {
+							type: "number",
+							minimum: 0,
+							maximum: 1e5
+						},
+						capturedAt: {
+							type: "integer",
+							minimum: 0
+						},
+						precision: { enum: ["approximate", "precise"] },
+						coordinateSystem: { const: "WGS84" }
+					}
+				}
+			}
+		}
+	};
+}));
+//#endregion
+init_location();
+export { LOCATION_INPUT_SCHEMA, LOCATION_OUTPUT_SCHEMA, init_location, locationRequestSchema, locationSampleSchema };

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

@@ -0,0 +1,149 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { DEVICE_EMPTY_INPUT_SCHEMA, ENDPOINT_CONTACT_OUTPUT_SCHEMA, ENDPOINT_FILE_OUTPUT_SCHEMA, init_src } from "./index.js";
+//#region packages/endpoint-tools-protocol/src/personal.ts
+/** User-mediated reads disclose only the selected item, never a device inventory. */
+function personalDescriptor(name) {
+	const calendar = name.includes(".calendar.");
+	const contact = name === "mobile.contacts.pick";
+	const titles = {
+		"mobile.file.pick": "Ask the user to select one file",
+		"mobile.media.pick": "Ask the user to select one photo",
+		"mobile.camera.capture": "Ask the user to take one photo",
+		"mobile.contacts.pick": "Ask the user to select a contact field",
+		"mobile.calendar.query_events": "Read calendar events for an approved time range",
+		"mobile.calendar.query_free_busy": "Read calendar availability without event titles"
+	};
+	return {
+		name,
+		title: titles[name],
+		description: titles[name] + ". Uses the device that sent this message, requires foreground user participation, and may be cancelled. Selected content is sent to the Agent and may appear in chat history." + (calendar ? " Range must be at most seven days. Only locally accessible calendars are covered; truncated or app-only results cannot establish that the user is free." : ""),
+		inputSchema: calendar ? CALENDAR_INPUT_SCHEMA : contact ? CONTACT_PICK_INPUT_SCHEMA : DEVICE_EMPTY_INPUT_SCHEMA,
+		outputSchema: calendar ? CALENDAR_OUTPUT_SCHEMA : contact ? ENDPOINT_CONTACT_OUTPUT_SCHEMA : ENDPOINT_FILE_OUTPUT_SCHEMA,
+		policyId: calendar ? "personal.foreground-read" : "personal.foreground-mediated-read",
+		sensitivity: "personal",
+		effect: "read",
+		confirmation: calendar ? "always" : "never",
+		requiresForeground: true,
+		requiredPermissions: [calendar ? "calendar-read-once" : contact ? "contacts-read-selected" : name === "mobile.camera.capture" ? "camera-capture-once" : "file-read"],
+		timeoutMs: 12e4,
+		maxConcurrency: 1,
+		supportsCancellation: true,
+		idempotent: false,
+		resultKinds: [calendar || contact ? "json" : "file"]
+	};
+}
+var PERSONAL_TOOL_NAMES, CONTACT_PICK_INPUT_SCHEMA, CALENDAR_INPUT_SCHEMA, CALENDAR_OUTPUT_SCHEMA;
+var init_personal = __esmMin((() => {
+	init_src();
+	PERSONAL_TOOL_NAMES = [
+		"mobile.file.pick",
+		"mobile.media.pick",
+		"mobile.camera.capture",
+		"mobile.contacts.pick",
+		"mobile.calendar.query_events",
+		"mobile.calendar.query_free_busy"
+	];
+	CONTACT_PICK_INPUT_SCHEMA = {
+		type: "object",
+		additionalProperties: false,
+		required: ["field"],
+		properties: { field: { enum: ["phone", "email"] } }
+	};
+	CALENDAR_INPUT_SCHEMA = {
+		type: "object",
+		additionalProperties: false,
+		required: ["startAt", "endAt"],
+		properties: {
+			startAt: {
+				type: "integer",
+				minimum: 0,
+				maximum: 864e13
+			},
+			endAt: {
+				type: "integer",
+				minimum: 0,
+				maximum: 864e13
+			}
+		}
+	};
+	CALENDAR_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",
+						"startAt",
+						"endAt",
+						"timeZone",
+						"accessScope",
+						"truncated",
+						"events"
+					],
+					properties: {
+						capturedAt: {
+							type: "integer",
+							minimum: 0
+						},
+						startAt: {
+							type: "integer",
+							minimum: 0
+						},
+						endAt: {
+							type: "integer",
+							minimum: 0
+						},
+						timeZone: {
+							type: "string",
+							minLength: 1,
+							maxLength: 100
+						},
+						accessScope: { enum: ["all_accessible", "app_only"] },
+						truncated: { type: "boolean" },
+						events: {
+							type: "array",
+							maxItems: 50,
+							items: {
+								type: "object",
+								additionalProperties: false,
+								required: [
+									"startAt",
+									"endAt",
+									"allDay",
+									"busy"
+								],
+								properties: {
+									startAt: {
+										type: "integer",
+										minimum: 0
+									},
+									endAt: {
+										type: "integer",
+										minimum: 0
+									},
+									allDay: { type: "boolean" },
+									busy: { type: "boolean" },
+									title: {
+										type: "string",
+										maxLength: 500
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	};
+}));
+//#endregion
+init_personal();
+export { CALENDAR_INPUT_SCHEMA, CALENDAR_OUTPUT_SCHEMA, CONTACT_PICK_INPUT_SCHEMA, PERSONAL_TOOL_NAMES, init_personal, personalDescriptor };