@xopcai/xopc 0.0.188 → 0.0.189

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

@@ -0,0 +1,18 @@
+//#region src/endpoint-tools/policy.ts
+var EndpointToolPolicyError = class extends Error {};
+var EndpointToolPolicy = class {
+	validateDescriptor(kind, descriptor) {
+		if (!descriptor.name.startsWith(`${kind}.`)) throw new EndpointToolPolicyError(`Tool ${descriptor.name} does not belong to ${kind}`);
+		if (descriptor.effect !== "read") {
+			if (descriptor.confirmation !== "always") throw new EndpointToolPolicyError(`Mutating tool ${descriptor.name} must always require confirmation`);
+			if (!descriptor.requiresForeground) throw new EndpointToolPolicyError(`Mutating tool ${descriptor.name} must require foreground`);
+			if (descriptor.requiredPermissions.length === 0) throw new EndpointToolPolicyError(`Mutating tool ${descriptor.name} must declare a permission`);
+		}
+	}
+	evaluate(descriptor, availability) {
+		if (descriptor.requiresForeground && availability !== "foreground") throw new EndpointToolPolicyError("Endpoint is not in the foreground");
+		return { confirmationRequired: descriptor.confirmation === "always" || descriptor.effect !== "read" };
+	}
+};
+//#endregion
+export { EndpointToolPolicy, EndpointToolPolicyError };

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

@@ -0,0 +1,45 @@
+import { type EndpointAvailability, type EndpointHelloPayload, type EndpointKind, type EndpointToolDescriptor } from '@xopcai/endpoint-tools-protocol';
+import { EndpointToolPolicy } from './policy.js';
+export interface EndpointTransport {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+}
+export interface RegisteredEndpointTool {
+    descriptor: EndpointToolDescriptor;
+    revision: string;
+}
+export interface EndpointConnectionSnapshot {
+    principalId: string;
+    endpointId: string;
+    connectionId: string;
+    displayName: string;
+    kind: EndpointKind;
+    platform: string;
+    appVersion: string;
+    availability: EndpointAvailability;
+    lastHeartbeatAt: number;
+    tools: RegisteredEndpointTool[];
+}
+export interface EndpointRegistration {
+    connection: EndpointConnectionSnapshot;
+    turnToken: string;
+}
+export declare function endpointToolRevision(descriptor: EndpointToolDescriptor): string;
+export declare class EndpointRegistry {
+    private readonly policy;
+    private readonly connectionByEndpointId;
+    constructor(policy?: EndpointToolPolicy);
+    register(hello: EndpointHelloPayload, connectionId: string, transport: EndpointTransport, now?: number): EndpointRegistration;
+    remove(endpointId: string, connectionId: string): boolean;
+    heartbeat(endpointId: string, connectionId: string, availability: EndpointAvailability, now?: number): void;
+    get(endpointId: string): EndpointConnectionSnapshot | undefined;
+    isCurrentConnection(endpointId: string, connectionId: string): boolean;
+    list(): EndpointConnectionSnapshot[];
+    getTool(endpointId: string, toolName: string): RegisteredEndpointTool | undefined;
+    verifyTurnClaim(endpointId: string, turnToken: string): boolean;
+    send(endpointId: string, type: 'tool.invoke' | 'tool.cancel', payload: unknown): void;
+    disconnect(endpointId: string, code?: number, reason?: string): boolean;
+    closeAll(code?: number, reason?: string): void;
+    private requireConnection;
+}

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

@@ -0,0 +1,121 @@
+import { canonicalJson } from "../../packages/endpoint-tools-protocol/src/index.js";
+import { EndpointToolPolicy } from "./policy.js";
+import crypto from "node:crypto";
+//#region src/endpoint-tools/registry.ts
+function endpointToolRevision(descriptor) {
+	return crypto.createHash("sha256").update(canonicalJson(descriptor)).digest("hex");
+}
+function snapshot(connection) {
+	return {
+		principalId: connection.principalId,
+		endpointId: connection.endpointId,
+		connectionId: connection.connectionId,
+		displayName: connection.displayName,
+		kind: connection.kind,
+		platform: connection.platform,
+		appVersion: connection.appVersion,
+		availability: connection.availability,
+		lastHeartbeatAt: connection.lastHeartbeatAt,
+		tools: [...connection.toolByName.values()]
+	};
+}
+var EndpointRegistry = class {
+	connectionByEndpointId = /* @__PURE__ */ new Map();
+	constructor(policy = new EndpointToolPolicy()) {
+		this.policy = policy;
+	}
+	register(hello, connectionId, transport, now = Date.now()) {
+		const toolByName = /* @__PURE__ */ new Map();
+		for (const descriptor of hello.tools) {
+			this.policy.validateDescriptor(hello.kind, descriptor);
+			if (toolByName.has(descriptor.name)) throw new Error(`Endpoint catalog contains duplicate tool: ${descriptor.name}`);
+			toolByName.set(descriptor.name, {
+				descriptor,
+				revision: endpointToolRevision(descriptor)
+			});
+		}
+		const previous = this.connectionByEndpointId.get(hello.endpointId);
+		if (previous && previous.principalId !== hello.principalId) throw new Error("Endpoint instance belongs to another principal");
+		if (previous) previous.transport.close(4001, "Endpoint connected elsewhere");
+		const connection = {
+			principalId: hello.principalId,
+			endpointId: hello.endpointId,
+			connectionId,
+			displayName: hello.displayName,
+			kind: hello.kind,
+			platform: hello.platform,
+			appVersion: hello.appVersion,
+			availability: hello.availability,
+			lastHeartbeatAt: now,
+			tools: [],
+			transport,
+			turnToken: crypto.randomBytes(32).toString("base64url"),
+			toolByName
+		};
+		this.connectionByEndpointId.set(connection.endpointId, connection);
+		return {
+			connection: snapshot(connection),
+			turnToken: connection.turnToken
+		};
+	}
+	remove(endpointId, connectionId) {
+		const connection = this.connectionByEndpointId.get(endpointId);
+		if (!connection || connection.connectionId !== connectionId) return false;
+		this.connectionByEndpointId.delete(endpointId);
+		return true;
+	}
+	heartbeat(endpointId, connectionId, availability, now = Date.now()) {
+		const connection = this.requireConnection(endpointId, connectionId);
+		connection.availability = availability;
+		connection.lastHeartbeatAt = now;
+	}
+	get(endpointId) {
+		const connection = this.connectionByEndpointId.get(endpointId);
+		return connection ? snapshot(connection) : void 0;
+	}
+	isCurrentConnection(endpointId, connectionId) {
+		return this.connectionByEndpointId.get(endpointId)?.connectionId === connectionId;
+	}
+	list() {
+		return [...this.connectionByEndpointId.values()].map(snapshot);
+	}
+	getTool(endpointId, toolName) {
+		return this.connectionByEndpointId.get(endpointId)?.toolByName.get(toolName);
+	}
+	verifyTurnClaim(endpointId, turnToken) {
+		const connection = this.connectionByEndpointId.get(endpointId);
+		if (!connection || connection.transport.readyState !== 1) return false;
+		const expected = Buffer.from(connection.turnToken);
+		const actual = Buffer.from(turnToken);
+		return expected.length === actual.length && crypto.timingSafeEqual(expected, actual);
+	}
+	send(endpointId, type, payload) {
+		const connection = this.connectionByEndpointId.get(endpointId);
+		if (!connection || connection.transport.readyState !== 1) throw new Error(`Endpoint is offline: ${endpointId}`);
+		const message = {
+			protocolVersion: 1,
+			messageId: crypto.randomUUID(),
+			type,
+			sentAt: Date.now(),
+			payload
+		};
+		connection.transport.send(JSON.stringify(message));
+	}
+	disconnect(endpointId, code = 4003, reason = "Endpoint disconnected") {
+		const connection = this.connectionByEndpointId.get(endpointId);
+		if (!connection) return false;
+		connection.transport.close(code, reason);
+		return true;
+	}
+	closeAll(code = 1001, reason = "Gateway stopping") {
+		for (const connection of this.connectionByEndpointId.values()) connection.transport.close(code, reason);
+		this.connectionByEndpointId.clear();
+	}
+	requireConnection(endpointId, connectionId) {
+		const connection = this.connectionByEndpointId.get(endpointId);
+		if (!connection || connection.connectionId !== connectionId) throw new Error("Endpoint connection is no longer active");
+		return connection;
+	}
+};
+//#endregion
+export { EndpointRegistry, endpointToolRevision };

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

@@ -0,0 +1,23 @@
+import { type ClientEndpointMessage, type EndpointHelloPayload } from '@xopcai/endpoint-tools-protocol';
+import { type EndpointAuthenticatorDeps } from './auth.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 invocations: EndpointInvocationService;
+    readonly uploads: EndpointUploadService;
+    private readonly authenticator;
+    private closed;
+    constructor(options?: {
+        auth?: EndpointAuthenticatorDeps;
+        audit?: EndpointInvocationAuditSink;
+        uploadRoot?: string;
+    });
+    connect(hello: EndpointHelloPayload, connectionId: string, transport: EndpointTransport): EndpointRegistration;
+    handleMessage(endpointId: string, connectionId: string, message: ClientEndpointMessage): void;
+    touch(endpointId: string, connectionId: string): void;
+    remove(endpointId: string, connectionId: string): void;
+    disconnect(endpointId: string, reason: string): void;
+    close(): void;
+}

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

@@ -0,0 +1,86 @@
+import { resolveStateDir } from "../config/paths-state.js";
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { bindEndpointPrincipal, getEndpointPrincipal, touchEndpointPrincipal } from "../storage/sqlite/endpoint-principal-repository.js";
+import { finishEndpointToolInvocationAudit, startEndpointToolInvocationAudit } from "../storage/sqlite/endpoint-tool-invocation-repository.js";
+import "../storage/sqlite/index.js";
+import { init_paths } from "../config/paths.js";
+import { EndpointAuthenticator } from "./auth.js";
+import { EndpointToolPolicy } from "./policy.js";
+import { EndpointInvocationService } from "./invocation-service.js";
+import { EndpointRegistry } from "./registry.js";
+import { EndpointUploadService } from "./upload-service.js";
+import { join } from "node:path";
+//#region src/endpoint-tools/runtime.ts
+init_paths();
+init_logger();
+const log = createLogger("EndpointTools");
+const MAX_MESSAGE_CLOCK_SKEW_MS = 6e4;
+var EndpointToolRuntime = class {
+	registry;
+	invocations;
+	uploads;
+	authenticator;
+	closed = false;
+	constructor(options = {}) {
+		const policy = new EndpointToolPolicy();
+		this.registry = new EndpointRegistry(policy);
+		this.authenticator = new EndpointAuthenticator(options.auth ?? {
+			getPrincipal: getEndpointPrincipal,
+			bindEndpoint: bindEndpointPrincipal,
+			touchPrincipal: touchEndpointPrincipal
+		});
+		this.uploads = new EndpointUploadService(options.uploadRoot ?? join(resolveStateDir(), "endpoint-tool-files"));
+		this.invocations = new EndpointInvocationService(this.registry, {
+			audit: options.audit ?? {
+				started: startEndpointToolInvocationAudit,
+				finished: finishEndpointToolInvocationAudit
+			},
+			uploads: this.uploads,
+			policy
+		});
+	}
+	connect(hello, connectionId, transport) {
+		if (this.closed) throw new Error("Endpoint runtime is closed");
+		this.authenticator.authenticate(hello);
+		const registration = this.registry.register(hello, connectionId, transport);
+		log.info({
+			endpointId: hello.endpointId,
+			connectionId,
+			kind: hello.kind
+		}, "Endpoint connected");
+		return registration;
+	}
+	handleMessage(endpointId, connectionId, message) {
+		if (!this.registry.isCurrentConnection(endpointId, connectionId)) throw new Error("Endpoint connection is no longer active");
+		if (Math.abs(Date.now() - message.sentAt) > MAX_MESSAGE_CLOCK_SKEW_MS) throw new Error("Endpoint message timestamp is outside the allowed window");
+		if (message.type === "endpoint.availability_changed") {
+			this.registry.heartbeat(endpointId, connectionId, message.payload.availability);
+			return;
+		}
+		this.invocations.handleMessage(endpointId, message);
+	}
+	touch(endpointId, connectionId) {
+		const endpoint = this.registry.get(endpointId);
+		if (endpoint?.connectionId === connectionId) this.registry.heartbeat(endpointId, connectionId, endpoint.availability);
+	}
+	remove(endpointId, connectionId) {
+		if (!this.registry.remove(endpointId, connectionId)) return;
+		this.invocations.failEndpoint(endpointId);
+		log.info({
+			endpointId,
+			connectionId
+		}, "Endpoint disconnected");
+	}
+	disconnect(endpointId, reason) {
+		this.registry.disconnect(endpointId, 4003, reason);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.invocations.close();
+		this.registry.closeAll();
+	}
+};
+//#endregion
+export { EndpointToolRuntime };

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

@@ -0,0 +1,41 @@
+import { type EndpointToolContent } from '@xopcai/endpoint-tools-protocol';
+export declare const ENDPOINT_UPLOAD_MAX_BYTES: number;
+export interface EndpointUploadedFile {
+    fileId: string;
+    invocationId: string;
+    name: string;
+    mimeType: string;
+    size: number;
+    sha256: string;
+    path: string;
+}
+export interface EndpointUploadGrant {
+    path: string;
+    token: string;
+    maxBytes: number;
+    maxFiles: number;
+    expiresAt: number;
+}
+export declare class EndpointUploadError extends Error {
+}
+export declare class EndpointUploadService {
+    private readonly rootDir;
+    private readonly grants;
+    private readonly files;
+    constructor(rootDir: string);
+    createGrant(invocationId: string, endpointId: string, now?: number): EndpointUploadGrant;
+    upload(params: {
+        invocationId: string;
+        endpointId: string;
+        token: string;
+        name: string;
+        mimeType: string;
+        bytes: Uint8Array;
+        now?: number;
+    }): EndpointUploadedFile;
+    validateAndClose(invocationId: string, content: EndpointToolContent[]): void;
+    abort(invocationId: string): void;
+    getFile(fileId: string): EndpointUploadedFile | undefined;
+    readFile(fileId: string): Uint8Array | undefined;
+    private deleteFile;
+}

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

@@ -0,0 +1,103 @@
+import { ENDPOINT_MAX_FILE_BYTES } from "../../packages/endpoint-tools-protocol/src/index.js";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import crypto from "node:crypto";
+//#region src/endpoint-tools/upload-service.ts
+const GRANT_TTL_MS = 5 * 6e4;
+const ENDPOINT_UPLOAD_MAX_BYTES = ENDPOINT_MAX_FILE_BYTES;
+const DEFAULT_MAX_FILES = 8;
+var EndpointUploadError = class extends Error {};
+var EndpointUploadService = class {
+	grants = /* @__PURE__ */ new Map();
+	files = /* @__PURE__ */ new Map();
+	constructor(rootDir) {
+		this.rootDir = rootDir;
+		mkdirSync(rootDir, {
+			recursive: true,
+			mode: 448
+		});
+	}
+	createGrant(invocationId, endpointId, now = Date.now()) {
+		const token = crypto.randomUUID();
+		const grant = {
+			invocationId,
+			endpointId,
+			token,
+			expiresAt: now + GRANT_TTL_MS,
+			maxBytes: ENDPOINT_UPLOAD_MAX_BYTES,
+			maxFiles: DEFAULT_MAX_FILES,
+			uploadedFileIds: []
+		};
+		this.grants.set(invocationId, grant);
+		return {
+			path: `/api/endpoint-tools/invocations/${encodeURIComponent(invocationId)}/files`,
+			token,
+			maxBytes: grant.maxBytes,
+			maxFiles: grant.maxFiles,
+			expiresAt: grant.expiresAt
+		};
+	}
+	upload(params) {
+		const grant = this.grants.get(params.invocationId);
+		const now = params.now ?? Date.now();
+		const expectedToken = grant ? Buffer.from(grant.token) : void 0;
+		const receivedToken = Buffer.from(params.token);
+		if (!grant || grant.endpointId !== params.endpointId || expectedToken?.byteLength !== receivedToken.byteLength || !crypto.timingSafeEqual(expectedToken, receivedToken)) throw new EndpointUploadError("Upload grant is invalid");
+		if (grant.expiresAt <= now) throw new EndpointUploadError("Upload grant expired");
+		if (grant.uploadedFileIds.length >= grant.maxFiles) throw new EndpointUploadError("Upload grant file limit exceeded");
+		if (params.bytes.byteLength > grant.maxBytes) throw new EndpointUploadError("Uploaded file is too large");
+		if (!params.name || params.name.length > 255 || !params.mimeType || params.mimeType.length > 255) throw new EndpointUploadError("Uploaded file metadata is invalid");
+		const fileId = crypto.randomUUID();
+		const path = join(this.rootDir, fileId);
+		const sha256 = crypto.createHash("sha256").update(params.bytes).digest("hex");
+		writeFileSync(path, params.bytes, {
+			flag: "wx",
+			mode: 384
+		});
+		const file = {
+			fileId,
+			invocationId: params.invocationId,
+			name: params.name,
+			mimeType: params.mimeType,
+			size: params.bytes.byteLength,
+			sha256,
+			path
+		};
+		this.files.set(fileId, file);
+		grant.uploadedFileIds.push(fileId);
+		return file;
+	}
+	validateAndClose(invocationId, content) {
+		const grant = this.grants.get(invocationId);
+		const referenced = content.filter((item) => item.type === "file");
+		for (const item of referenced) {
+			const file = this.files.get(item.fileId);
+			if (!file || file.invocationId !== invocationId || file.name !== item.name || file.mimeType !== item.mimeType || file.size !== item.size || file.sha256 !== item.sha256) throw new EndpointUploadError(`Endpoint file is not valid for invocation: ${item.fileId}`);
+		}
+		if (grant) {
+			for (const fileId of grant.uploadedFileIds) if (!referenced.some((item) => item.fileId === fileId)) this.deleteFile(fileId);
+			this.grants.delete(invocationId);
+		} else if (referenced.length > 0) throw new EndpointUploadError("Invocation did not have an upload grant");
+	}
+	abort(invocationId) {
+		const grant = this.grants.get(invocationId);
+		if (!grant) return;
+		for (const fileId of grant.uploadedFileIds) this.deleteFile(fileId);
+		this.grants.delete(invocationId);
+	}
+	getFile(fileId) {
+		return this.files.get(fileId);
+	}
+	readFile(fileId) {
+		const file = this.files.get(fileId);
+		return file ? readFileSync(file.path) : void 0;
+	}
+	deleteFile(fileId) {
+		const file = this.files.get(fileId);
+		if (!file) return;
+		rmSync(file.path, { force: true });
+		this.files.delete(fileId);
+	}
+};
+//#endregion
+export { ENDPOINT_UPLOAD_MAX_BYTES, EndpointUploadError, EndpointUploadService };

package/dist/src/extensions/types/hooks.d.ts

@@ -246,7 +246,7 @@ export interface WebchatTurnCompleteEvent extends HookContext {
     inboundUserText: string;
     /** Last assistant visible text after persistence (may be empty). */
     assistantPlainText: string;
-    /** User aborted the HTTP/SSE run. */
+    /** User aborted the realtime run. */
     aborted: boolean;
     /** Set when the direct stream threw before normal completion. */
     streamError?: string;

package/dist/src/extensions/update.js

@@ -4,8 +4,8 @@ import { init_paths, resolveBundledExtensionsDir, resolveExtensionsDir } from ".
 import { init_loader, loadConfig } from "../config/loader.js";
 import { downloadExtensionStoreZipBuffer, resolveExtensionZipDownloadUrl, resolveExtensionsStoreBaseUrl, verifyStoreArtifactSha256 } from "../agent/skills/marketplace/adapters/store/store-api-client.js";
 import { getExtensionLockfileManager } from "./lockfile.js";
-import { findExtension } from "./marketplace.js";
 import { installExtensionFromStoreZip, installFromNpm } from "./install.js";
+import { findExtension } from "./marketplace.js";
 import { join } from "node:path";
 import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import semver from "semver";

package/dist/src/gateway/chat-stream/protocol.d.ts

@@ -24,7 +24,6 @@ export type PetFeedback = {
 };
 export interface ChatStreamEnvelope<TType extends string, TPayload> {
     type: TType;
-    seq?: number;
     runId: string;
     sessionKey: string;
     timestamp: number;

package/dist/src/gateway/clarify-bridge.d.ts

@@ -1,4 +1,6 @@
-import type { AgentRunRelay, RelayEvent } from './agent-run-relay.js';
+export type ClarifyStreamEvent = {
+    type: string;
+} & Record<string, unknown>;
 /** User inactivity window before pending clarification is rejected (web/Telegram, etc.). */
 export declare const CLARIFY_USER_RESPONSE_TIMEOUT_MS: number;
 export interface ClarifyBridgeRequest {
@@ -8,10 +10,9 @@ export interface ClarifyBridgeRequest {
 }
 export interface StartClarifyRequestOptions {
     sessionKey: string;
-    /** Present for in-flight webchat runs (SSE + relay). */
+    /** Present for in-flight webchat runs. */
     runId?: string;
-    relay: AgentRunRelay;
-    publishSse?: (event: RelayEvent) => void;
+    publishStream?: (event: ClarifyStreamEvent) => void;
     request: ClarifyBridgeRequest;
     /** e.g. Telegram inline keyboard + prompt message */
     deliver?: (ctx: {

package/dist/src/gateway/clarify-bridge.js

@@ -14,7 +14,7 @@ var ClarifyBridge = class {
 	/** sessionKey → requestId when waiting for a free-text reply (no multiple-choice). */
 	pendingFreeTextBySession = /* @__PURE__ */ new Map();
 	startRequest(opts) {
-		const { sessionKey, runId, relay, publishSse, request, deliver } = opts;
+		const { sessionKey, runId, publishStream, request, deliver } = opts;
 		const requestId = crypto.randomUUID();
 		const hasChoices = Array.isArray(request.choices) && request.choices.length >= 2;
 		const needsFreeText = !hasChoices;
@@ -44,14 +44,13 @@ var ClarifyBridge = class {
 				default: request.default,
 				petFeedback: createPetFeedback("clarify")
 			};
-			if (runId) relay.publish(runId, payload);
 			try {
-				publishSse?.(payload);
+				if (runId) publishStream?.(payload);
 			} catch (err) {
 				log.warn({
 					err,
 					requestId
-				}, "clarify SSE publish failed");
+				}, "Clarify stream publication failed");
 			}
 			if (deliver) deliver({
 				sessionKey,

package/dist/src/gateway/heartbeat/service.js

@@ -138,7 +138,10 @@ var HeartbeatService = class {
 		}
 		let reply;
 		try {
-			reply = await this.deps.agentService.turnDispatcher.processDirect(prompt, sessionKey);
+			reply = await this.deps.agentService.turnDispatcher.processDirect(prompt, sessionKey, {
+				type: "system",
+				source: "heartbeat"
+			});
 		} catch (error) {
 			log.error({ err: error }, "Heartbeat: agent call failed");
 			return;

package/dist/src/gateway/hono/app.js

@@ -223,11 +223,7 @@ function createHonoApp(config) {
 			trustedProxies: service.currentConfig.gateway?.trustedProxies,
 			allowRealIpFallback: service.currentConfig.gateway?.allowRealIpFallback === true
 		}) }),
-		channelRateLimitMiddleware,
-		sseConfig: {
-			service,
-			maxSseConnections: service.currentConfig.gateway.maxSseConnections
-		}
+		channelRateLimitMiddleware
 	});
 	const prewarm = prewarmStaticUiCache();
 	if (prewarm.loaded > 0) log.debug({

package/dist/src/gateway/hono/index.d.ts

@@ -1,2 +1 @@
 export { createHonoApp, type HonoAppConfig } from './app.js';
-export { createAgentResumeHandler, createSendHandler, createEventsSSEHandler, type SSEHandlerConfig } from './sse.js';

package/dist/src/gateway/hono/index.js

@@ -1,3 +1,2 @@
-import { createAgentResumeHandler, createEventsSSEHandler, createSendHandler } from "./sse.js";
 import { createHonoApp } from "./app.js";
-export { createAgentResumeHandler, createEventsSSEHandler, createHonoApp, createSendHandler };
+export { createHonoApp };

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -209,7 +209,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
     /** Masked `cfg.providers` for capability keys (image / STT / etc.). */
     providersConfig: Record<string, import("./safe-providers-config.js").SafeProviderAuthEntry>;
     gateway: {
-        bind: "auto" | "custom" | "loopback" | "lan" | "tailnet";
+        bind: "custom" | "auto" | "loopback" | "lan" | "tailnet";
         customBindHost: string;
         port: number;
         corsOrigins: string[];
@@ -255,7 +255,6 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
         webchat: {
             activityDetailDefault: "stream" | "on" | "off";
         };
-        maxSseConnections: number;
         channelConnectDeferMode: "explicit" | "off" | "auto";
         channelConnectDeferIds: string[];
         channelConnectDeferSkipIds: string[];

package/dist/src/gateway/hono/lib/config-payload.js

@@ -166,7 +166,6 @@ async function buildSafeWebConfigPayload(service, options = {}) {
 				activeHours: config.gateway?.heartbeat?.activeHours
 			},
 			webchat: { activityDetailDefault: config.gateway?.webchat?.activityDetailDefault ?? "on" },
-			maxSseConnections: typeof config.gateway?.maxSseConnections === "number" ? config.gateway.maxSseConnections : 100,
 			channelConnectDeferMode: config.gateway?.channelConnectDeferMode ?? "auto",
 			channelConnectDeferIds: Array.isArray(config.gateway?.channelConnectDeferIds) ? config.gateway.channelConnectDeferIds : [],
 			channelConnectDeferSkipIds: Array.isArray(config.gateway?.channelConnectDeferSkipIds) ? config.gateway.channelConnectDeferSkipIds : [],

package/dist/src/gateway/hono/middleware/auth.js

@@ -29,18 +29,16 @@ function extractTokenFromHeader(authHeader) {
 }
 /**
 * SECURITY: query-string tokens leak into server logs, Referer headers, and
-* browser history. We accept them only where the `Authorization` header cannot
-* be set — SSE/WebSocket (`EventSource`) and `<img>` subresource loads for agent
-* avatars. Note media uses Bearer-authenticated blob fetch in the gateway console.
+* browser history. We accept them only for agent avatar `<img>` loads, where an
+* Authorization header cannot be set. Realtime WebSocket authentication uses a
+* one-time ticket acquired over authenticated HTTP.
 */
 function extractTokenFromQuery(url) {
 	return new URL(url).searchParams.get("token");
 }
-const QUERY_TOKEN_ALLOWED_PATHS = new Set(["/api/events", "/api/ws"]);
 const AGENT_AVATAR_GET_PATH = /^\/api\/agents\/[^/]+\/avatar$/;
 /** Exported for gateway security tests. */
 function isQueryTokenAllowedPath(path, method) {
-	if (QUERY_TOKEN_ALLOWED_PATHS.has(path) || path.startsWith("/api/events")) return true;
 	if (method === "GET" && AGENT_AVATAR_GET_PATH.test(path)) return true;
 	return false;
 }