@xopcai/xopc 0.0.196 → 0.0.197

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

@@ -0,0 +1,198 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { evictEmbeddedSessionRunner } from "../../agent/embedded/session-runner.js";
+import { InMemoryTranscriptRuntime } from "../../agent/embedded/transcript-runtime.js";
+import { createSideChatContextSnapshot, formatSideChatSelections, validateSideChatSelections } from "./context-snapshot.js";
+import { randomUUID } from "node:crypto";
+//#region src/gateway/side-chat/manager.ts
+init_logger();
+const DEFAULT_IDLE_TTL_MS = 1800 * 1e3;
+const DEFAULT_MAX_PER_CLIENT = 5;
+const DEFAULT_MAX_TOTAL = 50;
+const log = createLogger("Gateway:SideChat");
+var SideChatError = class extends Error {
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+	}
+};
+var EphemeralSideChatManager = class {
+	entries = /* @__PURE__ */ new Map();
+	now;
+	idleTtlMs;
+	maxPerClient;
+	maxTotal;
+	sweepTimer;
+	constructor(options) {
+		this.options = options;
+		this.now = options.now ?? Date.now;
+		this.idleTtlMs = options.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
+		this.maxPerClient = options.maxPerClient ?? DEFAULT_MAX_PER_CLIENT;
+		this.maxTotal = options.maxTotal ?? DEFAULT_MAX_TOTAL;
+		this.sweepTimer = options.startSweepTimer === false ? null : setInterval(() => {
+			this.sweepExpired().catch((err) => {
+				log.warn({
+					err,
+					phase: "side_chat_sweep"
+				}, "Side chat expiry sweep failed");
+			});
+		}, Math.min(this.idleTtlMs, 6e4));
+		this.sweepTimer?.unref();
+	}
+	async create(input) {
+		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");
+		const metadata = await this.options.getParentMetadata(parentSessionKey);
+		if (!metadata || !metadata.sessionId) throw new SideChatError("Parent session not found", "NOT_FOUND");
+		const parentMessages = await this.options.loadParentMessages(parentSessionKey);
+		let selections;
+		try {
+			selections = validateSideChatSelections(input.selections);
+		} catch (error) {
+			throw new SideChatError(error instanceof Error ? error.message : "Invalid selections", "INVALID_REQUEST");
+		}
+		const now = this.now();
+		const createdAt = new Date(now).toISOString();
+		const id = randomUUID();
+		const runtime = new InMemoryTranscriptRuntime({
+			runtimeId: `${parentSessionKey}:side-chat:${id}`,
+			cwd: this.options.getWorkspacePath(metadata),
+			initialMessages: structuredClone(parentMessages)
+		});
+		const selectionContext = formatSideChatSelections(selections);
+		if (selectionContext) runtime.openSessionManager(this.options.getWorkspacePath(metadata)).appendCustomMessageEntry("side-chat-selection", selectionContext, false);
+		runtime.captureBaseline();
+		const config = {
+			modelRef: normalizeOptionalString(input.config?.modelRef) || this.options.getDefaultModelRef(parentSessionKey),
+			thinkingLevel: input.config?.thinkingLevel
+		};
+		const entry = {
+			id,
+			parentSessionKey,
+			clientInstanceId,
+			status: "idle",
+			createdAt,
+			lastActiveAt: createdAt,
+			expiresAt: new Date(now + this.idleTtlMs).toISOString(),
+			messageCount: 0,
+			context: createSideChatContextSnapshot({
+				parentSessionKey,
+				parentSessionId: metadata.sessionId,
+				parentMessages,
+				selections,
+				createdAt
+			}),
+			config,
+			runtime
+		};
+		this.entries.set(id, entry);
+		return toView(entry);
+	}
+	get(id, clientInstanceId) {
+		return toView(this.requireEntry(id, clientInstanceId));
+	}
+	getRuntime(id, clientInstanceId) {
+		return this.requireEntry(id, clientInstanceId).runtime;
+	}
+	getMessages(id, clientInstanceId) {
+		const entry = this.requireEntry(id, clientInstanceId);
+		const messages = entry.runtime.loadConversationMessages();
+		entry.messageCount = messages.length;
+		return structuredClone(messages);
+	}
+	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");
+		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);
+	}
+	heartbeat(id, clientInstanceId) {
+		const entry = this.requireEntry(id, clientInstanceId);
+		this.touchEntry(entry);
+		return toView(entry);
+	}
+	setStatus(id, clientInstanceId, status) {
+		const entry = this.requireEntry(id, clientInstanceId);
+		entry.status = status;
+		this.touchEntry(entry);
+		return toView(entry);
+	}
+	async dispose(id, clientInstanceId) {
+		const entry = this.entries.get(id);
+		if (!entry || 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;
+	}
+	async disposeClient(clientInstanceId) {
+		const ids = [...this.entries.values()].filter((entry) => entry.clientInstanceId === clientInstanceId).map((entry) => entry.id);
+		await Promise.all(ids.map((id) => this.dispose(id, clientInstanceId)));
+		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)));
+		return expired.length;
+	}
+	async disposeAll() {
+		if (this.sweepTimer) clearInterval(this.sweepTimer);
+		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")));
+	}
+	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;
+	}
+	touchEntry(entry) {
+		const now = this.now();
+		entry.lastActiveAt = new Date(now).toISOString();
+		entry.expiresAt = new Date(now + this.idleTtlMs).toISOString();
+	}
+	async runBeforeDispose(id, clientInstanceId) {
+		try {
+			await this.options.onBeforeDispose?.(id, clientInstanceId);
+		} catch (err) {
+			log.warn({
+				err,
+				sideChatId: id,
+				phase: "side_chat_abort"
+			}, "Side chat run cleanup failed");
+		}
+	}
+};
+function toView(entry) {
+	const { runtime: _runtime, ...view } = entry;
+	return structuredClone(view);
+}
+function normalizeOptionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function parseThinkingLevel(value) {
+	if (value === void 0 || value === null || value === "") return void 0;
+	if (typeof value !== "string" || !new Set([
+		"off",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	]).has(value)) throw new SideChatError("Invalid thinkingLevel", "INVALID_REQUEST");
+	return value;
+}
+//#endregion
+export { EphemeralSideChatManager, SideChatError, parseThinkingLevel };

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

@@ -0,0 +1,22 @@
+import type { AgentService } from '../../agent/service.js';
+import type { GatewayAgentRunner } from '../service/agent-runner.js';
+import { type EphemeralSideChatManager } from './manager.js';
+export interface SideChatRunServiceOptions {
+    manager: EphemeralSideChatManager;
+    getAgentService: () => AgentService;
+    agentRunner: GatewayAgentRunner;
+    publishRealtime: (topic: string, event: string, data: unknown) => void;
+    completeRealtimeTopic: (topic: string) => void;
+}
+export declare class SideChatRunService {
+    private readonly options;
+    private readonly activeBySideChat;
+    constructor(options: SideChatRunServiceOptions);
+    submit(sideChatId: string, clientInstanceId: string, content: string): {
+        runId: string;
+    };
+    abort(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

@@ -0,0 +1,110 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { abortEmbeddedRun } from "../../agent/embedded/runs.js";
+import { SideChatError } from "./manager.js";
+import { ChatStreamMapper } from "../chat-stream/mapper.js";
+import { randomUUID } from "node:crypto";
+//#region src/gateway/side-chat/run-service.ts
+init_logger();
+const log = createLogger("Gateway:SideChatRun");
+var SideChatRunService = class {
+	activeBySideChat = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	submit(sideChatId, clientInstanceId, content) {
+		const text = content.trim();
+		if (!text) throw new SideChatError("content is required", "INVALID_REQUEST");
+		const sideChat = this.options.manager.get(sideChatId, clientInstanceId);
+		if (this.activeBySideChat.has(sideChatId)) throw new SideChatError("A side chat run is already active", "CONFLICT");
+		const run = {
+			sideChatId,
+			clientInstanceId,
+			executionSessionKey: this.options.manager.getRuntime(sideChatId, clientInstanceId).runtimeId,
+			runId: randomUUID(),
+			abortController: new AbortController()
+		};
+		this.activeBySideChat.set(sideChatId, run);
+		this.options.manager.setStatus(sideChatId, clientInstanceId, "running");
+		this.execute(run, text, sideChat.config).catch((err) => {
+			log.error({
+				err,
+				sideChatId,
+				runId: run.runId
+			}, "Side chat run cleanup failed");
+		});
+		return { runId: run.runId };
+	}
+	async abort(sideChatId, clientInstanceId, runId) {
+		this.options.manager.get(sideChatId, clientInstanceId);
+		const active = this.activeBySideChat.get(sideChatId);
+		if (!active || runId && active.runId !== runId) return false;
+		this.options.agentRunner.cancelClarificationForRun(active.runId);
+		active.abortController.abort();
+		await abortEmbeddedRun(active.executionSessionKey).catch(() => false);
+		return true;
+	}
+	async dispose(sideChatId, clientInstanceId) {
+		await this.abort(sideChatId, clientInstanceId).catch(() => false);
+		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);
+	}
+	async execute(run, content, config) {
+		const topic = `run:${run.runId}`;
+		const mapper = new ChatStreamMapper({
+			runId: run.runId,
+			sessionKey: run.sideChatId,
+			channel: "side-chat"
+		});
+		const publish = (event) => {
+			this.options.publishRealtime(topic, event.type, event);
+		};
+		const publishMapped = (event) => {
+			for (const mapped of mapper.map(event)) publish(mapped);
+		};
+		try {
+			for (const event of mapper.start()) publish(event);
+			publishMapped({
+				type: "user_message",
+				message: {
+					role: "user",
+					content,
+					timestamp: Date.now()
+				}
+			});
+			this.options.agentRunner.registerExternalWebchatRun(run.executionSessionKey, run.runId, (event) => publishMapped(event));
+			const result = await this.options.getAgentService().runEphemeralTurn({
+				executionSessionKey: run.executionSessionKey,
+				parentSessionKey: this.options.manager.get(run.sideChatId, run.clientInstanceId).parentSessionKey,
+				runId: run.runId,
+				content,
+				modelRef: config.modelRef,
+				thinkingLevel: config.thinkingLevel,
+				transcriptRuntime: this.options.manager.getRuntime(run.sideChatId, run.clientInstanceId),
+				abortSignal: run.abortController.signal,
+				onEvent: publishMapped
+			});
+			const cancelled = run.abortController.signal.aborted;
+			const status = cancelled ? "cancelled" : result.ok ? "success" : "error";
+			if (!result.ok && result.errorMessage) for (const event of mapper.error(result.errorMessage)) publish(event);
+			for (const event of mapper.end(status, cancelled ? "Interrupted" : result.errorMessage)) publish(event);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			for (const event of mapper.error(message)) publish(event);
+			for (const event of mapper.end("error", message)) publish(event);
+		} finally {
+			this.options.agentRunner.unregisterExternalWebchatRun(run.executionSessionKey, run.runId);
+			this.activeBySideChat.delete(run.sideChatId);
+			try {
+				this.options.manager.getMessages(run.sideChatId, run.clientInstanceId);
+				this.options.manager.setStatus(run.sideChatId, run.clientInstanceId, "idle");
+			} catch {}
+			this.options.completeRealtimeTopic(topic);
+		}
+	}
+};
+//#endregion
+export { SideChatRunService };

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

@@ -0,0 +1,61 @@
+import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
+export type SideChatStatus = 'idle' | 'running' | 'waiting-approval' | 'waiting-input' | 'closing';
+export type SideChatSelection = {
+    id: string;
+    type: 'message';
+    messageId: string;
+    role: string;
+    content: string;
+    label?: string;
+} | {
+    id: string;
+    type: 'text';
+    text: string;
+    sourceMessageId?: string;
+    label?: string;
+} | {
+    id: string;
+    type: 'file-range';
+    path: string;
+    startLine: number;
+    endLine: number;
+    text: string;
+    contentHash?: string;
+    label?: string;
+} | {
+    id: string;
+    type: 'diff';
+    diff: string;
+    path?: string;
+    label?: string;
+};
+export interface SideChatContextSnapshot {
+    parentSessionKey: string;
+    parentSessionId: string;
+    parentMessageCount: number;
+    createdAt: string;
+    selections: SideChatSelection[];
+    contentHash: string;
+}
+export interface SideChatConfig {
+    modelRef: string;
+    thinkingLevel?: ThinkingLevel;
+}
+export interface SideChatView {
+    id: string;
+    parentSessionKey: string;
+    clientInstanceId: string;
+    status: SideChatStatus;
+    createdAt: string;
+    lastActiveAt: string;
+    expiresAt: string;
+    messageCount: number;
+    context: SideChatContextSnapshot;
+    config: SideChatConfig;
+}
+export interface CreateSideChatInput {
+    parentSessionKey: string;
+    clientInstanceId: string;
+    selections?: SideChatSelection[];
+    config?: Partial<SideChatConfig>;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/src/routing/session-key-utils.d.ts

@@ -14,7 +14,6 @@ export type RawSessionConversationRef = {
 };
 /** Parse `agent:{agentId}:{rest}` session keys (OpenClaw canonical form). */
 export declare function parseAgentSessionKey(sessionKey: string | undefined | null): ParsedAgentSessionKey | null;
-export declare function isCronRunSessionKey(sessionKey: string | undefined | null): boolean;
 export declare function isCronSessionKey(sessionKey: string | undefined | null): boolean;
 export declare function isSubagentSessionKey(sessionKey: string | undefined | null): boolean;
 export declare function getSubagentDepth(sessionKey: string | undefined | null): number;

package/dist/src/routing/session-key-utils.js

@@ -16,11 +16,6 @@ function parseAgentSessionKey(sessionKey) {
 		rest
 	};
 }
-function isCronRunSessionKey(sessionKey) {
-	const parsed = parseAgentSessionKey(sessionKey);
-	if (!parsed) return false;
-	return /^cron:[^:]+:run:[^:]+$/.test(parsed.rest);
-}
 function isCronSessionKey(sessionKey) {
 	const parsed = parseAgentSessionKey(sessionKey);
 	if (!parsed) return false;
@@ -87,4 +82,4 @@ var init_session_key_utils = __esmMin((() => {
 }));
 //#endregion
 init_session_key_utils();
-export { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronRunSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey };
+export { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey };

package/dist/src/routing/session-key.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId, normalizeOptionalAccountId } from "./account-id.js";
-import { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronRunSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey } from "./session-key-utils.js";
+import { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey } from "./session-key-utils.js";
 import { DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentSessionKey, buildAgentMainSessionKey, buildAgentPeerSessionKey, buildGroupHistoryKey, classifySessionKeyShape, defaultMainSessionKey, init_agent_session_key, isValidAgentId, normalizeAgentId, normalizeMainKey, normalizeSessionKey, resolveAgentIdFromSessionKey, resolveThreadSessionKeys, sanitizeAgentId, scopedHeartbeatWakeOptions, toAgentRequestSessionKey, toAgentStoreSessionKey } from "./agent-session-key.js";
 //#region src/routing/session-key.ts
 function sanitizeSegment(value, options) {
@@ -188,4 +188,4 @@ var init_session_key = __esmMin((() => {
 }));
 //#endregion
 init_session_key();
-export { DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentSessionKey, buildAgentMainSessionKey, buildAgentPeerSessionKey, buildGroupHistoryKey, buildSessionKey, buildSubagentSessionKey, classifySessionKeyShape, defaultMainSessionKey, getParentSessionKey, getSubagentDepth, init_session_key, isAcpSessionKey, isCronRunSessionKey, isCronSessionKey, isSubagentSessionKey, isValidAgentId, isValidSegment, normalizeAccountId, normalizeAgentId, normalizeMainKey, normalizeOptionalAccountId, normalizeSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseSessionKey, parseThreadSessionSuffix, resolveAgentIdFromSessionKey, resolveThreadParentSessionKey, resolveThreadSessionKeys, sanitizeAgentId, sanitizeSegment, scopedHeartbeatWakeOptions, toAgentRequestSessionKey, toAgentStoreSessionKey };
+export { DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentSessionKey, buildAgentMainSessionKey, buildAgentPeerSessionKey, buildGroupHistoryKey, buildSessionKey, buildSubagentSessionKey, classifySessionKeyShape, defaultMainSessionKey, getParentSessionKey, getSubagentDepth, init_session_key, isAcpSessionKey, isCronSessionKey, isSubagentSessionKey, isValidAgentId, isValidSegment, normalizeAccountId, normalizeAgentId, normalizeMainKey, normalizeOptionalAccountId, normalizeSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseSessionKey, parseThreadSessionSuffix, resolveAgentIdFromSessionKey, resolveThreadParentSessionKey, resolveThreadSessionKeys, sanitizeAgentId, sanitizeSegment, scopedHeartbeatWakeOptions, toAgentRequestSessionKey, toAgentStoreSessionKey };

package/dist/src/tasks/home-query-service.d.ts

@@ -6,12 +6,25 @@ import type { NotesService } from '../notes/service.js';
 import type { ProactiveInboxService } from '../proactive/inbox/service.js';
 import type { ProjectService } from '../projects/project-service.js';
 import type { SessionIndex } from '../session/manager.js';
+import type { WorkflowRunSummary } from '../workflows/domain/index.js';
 import type { WorkflowRunService } from '../workflows/service/workflow-run-service.js';
 import { type TaskReadModel } from './task-read-model-projector.js';
 type HomeDecision = HomeResponse['decisions'][number];
 type HomeAttention = HomeResponse['attention'][number];
 type HomeBriefingWin = HomeResponse['briefing']['wins'][number];
 type HomeAutomation = HomeResponse['upcomingAutomations'][number];
+type HomeFocusItem = HomeResponse['focusItems'][number];
+type HomeWorkflowRun = {
+    id: string;
+    definitionId: string;
+    title: string;
+    status: WorkflowRunSummary['status'];
+    sessionKey?: string;
+    createdAtMs: number;
+    startedAtMs?: number;
+    completedAtMs?: number;
+    metrics: WorkflowRunSummary['metrics'];
+};
 type HomeAutomationRun = {
     id: string;
     automationId: string;
@@ -126,6 +139,17 @@ export declare function buildHomeBriefing(input: {
         name?: string;
     };
 };
+export declare function buildHomeFocusItems(input: {
+    locale?: string;
+    decisions: HomeDecision[];
+    attention: HomeAttention[];
+    activeWorkflowRuns: HomeWorkflowRun[];
+    runningTasks: HomeResponse['tasks']['running'];
+    wins: HomeBriefingWin[];
+    nextScheduled?: HomeAutomation;
+    inboxCount: number;
+    nowMs: number;
+}): HomeFocusItem[];
 export declare class HomeQueryService {
     #private;
     private readonly service;