npm - @xopcai/xopc - Versions diffs - 0.0.188 → 0.0.190 - Mend

@xopcai/xopc 0.0.188 → 0.0.190

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (490) hide show

package/dist/gateway/static/root/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png?v=20260713-1" />
     <link rel="manifest" href="/site.webmanifest?v=20260713-1" />
     <title>XOPC — Turn goals into loops. Keep what matters moving.</title>
-    <script type="module" crossorigin src="/assets/index-OJgiMh07.js"></script>
+    <script type="module" crossorigin src="/assets/index-CYT5DOzr.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-aKtaBQYM.js">
     <link rel="modulepreload" crossorigin href="/assets/preload-helper-zJ_50EbN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BOUWij0V.js">
@@ -23,17 +23,17 @@
     <link rel="modulepreload" crossorigin href="/assets/createLucideIcon-DPHK1VkS.js">
     <link rel="modulepreload" crossorigin href="/assets/check-DUBLcKHA.js">
     <link rel="modulepreload" crossorigin href="/assets/middleware-Pd0e8Igk.js">
-    <link rel="modulepreload" crossorigin href="/assets/messages-D02NNLCZ.js">
-    <link rel="modulepreload" crossorigin href="/assets/locale-store-D6hs74o5.js">
+    <link rel="modulepreload" crossorigin href="/assets/messages-B4XqB8I6.js">
+    <link rel="modulepreload" crossorigin href="/assets/locale-store-deR2zRaE.js">
     <link rel="modulepreload" crossorigin href="/assets/cn-JdwAhgNB.js">
-    <link rel="modulepreload" crossorigin href="/assets/schemas-C6onAggk.js">
-    <link rel="modulepreload" crossorigin href="/assets/product-delivery-C8JbSj5Y.js">
+    <link rel="modulepreload" crossorigin href="/assets/schemas-zIBW3wiV.js">
+    <link rel="modulepreload" crossorigin href="/assets/product-delivery-tRr-7IxY.js">
     <link rel="modulepreload" crossorigin href="/assets/config-reload-event-Bjh2zoKp.js">
     <link rel="modulepreload" crossorigin href="/assets/copy-to-clipboard-HOJ79TWv.js">
-    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-B2DmdlwO.js">
-    <link rel="modulepreload" crossorigin href="/assets/activity-store--QoUGhiS.js">
-    <link rel="modulepreload" crossorigin href="/assets/theme-store-BRxdsmic.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-Cl5n1f_U.css">
+    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-EO9mKvzE.js">
+    <link rel="modulepreload" crossorigin href="/assets/activity-store-DstnJCS5.js">
+    <link rel="modulepreload" crossorigin href="/assets/theme-store-DnBOcGXi.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-D6e3tPL-.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/package.js CHANGED Viewed

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.0.188";
+var version = "0.0.190";
 //#endregion
 export { version };

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

@@ -0,0 +1,184 @@
+import { z } from "zod";
+const ENDPOINT_MAX_FILE_BYTES = 25 * 1024 * 1024;
+const ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS = 3e3;
+const endpointKindSchema = z.enum([
+	"web",
+	"desktop",
+	"mobile"
+]);
+const endpointAvailabilitySchema = z.enum(["foreground", "background"]);
+const endpointEffectSchema = z.enum([
+	"read",
+	"write",
+	"destructive"
+]);
+const endpointConfirmationSchema = z.enum(["never", "always"]);
+const endpointResultKindSchema = z.enum([
+	"text",
+	"json",
+	"file"
+]);
+const identifierSchema = z.string().min(1).max(160);
+const turnTokenSchema = z.string().min(32).max(160).regex(/^[A-Za-z0-9_-]+$/);
+const turnOriginSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("endpoint"),
+		endpointId: identifierSchema
+	}),
+	z.strictObject({
+		type: z.literal("channel"),
+		channel: z.string().min(1).max(64)
+	}),
+	z.strictObject({
+		type: z.literal("system"),
+		source: z.enum([
+			"cli",
+			"automation",
+			"heartbeat",
+			"workflow",
+			"internal"
+		])
+	})
+]);
+const endpointTurnClaimSchema = turnOriginSchema.options[0].extend({ token: turnTokenSchema });
+const messageIdSchema = z.uuid();
+const timestampSchema = z.number().int().nonnegative();
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const endpointToolDescriptorSchema = z.strictObject({
+	name: z.string().regex(/^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/).max(120),
+	title: z.string().min(1).max(120),
+	description: z.string().min(1).max(2e3),
+	inputSchema: jsonObjectSchema,
+	effect: endpointEffectSchema,
+	confirmation: endpointConfirmationSchema,
+	requiresForeground: z.boolean(),
+	requiredPermissions: z.array(z.string().min(1).max(120)).max(20),
+	timeoutMs: z.number().int().min(1e3).max(3e5),
+	maxConcurrency: z.number().int().min(1).max(4),
+	supportsCancellation: z.boolean(),
+	idempotent: z.boolean(),
+	resultKinds: z.array(endpointResultKindSchema).min(1).max(3)
+});
+const endpointPrincipalRegistrationSchema = z.strictObject({
+	principalId: identifierSchema,
+	displayName: z.string().min(1).max(120),
+	kind: endpointKindSchema,
+	platform: z.string().min(1).max(80),
+	publicKey: z.string().min(32).max(2048)
+});
+const endpointHelloPayloadSchema = z.strictObject({
+	principalId: identifierSchema,
+	endpointId: identifierSchema,
+	connectionInstanceId: z.uuid(),
+	displayName: z.string().min(1).max(120),
+	kind: endpointKindSchema,
+	platform: z.string().min(1).max(80),
+	appVersion: z.string().min(1).max(80),
+	availability: endpointAvailabilitySchema,
+	nonce: identifierSchema,
+	signedAt: timestampSchema,
+	signature: z.string().min(16).max(1024),
+	tools: z.array(endpointToolDescriptorSchema).max(100)
+});
+const toolInvokePayloadSchema = z.strictObject({
+	invocationId: z.uuid(),
+	toolCallId: identifierSchema,
+	toolName: endpointToolDescriptorSchema.shape.name,
+	arguments: jsonObjectSchema,
+	descriptorRevision: z.string().min(1).max(128),
+	confirmationRequired: z.boolean(),
+	deadlineAt: timestampSchema,
+	uploadGrant: z.strictObject({
+		path: z.string().startsWith("/").max(500),
+		token: identifierSchema,
+		maxBytes: z.number().int().positive(),
+		maxFiles: z.number().int().min(1).max(20),
+		expiresAt: timestampSchema
+	}).optional()
+});
+const toolCancelPayloadSchema = z.strictObject({
+	invocationId: z.uuid(),
+	reason: z.string().min(1).max(500)
+});
+const invocationPayloadSchema = z.strictObject({ invocationId: z.uuid() });
+const endpointToolContentSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("text"),
+		text: z.string().max(256 * 1024)
+	}),
+	z.strictObject({
+		type: z.literal("json"),
+		value: z.unknown()
+	}),
+	z.strictObject({
+		type: z.literal("file"),
+		fileId: identifierSchema,
+		name: z.string().min(1).max(255),
+		mimeType: z.string().min(1).max(255),
+		size: z.number().int().nonnegative(),
+		sha256: z.string().regex(/^[a-f0-9]{64}$/)
+	})
+]);
+const endpointToolErrorCodeSchema = z.enum([
+	"ENDPOINT_OFFLINE",
+	"ENDPOINT_NOT_FOREGROUND",
+	"ENDPOINT_DISCONNECTED",
+	"TOOL_NOT_FOUND",
+	"TOOL_REVISION_MISMATCH",
+	"INVALID_ARGUMENTS",
+	"PERMISSION_DENIED",
+	"USER_DENIED",
+	"TOOL_BUSY",
+	"TOOL_TIMEOUT",
+	"TOOL_CANCELLED",
+	"RESULT_TOO_LARGE",
+	"PROTOCOL_ERROR"
+]);
+const envelope = (type, payload) => z.strictObject({
+	protocolVersion: z.literal(1),
+	messageId: messageIdSchema,
+	type: z.literal(type),
+	sentAt: timestampSchema,
+	payload
+});
+const clientEndpointMessageSchema = z.discriminatedUnion("type", [
+	envelope("endpoint.availability_changed", z.strictObject({ availability: endpointAvailabilitySchema })),
+	envelope("tool.received", invocationPayloadSchema),
+	envelope("tool.progress", z.strictObject({
+		invocationId: z.uuid(),
+		message: z.string().max(500).optional(),
+		percent: z.number().min(0).max(100).optional()
+	})),
+	envelope("tool.result", z.strictObject({
+		invocationId: z.uuid(),
+		content: z.array(endpointToolContentSchema).min(1).max(20),
+		details: jsonObjectSchema.optional()
+	})),
+	envelope("tool.error", z.strictObject({
+		invocationId: z.uuid(),
+		code: endpointToolErrorCodeSchema,
+		message: z.string().min(1).max(2e3)
+	})),
+	envelope("tool.cancelled", invocationPayloadSchema)
+]);
+const serverEndpointMessageSchema = z.discriminatedUnion("type", [envelope("tool.invoke", toolInvokePayloadSchema), envelope("tool.cancel", toolCancelPayloadSchema)]);
+function canonicalJson(value) {
+	if (value === null) return "null";
+	if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("Canonical JSON only supports finite numbers");
+		return JSON.stringify(value);
+	}
+	if (typeof value !== "object") throw new Error(`Canonical JSON does not support ${typeof value}`);
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new Error("Canonical JSON only supports plain objects");
+	const record = value;
+	return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+function endpointHelloSigningPayload(payload) {
+	const { signature: _signature, ...unsigned } = payload;
+	return canonicalJson(unsigned);
+}
+//#endregion
+export { ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS, ENDPOINT_MAX_FILE_BYTES, canonicalJson, clientEndpointMessageSchema, endpointHelloPayloadSchema, endpointHelloSigningPayload, endpointPrincipalRegistrationSchema, endpointTurnClaimSchema, serverEndpointMessageSchema, turnOriginSchema };

package/dist/packages/gateway-contract/src/tool-activity.js CHANGED Viewed

@@ -62,42 +62,6 @@ const TOOL_ACTIVITY_CATALOG = {
 		source: "internet",
 		sensitivity: "normal"
 	},
-	search_graph: {
-		category: "code",
-		action: "search",
-		source: "workspace",
-		sensitivity: "normal"
-	},
-	search_code: {
-		category: "code",
-		action: "search",
-		source: "workspace",
-		sensitivity: "normal"
-	},
-	query_graph: {
-		category: "code",
-		action: "search",
-		source: "workspace",
-		sensitivity: "normal"
-	},
-	trace_path: {
-		category: "code",
-		action: "search",
-		source: "workspace",
-		sensitivity: "normal"
-	},
-	get_architecture: {
-		category: "code",
-		action: "search",
-		source: "workspace",
-		sensitivity: "normal"
-	},
-	get_code_snippet: {
-		category: "file",
-		action: "read",
-		source: "workspace",
-		sensitivity: "normal"
-	},
 	grep: {
 		category: "code",
 		action: "search",

package/dist/packages/realtime-client/src/index.js ADDED Viewed

@@ -0,0 +1,256 @@
+import { parseServerRealtimeMessage } from "../../realtime-protocol/src/index.js";
+//#region packages/realtime-client/src/index.ts
+function frameText(data) {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) {
+		const bytes = Uint8Array.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+		return new TextDecoder().decode(bytes);
+	}
+	throw new Error("Realtime server sent a non-text frame");
+}
+var RealtimeClient = class {
+	desiredSubscriptions = /* @__PURE__ */ new Map();
+	cursors = /* @__PURE__ */ new Map();
+	socket;
+	reconnectTimer;
+	heartbeatTimer;
+	connectionTimer;
+	ticketAbort;
+	generation = 0;
+	reconnectAttempts = 0;
+	shouldReconnect = false;
+	ready = false;
+	lastServerMessageAt = 0;
+	endpointBinding;
+	constructor(options) {
+		this.options = options;
+	}
+	connect() {
+		if (this.shouldReconnect) return;
+		this.shouldReconnect = true;
+		this.open(false);
+	}
+	disconnect() {
+		this.shouldReconnect = false;
+		this.generation += 1;
+		this.clearTimers();
+		this.ready = false;
+		this.endpointBinding?.onDisconnected?.();
+		this.socket?.close(1e3, "Client disconnected");
+		this.socket = void 0;
+		this.options.onStateChange?.("disconnected");
+	}
+	reconnect() {
+		this.generation += 1;
+		this.clearTimers();
+		this.ready = false;
+		this.endpointBinding?.onDisconnected?.();
+		this.socket?.close(1e3, "Client reconnecting");
+		this.socket = void 0;
+		this.reconnectAttempts = 0;
+		this.shouldReconnect = true;
+		this.open(true);
+	}
+	subscribe(topic, afterSeq) {
+		this.desiredSubscriptions.set(topic, afterSeq);
+		if (afterSeq !== void 0) this.cursors.set(topic, afterSeq);
+		if (this.ready) this.sendSubscriptions([{
+			topic,
+			afterSeq: this.cursors.get(topic) ?? afterSeq
+		}]);
+	}
+	unsubscribe(topic) {
+		this.desiredSubscriptions.delete(topic);
+		if (this.ready) this.send(this.clientMessage("realtime.unsubscribe", { topics: [topic] }));
+	}
+	sendEndpointMessage(message) {
+		if (!this.ready) throw new Error("Realtime connection is not ready");
+		this.send(this.clientMessage("endpoint.message", message));
+	}
+	setEndpoint(binding) {
+		this.endpointBinding = binding;
+		if (this.shouldReconnect) this.reconnect();
+	}
+	clearEndpoint(binding) {
+		if (binding && this.endpointBinding !== binding) return;
+		const previous = this.endpointBinding;
+		this.endpointBinding = void 0;
+		previous?.onDisconnected?.();
+		if (this.shouldReconnect) this.reconnect();
+	}
+	async open(reconnecting) {
+		const generation = ++this.generation;
+		const timeoutMs = this.options.connectionTimeoutMs ?? 15e3;
+		const ticketAbort = new AbortController();
+		this.ticketAbort?.abort();
+		this.ticketAbort = ticketAbort;
+		let socket;
+		let closed = false;
+		let messageQueue;
+		const failAttempt = (error) => {
+			if (closed || generation !== this.generation) return;
+			closed = true;
+			this.clearConnectionTimer();
+			ticketAbort.abort();
+			if (this.ticketAbort === ticketAbort) this.ticketAbort = void 0;
+			this.ready = false;
+			this.endpointBinding?.onDisconnected?.();
+			this.clearHeartbeat();
+			if (this.socket === socket) this.socket = void 0;
+			if (socket) {
+				socket.onopen = null;
+				socket.onmessage = null;
+				socket.onerror = null;
+				socket.onclose = null;
+				socket.close(4e3, error.slice(0, 120));
+			}
+			if (this.shouldReconnect) this.scheduleReconnect(error);
+			else this.options.onStateChange?.("disconnected");
+		};
+		this.connectionTimer = setTimeout(() => failAttempt("Realtime connection timed out"), timeoutMs);
+		this.options.onStateChange?.(reconnecting ? "reconnecting" : "connecting");
+		try {
+			const [ticket, endpoint] = await Promise.all([this.options.issueTicket(ticketAbort.signal), this.endpointBinding?.createHello()]);
+			if (closed || !this.shouldReconnect || generation !== this.generation) return;
+			socket = this.options.createWebSocket(this.options.getWebSocketUrl());
+			this.socket = socket;
+			socket.onopen = () => {
+				if (generation !== this.generation) return;
+				const subscriptions = [...this.desiredSubscriptions].map(([topic, afterSeq]) => ({
+					topic,
+					afterSeq: this.cursors.get(topic) ?? afterSeq
+				}));
+				this.send(this.clientMessage("realtime.hello", {
+					ticket,
+					clientId: this.options.clientId,
+					clientKind: this.options.clientKind,
+					subscriptions,
+					...endpoint ? { endpoint } : {}
+				}));
+			};
+			socket.onmessage = (event) => {
+				if (generation !== this.generation) return;
+				const process = () => {
+					if (closed || generation !== this.generation) return;
+					return this.handleServerMessage(frameText(event.data));
+				};
+				if (!messageQueue) {
+					try {
+						const pending = process();
+						if (!pending) return;
+						const current = pending.catch((error) => failAttempt(error instanceof Error ? error.message : "Invalid realtime server message")).then(() => void 0);
+						messageQueue = current;
+						current.finally(() => {
+							if (messageQueue === current) messageQueue = void 0;
+						});
+					} catch (error) {
+						failAttempt(error instanceof Error ? error.message : "Invalid realtime server message");
+					}
+					return;
+				}
+				const current = messageQueue.then(process).catch((error) => failAttempt(error instanceof Error ? error.message : "Invalid realtime server message")).then(() => void 0);
+				messageQueue = current;
+				current.finally(() => {
+					if (messageQueue === current) messageQueue = void 0;
+				});
+			};
+			socket.onerror = () => {
+				failAttempt("Realtime WebSocket failed");
+			};
+			socket.onclose = (event) => {
+				failAttempt(event.reason || `WebSocket closed (${event.code ?? 0})`);
+			};
+		} catch (error) {
+			failAttempt(error instanceof Error ? error.message : "Realtime connection failed");
+		}
+	}
+	handleServerMessage(text) {
+		const message = parseServerRealtimeMessage(JSON.parse(text));
+		this.lastServerMessageAt = Date.now();
+		if (message.kind === "realtime.ready") {
+			this.ready = true;
+			this.reconnectAttempts = 0;
+			this.clearConnectionTimer();
+			this.ticketAbort = void 0;
+			this.options.onStateChange?.("connected");
+			if (message.payload.endpoint) this.endpointBinding?.onReady(message.payload.endpoint);
+			this.clearHeartbeat();
+			this.heartbeatTimer = setInterval(() => {
+				if (!this.ready) return;
+				if (Date.now() - this.lastServerMessageAt >= message.payload.heartbeatTimeoutMs) {
+					this.reconnect();
+					return;
+				}
+				this.send(this.clientMessage("realtime.ping", {}));
+			}, message.payload.heartbeatIntervalMs);
+		} else if (message.kind === "realtime.event") {
+			const cursor = this.cursors.get(message.payload.topic);
+			if (cursor !== void 0 && message.payload.seq <= cursor) return;
+			this.options.onEvent?.(message.payload);
+			this.cursors.set(message.payload.topic, message.payload.seq);
+		} else if (message.kind === "realtime.subscribed") this.cursors.set(message.payload.topic, message.payload.cursor);
+		else if (message.kind === "realtime.gap") {
+			this.cursors.set(message.payload.topic, message.payload.earliestSeq - 1);
+			return this.options.onGap?.(message.payload);
+		} else if (message.kind === "realtime.error") this.options.onStateChange?.("error", message.payload.message);
+		else if (message.kind === "endpoint.message") {
+			this.endpointBinding?.onMessage(message.payload);
+			this.options.onEndpointMessage?.(message.payload);
+		}
+	}
+	sendSubscriptions(subscriptions) {
+		this.send(this.clientMessage("realtime.subscribe", { subscriptions }));
+	}
+	clientMessage(kind, payload) {
+		const messageId = this.options.createMessageId?.() ?? globalThis.crypto?.randomUUID?.();
+		if (!messageId) throw new Error("RealtimeClient requires createMessageId when crypto.randomUUID is unavailable");
+		return {
+			protocolVersion: 1,
+			messageId,
+			kind,
+			sentAt: Date.now(),
+			payload
+		};
+	}
+	send(message) {
+		if (!this.socket || this.socket.readyState !== 1) return;
+		this.socket.send(JSON.stringify(message));
+	}
+	scheduleReconnect(error) {
+		if (!this.shouldReconnect) return;
+		this.reconnectAttempts += 1;
+		const max = this.options.maxReconnectAttempts;
+		if (max !== void 0 && this.reconnectAttempts > max) {
+			this.shouldReconnect = false;
+			this.options.onStateChange?.("error", error);
+			return;
+		}
+		this.options.onStateChange?.("reconnecting", error);
+		const cap = Math.min(3e4, 1e3 * 2 ** Math.min(this.reconnectAttempts - 1, 5));
+		const delay = Math.round(cap * (.5 + Math.random() * .5));
+		if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = void 0;
+			this.open(true);
+		}, delay);
+	}
+	clearHeartbeat() {
+		if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+		this.heartbeatTimer = void 0;
+	}
+	clearTimers() {
+		if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+		this.reconnectTimer = void 0;
+		this.clearConnectionTimer();
+		this.ticketAbort?.abort();
+		this.ticketAbort = void 0;
+		this.clearHeartbeat();
+	}
+	clearConnectionTimer() {
+		if (this.connectionTimer) clearTimeout(this.connectionTimer);
+		this.connectionTimer = void 0;
+	}
+};
+//#endregion
+export { RealtimeClient };

package/dist/packages/realtime-protocol/src/index.js ADDED Viewed

@@ -0,0 +1,88 @@
+import { clientEndpointMessageSchema, endpointHelloPayloadSchema, serverEndpointMessageSchema } from "../../endpoint-tools-protocol/src/index.js";
+import { z } from "zod";
+const REALTIME_MAX_CLIENT_FRAME_BYTES = 256 * 1024;
+const REALTIME_HELLO_TIMEOUT_MS = 5e3;
+const REALTIME_HEARTBEAT_INTERVAL_MS = 15e3;
+const REALTIME_HEARTBEAT_TIMEOUT_MS = 45e3;
+const realtimeClientKindSchema = z.enum([
+	"web",
+	"desktop",
+	"mobile",
+	"tui",
+	"mcp"
+]);
+const realtimeTopicSchema = z.string().min(1).max(512);
+const realtimeEventNameSchema = z.string().regex(/^[a-z][a-z0-9_.-]*$/).max(160);
+const messageIdSchema = z.uuid();
+const timestampSchema = z.number().int().nonnegative();
+const sequenceSchema = z.number().int().positive();
+const envelope = (kind, payload) => z.strictObject({
+	protocolVersion: z.literal(1),
+	messageId: messageIdSchema,
+	kind: z.literal(kind),
+	sentAt: timestampSchema,
+	payload
+});
+const realtimeSubscriptionSchema = z.strictObject({
+	topic: realtimeTopicSchema,
+	afterSeq: z.number().int().nonnegative().optional()
+});
+const clientRealtimeMessageSchema = z.discriminatedUnion("kind", [
+	envelope("realtime.hello", z.strictObject({
+		ticket: z.string().min(32).max(512),
+		clientId: z.string().min(1).max(160),
+		clientKind: realtimeClientKindSchema,
+		subscriptions: z.array(realtimeSubscriptionSchema).max(100).default([]),
+		endpoint: endpointHelloPayloadSchema.optional()
+	})),
+	envelope("realtime.subscribe", z.strictObject({ subscriptions: z.array(realtimeSubscriptionSchema).min(1).max(100) })),
+	envelope("realtime.unsubscribe", z.strictObject({ topics: z.array(realtimeTopicSchema).min(1).max(100) })),
+	envelope("realtime.ping", z.strictObject({})),
+	envelope("endpoint.message", clientEndpointMessageSchema)
+]);
+const realtimeEventPayloadSchema = z.strictObject({
+	topic: realtimeTopicSchema,
+	seq: sequenceSchema,
+	event: realtimeEventNameSchema,
+	data: z.unknown()
+});
+const serverRealtimeMessageSchema = z.discriminatedUnion("kind", [
+	envelope("realtime.ready", z.strictObject({
+		connectionId: z.uuid(),
+		heartbeatIntervalMs: z.literal(REALTIME_HEARTBEAT_INTERVAL_MS),
+		heartbeatTimeoutMs: z.literal(REALTIME_HEARTBEAT_TIMEOUT_MS),
+		endpoint: z.strictObject({
+			endpointId: z.string().min(1).max(160),
+			turnToken: z.string().min(32).max(160)
+		}).optional()
+	})),
+	envelope("realtime.event", realtimeEventPayloadSchema),
+	envelope("realtime.subscribed", z.strictObject({
+		topic: realtimeTopicSchema,
+		cursor: z.number().int().nonnegative()
+	})),
+	envelope("realtime.gap", z.strictObject({
+		topic: realtimeTopicSchema,
+		requestedSeq: z.number().int().nonnegative(),
+		earliestSeq: sequenceSchema,
+		recoverable: z.boolean()
+	})),
+	envelope("realtime.pong", z.strictObject({})),
+	envelope("realtime.error", z.strictObject({
+		code: z.string().min(1).max(80),
+		message: z.string().min(1).max(500)
+	})),
+	envelope("endpoint.message", serverEndpointMessageSchema)
+]);
+function parseClientRealtimeMessage(value) {
+	return clientRealtimeMessageSchema.parse(value);
+}
+function parseServerRealtimeMessage(value) {
+	return serverRealtimeMessageSchema.parse(value);
+}
+function parseClientRealtimeJsonFrame(text) {
+	if (new TextEncoder().encode(text).byteLength > 262144) throw new Error(`Realtime client frame exceeds ${REALTIME_MAX_CLIENT_FRAME_BYTES} bytes`);
+	return JSON.parse(text);
+}
+//#endregion
+export { REALTIME_HEARTBEAT_INTERVAL_MS, REALTIME_HEARTBEAT_TIMEOUT_MS, REALTIME_HELLO_TIMEOUT_MS, REALTIME_MAX_CLIENT_FRAME_BYTES, parseClientRealtimeJsonFrame, parseClientRealtimeMessage, parseServerRealtimeMessage, realtimeClientKindSchema, realtimeEventNameSchema, realtimeTopicSchema };

package/dist/src/agent/agent-manager.d.ts CHANGED Viewed

@@ -70,6 +70,7 @@ export interface AgentManagerConfig {
     model?: string;
     config?: Config;
     extensionRegistry?: ExtensionRegistry;
+    endpointTools?: import('../endpoint-tools/index.js').EndpointToolRuntime;
     hookRunner?: import('../extensions/index.js').ExtensionHookRunner;
     bus: MessageBus;
     getCurrentContext: () => SessionContext | null;
@@ -190,7 +191,6 @@ export declare class AgentManager implements AgentInstanceGateway {
     private buildToolsFactoryDeps;
     getMemoryManager(): MemoryManager;
     getMemoryManagerForSession(sessionKey: string): MemoryManager;
-    markCodeIntelligenceDirty(sessionKey: string, paths: readonly string[]): void;
     /** Build the bounded, policy-filtered context used for this model turn. */
     prepareUserTurnContext(userMessage: AgentMessage, sessionKey: string, turnId: string): Promise<UserContextPlan>;
     /**