@xopcai/xopc 0.0.247 → 0.0.249

package/dist/src/voice/realtime/memory-context.js

@@ -1,31 +1,26 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { onUserContextChange } from "../../user-context/changes.js";
-import { getUnderstanding, getUserProfile } from "../../storage/sqlite/user-context-repository.js";
 import { parseAgentSessionKey } from "../../routing/session-key-utils.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import { getSessionConfig } from "../../storage/sqlite/config-repository.js";
 import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
-import { getUserFocus } from "../../user-context/sources/repository.js";
-import { allowsAutomaticDisclosure, focusRejectionReason, rejectionReason } from "../../user-context/selection-policy.js";
+import { getKnowledgeItem } from "../../knowledge-memory/repository.js";
+import "../../knowledge-memory/index.js";
+import { getUserAssertion } from "../../user-model/repository.js";
+import "../../user-model/index.js";
+import { buildExecutionContext } from "../../agent/context/execution-context.js";
 import { stripRuntimeContextFromUserMessage } from "../../session/user-message-display.js";
-import { remoteContextEligibleIds } from "../../storage/sqlite/remote-context-repository.js";
-import { selectAutomaticContext } from "../../user-context/automatic-context.js";
 //#region src/voice/realtime/memory-context.ts
 init_session_key();
 init_logger();
 const log = createLogger("Voice:Memory");
-const policyVersion = (config) => JSON.stringify({
-	userContext: config.userContext,
-	agents: config.agents
-});
 function voiceMemoryEnabled(config, sessionKey) {
 	const parsed = parseSessionKey(sessionKey);
 	const rest = parseAgentSessionKey(sessionKey)?.rest;
 	const parts = rest?.split(":") ?? [];
 	const explicitlyPrivate = rest === "main" || parts.every(Boolean) && !["cron", "subagent"].includes(parts[0] ?? "") && (parts[0] === "direct" && parts.length >= 2 || parts[1] === "direct" && parts.length >= 3 || parts[2] === "direct" && parts.length >= 4);
 	const user = config.userContext;
-	if (!parsed || !explicitlyPrivate || parsed.peerKind !== "direct" || !user.enabled || !user.understanding.enabled || user.memory.mode === "off" || !user.memory.sources.includes("understanding")) return false;
+	if (!parsed || !explicitlyPrivate || parsed.peerKind !== "direct" || !user.enabled || !user.userModel.enabled || !user.contextPlanning.enabled) return false;
 	const mode = getSessionConfig(sessionKey)?.userContextMode;
 	return mode === void 0 || mode === "enabled";
 }
@@ -37,56 +32,49 @@ function voiceMemoryQuery(history) {
 function buildVoiceMemoryContext(input) {
 	const started = performance.now();
 	try {
-		if (!voiceMemoryEnabled(input.getConfig(), input.sessionKey) || input.maxChars < 128) return;
-		const policy = policyVersion(input.getConfig());
-		const workspace = getSessionConfig(input.sessionKey)?.workingDirectoryOverride;
-		const sessionId = getSessionMetadata(input.sessionKey)?.sessionId;
-		const selection = selectAutomaticContext({
-			...input,
+		const config = input.getConfig();
+		if (!voiceMemoryEnabled(config, input.sessionKey) || input.maxChars < 128) return;
+		const session = getSessionMetadata(input.sessionKey);
+		const context = buildExecutionContext({
 			query: voiceMemoryQuery(input.history),
-			deadline: started + 150
+			agentId: session?.routing?.agentId ?? "main",
+			workspaceId: input.workspaceId,
+			projectId: input.projectId,
+			sessionId: input.sessionKey,
+			maxAssertions: 6,
+			maxKnowledge: 3
 		});
-		if (!selection.block) return;
-		let invalid = false;
+		const block = JSON.stringify({ backgroundMemory: {
+			userFacts: context.assertions.map((item) => item.assertion.statement),
+			priorities: context.priorities.map((item) => `${item.rank}: ${item.targetType}/${item.targetId}`),
+			knowledge: context.knowledge.map((item) => item.content)
+		} });
+		if (block.length > input.maxChars || block === "{\"backgroundMemory\":{\"userFacts\":[],\"priorities\":[],\"knowledge\":[]}}") return;
+		const references = [...context.assertions.map((item) => ({
+			kind: "assertion",
+			id: item.assertion.id,
+			updatedAt: item.assertion.recordedAt
+		})), ...context.knowledge.map((item) => ({
+			kind: "knowledge",
+			id: item.id,
+			updatedAt: item.updatedAt
+		}))];
+		const configVersion = JSON.stringify(config.userContext);
 		const isCurrent = () => {
-			try {
-				if (invalid || !voiceMemoryEnabled(input.getConfig(), input.sessionKey) || policy !== policyVersion(input.getConfig()) || workspace !== getSessionConfig(input.sessionKey)?.workingDirectoryOverride) return false;
-				const session = getSessionMetadata(input.sessionKey);
-				if (session?.sessionId !== sessionId || session?.projectId !== input.projectId) return false;
-				const understandingIds = selection.references.filter((r) => r.kind === "understanding").map((r) => r.id);
-				const focusIds = selection.references.filter((r) => r.kind === "focus").map((r) => r.id);
-				const allowed = new Set([...remoteContextEligibleIds("understanding", understandingIds), ...remoteContextEligibleIds("focus", focusIds)]);
-				return selection.references.every((ref) => {
-					if (ref.kind === "profile") return ref.version === JSON.stringify(getUserProfile());
-					if (!allowed.has(ref.id)) return false;
-					if (ref.kind === "focus") {
-						const item = getUserFocus(ref.id);
-						return !!item && item.versionId === ref.version && allowsAutomaticDisclosure(item) && !focusRejectionReason(item, input, Date.now());
-					}
-					const item = getUnderstanding(ref.id);
-					return !!item && item.status === "active" && item.versionId === ref.version && allowsAutomaticDisclosure(item) && !rejectionReason(item, input, Date.now(), []);
-				});
-			} catch {
-				return false;
-			}
+			if (!voiceMemoryEnabled(input.getConfig(), input.sessionKey) || JSON.stringify(input.getConfig().userContext) !== configVersion) return false;
+			return references.every((reference) => reference.kind === "assertion" ? getUserAssertion(reference.id)?.recordedAt === reference.updatedAt : getKnowledgeItem(reference.id)?.updatedAt === reference.updatedAt);
 		};
 		log.debug({
 			sessionKey: input.sessionKey,
-			selectedCount: selection.references.length,
-			contextChars: selection.block.length,
+			selectedCount: references.length,
+			contextChars: block.length,
 			durationMs: performance.now() - started
 		}, "Native voice memory selected");
 		return {
-			...selection,
+			block,
+			references,
 			isCurrent,
-			subscribe: (invalidate) => onUserContextChange((change) => {
-				if (change.kind === "policy" || change.kind === "session" && change.id === input.sessionKey && !isCurrent() || selection.references.some((ref) => ref.kind === change.kind && ref.id === change.id)) {
-					if (!isCurrent()) {
-						invalid = true;
-						invalidate();
-					}
-				}
-			})
+			subscribe: () => () => {}
 		};
 	} catch {
 		log.warn({

package/dist/src/voice/realtime/omniEngine.js

@@ -1,6 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { AudioPlaybackWindow } from "./audio-playback-window.js";
+import { ConversationTurn } from "./conversationTurn.js";
 import crypto from "node:crypto";
 import WebSocket from "ws";
 //#region src/voice/realtime/omniEngine.ts
@@ -47,6 +48,23 @@ function createOmniVoiceEngine(options) {
 	let queuedInputBytes = 0;
 	let uploadingBytes = 0;
 	let uploadTimer;
+	let turnSettled = false;
+	const speaking = /* @__PURE__ */ new Set();
+	const turn = new ConversationTurn(options.silenceDurationMs, () => {
+		if (closed || failed || muted || inputBlocked) return;
+		turnSettled = true;
+		if (active) publish(active);
+	});
+	function publish(response) {
+		if (response.published || active !== response) return;
+		response.published = true;
+		options.send("response.created", { responseId: response.id });
+		if (response.text) options.send("response.text.delta", {
+			responseId: response.id,
+			delta: response.text
+		});
+		response.release();
+	}
 	const send = (type, fields = {}) => {
 		if (closed || socket?.readyState !== WebSocket.OPEN) throw new Error("Omni connection is closed");
 		socket.send(JSON.stringify({
@@ -103,23 +121,29 @@ function createOmniVoiceEngine(options) {
 		if (!response) return false;
 		active = void 0;
 		response.abort.abort(reason);
-		save({
-			itemId: response.id,
-			role: "assistant",
-			text: response.text,
-			interrupted: true
-		});
-		options.send("response.cancelled", {
-			responseId: response.id,
-			reason
-		});
-		if (reason === "client_cancelled" && response.generating && socket?.readyState === WebSocket.OPEN) {
+		response.release();
+		if (response.published) {
+			save({
+				itemId: response.id,
+				role: "assistant",
+				text: response.text,
+				interrupted: true
+			});
+			options.send("response.cancelled", {
+				responseId: response.id,
+				reason
+			});
+		}
+		if ((reason === "client_cancelled" || reason === "barge_in" && !options.bargeIn) && response.generating && socket?.readyState === WebSocket.OPEN) {
 			cancellationPending = true;
 			send("response.cancel");
 		}
 		return true;
 	};
 	const finish = async (response) => {
+		await response.settled;
+		if (active !== response || closed) return;
+		options.send("response.text.done", { responseId: response.id });
 		await response.tail;
 		if (active !== response || closed) return;
 		await response.playback.drain(response.abort.signal);
@@ -157,6 +181,7 @@ function createOmniVoiceEngine(options) {
 	function fail(code, details = {}) {
 		if (closed || failed) return;
 		failed = true;
+		turn.reset();
 		log.warn({
 			sessionId: options.callId,
 			platformRequestId,
@@ -179,6 +204,10 @@ function createOmniVoiceEngine(options) {
 		options.onClose("omni_error", true);
 	}
 	function discardInput() {
+		turn.reset();
+		speaking.clear();
+		turnSettled = false;
+		if (active && !active.published) cancel("client_cancelled");
 		inputQueue = [];
 		queuedInputBytes = 0;
 		inputBlocked = true;
@@ -266,12 +295,18 @@ function createOmniVoiceEngine(options) {
 								discardedInputs.add(String(event.item_id));
 								return;
 							}
+							if (recorded.has(String(event.item_id)) || pendingInputs.has(String(event.item_id))) return;
 							inputBlocked = false;
 							pendingInputs.add(String(event.item_id));
-							if (options.bargeIn) cancel("barge_in");
+							turnSettled = false;
+							speaking.add(String(event.item_id));
+							turn.start(String(event.item_id));
+							if (options.bargeIn || active && !active.published) cancel("barge_in");
 							options.send("input.speech_started", { utteranceId: String(event.item_id) });
 						} else if (event.type === "input_audio_buffer.speech_stopped") {
-							if (muted || inputBlocked || discardedInputs.has(String(event.item_id))) return;
+							if (muted || inputBlocked || discardedInputs.has(String(event.item_id)) || recorded.has(String(event.item_id))) return;
+							speaking.delete(String(event.item_id));
+							turn.stop(String(event.item_id));
 							options.send("input.speech_stopped", { utteranceId: String(event.item_id) });
 						} else if (event.type === "conversation.item.input_audio_transcription.completed") {
 							if (typeof event.transcript !== "string" || event.transcript.length > 32e3 || typeof event.item_id !== "string") {
@@ -280,6 +315,8 @@ function createOmniVoiceEngine(options) {
 							}
 							if (muted || inputBlocked || discardedInputs.has(event.item_id) || recorded.has(event.item_id)) return;
 							pendingInputs.delete(event.item_id);
+							speaking.delete(event.item_id);
+							turn.final(event.item_id, event.transcript);
 							save({
 								itemId: event.item_id,
 								role: "user",
@@ -291,8 +328,16 @@ function createOmniVoiceEngine(options) {
 								revision: 1,
 								text: event.transcript
 							});
+						} else if (event.type === "conversation.item.input_audio_transcription.failed") {
+							if (muted || inputBlocked || discardedInputs.has(String(event.item_id))) return;
+							discardInput();
+							options.send("session.error", {
+								code: "INPUT_DROPPED",
+								message: "Could not transcribe this voice turn. Please repeat it.",
+								recoverable: true
+							});
 						} else if (event.type === "response.created") {
-							if (muted || inputBlocked) {
+							if (muted || inputBlocked || speaking.size > 0) {
 								cancellationPending = true;
 								send("response.cancel");
 								return;
@@ -301,6 +346,10 @@ function createOmniVoiceEngine(options) {
 							if (active) cancel("barge_in");
 							const id = event.response?.id;
 							if (typeof id !== "string" || !id.length || id.length > 160) throw new Error("Invalid response ID");
+							let release;
+							const settled = new Promise((resolve) => {
+								release = resolve;
+							});
 							active = {
 								id,
 								text: "",
@@ -309,16 +358,19 @@ function createOmniVoiceEngine(options) {
 								queuedBytes: 0,
 								abort: new AbortController(),
 								playback: new AudioPlaybackWindow(),
-								tail: Promise.resolve()
+								tail: Promise.resolve(),
+								published: false,
+								settled,
+								release
 							};
-							options.send("response.created", { responseId: id });
+							if (turnSettled) publish(active);
 						} else if (active && event.response_id === active.id && event.type === "response.audio_transcript.delta") {
 							if (typeof event.delta !== "string" || active.text.length + event.delta.length > 32e3) {
 								fail("OMNI_TRANSCRIPT_LIMIT");
 								return;
 							}
 							active.text += event.delta;
-							options.send("response.text.delta", {
+							if (active.published) options.send("response.text.delta", {
 								responseId: active.id,
 								delta: event.delta
 							});
@@ -339,6 +391,7 @@ function createOmniVoiceEngine(options) {
 							}
 							response.queuedBytes += audio.length;
 							response.tail = response.tail.then(async () => {
+								await response.settled;
 								for (let offset = 0; offset < audio.length; offset += 24e3) {
 									if (closed || active !== response) return;
 									const chunk = audio.subarray(offset, offset + 24e3);
@@ -368,7 +421,6 @@ function createOmniVoiceEngine(options) {
 							else if (event.response.status !== "completed") fail("OMNI_RESPONSE_FAILED");
 							else {
 								const response = active;
-								options.send("response.text.done", { responseId: response.id });
 								finish(response).catch(() => {
 									if (!response.abort.signal.aborted) stopReply(response, "OMNI_PLAYBACK_FAILED");
 								});
@@ -429,6 +481,8 @@ function createOmniVoiceEngine(options) {
 			clearTimeout(timer);
 			clearTimeout(clearTimer);
 			clearTimeout(uploadTimer);
+			turn.reset();
+			speaking.clear();
 			inputQueue = [];
 			queuedInputBytes = 0;
 			rejectStart?.(/* @__PURE__ */ new Error("Omni connection closed"));

package/dist/src/work-discovery/service.d.ts

@@ -57,7 +57,7 @@ export declare class WorkDiscoveryService {
     importUnderstandingSources(rawItems: unknown[], processingPolicy: ModelProcessingPolicy, signal?: AbortSignal, runId?: string, rawCheckpoints?: Record<string, unknown>): Promise<{
         profileCandidates: any[];
         workThreads: any[];
-        focuses: any[];
+        knowledgeCandidates: any[];
         sourceStatuses: {
             sourceId: string;
             status: "completed";
@@ -65,7 +65,7 @@ export declare class WorkDiscoveryService {
     } | {
         profileCandidates: {
             status: "pending" | "rejected";
-            understandingId: string;
+            assertionId: string;
             id: string;
             category: "role" | "responsibility" | "preference" | "routine";
             factKey: string;
@@ -75,20 +75,9 @@ export declare class WorkDiscoveryService {
             evidenceRefs?: string[];
         }[];
         workThreads: import("./types.js").WorkUnderstandingThread[];
-        focuses: import("../user-context/sources/types.js").UserFocus[];
+        knowledgeCandidates: import("../knowledge-memory/domain.js").KnowledgeItem[];
         sourceStatuses: import("./analyzer.js").UnderstandingSourceAnalysisStatus[];
     }>;
-    updateUnderstandingSourceProfile(input: {
-        decisions: Array<{
-            understandingId: string;
-            status: 'accepted' | 'edited' | 'rejected';
-            statement?: string;
-        }>;
-    }): {
-        understandingId: string;
-        status: "rejected" | "accepted" | "edited";
-        statement: string;
-    }[];
     rescanDirectorySource(input: {
         id: string;
         idempotencyKey: string;