@xopcai/xopc 0.0.247 → 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/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 };

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/workflows/authoring/workflow-draft-store.d.ts

@@ -17,15 +17,11 @@ export interface SaveWorkflowAuthoringDraftInput {
     expectedUpdatedAtMs?: number;
 }
 export declare class WorkflowDraftStore {
-    private readonly draftsDir;
-    constructor(options?: {
-        userDir?: string;
-    });
+    private readonly state;
     list(workflowName?: string): WorkflowAuthoringDraft[];
     get(id: string): WorkflowAuthoringDraft | null;
     save(input: SaveWorkflowAuthoringDraftInput): WorkflowAuthoringDraft;
     remove(id: string): boolean;
-    private readFile;
 }
 export declare class WorkflowDraftConflictError extends Error {
     readonly currentUpdatedAtMs?: number;