@xopcai/xopc 0.0.188 → 0.0.190

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/agent-builtin-tools.d.ts

@@ -2,5 +2,5 @@
  * Built-in agent tool `name` values for gateway admin UI (disable toggles).
  * Extension tools are not listed; users can still add arbitrary strings in config.
  */
-export declare const GATEWAY_BUILTIN_TOOL_IDS: readonly ["code_search", "code_read_symbol", "code_trace", "code_impact", "code_architecture", "read_file", "write_file", "apply_patch", "list_dir", "grep", "find", "exec_command", "update_plan", "session_status", "dreaming", "tool_manual", "clarify", "todo", "skills_list", "skill_view", "skill_manage", "skills_marketplace_search", "skill_install", "web_search", "web_fetch", "web_extract", "send_message", "send_media", "read_media", "create_share", "text_to_speech", "memory_search", "memory_get", "session_search", "automation", "workflow", "delegate_task", "execute_code", "image", "image_generate", "create_desktop_pet", "browser_use", "xopc_tool_search", "xopc_tool_describe", "xopc_tool_execute"];
+export declare const GATEWAY_BUILTIN_TOOL_IDS: readonly ["read_file", "write_file", "apply_patch", "list_dir", "grep", "find", "exec_command", "update_plan", "session_status", "dreaming", "tool_manual", "clarify", "todo", "skills_list", "skill_view", "skill_manage", "skills_marketplace_search", "skill_install", "web_search", "web_fetch", "web_extract", "send_message", "send_media", "read_media", "create_share", "text_to_speech", "memory_search", "memory_get", "session_search", "automation", "workflow", "delegate_task", "execute_code", "image", "image_generate", "create_desktop_pet", "browser_use", "xopc_tool_search", "xopc_tool_describe", "xopc_tool_execute"];
 export type GatewayBuiltinToolId = (typeof GATEWAY_BUILTIN_TOOL_IDS)[number];

package/dist/src/gateway/agent-builtin-tools.js

@@ -6,11 +6,6 @@ import "../agent/external-tools/index.js";
 * Extension tools are not listed; users can still add arbitrary strings in config.
 */
 const GATEWAY_BUILTIN_TOOL_IDS = [
-	"code_search",
-	"code_read_symbol",
-	"code_trace",
-	"code_impact",
-	"code_architecture",
 	"read_file",
 	"write_file",
 	"apply_patch",

package/dist/src/gateway/agents-admin.d.ts

@@ -140,13 +140,6 @@ export declare function writeAgentProfileFile(cfg: Config, agentId: string, name
     agentId: string;
     path: string;
 }>>;
-export declare function readUserProfileFile(): Promise<AgentAdminResult<{
-    content: string;
-    path: string;
-}>>;
-export declare function writeUserProfileFile(content: string): Promise<AgentAdminResult<{
-    path: string;
-}>>;
 export declare function readAgentAvatarFile(cfg: Config, agentId: string): Promise<AgentAdminResult<{
     agentId: string;
     buffer: Buffer;

package/dist/src/gateway/agents-admin.js

@@ -1,14 +1,14 @@
 import { resolveCapabilityPresetLayer, resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
-import { WORKSPACE_FILES, init_paths, resolveUserProfilePath } from "../config/paths.js";
+import { WORKSPACE_FILES, init_paths } from "../config/paths.js";
 import { AGENT_PROFILE_MARKDOWN_SYSTEM_FILES, REQUIRED_AGENT_PROFILE_MARKDOWN_FILE_SET } from "../agent/context/workspace.js";
 import { isPathUnderWorkspace, resolveWorkspaceSafePath } from "./workspace-editor-path.js";
 import { seedAgentProfileMarkdownFiles } from "../agent/context/workspace-seed.js";
 import { applyAgentConfig, findAgentEntryIndex, getAgentDeleteBlocker, pruneAgentConfig, removeAgentDirsFromDisk } from "../commands/agents.config.js";
 import { resolveEffectiveTypedModels } from "../config/agent-typed-models.js";
 import { GATEWAY_BUILTIN_TOOL_IDS } from "./agent-builtin-tools.js";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { cp, mkdir, readFile, readdir, realpath, stat, unlink, writeFile } from "node:fs/promises";
 //#region src/gateway/agents-admin.ts
 /**
@@ -525,35 +525,6 @@ async function writeAgentProfileFile(cfg, agentId, name, content) {
 		}
 	};
 }
-async function readUserProfileFile() {
-	const path = resolveUserProfilePath();
-	try {
-		return {
-			ok: true,
-			data: {
-				content: await readFile(path, "utf-8"),
-				path
-			}
-		};
-	} catch {
-		return {
-			ok: true,
-			data: {
-				content: "",
-				path
-			}
-		};
-	}
-}
-async function writeUserProfileFile(content) {
-	const path = resolveUserProfilePath();
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content, "utf-8");
-	return {
-		ok: true,
-		data: { path }
-	};
-}
 const AGENT_AVATAR_MAX_BYTES = 512 * 1024;
 const AGENT_AVATAR_BASENAME = "agent-avatar";
 const AGENT_AVATAR_EXTENSIONS = [
@@ -701,4 +672,4 @@ async function deleteAgentAvatarFile(cfg, agentId) {
 	};
 }
 //#endregion
-export { deleteAgentAvatarFile, extractAvatarFromIdentityMarkdown, finalizeCreateAgentDirs, getGatewayAgentEffectiveManifest, listAgentProfileFiles, listGatewayAgents, parseIdentityMarkdown, prepareCreateAgent, prepareDeleteAgent, prepareUpdateAgent, readAgentAvatarFile, readAgentProfileFile, readUserProfileFile, runAfterDeletePurge, writeAgentAvatarFromBase64, writeAgentProfileFile, writeUserProfileFile };
+export { deleteAgentAvatarFile, extractAvatarFromIdentityMarkdown, finalizeCreateAgentDirs, getGatewayAgentEffectiveManifest, listAgentProfileFiles, listGatewayAgents, parseIdentityMarkdown, prepareCreateAgent, prepareDeleteAgent, prepareUpdateAgent, readAgentAvatarFile, readAgentProfileFile, runAfterDeletePurge, writeAgentAvatarFromBase64, writeAgentProfileFile };

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/dreaming-automation-reconciler.d.ts

@@ -1,9 +1,9 @@
 import type { Config } from '../config/schema.js';
 import type { AutomationService } from '../automations/index.js';
 export type DreamingAutomationReconcileResult = {
-    created: string[];
-    updated: string[];
-    disabled: string[];
+    created: boolean;
+    updated: boolean;
+    disabled: boolean;
 };
 export declare function reconcileDreamingAutomations(params: {
     config: Config;