@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/gateway/side-chat/manager.js

@@ -9,15 +9,21 @@ init_logger();
 const DEFAULT_IDLE_TTL_MS = 1800 * 1e3;
 const DEFAULT_MAX_PER_CLIENT = 5;
 const DEFAULT_MAX_TOTAL = 50;
+const MAX_EXPIRED_RECORDS = 500;
 const log = createLogger("Gateway:SideChat");
 var SideChatError = class extends Error {
-	constructor(message, code) {
+	constructor(message, code, reason) {
 		super(message);
 		this.code = code;
+		this.reason = reason;
 	}
 };
 var EphemeralSideChatManager = class {
 	entries = /* @__PURE__ */ new Map();
+	reservations = /* @__PURE__ */ new Map();
+	expired = /* @__PURE__ */ new Map();
+	disposals = /* @__PURE__ */ new Map();
+	stopped = false;
 	now;
 	idleTtlMs;
 	maxPerClient;
@@ -43,11 +49,28 @@ var EphemeralSideChatManager = class {
 		const parentSessionKey = input.parentSessionKey.trim();
 		const clientInstanceId = input.clientInstanceId.trim();
 		if (!parentSessionKey || !clientInstanceId) throw new SideChatError("parentSessionKey and clientInstanceId are required", "INVALID_REQUEST");
-		if (this.entries.size >= this.maxTotal) throw new SideChatError("The side chat capacity has been reached", "LIMIT_REACHED");
-		if ([...this.entries.values()].filter((entry) => entry.clientInstanceId === clientInstanceId).length >= this.maxPerClient) throw new SideChatError(`A client can have at most ${this.maxPerClient} side chats`, "LIMIT_REACHED");
+		await this.sweepExpired();
+		if (this.stopped || this.entries.size + [...this.reservations.values()].reduce((a, b) => a + b, 0) >= this.maxTotal) throw new SideChatError("The side chat capacity has been reached", "CAPACITY_REACHED");
+		if ([...this.entries.values()].filter((entry) => entry.clientInstanceId === clientInstanceId).length + (this.reservations.get(clientInstanceId) ?? 0) >= this.maxPerClient) throw new SideChatError(`A client can have at most ${this.maxPerClient} side chats`, "LIMIT_REACHED");
+		this.reservations.set(clientInstanceId, (this.reservations.get(clientInstanceId) ?? 0) + 1);
+		try {
+			return await this.createEntry({
+				...input,
+				parentSessionKey,
+				clientInstanceId
+			});
+		} finally {
+			const remaining = (this.reservations.get(clientInstanceId) ?? 1) - 1;
+			if (remaining) this.reservations.set(clientInstanceId, remaining);
+			else this.reservations.delete(clientInstanceId);
+		}
+	}
+	async createEntry(input) {
+		const { parentSessionKey, clientInstanceId } = input;
 		const metadata = await this.options.getParentMetadata(parentSessionKey);
-		if (!metadata || !metadata.sessionId) throw new SideChatError("Parent session not found", "NOT_FOUND");
+		if (!metadata || !metadata.sessionId) throw new SideChatError("Parent session not found", "PARENT_NOT_FOUND");
 		const parentMessages = await this.options.loadParentMessages(parentSessionKey);
+		if (this.stopped) throw new SideChatError("Gateway is stopping", "CAPACITY_REACHED");
 		let selections;
 		try {
 			selections = validateSideChatSelections(input.selections);
@@ -76,6 +99,7 @@ var EphemeralSideChatManager = class {
 			status: "idle",
 			createdAt,
 			lastActiveAt: createdAt,
+			lastSeenAt: createdAt,
 			expiresAt: new Date(now + this.idleTtlMs).toISOString(),
 			messageCount: 0,
 			context: createSideChatContextSnapshot({
@@ -89,10 +113,10 @@ var EphemeralSideChatManager = class {
 			runtime
 		};
 		this.entries.set(id, entry);
-		return toView(entry);
+		return this.toView(entry);
 	}
 	get(id, clientInstanceId) {
-		return toView(this.requireEntry(id, clientInstanceId));
+		return this.toView(this.requireEntry(id, clientInstanceId));
 	}
 	getRuntime(id, clientInstanceId) {
 		return this.requireEntry(id, clientInstanceId).runtime;
@@ -105,35 +129,61 @@ var EphemeralSideChatManager = class {
 	}
 	updateConfig(id, clientInstanceId, patch) {
 		const entry = this.requireEntry(id, clientInstanceId);
-		if (entry.status === "running") throw new SideChatError("Cannot change config while a run is active", "CONFLICT");
+		if (entry.status !== "idle") throw new SideChatError("Cannot change config while a run is active", "CONFLICT");
 		const modelRef = patch.modelRef === void 0 ? entry.config.modelRef : normalizeOptionalString(patch.modelRef);
 		if (!modelRef) throw new SideChatError("modelRef cannot be empty", "INVALID_REQUEST");
 		entry.config = {
 			modelRef,
 			thinkingLevel: patch.thinkingLevel === void 0 ? entry.config.thinkingLevel : patch.thinkingLevel
 		};
-		this.touchEntry(entry);
-		return toView(entry);
+		return this.toView(entry);
 	}
 	heartbeat(id, clientInstanceId) {
+		const entry = this.requireEntry(id, clientInstanceId);
+		entry.lastSeenAt = new Date(this.now()).toISOString();
+		return this.toView(entry);
+	}
+	extend(id, clientInstanceId) {
 		const entry = this.requireEntry(id, clientInstanceId);
 		this.touchEntry(entry);
-		return toView(entry);
+		return this.toView(entry);
 	}
-	setStatus(id, clientInstanceId, status) {
+	setStatus(id, clientInstanceId, status, runId) {
 		const entry = this.requireEntry(id, clientInstanceId);
 		entry.status = status;
+		if (runId) entry.runId = runId;
+		if (status === "idle") entry.runId = void 0;
+		if (status === "idle" || status === "running") entry.clarification = void 0;
 		this.touchEntry(entry);
-		return toView(entry);
+		return this.toView(entry);
+	}
+	waitForInput(id, clientInstanceId, clarification, status = "waiting-input") {
+		this.setStatus(id, clientInstanceId, status);
+		this.requireEntry(id, clientInstanceId).clarification = clarification;
 	}
 	async dispose(id, clientInstanceId) {
 		const entry = this.entries.get(id);
-		if (!entry || entry.clientInstanceId !== clientInstanceId) return false;
+		if (!entry) {
+			const pending = this.disposals.get(id);
+			return pending?.clientInstanceId === clientInstanceId ? pending.promise : false;
+		}
+		if (entry.clientInstanceId !== clientInstanceId) return false;
 		entry.status = "closing";
-		await this.runBeforeDispose(id, clientInstanceId);
 		this.entries.delete(id);
-		await evictEmbeddedSessionRunner(entry.runtime.runtimeId, "side_chat_dispose");
-		return true;
+		const cleanup = (async () => {
+			try {
+				await this.runBeforeDispose(id, clientInstanceId);
+				await evictEmbeddedSessionRunner(entry.runtime.runtimeId, "side_chat_dispose");
+				return true;
+			} finally {
+				this.disposals.delete(id);
+			}
+		})();
+		this.disposals.set(id, {
+			clientInstanceId,
+			promise: cleanup
+		});
+		return cleanup;
 	}
 	async disposeClient(clientInstanceId) {
 		const ids = [...this.entries.values()].filter((entry) => entry.clientInstanceId === clientInstanceId).map((entry) => entry.id);
@@ -141,26 +191,69 @@ var EphemeralSideChatManager = class {
 		return ids.length;
 	}
 	async sweepExpired(at = this.now()) {
-		const expired = [...this.entries.values()].filter((entry) => Date.parse(entry.expiresAt) <= at);
-		await Promise.all(expired.map((entry) => this.dispose(entry.id, entry.clientInstanceId)));
+		this.pruneExpiredRecords(at);
+		const expired = [...this.entries.values()].filter((entry) => this.isExpired(entry, at));
+		await Promise.all(expired.map((entry) => this.expireEntry(entry)));
 		return expired.length;
 	}
 	async disposeAll() {
 		if (this.sweepTimer) clearInterval(this.sweepTimer);
+		this.stopped = true;
 		const entries = [...this.entries.values()];
-		await Promise.all(entries.map((entry) => this.runBeforeDispose(entry.id, entry.clientInstanceId)));
-		this.entries.clear();
-		await Promise.all(entries.map((entry) => evictEmbeddedSessionRunner(entry.runtime.runtimeId, "side_chat_shutdown")));
+		await Promise.all(entries.map((entry) => this.dispose(entry.id, entry.clientInstanceId)));
+		await Promise.all([...this.disposals.values()].map((entry) => entry.promise));
+		this.expired.clear();
 	}
 	requireEntry(id, clientInstanceId) {
 		const entry = this.entries.get(id);
-		if (!entry || entry.clientInstanceId !== clientInstanceId) throw new SideChatError("Side chat not found", "NOT_FOUND");
-		return entry;
+		if (entry && entry.clientInstanceId !== clientInstanceId) throw new SideChatError("Side chat not found", "NOT_FOUND");
+		if (entry && this.isExpired(entry, this.now())) this.expireEntry(entry).catch((err) => log.warn({
+			err,
+			sideChatId: id
+		}, "Side chat expiry cleanup failed"));
+		else if (entry) return entry;
+		this.pruneExpiredRecords(this.now());
+		const expired = this.expired.get(id);
+		if (expired?.clientInstanceId === clientInstanceId) throw new SideChatError("Side chat expired", "EXPIRED", expired.reason);
+		throw new SideChatError("Side chat not found", "NOT_FOUND");
+	}
+	isExpired(entry, at) {
+		return entry.status !== "running" && entry.expiresAt !== null && Date.parse(entry.expiresAt) <= at;
+	}
+	expireEntry(entry) {
+		const reason = entry.status.startsWith("waiting-") ? "waiting" : "idle";
+		this.expired.set(entry.id, {
+			clientInstanceId: entry.clientInstanceId,
+			reason,
+			removeAt: this.now() + DEFAULT_IDLE_TTL_MS
+		});
+		this.pruneExpiredRecords(this.now());
+		const cleanup = this.dispose(entry.id, entry.clientInstanceId);
+		try {
+			this.options.onExpired?.(entry.id, entry.clientInstanceId, reason);
+		} catch (err) {
+			log.warn({
+				err,
+				sideChatId: entry.id
+			}, "Side chat expiry notification failed");
+		}
+		return cleanup;
+	}
+	pruneExpiredRecords(at) {
+		for (const [id, entry] of this.expired) if (entry.removeAt <= at) this.expired.delete(id);
+		while (this.expired.size > MAX_EXPIRED_RECORDS) this.expired.delete(this.expired.keys().next().value);
+	}
+	toView(entry) {
+		const { runtime: _runtime, ...view } = entry;
+		return structuredClone({
+			...view,
+			serverNow: new Date(this.now()).toISOString()
+		});
 	}
 	touchEntry(entry) {
 		const now = this.now();
 		entry.lastActiveAt = new Date(now).toISOString();
-		entry.expiresAt = new Date(now + this.idleTtlMs).toISOString();
+		entry.expiresAt = entry.status === "running" ? null : new Date(now + this.idleTtlMs).toISOString();
 	}
 	async runBeforeDispose(id, clientInstanceId) {
 		try {
@@ -174,10 +267,6 @@ var EphemeralSideChatManager = class {
 		}
 	}
 };
-function toView(entry) {
-	const { runtime: _runtime, ...view } = entry;
-	return structuredClone(view);
-}
 function normalizeOptionalString(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }

package/dist/src/gateway/side-chat/run-service.d.ts

@@ -16,6 +16,8 @@ export declare class SideChatRunService {
         runId: string;
     };
     abort(sideChatId: string, clientInstanceId: string, runId?: string): Promise<boolean>;
+    /** Disposal has already removed the transcript from the public manager. */
+    cancelRun(sideChatId: string, clientInstanceId: string, runId?: string): Promise<boolean>;
     dispose(sideChatId: string, clientInstanceId: string): Promise<boolean>;
     submitClarification(sideChatId: string, clientInstanceId: string, requestId: string, answer: string): boolean;
     private execute;

package/dist/src/gateway/side-chat/run-service.js

@@ -25,7 +25,7 @@ var SideChatRunService = class {
 			abortController: new AbortController()
 		};
 		this.activeBySideChat.set(sideChatId, run);
-		this.options.manager.setStatus(sideChatId, clientInstanceId, "running");
+		this.options.manager.setStatus(sideChatId, clientInstanceId, "running", run.runId);
 		this.execute(run, text, sideChat.config).catch((err) => {
 			log.error({
 				err,
@@ -37,9 +37,14 @@ var SideChatRunService = class {
 	}
 	async abort(sideChatId, clientInstanceId, runId) {
 		this.options.manager.get(sideChatId, clientInstanceId);
+		return this.cancelRun(sideChatId, clientInstanceId, runId);
+	}
+	/** Disposal has already removed the transcript from the public manager. */
+	async cancelRun(sideChatId, clientInstanceId, runId) {
 		const active = this.activeBySideChat.get(sideChatId);
-		if (!active || runId && active.runId !== runId) return false;
+		if (!active || active.clientInstanceId !== clientInstanceId || runId && active.runId !== runId) return false;
 		this.options.agentRunner.cancelClarificationForRun(active.runId);
+		this.options.agentRunner.unregisterExternalWebchatRun(active.executionSessionKey, active.runId);
 		active.abortController.abort();
 		await abortEmbeddedRun(active.executionSessionKey).catch(() => false);
 		return true;
@@ -49,8 +54,10 @@ var SideChatRunService = class {
 		return this.options.manager.dispose(sideChatId, clientInstanceId);
 	}
 	submitClarification(sideChatId, clientInstanceId, requestId, answer) {
-		this.options.manager.get(sideChatId, clientInstanceId);
-		return this.options.agentRunner.submitClarifyResponse(requestId, answer);
+		if (this.options.manager.get(sideChatId, clientInstanceId).clarification?.requestId !== requestId) return false;
+		const handled = this.options.agentRunner.submitClarifyResponse(requestId, answer);
+		if (handled) this.options.manager.setStatus(sideChatId, clientInstanceId, "running");
+		return handled;
 	}
 	async execute(run, content, config) {
 		const topic = `run:${run.runId}`;
@@ -63,6 +70,12 @@ var SideChatRunService = class {
 			this.options.publishRealtime(topic, event.type, event);
 		};
 		const publishMapped = (event) => {
+			if (run.abortController.signal.aborted) return;
+			if (event.type === "clarify_request") this.options.manager.waitForInput(run.sideChatId, run.clientInstanceId, {
+				requestId: String(event.requestId),
+				question: String(event.question),
+				choices: Array.isArray(event.choices) ? event.choices.filter((choice) => typeof choice === "string") : void 0
+			}, event.kind === "approval" ? "waiting-approval" : "waiting-input");
 			for (const mapped of mapper.map(event)) publish(mapped);
 		};
 		try {
@@ -75,7 +88,17 @@ var SideChatRunService = class {
 					timestamp: Date.now()
 				}
 			});
-			this.options.agentRunner.registerExternalWebchatRun(run.executionSessionKey, run.runId, (event) => publishMapped(event));
+			this.options.agentRunner.registerExternalWebchatRun(run.executionSessionKey, run.runId, (event) => publishMapped(event), {
+				clarificationTimeoutMs: null,
+				beforeClarificationResponse: () => {
+					try {
+						this.options.manager.setStatus(run.sideChatId, run.clientInstanceId, "running");
+						return true;
+					} catch {
+						return false;
+					}
+				}
+			});
 			const result = await this.options.getAgentService().runEphemeralTurn({
 				executionSessionKey: run.executionSessionKey,
 				parentSessionKey: this.options.manager.get(run.sideChatId, run.clientInstanceId).parentSessionKey,

package/dist/src/gateway/side-chat/types.d.ts

@@ -48,7 +48,15 @@ export interface SideChatView {
     status: SideChatStatus;
     createdAt: string;
     lastActiveAt: string;
-    expiresAt: string;
+    lastSeenAt: string;
+    expiresAt: string | null;
+    serverNow?: string;
+    runId?: string;
+    clarification?: {
+        requestId: string;
+        question: string;
+        choices?: string[];
+    };
     messageCount: number;
     context: SideChatContextSnapshot;
     config: SideChatConfig;

package/dist/src/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

package/dist/src/knowledge/connected-knowledge-pipeline.d.ts

@@ -21,7 +21,5 @@ export declare class ConnectedKnowledgePipeline {
     private readonly batchSize;
     constructor(options: ConnectedKnowledgePipelineOptions);
     processPending(sourceInstanceId?: string): Promise<KnowledgeSynthesisBatchResult>;
-    /** Remove bounded raw items and every content-bearing memory derived only from them. */
     pruneBoundedRetention(sourceInstanceId: string, olderThanMs: number): ConnectedKnowledgePruneResult;
-    private rebuildDailySummary;
 }