@xopcai/xopc 0.0.369 → 0.0.371

package/dist/src/endpoint-tools/location-task.js

@@ -0,0 +1,114 @@
+import { locationRequestSchema, locationSampleSchema } from "../../packages/endpoint-tools-protocol/src/location.js";
+import { init_src } from "../../packages/endpoint-tools-protocol/src/index.js";
+//#region src/endpoint-tools/location-task.ts
+init_src();
+const WEATHER_URL = "https://api.open-meteo.com/v1/forecast";
+const PLACES_URL = "https://overpass-api.de/api/interpreter";
+const CATEGORY_FILTER = {
+	restaurant: "amenity=restaurant",
+	cafe: "amenity=cafe",
+	pharmacy: "amenity=pharmacy",
+	park: "leisure=park"
+};
+/** Sensitive samples never leave this processor as model, stream or persistence content. */
+async function processLocationTask(args, content, source, signal, request = fetch, now = Date.now) {
+	const input = locationRequestSchema.parse(args);
+	if (content.length !== 1 || content[0].type !== "json") throw new Error("Invalid location sample");
+	const sample = locationSampleSchema.parse(content[0].value);
+	if (sample.capturedAt < now() - 3e4 || sample.capturedAt > now() + 6e4) throw new Error("Location sample expired or has an invalid clock");
+	const approximate = input.precision === "approximate" || sample.precision === "approximate";
+	const latitude = approximate ? Math.round(sample.latitude * 50) / 50 : sample.latitude;
+	const longitude = approximate ? Math.round(sample.longitude * 50) / 50 : sample.longitude;
+	const scopedSignal = AbortSignal.any([signal ?? new AbortController().signal, AbortSignal.timeout(15e3)]);
+	const readResponse = async (response) => {
+		if (!response.ok || response.redirected) throw new Error("Location lookup service is unavailable");
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error("Location lookup service returned no data");
+		let bytes = 0;
+		const chunks = [];
+		try {
+			while (true) {
+				const part = await reader.read();
+				if (part.done) break;
+				bytes += part.value.length;
+				if (bytes > 512e3) throw new Error("Location lookup response is too large");
+				chunks.push(part.value);
+			}
+		} finally {
+			await reader.cancel().catch(() => {});
+		}
+		const joined = new Uint8Array(bytes);
+		let offset = 0;
+		for (const chunk of chunks) {
+			joined.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return JSON.parse(new TextDecoder().decode(joined));
+	};
+	let data;
+	try {
+		scopedSignal.throwIfAborted();
+		if (input.purpose === "weather") {
+			const url = new URL(WEATHER_URL);
+			url.searchParams.set("latitude", String(latitude));
+			url.searchParams.set("longitude", String(longitude));
+			url.searchParams.set("current", "temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m");
+			const current = (await readResponse(await request(url, {
+				signal: scopedSignal,
+				redirect: "error"
+			}))).current ?? {};
+			if (typeof current.temperature_2m !== "number" || !Number.isFinite(current.temperature_2m)) throw new Error("Invalid weather response");
+			const numeric = (key, min, max) => typeof current[key] === "number" && Number.isFinite(current[key]) && current[key] >= min && current[key] <= max ? current[key] : null;
+			data = {
+				provider: "Open-Meteo",
+				sourceUrl: "https://open-meteo.com/",
+				temperatureCelsius: numeric("temperature_2m", -100, 100),
+				humidityPercent: numeric("relative_humidity_2m", 0, 100),
+				weatherCode: numeric("weather_code", 0, 99),
+				windSpeedKmh: numeric("wind_speed_10m", 0, 500)
+			};
+		} else {
+			const query = `[out:json][timeout:10];nwr(around:2000,${latitude},${longitude})[${CATEGORY_FILTER[input.category]}];out tags 10;`;
+			const response = await readResponse(await request(PLACES_URL, {
+				method: "POST",
+				signal: scopedSignal,
+				redirect: "error",
+				headers: { "Content-Type": "application/x-www-form-urlencoded" },
+				body: new URLSearchParams({ data: query })
+			}));
+			if (!Array.isArray(response.elements)) throw new Error("Invalid nearby service result");
+			const text = (value) => typeof value === "string" ? value.slice(0, 160).replaceAll(String(sample.latitude), "[location]").replaceAll(String(sample.longitude), "[location]") : "";
+			data = {
+				provider: "OpenStreetMap",
+				sourceUrl: "https://www.openstreetmap.org/",
+				category: input.category,
+				radiusMeters: 2e3,
+				places: response.elements.slice(0, 10).map((element) => ({
+					name: text(element.tags?.name),
+					street: text(element.tags?.["addr:street"]),
+					houseNumber: text(element.tags?.["addr:housenumber"])
+				})).filter((place) => place.name.length > 0)
+			};
+		}
+	} catch {
+		throw new Error(scopedSignal.aborted ? "Location lookup cancelled or timed out" : "Location lookup service is unavailable");
+	}
+	scopedSignal.throwIfAborted();
+	if (sample.capturedAt < now() - 3e4) throw new Error("Location sample expired during lookup");
+	return {
+		version: 1,
+		source,
+		capturedAt: sample.capturedAt,
+		receivedAt: now(),
+		validUntil: Math.min(sample.capturedAt, now()) + 3e4,
+		cached: false,
+		retention: "summary",
+		purpose: input.purpose,
+		precision: approximate ? "approximate" : "precise",
+		accuracyMeters: approximate ? Math.max(3e3, sample.accuracyMeters) : sample.accuracyMeters,
+		status: "ok",
+		data
+	};
+}
+//#endregion
+export { processLocationTask };

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

@@ -1,4 +1,7 @@
-import { ENDPOINT_CONTACT_LIST_OUTPUT_SCHEMA, ENDPOINT_CONTACT_OUTPUT_SCHEMA, ENDPOINT_FILE_OUTPUT_SCHEMA, ENDPOINT_TEXT_OUTPUT_SCHEMA, canonicalJson, init_src } from "../../packages/endpoint-tools-protocol/src/index.js";
+import { BRIDGE_LIST_OUTPUT_SCHEMA, BRIDGE_READ_INPUT_SCHEMA, BRIDGE_READ_OUTPUT_SCHEMA } from "../../packages/endpoint-tools-protocol/src/bridge.js";
+import { LOCATION_INPUT_SCHEMA, LOCATION_OUTPUT_SCHEMA } from "../../packages/endpoint-tools-protocol/src/location.js";
+import { PERSONAL_TOOL_NAMES, personalDescriptor } from "../../packages/endpoint-tools-protocol/src/personal.js";
+import { 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_TEXT_OUTPUT_SCHEMA, canonicalJson, init_src } from "../../packages/endpoint-tools-protocol/src/index.js";
 import { COMPUTER_INPUT_SCHEMA, COMPUTER_OUTPUT_SCHEMA, init_src as init_src$1 } from "../../packages/computer-control-contract/src/index.js";
 import { BROWSER_CONTROL_ENDPOINT_DESCRIPTOR, BROWSER_CONTROL_ENDPOINT_INPUT_SCHEMA, BROWSER_CONTROL_ENDPOINT_OUTPUT_SCHEMA, BROWSER_RECORDING_ENDPOINT_DESCRIPTOR, BROWSER_RECORDING_ENDPOINT_INPUT_SCHEMA } from "../../packages/browser-control-contract/src/index.js";
 import Ajv2020 from "ajv/dist/2020.js";
@@ -17,6 +20,19 @@ function contract(policyId, outputSchema, resultKinds, permissions, legacyPolicy
 	};
 }
 const POLICY_BY_TOOL = {
+	...Object.fromEntries([
+		"mobile",
+		"desktop",
+		"web",
+		"browser"
+	].flatMap((kind) => [[`${kind}.device.get_state`, contract("public.background-read", DEVICE_STATE_OUTPUT_SCHEMA, ["json"], [], [], DEVICE_EMPTY_INPUT_SCHEMA)], [`${kind}.device.get_power`, contract("public.background-read", DEVICE_POWER_OUTPUT_SCHEMA, ["json"], [], [], DEVICE_EMPTY_INPUT_SCHEMA)]])),
+	...Object.fromEntries([
+		"mobile",
+		"desktop",
+		"web"
+	].map((kind) => [`${kind}.device.get_location`, contract("personal.foreground-read", LOCATION_OUTPUT_SCHEMA, ["json"], ["location-read-once"], [], LOCATION_INPUT_SCHEMA)])),
+	"desktop.bridge.list_resources": contract("public.background-read", BRIDGE_LIST_OUTPUT_SCHEMA, ["json"], [], [], DEVICE_EMPTY_INPUT_SCHEMA),
+	"desktop.bridge.read_sensor": contract("public.background-read", BRIDGE_READ_OUTPUT_SCHEMA, ["json"], [], [], BRIDGE_READ_INPUT_SCHEMA),
 	"desktop.computer.control": contract("computer.session-scoped", COMPUTER_OUTPUT_SCHEMA, ["json", "file"], ["computer-control"], [], COMPUTER_INPUT_SCHEMA),
 	"web.file.pick": contract("personal.foreground-read", ENDPOINT_FILE_OUTPUT_SCHEMA, ["file"], ["file-read"]),
 	"web.file.download": contract("user.foreground-write", ENDPOINT_TEXT_OUTPUT_SCHEMA, ["text"], ["file-download"]),
@@ -33,6 +49,10 @@ const POLICY_BY_TOOL = {
 	"mobile.contacts.search": contract("personal.foreground-read", ENDPOINT_CONTACT_LIST_OUTPUT_SCHEMA, ["json"], ["contacts-read"]),
 	"mobile.contacts.get": contract("personal.foreground-read", ENDPOINT_CONTACT_OUTPUT_SCHEMA, ["json"], ["contacts-read"]),
 	"mobile.file.pick": contract("personal.foreground-mediated-read", ENDPOINT_FILE_OUTPUT_SCHEMA, ["file"], ["file-read"], ["personal.foreground-read"]),
+	...Object.fromEntries(PERSONAL_TOOL_NAMES.map((name) => {
+		const descriptor = personalDescriptor(name);
+		return [name, contract(descriptor.policyId, descriptor.outputSchema, descriptor.resultKinds, descriptor.requiredPermissions, ["mobile.file.pick", "mobile.contacts.pick"].includes(name) ? ["personal.foreground-read"] : [], ["mobile.file.pick", "mobile.contacts.pick"].includes(name) ? void 0 : descriptor.inputSchema)];
+	})),
 	"mobile.file.share": contract("user.foreground-mediated-write", ENDPOINT_TEXT_OUTPUT_SCHEMA, ["text"], ["file-share"], ["user.foreground-write"]),
 	"mobile.notification.show": contract("user.foreground-write", ENDPOINT_TEXT_OUTPUT_SCHEMA, ["text"], ["notifications"]),
 	"mobile.device.get_info": contract("public.background-read", ENDPOINT_TEXT_OUTPUT_SCHEMA, ["text"], []),

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

@@ -29,6 +29,8 @@ export declare function endpointToolRevision(descriptor: EndpointToolDescriptor)
 export declare class EndpointRegistry {
     private readonly policy;
     private readonly connectionByEndpointId;
+    private readonly changeListeners;
+    onChange(listener: (endpointId: string) => void): () => void;
     constructor(policy?: EndpointToolPolicy);
     register(hello: EndpointHelloPayload, connectionId: string, transport: EndpointTransport, now?: number): EndpointRegistration;
     remove(endpointId: string, connectionId: string): boolean;

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

@@ -22,6 +22,13 @@ function snapshot(connection) {
 }
 var EndpointRegistry = class {
 	connectionByEndpointId = /* @__PURE__ */ new Map();
+	changeListeners = /* @__PURE__ */ new Set();
+	onChange(listener) {
+		this.changeListeners.add(listener);
+		return () => {
+			this.changeListeners.delete(listener);
+		};
+	}
 	constructor(policy = new EndpointToolPolicy()) {
 		this.policy = policy;
 	}
@@ -54,6 +61,7 @@ var EndpointRegistry = class {
 			toolByName
 		};
 		this.connectionByEndpointId.set(connection.endpointId, connection);
+		for (const listener of this.changeListeners) listener(connection.endpointId);
 		return {
 			connection: snapshot(connection),
 			turnToken: connection.turnToken
@@ -63,6 +71,7 @@ var EndpointRegistry = class {
 		const connection = this.connectionByEndpointId.get(endpointId);
 		if (!connection || connection.connectionId !== connectionId) return false;
 		this.connectionByEndpointId.delete(endpointId);
+		for (const listener of this.changeListeners) listener(endpointId);
 		return true;
 	}
 	heartbeat(endpointId, connectionId, availability, now = Date.now()) {

package/dist/src/endpoint-tools/result-projector.d.ts

@@ -0,0 +1,15 @@
+import type { EndpointToolContent } from '@xopcai/endpoint-tools-protocol';
+/** Only fixed bounded state contracts are retained; personal tools use their existing policies. */
+export declare function projectDeviceReading(toolName: string, endpointId: string, principalId: string, content: EndpointToolContent[], receivedAt?: number, args?: Record<string, unknown>): {
+    version: number;
+    source: {
+        resourceId?: unknown;
+        endpointId: string;
+        principalId: string;
+    };
+    capturedAt: number;
+    receivedAt: number;
+    validUntil: number;
+    cached: boolean;
+    data: object;
+};

package/dist/src/endpoint-tools/result-projector.js

@@ -0,0 +1,31 @@
+//#region src/endpoint-tools/result-projector.ts
+/** Only fixed bounded state contracts are retained; personal tools use their existing policies. */
+function projectDeviceReading(toolName, endpointId, principalId, content, receivedAt = Date.now(), args) {
+	const sensor = toolName === "desktop.bridge.read_sensor";
+	if (!sensor && !/^(mobile|desktop|web|browser)\.device\.get_(state|power)$/.test(toolName)) return void 0;
+	const item = content[0];
+	if (item?.type !== "json" || !item.value || typeof item.value !== "object") throw new Error("Invalid device reading");
+	if (sensor) {
+		const reading = item.value;
+		if (reading.resourceId !== args?.resourceId) throw new Error("Bridge returned a different resource");
+		const expectedUnit = reading.measurement === "humidity" ? "percent" : "celsius";
+		if (reading.unit !== expectedUnit || reading.measurement === "humidity" && reading.value !== null && (typeof reading.value !== "number" || reading.value < 0 || reading.value > 100)) throw new Error("Invalid Bridge measurement");
+	}
+	const capturedAt = item.value.capturedAt;
+	if (typeof capturedAt !== "number" || !Number.isSafeInteger(capturedAt) || capturedAt > receivedAt + 6e4 || capturedAt < receivedAt - 3e4) throw new Error("Device sample is stale or has an invalid clock");
+	return {
+		version: 1,
+		source: {
+			endpointId,
+			principalId,
+			...sensor ? { resourceId: item.value.resourceId } : {}
+		},
+		capturedAt,
+		receivedAt,
+		validUntil: Math.min(receivedAt, capturedAt) + 3e4,
+		cached: false,
+		data: item.value
+	};
+}
+//#endregion
+export { projectDeviceReading };

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

@@ -1,11 +1,13 @@
 import { type ClientEndpointMessage, type EndpointHelloPayload } from '@xopcai/endpoint-tools-protocol';
 import { type EndpointAuthenticatorDeps } from './auth.js';
+import { DeviceGrantService } from './grant-service.js';
 import { EndpointBindingService } from './binding-service.js';
 import { EndpointInvocationService, type EndpointInvocationAuditSink } from './invocation-service.js';
 import { EndpointRegistry, type EndpointRegistration, type EndpointTransport } from './registry.js';
 import { EndpointUploadService } from './upload-service.js';
 export declare class EndpointToolRuntime {
     readonly registry: EndpointRegistry;
+    readonly grants: DeviceGrantService;
     readonly invocations: EndpointInvocationService;
     readonly uploads: EndpointUploadService;
     readonly bindings: EndpointBindingService;

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

@@ -7,10 +7,12 @@ import { bindEndpointPrincipal, getEndpointPrincipal, touchEndpointPrincipal } f
 import { finishEndpointToolInvocationAudit, startEndpointToolInvocationAudit } from "../storage/sqlite/endpoint-tool-invocation-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { init_paths } from "../config/paths.js";
-import { EndpointAuthenticator } from "./auth.js";
-import { EndpointBindingService } from "./binding-service.js";
 import { EndpointToolPolicy } from "./policy.js";
 import { EndpointInvocationService } from "./invocation-service.js";
+import { EndpointAuthenticator } from "./auth.js";
+import { EndpointBindingService } from "./binding-service.js";
+import { DeviceGrantService } from "./grant-service.js";
+import { recordDeviceGrantEvent } from "../storage/sqlite/device-grant-audit-repository.js";
 import { EndpointRegistry } from "./registry.js";
 import { EndpointUploadService } from "./upload-service.js";
 import { join } from "node:path";
@@ -22,6 +24,7 @@ const log = createLogger("EndpointTools");
 const MAX_MESSAGE_CLOCK_SKEW_MS = 6e4;
 var EndpointToolRuntime = class {
 	registry;
+	grants;
 	invocations;
 	uploads;
 	bindings;
@@ -30,6 +33,7 @@ var EndpointToolRuntime = class {
 	constructor(options = {}) {
 		const policy = new EndpointToolPolicy();
 		this.registry = new EndpointRegistry(policy);
+		this.grants = new DeviceGrantService(this.registry, Date.now, recordDeviceGrantEvent);
 		this.bindings = new EndpointBindingService(this.registry, {
 			get: getEndpointSessionBinding,
 			set: setEndpointSessionBinding,
@@ -53,6 +57,11 @@ var EndpointToolRuntime = class {
 	connect(hello, connectionId, transport) {
 		if (this.closed) throw new Error("Endpoint runtime is closed");
 		this.authenticator.authenticate(hello);
+		const previous = this.registry.get(hello.endpointId);
+		if (previous) {
+			this.grants.revokeEndpoint(previous.endpointId, previous.principalId);
+			this.invocations.failEndpoint(previous.endpointId);
+		}
 		const registration = this.registry.register(hello, connectionId, transport);
 		log.info({
 			endpointId: hello.endpointId,
@@ -75,7 +84,9 @@ var EndpointToolRuntime = class {
 		if (endpoint?.connectionId === connectionId) this.registry.heartbeat(endpointId, connectionId, endpoint.availability);
 	}
 	remove(endpointId, connectionId) {
+		const principalId = this.registry.get(endpointId)?.principalId;
 		if (!this.registry.remove(endpointId, connectionId)) return;
+		this.grants.revokeEndpoint(endpointId, principalId);
 		this.invocations.failEndpoint(endpointId);
 		deleteBrowserTabBindingsByEndpoint(endpointId);
 		log.info({
@@ -84,11 +95,13 @@ var EndpointToolRuntime = class {
 		}, "Endpoint disconnected");
 	}
 	disconnect(endpointId, reason) {
+		this.grants.revokeEndpoint(endpointId);
 		this.registry.disconnect(endpointId, 4003, reason);
 	}
 	close() {
 		if (this.closed) return;
 		this.closed = true;
+		this.grants.close();
 		this.invocations.close();
 		this.uploads.close();
 		this.registry.closeAll();

package/dist/src/endpoint-tools/target-resolver.d.ts

@@ -0,0 +1,12 @@
+import type { TurnOrigin } from '@xopcai/endpoint-tools-protocol';
+import type { DeviceGrantService } from './grant-service.js';
+import type { EndpointBindingService } from './binding-service.js';
+import type { EndpointRegistry } from './registry.js';
+export declare class DeviceTargetResolver {
+    private readonly registry;
+    private readonly bindings;
+    private readonly grants?;
+    constructor(registry: EndpointRegistry, bindings: EndpointBindingService, grants?: DeviceGrantService);
+    candidates(conversationId: string, origin: TurnOrigin): import("./registry.js").EndpointConnectionSnapshot[];
+    resolve(conversationId: string, origin: TurnOrigin, endpointId: string, toolName: string): import("./registry.js").EndpointConnectionSnapshot;
+}

package/dist/src/endpoint-tools/target-resolver.js

@@ -0,0 +1,27 @@
+import { deviceCapabilityTarget } from "./capability-catalog.js";
+//#region src/endpoint-tools/target-resolver.ts
+var DeviceTargetResolver = class {
+	constructor(registry, bindings, grants) {
+		this.registry = registry;
+		this.bindings = bindings;
+		this.grants = grants;
+	}
+	candidates(conversationId, origin) {
+		const source = origin.type === "endpoint" ? this.registry.get(origin.endpointId) : void 0;
+		const execution = this.bindings.get(conversationId) ? this.bindings.resolve(conversationId) : source;
+		const authorized = (this.grants?.candidates(conversationId, origin) ?? []).map((grant) => this.registry.get(grant.targetEndpointId));
+		return [...new Map([
+			source,
+			execution,
+			...authorized
+		].filter((endpoint) => endpoint !== void 0).map((endpoint) => [endpoint.endpointId, endpoint])).values()];
+	}
+	resolve(conversationId, origin, endpointId, toolName) {
+		const grant = this.grants?.find(conversationId, origin, endpointId, toolName);
+		if (grant) return this.registry.get(grant.targetEndpointId);
+		const binding = this.bindings.get(conversationId);
+		return (deviceCapabilityTarget(toolName) === "turn_origin" ? origin.type === "endpoint" ? origin.endpointId : void 0 : binding?.endpointId ?? (origin.type === "endpoint" ? origin.endpointId : void 0)) === endpointId ? this.registry.get(endpointId) : void 0;
+	}
+};
+//#endregion
+export { DeviceTargetResolver };

package/dist/src/endpoint-tools/turn-context.d.ts

@@ -0,0 +1,6 @@
+import type { EndpointContext } from '@xopcai/gateway-contract';
+import type { AgentSourceContext } from '../agent/source-context/types.js';
+import type { GatewayPrincipal } from '../gateway/security/gateway-principal.js';
+import type { EndpointConnectionSnapshot, EndpointRegistry } from './registry.js';
+export declare function endpointClaimBelongsToPrincipal(registry: EndpointRegistry, endpointId: string, principal: GatewayPrincipal): boolean;
+export declare function deviceTurnSourceContext(endpoint: EndpointConnectionSnapshot, environment?: EndpointContext): AgentSourceContext;

package/dist/src/endpoint-tools/turn-context.js

@@ -0,0 +1,29 @@
+import { getEndpointDeviceSettings } from "../storage/sqlite/endpoint-device-settings-repository.js";
+import { createHash } from "node:crypto";
+//#region src/endpoint-tools/turn-context.ts
+function endpointClaimBelongsToPrincipal(registry, endpointId, principal) {
+	const endpoint = registry.get(endpointId);
+	return Boolean(endpoint && (principal.kind === "owner" || principal.kind === "device" && endpoint.principalId === principal.deviceId));
+}
+function deviceTurnSourceContext(endpoint, environment) {
+	const name = getEndpointDeviceSettings(endpoint.principalId)?.nickname ?? endpoint.displayName;
+	const snapshot = {
+		endpointId: endpoint.endpointId,
+		principalId: endpoint.principalId,
+		name: name.slice(0, 80),
+		platform: endpoint.platform.slice(0, 40),
+		kind: endpoint.kind,
+		...environment ? { environment } : {}
+	};
+	const text = JSON.stringify(snapshot).replaceAll("<", "\\u003c").replaceAll(">", "\\u003e");
+	return {
+		kind: "device_context",
+		sourceId: endpoint.endpointId,
+		version: createHash("sha256").update(text).digest("hex"),
+		title: name.slice(0, 80),
+		text,
+		capturedAt: environment?.capturedAt ?? Date.now()
+	};
+}
+//#endregion
+export { deviceTurnSourceContext, endpointClaimBelongsToPrincipal };

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

@@ -3,6 +3,8 @@ export declare const ENDPOINT_UPLOAD_MAX_BYTES: number;
 export interface EndpointUploadedFile {
     fileId: string;
     invocationId: string;
+    endpointId: string;
+    principalId?: string;
     name: string;
     mimeType: string;
     size: number;
@@ -28,7 +30,7 @@ export declare class EndpointUploadService {
     private readonly pruneTimer;
     private readonly validatingFrames;
     constructor(rootDir: string);
-    createGrant(invocationId: string, endpointId: string, now?: number, profile?: 'durable' | 'computer-frame'): EndpointUploadGrant;
+    createGrant(invocationId: string, endpointId: string, now?: number, profile?: 'durable' | 'computer-frame' | 'personal', principalId?: string): EndpointUploadGrant;
     upload(params: {
         invocationId: string;
         endpointId: string;
@@ -45,7 +47,7 @@ export declare class EndpointUploadService {
     readFile(fileId: string): Uint8Array | undefined;
     getGrantLimits(invocationId: string, endpointId: string, token: string): {
         maxBytes: number;
-        profile: "durable" | "computer-frame";
+        profile: "personal" | "durable" | "computer-frame";
     };
     uploadValidated(params: Parameters<EndpointUploadService['upload']>[0]): Promise<EndpointUploadedFile>;
     /** Single-consumer handoff, inaccessible through generic attachment routes. */

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

@@ -31,16 +31,17 @@ var EndpointUploadService = class {
 		this.pruneTimer = setInterval(() => this.pruneFrames(Date.now()), 1e3);
 		this.pruneTimer.unref();
 	}
-	createGrant(invocationId, endpointId, now = Date.now(), profile = "durable") {
+	createGrant(invocationId, endpointId, now = Date.now(), profile = "durable", principalId) {
 		const token = crypto.randomUUID();
 		const grant = {
 			profile,
+			principalId,
 			invocationId,
 			endpointId,
 			token,
 			expiresAt: now + GRANT_TTL_MS,
-			maxBytes: profile === "computer-frame" ? COMPUTER_FRAME_MAX_BYTES : ENDPOINT_UPLOAD_MAX_BYTES,
-			maxFiles: profile === "computer-frame" ? 1 : DEFAULT_MAX_FILES,
+			maxBytes: profile === "computer-frame" ? COMPUTER_FRAME_MAX_BYTES : profile === "personal" ? 10 * 1024 * 1024 : ENDPOINT_UPLOAD_MAX_BYTES,
+			maxFiles: profile === "durable" ? DEFAULT_MAX_FILES : 1,
 			uploadedFileIds: []
 		};
 		this.grants.set(invocationId, grant);
@@ -66,7 +67,7 @@ var EndpointUploadService = class {
 		const fileId = crypto.randomUUID();
 		const path = join(this.rootDir, fileId);
 		const sha256 = crypto.createHash("sha256").update(params.bytes).digest("hex");
-		if (grant.profile === "durable") writeFileSync(path, params.bytes, {
+		if (grant.profile !== "computer-frame") writeFileSync(path, params.bytes, {
 			flag: "wx",
 			mode: 384
 		});
@@ -83,6 +84,8 @@ var EndpointUploadService = class {
 		const file = {
 			fileId,
 			invocationId: params.invocationId,
+			endpointId: params.endpointId,
+			principalId: grant.principalId,
 			name: params.name,
 			mimeType: params.mimeType,
 			size: params.bytes.byteLength,
@@ -154,6 +157,28 @@ var EndpointUploadService = class {
 				validatedFrame: true
 			});
 		}
+		if (grant.profile === "personal" && params.mimeType.startsWith("image/")) try {
+			const image = sharp(params.bytes, {
+				limitInputPixels: 4e7,
+				failOn: "warning"
+			});
+			if (((await image.metadata()).pages ?? 1) !== 1) throw new Error("Animated images are unsupported");
+			const bytes = await image.rotate().resize({
+				width: 2048,
+				height: 2048,
+				fit: "inside",
+				withoutEnlargement: true
+			}).jpeg({ quality: 85 }).toBuffer();
+			return this.upload({
+				...params,
+				bytes,
+				name: params.name.replace(/\.[^.]*$/, "").slice(0, 251) + ".jpg",
+				mimeType: "image/jpeg"
+			});
+		} catch (error) {
+			if (error instanceof EndpointUploadError) throw error;
+			throw new EndpointUploadError("Selected image could not be decoded");
+		}
 		return this.upload(params);
 	}
 	/** Single-consumer handoff, inaccessible through generic attachment routes. */

package/dist/src/extensions/agent-plugins/auth.d.ts

@@ -4,9 +4,7 @@ import { type PluginServer } from './validation.js';
 declare const bindingSchema: z.ZodObject<{
     serverName: z.ZodString;
     mode: z.ZodEnum<{
-        none: "none";
         auto: "auto";
-        oauth: "oauth";
         "api-key": "api-key";
     }>;
     identityScope: z.ZodLiteral<"owner">;

package/dist/src/extensions/agent-plugins/auth.js

@@ -1,9 +1,8 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
 import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
-import { pluginName } from "./validation.js";
-import { clearPluginMcpHealth } from "./health.js";
 import { isDangerousHostEnvVarName } from "../../infra/host-env-security.js";
+import { pluginName } from "./validation.js";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";
@@ -15,12 +14,7 @@ init_write_file_atomic();
 init_paths_state();
 const bindingSchema = z.strictObject({
 	serverName: z.string(),
-	mode: z.enum([
-		"auto",
-		"oauth",
-		"api-key",
-		"none"
-	]),
+	mode: z.enum(["auto", "api-key"]),
 	identityScope: z.literal("owner"),
 	endpointFingerprint: z.string(),
 	fields: z.array(z.strictObject({
@@ -49,7 +43,6 @@ async function savePluginAuthBinding(store, id, name, input) {
 	const plugin = store.get(id);
 	const server = plugin?.servers[name];
 	if (!server || plugin?.readiness === "blocked") throw new Error("Plugin MCP server unavailable");
-	if (input.mode === "oauth" && server.type !== "streamable-http") throw new Error("OAuth requires streamable HTTP");
 	const endpointFingerprint = pluginEndpointFingerprint(server);
 	const fields = [];
 	const resolver = new CredentialResolver(store.stateDir === resolveStateDir() ? {} : { stateDir: store.stateDir });
@@ -95,20 +88,10 @@ async function savePluginAuthBinding(store, id, name, input) {
 		fields
 	});
 	await writeTextAtomic(bindingPath(store, id, name), JSON.stringify(binding));
-	clearPluginMcpHealth(id, name, store.stateDir);
 }
 function applyPluginAuthBinding(raw, binding) {
 	if (!binding) return raw;
 	const result = { ...raw };
-	if (binding.mode === "none" || binding.mode === "api-key") {
-		delete result.auth;
-		delete result.xopcAutoAuth;
-	}
-	if (binding.mode === "oauth") {
-		result.auth = { type: "oauth" };
-		delete result.xopcAutoAuth;
-		result.headers = Object.fromEntries(Object.entries(result.headers ?? {}).filter(([key]) => key.toLowerCase() !== "authorization"));
-	}
 	for (const field of binding.fields) {
 		const values = { ...result[field.target] };
 		const insensitive = field.target === "headers" || process.platform === "win32";

package/dist/src/extensions/agent-plugins/credentials.js

@@ -1,31 +1,15 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
-import { pluginName, pluginServerId } from "./validation.js";
-import { parsePluginAuthBinding, pluginCredentialProviderPrefix } from "./auth.js";
-import { McpOAuthStore } from "../../agent/mcp/oauth/mcp-oauth-store.js";
-import { getMcpOAuthManager } from "../../agent/mcp/oauth/mcp-oauth-manager.js";
+import { pluginName } from "./validation.js";
+import { pluginCredentialProviderPrefix } from "./auth.js";
 import { join } from "node:path";
-import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { existsSync, rmSync } from "node:fs";
 //#region src/extensions/agent-plugins/credentials.ts
 init_credentials();
 init_paths_state();
 async function removePluginCredentials(store, id) {
 	pluginName.parse(id);
-	const plugin = store.get(id);
-	const serverNames = new Set(Object.keys(plugin?.servers ?? {}));
 	const dir = join(store.stateDir, "plugin-auth", id);
-	if (existsSync(dir)) for (const file of readdirSync(dir)) {
-		if (!/^[a-f0-9]{64}\.json$/.test(file)) throw new Error("Unexpected plugin auth store entry");
-		const binding = parsePluginAuthBinding(JSON.parse(readFileSync(join(dir, file), "utf8")));
-		serverNames.add(binding.serverName);
-	}
-	for (const name of serverNames) {
-		await getMcpOAuthManager({ xopcPlugin: {
-			id,
-			serverName: name
-		} }).cancelPending();
-		await new McpOAuthStore(`owner:${pluginServerId(id, name)}`).deleteScope();
-	}
 	const resolver = new CredentialResolver(store.stateDir === resolveStateDir() ? {} : { stateDir: store.stateDir });
 	for (const profile of await resolver.listProfiles()) if (profile.provider.startsWith(pluginCredentialProviderPrefix(id))) await resolver.deleteProviderCredential(profile.provider);
 	if (existsSync(dir)) rmSync(dir, {

package/dist/src/extensions/agent-plugins/inventory.d.ts

@@ -7,7 +7,7 @@ export declare function agentPluginInventoryRow(plugin: InstalledAgentPlugin): {
         mcp: {
             name: string;
             id: string;
-            type: "sse" | "streamable-http" | "stdio";
+            type: "stdio" | "streamable-http";
         }[];
     };
     diagnostics: import("./validation.js").PluginDiagnostic[];
@@ -45,7 +45,7 @@ export declare function listAgentPluginInventory(): {
         mcp: {
             name: string;
             id: string;
-            type: "sse" | "streamable-http" | "stdio";
+            type: "stdio" | "streamable-http";
         }[];
     };
     diagnostics: import("./validation.js").PluginDiagnostic[];

package/dist/src/extensions/agent-plugins/mcp-adapter.js

@@ -17,11 +17,7 @@ function materializePluginServers(plugin, store = new AgentPluginStore(), diagno
 		};
 		const raw = server.type !== "stdio" ? {
 			...server,
-			xopcPlugin: origin,
-			...server.type === "streamable-http" && !Object.keys(server.headers ?? {}).some((key) => key.toLowerCase() === "authorization") ? {
-				auth: { type: "oauth" },
-				xopcAutoAuth: true
-			} : {}
+			xopcPlugin: origin
 		} : {
 			type: "stdio",
 			xopcPlugin: origin,

package/dist/src/extensions/agent-plugins/source-http-fetch.d.ts

@@ -0,0 +1,2 @@
+import type { FetchLike } from '@modelcontextprotocol/sdk/shared/transport.js';
+export declare function createPluginSourceFetch(endpoint: URL, configuredHeaders: Record<string, string>): FetchLike;