@xopcai/xopc 0.0.246 → 0.0.248

package/dist/src/storage/sqlite/migrations/147_durable_application_state.sql

@@ -0,0 +1,39 @@
+CREATE TABLE durable_state (
+  namespace TEXT NOT NULL,
+  scope TEXT NOT NULL,
+  key TEXT NOT NULL,
+  payload TEXT NOT NULL CHECK(json_valid(payload)),
+  UNIQUE(namespace, scope, key)
+);
+CREATE TABLE workflow_events (
+  agent_id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  sequence INTEGER NOT NULL CHECK(sequence > 0),
+  id TEXT NOT NULL UNIQUE,
+  payload TEXT NOT NULL CHECK(json_valid(payload)),
+  PRIMARY KEY(agent_id, run_id, sequence)
+);
+CREATE TABLE note_snapshots (
+  note_id TEXT NOT NULL REFERENCES notes(note_id) ON DELETE CASCADE,
+  timestamp INTEGER NOT NULL,
+  payload TEXT NOT NULL CHECK(json_valid(payload)),
+  PRIMARY KEY(note_id, timestamp)
+);
+CREATE TABLE durable_messages (
+  sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+  queue TEXT NOT NULL,
+  scope TEXT NOT NULL,
+  id TEXT NOT NULL,
+  payload TEXT NOT NULL CHECK(json_valid(payload)),
+  enqueued_at INTEGER NOT NULL,
+  processed_at INTEGER,
+  lease_token TEXT,
+  lease_until INTEGER,
+  UNIQUE(queue, scope, id)
+);
+CREATE INDEX durable_messages_pending ON durable_messages(queue, scope, processed_at, sequence);
+
+CREATE UNIQUE INDEX durable_share_token ON durable_state(namespace, json_extract(payload, '$.token'))
+  WHERE namespace IN ('shares', 'site-shares');
+CREATE UNIQUE INDEX durable_site_subdomain ON durable_state(json_extract(payload, '$.subdomain'))
+  WHERE namespace = 'site-shares' AND json_extract(payload, '$.subdomain') IS NOT NULL;

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 145;
+export declare const XOPC_DB_SCHEMA_VERSION = 147;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 145;
+const XOPC_DB_SCHEMA_VERSION = 147;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function backupBeforeTaskCutover(db, databasePath) {
 	db.exec("PRAGMA wal_checkpoint(FULL)");
@@ -57,7 +57,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 145;
+	const targetVersion = options.targetVersion ?? 147;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -94,7 +94,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 145;
+	const appVersion = options.targetVersion ?? 147;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

package/dist/src/storage/sqlite/migrations/runner.ts

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 145;
+export const XOPC_DB_SCHEMA_VERSION = 147;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/schema.js

@@ -32,7 +32,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 11;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 145,
+		targetVersion: 147,
 		databasePath: options.databasePath
 	});
 }

package/dist/src/storage/sqlite/understanding-focus-exclusions.d.ts

@@ -0,0 +1,2 @@
+export declare function listUnderstandingFocusExclusions(): Map<string, string[]>;
+export declare function setUnderstandingFocusExclusion(understandingId: string, focusId: string, excluded: boolean): void;

package/dist/src/storage/sqlite/understanding-focus-exclusions.js

@@ -0,0 +1,24 @@
+import { getSqliteDatabase } from "./transaction.js";
+import { notifyUserContextChange } from "../../user-context/changes.js";
+//#region src/storage/sqlite/understanding-focus-exclusions.ts
+function listUnderstandingFocusExclusions() {
+	const rows = getSqliteDatabase().prepare("SELECT understanding_id, focus_id FROM understanding_focus_exclusions").all();
+	const result = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const ids = result.get(row.understanding_id) ?? [];
+		ids.push(row.focus_id);
+		result.set(row.understanding_id, ids);
+	}
+	return result;
+}
+function setUnderstandingFocusExclusion(understandingId, focusId, excluded) {
+	const db = getSqliteDatabase();
+	if (excluded) db.prepare("INSERT OR IGNORE INTO understanding_focus_exclusions (understanding_id, focus_id, created_at) VALUES (?, ?, ?)").run(understandingId, focusId, Date.now());
+	else db.prepare("DELETE FROM understanding_focus_exclusions WHERE understanding_id = ? AND focus_id = ?").run(understandingId, focusId);
+	notifyUserContextChange({
+		kind: "understanding",
+		id: understandingId
+	});
+}
+//#endregion
+export { listUnderstandingFocusExclusions, setUnderstandingFocusExclusion };

package/dist/src/tui/tui-scoped-models.js

@@ -1,15 +1,18 @@
-import { homedir } from "node:os";
+import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
 import { join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 //#region src/tui/tui-scoped-models.ts
-const STORE_PATH = join(homedir(), ".xopc", "tui-scoped-models.json");
+init_paths_state();
+function storePath() {
+	return join(resolveStateDir(), "tui-scoped-models.json");
+}
 function normalizeWorkspaceKey(cwd) {
 	return cwd.replace(/\\/g, "/").replace(/\/+$/, "") || "/";
 }
 function readStore() {
 	try {
-		if (!existsSync(STORE_PATH)) return {};
-		const raw = readFileSync(STORE_PATH, "utf8");
+		if (!existsSync(storePath())) return {};
+		const raw = readFileSync(storePath(), "utf8");
 		const parsed = JSON.parse(raw);
 		return parsed && typeof parsed === "object" ? parsed : {};
 	} catch {
@@ -17,9 +20,9 @@ function readStore() {
 	}
 }
 function writeStore(data) {
-	const dir = join(homedir(), ".xopc");
+	const dir = resolveStateDir();
 	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-	writeFileSync(STORE_PATH, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+	writeFileSync(storePath(), `${JSON.stringify(data, null, 2)}\n`, "utf8");
 }
 /** Load scoped model refs for Ctrl+P cycling (`null` = all models). */
 function loadScopedModelRefs(cwd = process.cwd()) {

package/dist/src/tui/tui-startup-resources.js

@@ -5,9 +5,9 @@ import { resolveBootstrapFilesSync } from "../agent/bootstrap/bootstrap-files.js
 import { createSkillConfigManager, isSkillEnabled } from "../agent/skills/config.js";
 import { loadSkills } from "../agent/skills/index.js";
 import { createWorkflowCatalog } from "../agent/workflow/catalog.js";
-import { listConnectorInstances } from "../connectors/instances.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
+import { listConnectorInstances } from "../connectors/instances.js";
 import { basename } from "node:path";
 //#region src/tui/tui-startup-resources.ts
 init_paths();

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

@@ -1,8 +1,28 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
 import { createRequire } from "node:module";
 import crypto from "node:crypto";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#region src/voice/dashscope/streaming-tts-stream.ts
+init_logger();
 const { WebSocket } = createRequire(import.meta.url)("ws");
 const DEFAULT_REALTIME_URL = "wss://dashscope.aliyuncs.com/api-ws/v1/realtime";
+const log = createLogger("TTS:DashScope");
+var TtsHandshakeError = class extends Error {
+	constructor(statusCode, retryAfterMs) {
+		super(`Realtime TTS WebSocket handshake failed (HTTP ${statusCode})${retryAfterMs === void 0 ? "" : `; retry after ${retryAfterMs} ms`}`);
+		this.statusCode = statusCode;
+		this.retryAfterMs = retryAfterMs;
+		this.name = "TtsHandshakeError";
+	}
+};
+function parseRetryAfter(value) {
+	if (!value?.trim()) return void 0;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	const timestamp = Date.parse(value);
+	return Number.isFinite(timestamp) ? Math.max(0, timestamp - Date.now()) : void 0;
+}
 function realtimeUrl(baseUrl, model) {
 	const configured = baseUrl ? new URL(baseUrl) : new URL(DEFAULT_REALTIME_URL);
 	const wasWebSocket = configured.protocol === "ws:" || configured.protocol === "wss:";
@@ -26,6 +46,31 @@ function event(type, extra = {}) {
 	});
 }
 async function openDashScopeStreamingTts(request) {
+	const deadline = Date.now() + request.timeoutMs;
+	for (let attempt = 1;; attempt += 1) {
+		request.signal.throwIfAborted();
+		try {
+			return await openStreamingTtsAttempt({
+				...request,
+				timeoutMs: Math.max(1, deadline - Date.now())
+			});
+		} catch (error) {
+			if (request.signal.aborted) throw error;
+			if (!(error instanceof TtsHandshakeError) || error.statusCode !== 429 || attempt >= 3) throw error;
+			const delayMs = Math.max(error.retryAfterMs ?? 0, 500 * 2 ** (attempt - 1) + Math.floor(Math.random() * 250));
+			if (delayMs > 5e3 || Date.now() + delayMs >= deadline) throw error;
+			log.warn({
+				model: request.model,
+				statusCode: error.statusCode,
+				attempt,
+				delayMs
+			}, "Realtime TTS handshake rate limited; retrying");
+			await setTimeout$1(delayMs, void 0, { signal: request.signal });
+			if (Date.now() >= deadline) throw error;
+		}
+	}
+}
+async function openStreamingTtsAttempt(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), {
@@ -72,6 +117,10 @@ async function openDashScopeStreamingTts(request) {
 		else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
 	};
 	request.signal.addEventListener("abort", onAbort, { once: true });
+	socket.on("unexpected-response", (_request, response) => {
+		fail(new TtsHandshakeError(response.statusCode ?? 0, parseRetryAfter(response.headers["retry-after"])));
+		response.destroy();
+	});
 	socket.on("message", (data, isBinary) => {
 		if (streamClosed || request.signal.aborted) return;
 		if (isBinary) return;

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

@@ -2,6 +2,7 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { speakStream } from "../tts/speak-core.js";
 import { AudioPlaybackWindow } from "./audio-playback-window.js";
+import { ConversationTurn } from "./conversationTurn.js";
 import { SpeakableSegmenter } from "./speakable-segmenter.js";
 import crypto from "node:crypto";
 //#region src/voice/realtime/agentEngine.ts
@@ -29,6 +30,32 @@ function createAgentVoiceEngine(options) {
 	let finalCount = 0;
 	let committing = false;
 	const finalizedUtterances = /* @__PURE__ */ new Set();
+	let pendingTurn;
+	const turn = new ConversationTurn(claim.silenceDurationMs, (text) => {
+		if (closed || muted) return;
+		if (queuedTurns >= 8) {
+			send("session.error", {
+				code: "INPUT_BACKPRESSURE",
+				message: "Too many queued voice turns",
+				recoverable: false
+			});
+			options.onClose("input_backpressure", true);
+			return;
+		}
+		queuedTurns += 1;
+		const generation = inputGeneration;
+		const pending = {
+			text,
+			cancelled: false
+		};
+		pendingTurn = pending;
+		conversationTail = conversationTail.then(() => {
+			if (pendingTurn === pending) pendingTurn = void 0;
+			if (generation === inputGeneration && !pending.cancelled) return runConversationTurn(text);
+		}).finally(() => {
+			if (generation === inputGeneration) queuedTurns -= 1;
+		});
+	});
 	function cancelActiveResponse(reason) {
 		const response = activeResponse;
 		if (!response) return false;
@@ -238,10 +265,23 @@ function createAgentVoiceEngine(options) {
 			}
 		});
 	}
+	function bufferFinal(utteranceId, text) {
+		try {
+			turn.final(utteranceId, text);
+		} catch {
+			send("session.error", {
+				code: "INPUT_BACKPRESSURE",
+				message: "Voice turn input limit reached",
+				recoverable: false
+			});
+			options.onClose("input_backpressure", true);
+		}
+	}
 	function onSttEvent(event) {
 		if (closed) return;
 		if (event.type === "ready" || event.type === "usage") return;
 		if (event.type === "error") {
+			turn.reset();
 			log.warn({
 				err: event.error,
 				sessionId: claim.sessionId,
@@ -257,10 +297,21 @@ function createAgentVoiceEngine(options) {
 		}
 		if (muted || finalizedUtterances.has(event.utteranceId)) return;
 		if (event.type === "speech_started") {
+			if (claim.request.purpose === "conversation") {
+				if (pendingTurn) {
+					pendingTurn.cancelled = true;
+					turn.restore(pendingTurn.text);
+					pendingTurn = void 0;
+				}
+				turn.start(event.utteranceId);
+			}
 			if (claim.request.purpose === "conversation" && claim.config.voice?.realtime?.bargeIn && !activeResponse?.awaitingClarification) cancelActiveResponse("barge_in");
 			send("input.speech_started", { utteranceId: event.utteranceId });
 		}
-		if (event.type === "speech_stopped") send("input.speech_stopped", { utteranceId: event.utteranceId });
+		if (event.type === "speech_stopped") {
+			if (claim.request.purpose === "conversation") turn.stop(event.utteranceId);
+			send("input.speech_stopped", { utteranceId: event.utteranceId });
+		}
 		if (event.type === "transcript_delta") send("input.transcript.delta", {
 			utteranceId: event.utteranceId,
 			revision: event.revision,
@@ -268,7 +319,10 @@ function createAgentVoiceEngine(options) {
 		});
 		if (event.type === "transcript_final") {
 			const text = event.text.trim();
-			if (!text) return;
+			if (!text) {
+				if (claim.request.purpose === "conversation") bufferFinal(event.utteranceId, "");
+				return;
+			}
 			if (finalizedUtterances.size >= 1e4) {
 				options.onClose("utterance_limit", true);
 				return;
@@ -282,28 +336,18 @@ function createAgentVoiceEngine(options) {
 				...event.language === "zh" || event.language === "en" ? { language: event.language } : {}
 			});
 			if (claim.request.purpose === "conversation") {
-				if (activeResponse?.awaitingClarification) return;
-				if (claim.config.voice?.realtime?.bargeIn) cancelActiveResponse("barge_in");
-				if (queuedTurns >= 8) {
-					send("session.error", {
-						code: "INPUT_BACKPRESSURE",
-						message: "Too many queued voice turns",
-						recoverable: false
-					});
-					options.onClose("input_backpressure", true);
+				if (activeResponse?.awaitingClarification) {
+					turn.reset();
 					return;
 				}
-				queuedTurns += 1;
-				const generation = inputGeneration;
-				conversationTail = conversationTail.then(() => {
-					if (generation === inputGeneration) return runConversationTurn(text);
-				}).finally(() => {
-					if (generation === inputGeneration) queuedTurns -= 1;
-				});
+				if (claim.config.voice?.realtime?.bargeIn) cancelActiveResponse("barge_in");
+				bufferFinal(event.utteranceId, text);
 			}
 		}
 	}
 	function discardInput() {
+		turn.reset();
+		pendingTurn = void 0;
 		inputGeneration += 1;
 		queuedTurns = 0;
 		bufferedAudio = [];
@@ -387,6 +431,7 @@ function createAgentVoiceEngine(options) {
 		close() {
 			if (closing) return closing;
 			closed = true;
+			turn.reset();
 			cancelActiveResponse("session_closed");
 			sttAbort.abort("session_closed");
 			sttSession?.abort("session_closed");

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

@@ -0,0 +1,20 @@
+/** Conservative continuation hints, not a semantic model or punctuation-based endpoint detector. */
+export declare function needsContinuation(text: string): boolean;
+/** Joins provider utterances until both transcription and the continuation window have settled. */
+export declare class ConversationTurn {
+    private readonly silenceDurationMs;
+    private readonly onTurn;
+    private readonly parts;
+    private timer;
+    private stoppedAt;
+    constructor(silenceDurationMs: number, onTurn: (text: string) => void);
+    start(id: string): void;
+    stop(id: string): void;
+    final(id: string, text: string): void;
+    reset(): void;
+    /** Restore a settled turn if generation was still queued when the user resumed. */
+    restore(text: string): void;
+    private text;
+    private clearTimer;
+    private schedule;
+}

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

@@ -0,0 +1,83 @@
+//#region src/voice/realtime/conversationTurn.ts
+const MIN_TURN_SILENCE_MS = 1200;
+const FINAL_SETTLE_MS = 350;
+const INCOMPLETE_HOLD_MS = 1800;
+/** Conservative continuation hints, not a semantic model or punctuation-based endpoint detector. */
+function needsContinuation(text) {
+	const tail = text.trim().replace(/[\s，。！？、；：,.!?;:]+$/u, "");
+	return /(?:…|\.\.\.)[\s，。！？,.!?]*$/u.test(text) || /(?:因为|但是|然后|而且|如果|所以|比如|或者|还有|我想|我要|我觉得|帮我|帮我查一下|帮我查查|请帮我|就是说|那个|这个|呃|嗯)$/u.test(tail) || /\b(?:because|but|and|or|if|so|then|um|uh|i want to|i would like to|can you|could you|let me)\s*$/iu.test(tail);
+}
+/** Joins provider utterances until both transcription and the continuation window have settled. */
+var ConversationTurn = class {
+	parts = /* @__PURE__ */ new Map();
+	timer;
+	stoppedAt = 0;
+	constructor(silenceDurationMs, onTurn) {
+		this.silenceDurationMs = silenceDurationMs;
+		this.onTurn = onTurn;
+	}
+	start(id) {
+		if (this.parts.has(id)) return;
+		this.clearTimer();
+		this.parts.set(id, { stopped: false });
+	}
+	stop(id) {
+		const part = this.parts.get(id);
+		if (part?.stopped) return;
+		this.parts.set(id, {
+			...part,
+			stopped: true
+		});
+		this.stoppedAt = Date.now();
+		this.schedule();
+	}
+	final(id, text) {
+		const part = this.parts.get(id);
+		if (part?.text !== void 0) return;
+		if (!part?.stopped) this.stoppedAt = Date.now();
+		this.parts.set(id, {
+			text: text.trim(),
+			stopped: true
+		});
+		if (this.parts.size > 256 || this.text().length > 32e3) {
+			this.reset();
+			throw new Error("Voice turn input limit reached");
+		}
+		this.schedule();
+	}
+	reset() {
+		this.clearTimer();
+		this.parts.clear();
+	}
+	/** Restore a settled turn if generation was still queued when the user resumed. */
+	restore(text) {
+		this.parts.set("queued-turn", {
+			text,
+			stopped: true
+		});
+		this.clearTimer();
+	}
+	text() {
+		return [...this.parts.values()].map((part) => part.text ?? "").filter(Boolean).join(" ");
+	}
+	clearTimer() {
+		clearTimeout(this.timer);
+		this.timer = void 0;
+	}
+	schedule() {
+		this.clearTimer();
+		if ([...this.parts.values()].some((part) => !part.stopped || part.text === void 0)) return;
+		const text = this.text();
+		if (!text) {
+			this.reset();
+			return;
+		}
+		const holdMs = Math.max(FINAL_SETTLE_MS, MIN_TURN_SILENCE_MS - this.silenceDurationMs, needsContinuation(text) ? INCOMPLETE_HOLD_MS : 0);
+		this.timer = setTimeout(() => {
+			this.reset();
+			this.onTurn(text);
+		}, Math.max(FINAL_SETTLE_MS, this.stoppedAt + holdMs - Date.now()));
+	}
+};
+//#endregion
+export { ConversationTurn, needsContinuation };