@xopcai/xopc 0.0.241 → 0.0.243

package/dist/src/user-context/sources/repository.js

@@ -1,5 +1,6 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import "../domain.js";
+import { USER_CONTEXT_PRINCIPAL_ID } from "../domain.js";
+import { notifyUserContextChange } from "../changes.js";
 import { focusLifecycle } from "../focus-lifecycle.js";
 import { randomUUID } from "node:crypto";
 //#region src/user-context/sources/repository.ts
@@ -139,6 +140,7 @@ function getUnderstandingSourceGrant(id) {
 	return row ? grantFromRow(row) : null;
 }
 function upsertUnderstandingSourceGrant(input) {
+	notifyUserContextChange({ kind: "policy" });
 	const id = randomUUID();
 	const now = input.nowMs ?? Date.now();
 	const existingRow = getSqliteDatabase().prepare("SELECT * FROM understanding_source_grants WHERE source_key = ?").get(input.sourceKey);
@@ -169,6 +171,7 @@ function updateUnderstandingSourceGrantCheckpoint(id, input) {
 	return getUnderstandingSourceGrant(id);
 }
 function updateUnderstandingSourceGrantPolicies(id, patch) {
+	notifyUserContextChange({ kind: "policy" });
 	const current = getUnderstandingSourceGrant(id);
 	if (!current) return null;
 	runSqliteWriteTransaction((db) => db.prepare(`
@@ -179,6 +182,7 @@ function updateUnderstandingSourceGrantPolicies(id, patch) {
 	return getUnderstandingSourceGrant(id);
 }
 function revokeUnderstandingSourceGrant(id, nowMs = Date.now()) {
+	notifyUserContextChange({ kind: "policy" });
 	runSqliteWriteTransaction((db) => db.prepare("UPDATE understanding_source_grants SET status = 'revoked', updated_at = ? WHERE grant_id = ?").run(nowMs, id));
 	return getUnderstandingSourceGrant(id);
 }
@@ -218,6 +222,10 @@ function upsertUserFocus(input) {
 	const disclosurePolicy = input.disclosurePolicy ?? "referenceable";
 	const existingRow = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey);
 	if (existingRow?.explicitness === "explicit" && explicitness !== "explicit") return focusFromRow(existingRow);
+	if (existingRow) notifyUserContextChange({
+		kind: "focus",
+		id: existingRow.focus_id
+	});
 	let currentVersionId = existingRow?.current_version_id;
 	runSqliteWriteTransaction((db) => {
 		db.prepare(`
@@ -253,12 +261,21 @@ function upsertUserFocus(input) {
 	if (currentVersionId) linkFocusEvidence(currentVersionId, input.evidenceRefs, input.confidence);
 	return focusFromRow(getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey));
 }
-function listUserFocuses(statuses) {
-	if (!statuses?.length) return getSqliteDatabase().prepare("SELECT * FROM user_focuses ORDER BY updated_at DESC").all().map(focusFromRow);
+function listUserFocuses(statuses, limit) {
+	const maxRows = limit === void 0 ? -1 : Math.max(1, Math.min(200, Math.floor(limit)));
+	if (!statuses?.length) return getSqliteDatabase().prepare("SELECT * FROM user_focuses ORDER BY updated_at DESC LIMIT ?").all(maxRows).map(focusFromRow);
 	const placeholders = statuses.map(() => "?").join(", ");
-	return getSqliteDatabase().prepare(`SELECT * FROM user_focuses WHERE status IN (${placeholders}) ORDER BY updated_at DESC`).all(...statuses).map(focusFromRow);
+	return getSqliteDatabase().prepare(`SELECT * FROM user_focuses WHERE status IN (${placeholders}) ORDER BY updated_at DESC LIMIT ?`).all(...statuses, maxRows).map(focusFromRow);
+}
+function getUserFocus(id) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ? AND principal_id = ?").get(id, USER_CONTEXT_PRINCIPAL_ID);
+	return row ? focusFromRow(row) : void 0;
 }
 function updateUserFocus(id, patch, nowMs = Date.now()) {
+	notifyUserContextChange({
+		kind: "focus",
+		id
+	});
 	const currentRow = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
 	if (!currentRow) return null;
 	const current = focusFromRow(currentRow);
@@ -283,7 +300,11 @@ function updateUserFocus(id, patch, nowMs = Date.now()) {
 	return row ? focusFromRow(row) : null;
 }
 function deleteUserFocus(id) {
+	notifyUserContextChange({
+		kind: "focus",
+		id
+	});
 	return Number(getSqliteDatabase().prepare("DELETE FROM user_focuses WHERE focus_id = ?").run(id).changes) > 0;
 }
 //#endregion
-export { createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus };
+export { createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus };

package/dist/src/voice/dashscope/streaming-stt-session.d.ts

@@ -0,0 +1,2 @@
+import type { StreamingSttOpenRequest, StreamingSttSession } from '../../media-understanding/types.js';
+export declare function openDashScopeStreamingStt(request: StreamingSttOpenRequest): Promise<StreamingSttSession>;

package/dist/src/voice/dashscope/streaming-stt-session.js

@@ -0,0 +1,249 @@
+import { createRequire } from "node:module";
+import crypto from "node:crypto";
+//#region src/voice/dashscope/streaming-stt-session.ts
+const { WebSocket: NodeWebSocket } = createRequire(import.meta.url)("ws");
+const DEFAULT_REALTIME_URL = "wss://dashscope.aliyuncs.com/api-ws/v1/inference";
+const MAX_BUFFERED_AUDIO_BYTES = 512 * 1024;
+function realtimeUrl(baseUrl) {
+	if (!baseUrl) return DEFAULT_REALTIME_URL;
+	const url = new URL(baseUrl);
+	const wasWebSocket = url.protocol === "ws:" || url.protocol === "wss:";
+	url.protocol = url.protocol === "http:" ? "ws:" : url.protocol === "https:" ? "wss:" : url.protocol;
+	if (url.protocol !== "ws:" && url.protocol !== "wss:") throw new Error("DashScope realtime base URL must use HTTP or WebSocket");
+	if (!wasWebSocket && !url.pathname.includes("/api-ws/")) {
+		url.pathname = "/api-ws/v1/inference";
+		url.search = "";
+	}
+	return url.toString();
+}
+function rawText(data) {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+	if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+	return data.toString("utf8");
+}
+function providerError(message) {
+	const code = message.header?.error_code;
+	const detail = message.header?.error_message;
+	return new Error([code, detail].filter(Boolean).join(": ") || "DashScope realtime STT failed");
+}
+async function openDashScopeStreamingStt(request) {
+	if (!request.apiKey) throw new Error("DashScope STT API key is unavailable");
+	if (request.signal.aborted) throw request.signal.reason instanceof Error ? request.signal.reason : /* @__PURE__ */ new Error("DashScope realtime STT aborted");
+	if (request.inputFormat.encoding !== "pcm_s16le" || request.inputFormat.channels !== 1) throw new Error("DashScope realtime STT requires mono PCM16 audio");
+	const taskId = crypto.randomUUID();
+	const socket = new NodeWebSocket(realtimeUrl(request.baseUrl), {
+		headers: {
+			Authorization: `Bearer ${request.apiKey}`,
+			...request.headers
+		},
+		perMessageDeflate: false
+	});
+	let ready = false;
+	let finished = false;
+	let closing = false;
+	let currentUtteranceId;
+	let revision = 0;
+	let inputBytes = 0;
+	let failed = false;
+	let resolveReady;
+	let rejectReady;
+	const readyPromise = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	let resolveFinished;
+	const finishedPromise = new Promise((resolve) => {
+		resolveFinished = resolve;
+	});
+	const fail = (error) => {
+		if (failed) return;
+		failed = true;
+		if (!ready) rejectReady(error);
+		request.onEvent({
+			type: "error",
+			error
+		});
+	};
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		resolveFinished();
+	};
+	const closeSocket = (reason) => {
+		closing = true;
+		if (socket.readyState === NodeWebSocket.OPEN) socket.close(1e3, reason.slice(0, 120));
+		else if (socket.readyState === NodeWebSocket.CONNECTING) socket.terminate();
+	};
+	socket.on("open", () => {
+		socket.send(JSON.stringify({
+			header: {
+				action: "run-task",
+				task_id: taskId,
+				streaming: "duplex"
+			},
+			payload: {
+				task_group: "audio",
+				task: "asr",
+				function: "recognition",
+				model: request.model,
+				parameters: {
+					format: "pcm",
+					sample_rate: request.inputFormat.sampleRate,
+					semantic_punctuation_enabled: false,
+					max_sentence_silence: request.turnDetection.silenceDurationMs,
+					...request.language && request.language !== "auto" ? { language_hints: [request.language] } : {}
+				},
+				input: request.prompt ? { context: [{
+					role: "user",
+					content: [{
+						type: "input_text",
+						text: request.prompt.slice(0, 400)
+					}]
+				}] } : {}
+			}
+		}));
+	});
+	socket.on("message", (data, isBinary) => {
+		if (isBinary) return;
+		let message;
+		try {
+			message = JSON.parse(rawText(data));
+		} catch {
+			fail(/* @__PURE__ */ new Error("DashScope realtime STT returned invalid JSON"));
+			finish();
+			closeSocket("Invalid provider response");
+			return;
+		}
+		const event = message.header?.event;
+		if (event === "task-started") {
+			ready = true;
+			resolveReady();
+			request.onEvent({ type: "ready" });
+			return;
+		}
+		if (event === "task-failed") {
+			fail(providerError(message));
+			finish();
+			closeSocket("Provider task failed");
+			return;
+		}
+		if (event === "task-finished") {
+			const duration = Number(message.payload?.usage?.duration);
+			const inputAudioMs = Number.isFinite(duration) ? Math.max(0, Math.round(duration)) : Math.round(inputBytes / 2 / request.inputFormat.sampleRate * 1e3);
+			request.onEvent({
+				type: "usage",
+				inputAudioMs
+			});
+			finish();
+			closeSocket("Complete");
+			return;
+		}
+		if (event !== "result-generated") return;
+		const sentence = message.payload?.output?.sentence;
+		if (sentence?.heartbeat === true) return;
+		const text = sentence?.text;
+		if (typeof text !== "string") return;
+		if (sentence.sentence_begin === true) {
+			currentUtteranceId = crypto.randomUUID();
+			revision = 0;
+			request.onEvent({
+				type: "speech_started",
+				utteranceId: currentUtteranceId
+			});
+		}
+		if (!currentUtteranceId) return;
+		revision += 1;
+		if (sentence.sentence_end === true) {
+			request.onEvent({
+				type: "speech_stopped",
+				utteranceId: currentUtteranceId
+			});
+			request.onEvent({
+				type: "transcript_final",
+				utteranceId: currentUtteranceId,
+				revision,
+				text,
+				...request.language ? { language: request.language } : {}
+			});
+			currentUtteranceId = void 0;
+			revision = 0;
+		} else request.onEvent({
+			type: "transcript_delta",
+			utteranceId: currentUtteranceId,
+			revision,
+			text
+		});
+	});
+	socket.on("error", (error) => {
+		fail(error);
+		finish();
+		closeSocket("Provider socket failed");
+	});
+	socket.on("close", () => {
+		request.signal.removeEventListener("abort", onAbort);
+		if (!closing && !finished) fail(/* @__PURE__ */ new Error("DashScope realtime STT connection closed unexpectedly"));
+		finish();
+	});
+	const onAbort = () => {
+		if (!ready) rejectReady(request.signal.reason instanceof Error ? request.signal.reason : /* @__PURE__ */ new Error("DashScope realtime STT aborted"));
+		finish();
+		closeSocket("Aborted");
+	};
+	request.signal.addEventListener("abort", onAbort, { once: true });
+	const timeout = setTimeout(() => {
+		fail(/* @__PURE__ */ new Error("DashScope realtime STT setup timed out"));
+		finish();
+		closeSocket("Setup timeout");
+	}, request.timeoutMs);
+	try {
+		await readyPromise;
+	} finally {
+		clearTimeout(timeout);
+	}
+	return {
+		appendAudio(chunk) {
+			if (!ready || closing || finished || socket.readyState !== NodeWebSocket.OPEN) throw new Error("DashScope realtime STT is not writable");
+			if (socket.bufferedAmount + chunk.byteLength > MAX_BUFFERED_AUDIO_BYTES) throw new Error("DashScope realtime STT audio backpressure limit exceeded");
+			inputBytes += chunk.byteLength;
+			socket.send(chunk, { binary: true });
+		},
+		async commit() {
+			if (!closing && !finished) {
+				closing = true;
+				socket.send(JSON.stringify({
+					header: {
+						action: "finish-task",
+						task_id: taskId,
+						streaming: "duplex"
+					},
+					payload: { input: {} }
+				}));
+			}
+			await finishedPromise;
+			closeSocket("Complete");
+		},
+		async close() {
+			if (!closing && !finished) {
+				closing = true;
+				socket.send(JSON.stringify({
+					header: {
+						action: "finish-task",
+						task_id: taskId,
+						streaming: "duplex"
+					},
+					payload: { input: {} }
+				}));
+			}
+			await finishedPromise;
+			request.signal.removeEventListener("abort", onAbort);
+			closeSocket("Complete");
+		},
+		abort(reason) {
+			finish();
+			closeSocket(reason);
+		}
+	};
+}
+//#endregion
+export { openDashScopeStreamingStt };

package/dist/src/voice/dashscope/streaming-tts-stream.d.ts

@@ -0,0 +1,12 @@
+import type { SpeechSynthesisStreamResult } from '../tts/speech-provider-types.js';
+export interface DashScopeStreamingTtsRequest {
+    apiKey: string;
+    baseUrl?: string;
+    model: string;
+    voice: string;
+    text: string;
+    instructions?: string;
+    signal: AbortSignal;
+    timeoutMs: number;
+}
+export declare function openDashScopeStreamingTts(request: DashScopeStreamingTtsRequest): Promise<SpeechSynthesisStreamResult>;

package/dist/src/voice/dashscope/streaming-tts-stream.js

@@ -0,0 +1,153 @@
+import { createRequire } from "node:module";
+import crypto from "node:crypto";
+//#region src/voice/dashscope/streaming-tts-stream.ts
+const { WebSocket } = createRequire(import.meta.url)("ws");
+const DEFAULT_REALTIME_URL = "wss://dashscope.aliyuncs.com/api-ws/v1/realtime";
+function realtimeUrl(baseUrl, model) {
+	const configured = baseUrl ? new URL(baseUrl) : new URL(DEFAULT_REALTIME_URL);
+	const wasWebSocket = configured.protocol === "ws:" || configured.protocol === "wss:";
+	configured.protocol = configured.protocol === "http:" ? "ws:" : configured.protocol === "https:" ? "wss:" : configured.protocol;
+	if (configured.protocol !== "ws:" && configured.protocol !== "wss:") throw new Error("DashScope realtime TTS base URL must use HTTP or WebSocket");
+	if (!wasWebSocket) configured.pathname = "/api-ws/v1/realtime";
+	configured.searchParams.set("model", model);
+	return configured.toString();
+}
+function rawText(data) {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+	if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+	return data.toString("utf8");
+}
+function event(type, extra = {}) {
+	return JSON.stringify({
+		event_id: crypto.randomUUID(),
+		type,
+		...extra
+	});
+}
+async function openDashScopeStreamingTts(request) {
+	if (!request.apiKey) throw new Error("DashScope TTS API key is unavailable");
+	if (request.signal.aborted) throw request.signal.reason;
+	const socket = new WebSocket(realtimeUrl(request.baseUrl, request.model), {
+		headers: { Authorization: `Bearer ${request.apiKey}` },
+		perMessageDeflate: false
+	});
+	let controller;
+	let settled = false;
+	let streamClosed = false;
+	let resolveReady;
+	let rejectReady;
+	const readyPromise = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	const audioStream = new ReadableStream({
+		start(next) {
+			controller = next;
+		},
+		cancel() {
+			streamClosed = true;
+			socket.close(1e3, "Consumer cancelled");
+		}
+	});
+	const fail = (error, closeSocket = true) => {
+		if (!settled) rejectReady(error);
+		if (!streamClosed) {
+			streamClosed = true;
+			controller?.error(error);
+		}
+		if (closeSocket) {
+			if (socket.readyState === WebSocket.OPEN) socket.close(1011, "Provider stream failed");
+			else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
+		}
+	};
+	const finishStream = () => {
+		if (streamClosed) return;
+		streamClosed = true;
+		controller?.close();
+	};
+	const onAbort = () => {
+		fail(request.signal.reason instanceof Error ? request.signal.reason : new DOMException("Realtime TTS aborted", "AbortError"), false);
+		if (socket.readyState === WebSocket.OPEN) socket.close(1e3, "Aborted");
+		else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
+	};
+	request.signal.addEventListener("abort", onAbort, { once: true });
+	socket.on("message", (data, isBinary) => {
+		if (streamClosed || request.signal.aborted) return;
+		if (isBinary) return;
+		let message;
+		try {
+			message = JSON.parse(rawText(data));
+		} catch {
+			fail(/* @__PURE__ */ new Error("DashScope realtime TTS returned invalid JSON"));
+			return;
+		}
+		if (message.type === "session.created") {
+			socket.send(event("session.update", { session: {
+				voice: request.voice,
+				mode: "commit",
+				language_type: "Auto",
+				response_format: "pcm",
+				sample_rate: 24e3,
+				...request.instructions ? {
+					instructions: request.instructions,
+					optimize_instructions: false
+				} : {}
+			} }));
+			return;
+		}
+		if (message.type === "session.updated") {
+			settled = true;
+			resolveReady();
+			socket.send(event("input_text_buffer.append", { text: request.text }));
+			socket.send(event("input_text_buffer.commit"));
+			return;
+		}
+		if (message.type === "response.audio.delta") {
+			if (streamClosed) return;
+			if (typeof message.delta !== "string") {
+				fail(/* @__PURE__ */ new Error("DashScope realtime TTS returned invalid audio"));
+				return;
+			}
+			controller?.enqueue(Buffer.from(message.delta, "base64"));
+			return;
+		}
+		if (message.type === "response.audio.done") {
+			finishStream();
+			socket.send(event("session.finish"));
+			return;
+		}
+		if (message.type === "error") {
+			const code = typeof message.error?.code === "string" ? message.error.code : void 0;
+			const detail = typeof message.error?.message === "string" ? message.error.message : void 0;
+			fail(new Error([code, detail].filter(Boolean).join(": ") || "DashScope realtime TTS failed"));
+		}
+	});
+	socket.on("error", (error) => fail(error));
+	socket.on("close", () => {
+		request.signal.removeEventListener("abort", onAbort);
+		if (!streamClosed) fail(/* @__PURE__ */ new Error("DashScope realtime TTS connection closed unexpectedly"));
+	});
+	const timeout = setTimeout(() => {
+		fail(/* @__PURE__ */ new Error("DashScope realtime TTS setup timed out"));
+		socket.close(1011, "Setup timeout");
+	}, request.timeoutMs);
+	try {
+		await readyPromise;
+	} finally {
+		clearTimeout(timeout);
+	}
+	return {
+		audioStream,
+		outputFormat: "pcm",
+		fileExtension: "pcm",
+		voiceCompatible: false,
+		release: async () => {
+			request.signal.removeEventListener("abort", onAbort);
+			finishStream();
+			if (socket.readyState === WebSocket.OPEN) socket.close(1e3, "Released");
+		}
+	};
+}
+//#endregion
+export { openDashScopeStreamingTts };

package/dist/src/voice/realtime/agentEngine.d.ts

@@ -0,0 +1,10 @@
+import type { VoiceTicketClaim, VoiceRealtimeRuntimeOptions } from './runtime.js';
+import type { VoiceEngine, VoiceEventSink } from './engine.js';
+export declare function createAgentVoiceEngine(options: {
+    claim: VoiceTicketClaim;
+    runtime: VoiceRealtimeRuntimeOptions;
+    signal: AbortSignal;
+    send: VoiceEventSink;
+    sendAudio: (responseId: string, bytes: Uint8Array) => void;
+    onClose: (reason: string, notify: boolean) => Promise<void>;
+}): VoiceEngine;