@xopcai/xopc 0.0.369 → 0.0.370

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 };

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/gateway-contract/src/session-input-command.js

@@ -12,12 +12,18 @@ function canonicalSessionCommand(value) {
 }
 function sessionCommandIdentity(command) {
 	if ("origin" in command) {
-		const { origin: _origin, ...identity } = command;
-		return canonicalSessionCommand(identity);
+		const origin = command.origin.type === "endpoint" ? {
+			type: "endpoint",
+			endpointId: command.origin.endpointId
+		} : command.origin;
+		return canonicalSessionCommand({
+			...command,
+			origin
+		});
 	}
 	return canonicalSessionCommand(command);
 }
-var sessionCreationSchema, attachmentSchema, sessionInputContentSchema, originSchema, sessionInputCommandSchema, sessionMaterializeCommandSchema;
+var sessionCreationSchema, attachmentSchema, endpointContextSchema, sessionInputContentSchema, originSchema, sessionInputCommandSchema, sessionMaterializeCommandSchema;
 var init_session_input_command = __esmMin((() => {
 	init_app_context();
 	init_browser_page_context();
@@ -46,8 +52,28 @@ var init_session_input_command = __esmMin((() => {
 		workspaceRelativePath: z.string().optional(),
 		durationSeconds: z.number().nonnegative().optional()
 	});
+	endpointContextSchema = z.strictObject({
+		version: z.literal(1),
+		capturedAt: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+		timezone: z.string().min(1).max(80).refine((value) => {
+			try {
+				new Intl.DateTimeFormat("en", { timeZone: value });
+				return true;
+			} catch {
+				return false;
+			}
+		}, "Invalid timezone"),
+		locale: z.string().min(1).max(80).refine((value) => {
+			try {
+				return Intl.getCanonicalLocales(value).length === 1;
+			} catch {
+				return false;
+			}
+		}, "Invalid locale")
+	});
 	sessionInputContentSchema = z.strictObject({
 		content: z.string(),
+		endpointContext: endpointContextSchema.optional(),
 		attachments: z.array(attachmentSchema).optional(),
 		contextRefs: z.array(z.strictObject({
 			kind: z.enum([
@@ -56,7 +82,6 @@ var init_session_input_command = __esmMin((() => {
 				"file",
 				"session",
 				"browser_tab",
-				"mcp_resource",
 				"user_assertion"
 			]),
 			sourceId: z.string().trim().min(1),
@@ -108,4 +133,4 @@ var init_session_input_command = __esmMin((() => {
 }));
 //#endregion
 init_session_input_command();
-export { canonicalSessionCommand, init_session_input_command, sessionCommandIdentity, sessionCreationSchema, sessionInputCommandSchema, sessionInputContentSchema, sessionMaterializeCommandSchema };
+export { canonicalSessionCommand, endpointContextSchema, init_session_input_command, sessionCommandIdentity, sessionCreationSchema, sessionInputCommandSchema, sessionInputContentSchema, sessionMaterializeCommandSchema };

package/dist/src/agent/agent-manager.js

@@ -27,22 +27,18 @@ import { clearBootstrapSnapshot } from "./bootstrap/bootstrap-cache.js";
 import { resolveBootstrapContextSync } from "./bootstrap/bootstrap-files.js";
 import { loadProjectAgentsContextFile } from "./bootstrap/project-agents-context.js";
 import { getEmbeddedExecutionRunId } from "./embedded/execution-context.js";
-import { parseExternalToolRef } from "./external-tools/refs.js";
 import { loadSkillsLock } from "./skills/hub-lock.js";
 import { isUnderManagedSkillsDir } from "./skills/managed-store.js";
-import { mcpToolPolicyId } from "./mcp/bundle-mcp-policy.js";
-import { disposeAllSessionMcpRuntimes, retireSessionMcpRuntimeForConversationId } from "./mcp/bundle-mcp-runtime.js";
 import { createSkillConfigManager, isSkillEnabled, resolveSkillConfig } from "./skills/config.js";
 import { isValidSkillEnvVarName } from "./skills/required-env-vars.js";
 import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "./skills/workspace-skills-dir.js";
-import { replaceAgentSystemPrompt } from "./prompt/agent-system-prompt.js";
+import { abortEmbeddedRun } from "./embedded/runs.js";
 import { evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner } from "./embedded/session-runner.js";
 import { createAgentTurnPolicy } from "./orchestration/agent-turn-policy.js";
 import { createAgentCapabilitySessionState, resolveAgentCapabilityCatalog } from "./capabilities/registry.js";
 import "./capabilities/index.js";
 import { sortToolsForPromptCache } from "./tools/cache-stability.js";
 import { AgentToolsFactory } from "./tools/factory.js";
-import "./mcp/bundle-mcp-tools.js";
 import { isMemorySubsystemEnabled } from "./memory/memory-config.js";
 import { evaluateToolGate } from "./context/execution-context.js";
 import { ExecutionContextCoordinator } from "./context/coordinator.js";
@@ -51,6 +47,7 @@ import { BackgroundReviewCoordinator } from "./background-review/coordinator.js"
 import { maybeRequestChannelExecApproval } from "../channels/exec-approval-runtime.js";
 import { SkillFilesystemWatcher } from "./skills/filesystem-watcher.js";
 import { ProjectTrustStore, hasTrustRequiringProjectResources } from "../project-trust/trust-store.js";
+import { replaceAgentSystemPrompt } from "./prompt/agent-system-prompt.js";
 import { basename, resolve, sep } from "node:path";
 import { createHash } from "node:crypto";
 import { Agent } from "@earendil-works/pi-agent-core";
@@ -232,6 +229,22 @@ var AgentManager = class {
 	*/
 	updateRuntimeConfiguration(config) {
 		this.config.config = config;
+		for (const instance of this.agents.values()) {
+			const before = instance.effectiveProfile.config;
+			const after = resolveEffectiveAgentProfileForSession(instance.conversationId).config;
+			if (JSON.stringify([
+				before.runtime.codemode,
+				before.tools,
+				before.toolAllowlist
+			]) !== JSON.stringify([
+				after.runtime.codemode,
+				after.tools,
+				after.toolAllowlist
+			])) {
+				abortEmbeddedRun(instance.conversationId);
+				evictEmbeddedSessionRunner(instance.conversationId, "agent_tool_configuration_changed");
+			}
+		}
 		const ref = getAgentDefaultModelRef();
 		this.config.model = ref;
 		this.defaultModel = ref || getDefaultModelSync(config);
@@ -849,10 +862,6 @@ var AgentManager = class {
 		if (instance) {
 			this.backgroundReview.forgetSession(conversationId);
 			this.toolsFactory.closeBrowserPageForSession(conversationId);
-			retireSessionMcpRuntimeForConversationId({
-				conversationId,
-				reason: "agent-evict"
-			});
 			instance.agent.abort();
 			evictEmbeddedSessionRunner(conversationId, "agent_removed");
 			this.agents.delete(conversationId);
@@ -930,7 +939,6 @@ var AgentManager = class {
 		if (this.skillsUpdatedTimer) clearTimeout(this.skillsUpdatedTimer);
 		this.skillFilesystemWatcher.dispose();
 		this.toolsFactory.shutdownBrowser();
-		disposeAllSessionMcpRuntimes().catch(() => {});
 		evictAllEmbeddedSessionRunners("agent_manager_dispose");
 		this.backgroundReview.clear();
 		this.userUnderstandingMaintenance.clear();
@@ -1177,22 +1185,10 @@ var AgentManager = class {
 			} : void 0;
 		}
 		const toolRef = typeof args?.toolRef === "string" ? args.toolRef : "";
-		const parsed = parseExternalToolRef(toolRef, "mcp");
-		if (!parsed) {
-			const externalPolicy = profile.config.tools[toolRef];
-			return externalPolicy ? {
-				id: toolRef,
-				...externalPolicy
-			} : gatewayPolicy ? {
-				id: toolName,
-				...gatewayPolicy
-			} : void 0;
-		}
-		const id = mcpToolPolicyId(parsed.namespace, parsed.toolName);
-		const policy = profile.config.tools[id];
-		return policy ? {
-			id,
-			...policy
+		const externalPolicy = profile.config.tools[toolRef];
+		return externalPolicy ? {
+			id: toolRef,
+			...externalPolicy
 		} : gatewayPolicy ? {
 			id: toolName,
 			...gatewayPolicy

package/dist/src/agent/embedded/codemode-extension.d.ts

@@ -0,0 +1,7 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+import { type AgentSession, type ExtensionFactory } from '@earendil-works/pi-coding-agent';
+import type { EffectiveAgentConfig } from '../../agent-config/schema.js';
+export type CodemodePolicy = NonNullable<EffectiveAgentConfig['runtime']['codemode']>;
+/** Public pi extension, restricted to core reads and the current xopc turn policy. */
+export declare function createXopcCodemodeExtension(policy: CodemodePolicy, tools: readonly AgentTool[], getSession: () => AgentSession | undefined): ExtensionFactory;
+export declare function boundCodemodeSource(source: string, policy: CodemodePolicy): string;