@xopcai/xopc 0.0.242 → 0.0.244

package/dist/src/user-context/planner.js

@@ -1,5 +1,4 @@
 import { consumeContextConsent, ensureContextConsent, getUserProfile, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextRun } from "../storage/sqlite/user-context-repository.js";
-import { retrievalLexicalSimilarity } from "../retrieval/textFeatures.js";
 import { buildRetrievalQueryProfile } from "../retrieval/queryProfile.js";
 import "../storage/sqlite/index.js";
 import { init_session_key, parseSessionKey } from "../routing/session-key.js";
@@ -9,6 +8,7 @@ import { buildUserContextBlock } from "../agent/memory/context-fence.js";
 import { getUnderstandingSourceGrant, getUnderstandingSourceRun, listUserFocuses } from "./sources/repository.js";
 import { matchesUserContextScope } from "./scope.js";
 import { UserUnderstandingRetriever } from "./retriever.js";
+import { focusRejectionReason, focusScore, rejectionReason } from "./selection-policy.js";
 import { randomUUID } from "node:crypto";
 //#region src/user-context/planner.ts
 init_session_key();
@@ -103,35 +103,12 @@ function focusSourceDescription(focus) {
 		label: "Suggested from prior work"
 	};
 }
-function rejectionReason(item, input, now, timeHints) {
-	const historical = timeHints.includes("historical") && item.validTo !== void 0;
-	if (item.status === "needs_review" || item.status === "candidate" || item.status === "stale" && !historical) return "needs_review";
-	if (item.status === "rejected" || item.status === "archived" && !historical) return "disabled";
-	if (!matchesUserContextScope(item.scope, input)) return "scope_mismatch";
-	if (item.validFrom && item.validFrom > now && !timeHints.includes("future")) return "not_yet_valid";
-	if ((item.validTo && item.validTo < now || item.expiresAt && item.expiresAt < now) && !historical) return "expired";
-	if (item.sensitivity === "secret" || item.sensitivity === "regulated") return "sensitive";
-	if (item.conflictGroupId) return "conflict";
-}
 function ruleMatches(rule, input) {
 	if (rule.status !== "active" || !matchesUserContextScope(rule.scope, input)) return false;
 	const channel = typeof rule.conditions.channel === "string" ? rule.conditions.channel : void 0;
 	const agentId = typeof rule.conditions.agentId === "string" ? rule.conditions.agentId : void 0;
 	return (!channel || channel === input.channel) && (!agentId || agentId === input.agentId);
 }
-function focusRejectionReason(focus, input, now) {
-	if (focus.status !== "active") return "disabled";
-	if (!matchesUserContextScope(focus.scope, input)) return "scope_mismatch";
-	if (focus.validFrom && focus.validFrom > now) return "not_yet_valid";
-	if (focus.validTo && focus.validTo < now) return "expired";
-	if (focus.sensitivity === "secret" || focus.sensitivity === "regulated") return "sensitive";
-	if (focus.disclosurePolicy === "ask_before_reference") return "requires_consent";
-}
-function focusScore(focus, query, scopeInput) {
-	const lexical = retrievalLexicalSimilarity(buildRetrievalQueryProfile(query, scopeInput).normalized, `${focus.title} ${focus.summary}`);
-	const scoped = focus.scope.type !== "global" && matchesUserContextScope(focus.scope, scopeInput);
-	return Math.min(1, lexical * .75 + focus.confidence * .15 + (scoped ? .25 : 0));
-}
 function renderContextBlock(params) {
 	const understandingItems = params.items.filter((item) => item.objectType === "understanding");
 	return [

package/dist/src/user-context/retriever.js

@@ -1,5 +1,5 @@
 import { summarizeUnderstandingFeedback } from "../storage/sqlite/user-context-quality-repository.js";
-import { listUnderstandingEvidence, listUnderstandings, searchActiveUnderstandings } from "../storage/sqlite/user-context-repository.js";
+import { listUnderstandings, searchActiveUnderstandings, understandingSourceBuckets } from "../storage/sqlite/user-context-repository.js";
 import { normalizeRetrievalText, retrievalLexicalSimilarity } from "../retrieval/textFeatures.js";
 import { buildRetrievalQueryProfile } from "../retrieval/queryProfile.js";
 import "../storage/sqlite/index.js";
@@ -32,23 +32,18 @@ function temporalAdjustment(item, hints, now) {
 	}
 	return score;
 }
-function sourceBucket(item) {
-	if (item.explicitness === "explicit") return "user";
-	const evidence = listUnderstandingEvidence(item.id)[0];
-	if (!evidence) return `unknown:${item.id}`;
-	if (evidence.sourceInstanceId) return `${evidence.sourceType}:${evidence.sourceInstanceId}`;
-	return `${evidence.sourceType}:${evidence.sourceRef.split(":entry:")[0]}`;
-}
 function diversify(results, limit) {
 	const remaining = [...results];
 	const selected = [];
 	const sourceCounts = /* @__PURE__ */ new Map();
-	const sourceBuckets = new Map(results.map((result) => [result.understanding.id, sourceBucket(result.understanding)]));
+	const redundancies = /* @__PURE__ */ new Map();
+	const evidenceBuckets = understandingSourceBuckets(results.filter((result) => result.understanding.explicitness !== "explicit").map((result) => result.understanding.id));
+	const sourceBuckets = new Map(results.map(({ understanding: item }) => [item.id, item.explicitness === "explicit" ? "user" : evidenceBuckets.get(item.id) ?? `unknown:${item.id}`]));
 	while (remaining.length && selected.length < limit) {
 		let bestIndex = 0;
 		let bestScore = Number.NEGATIVE_INFINITY;
 		for (const [index, candidate] of remaining.entries()) {
-			const redundancy = selected.reduce((maximum, chosen) => Math.max(maximum, retrievalLexicalSimilarity(candidate.understanding.statement, chosen.understanding.statement)), 0);
+			const redundancy = redundancies.get(candidate.understanding.id) ?? 0;
 			const bucket = sourceBuckets.get(candidate.understanding.id);
 			const sourcePenalty = candidate.understanding.explicitness === "explicit" ? 0 : (sourceCounts.get(bucket) ?? 0) * .04;
 			const adjusted = candidate.score - redundancy * .18 - sourcePenalty;
@@ -65,6 +60,10 @@ function diversify(results, limit) {
 			score: Math.max(0, bestScore),
 			reasons: bestScore < candidate.score ? [...candidate.reasons, "diversified"] : candidate.reasons
 		});
+		if (selected.length < limit) for (const remainingItem of remaining) {
+			const id = remainingItem.understanding.id;
+			redundancies.set(id, Math.max(redundancies.get(id) ?? 0, retrievalLexicalSimilarity(remainingItem.understanding.statement, candidate.understanding.statement)));
+		}
 	}
 	return selected;
 }
@@ -90,7 +89,7 @@ var UserUnderstandingRetriever = class {
 			"active",
 			"archived",
 			"stale"
-		] : ["active"]]).slice(0, recentLimit);
+		] : ["active"]], void 0, recentLimit);
 		const candidates = /* @__PURE__ */ new Map();
 		for (const result of fts) candidates.set(result.understanding.id, result.understanding);
 		for (const item of recent) candidates.set(item.id, item);

package/dist/src/user-context/selection-policy.d.ts

@@ -0,0 +1,20 @@
+import type { UserContextRejectionReason } from '../agent/memory/context/types.js';
+import type { UserUnderstanding } from './domain.js';
+import type { UserFocus } from './sources/types.js';
+/** Automatic remote context never uses sensitive, consent-gated or weakly inferred facts. */
+export declare function allowsAutomaticDisclosure(item: Pick<UserUnderstanding, 'sensitivity' | 'disclosurePolicy' | 'explicitness' | 'confidence'>): boolean;
+export declare function rejectionReason(item: UserUnderstanding, input: {
+    sessionKey: string;
+    workspaceId: string;
+    projectId?: string;
+}, now: number, timeHints: string[]): UserContextRejectionReason | undefined;
+export declare function focusRejectionReason(focus: UserFocus, input: {
+    sessionKey: string;
+    workspaceId: string;
+    projectId?: string;
+}, now: number): UserContextRejectionReason | undefined;
+export declare function focusScore(focus: UserFocus, query: string, scopeInput: {
+    sessionKey: string;
+    workspaceId: string;
+    projectId?: string;
+}): number;

package/dist/src/user-context/selection-policy.js

@@ -0,0 +1,33 @@
+import { retrievalLexicalSimilarity } from "../retrieval/textFeatures.js";
+import { buildRetrievalQueryProfile } from "../retrieval/queryProfile.js";
+import { matchesUserContextScope } from "./scope.js";
+//#region src/user-context/selection-policy.ts
+/** Automatic remote context never uses sensitive, consent-gated or weakly inferred facts. */
+function allowsAutomaticDisclosure(item) {
+	return item.sensitivity === "normal" && item.disclosurePolicy !== "ask_before_reference" && (item.explicitness !== "inferred" || item.confidence >= .8);
+}
+function rejectionReason(item, input, now, timeHints) {
+	const historical = timeHints.includes("historical") && item.validTo !== void 0;
+	if (item.status === "needs_review" || item.status === "candidate" || item.status === "stale" && !historical) return "needs_review";
+	if (item.status === "rejected" || item.status === "archived" && !historical) return "disabled";
+	if (!matchesUserContextScope(item.scope, input)) return "scope_mismatch";
+	if (item.validFrom && item.validFrom > now && !timeHints.includes("future")) return "not_yet_valid";
+	if ((item.validTo && item.validTo < now || item.expiresAt && item.expiresAt < now) && !historical) return "expired";
+	if (item.sensitivity === "secret" || item.sensitivity === "regulated") return "sensitive";
+	if (item.conflictGroupId) return "conflict";
+}
+function focusRejectionReason(focus, input, now) {
+	if (focus.status !== "active") return "disabled";
+	if (!matchesUserContextScope(focus.scope, input)) return "scope_mismatch";
+	if (focus.validFrom && focus.validFrom > now) return "not_yet_valid";
+	if (focus.validTo && focus.validTo < now) return "expired";
+	if (focus.sensitivity === "secret" || focus.sensitivity === "regulated") return "sensitive";
+	if (focus.disclosurePolicy === "ask_before_reference") return "requires_consent";
+}
+function focusScore(focus, query, scopeInput) {
+	const lexical = retrievalLexicalSimilarity(buildRetrievalQueryProfile(query, scopeInput).normalized, `${focus.title} ${focus.summary}`);
+	const scoped = focus.scope.type !== "global" && matchesUserContextScope(focus.scope, scopeInput);
+	return Math.min(1, lexical * .75 + focus.confidence * .15 + (scoped ? .25 : 0));
+}
+//#endregion
+export { allowsAutomaticDisclosure, focusRejectionReason, focusScore, rejectionReason };

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

@@ -1,4 +1,4 @@
-import { createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus } from "./repository.js";
+import { createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus } from "./repository.js";
 import { clusterUnderstandingSignals, tokenizeUnderstandingSignal } from "./signal-clustering.js";
 import { listUnderstandingSourceDefinitions } from "./catalog.js";
-export { clusterUnderstandingSignals, createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceDefinitions, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, tokenizeUnderstandingSignal, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus };
+export { clusterUnderstandingSignals, createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceDefinitions, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, tokenizeUnderstandingSignal, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus };

package/dist/src/user-context/sources/repository.d.ts

@@ -54,7 +54,8 @@ export declare function updateUnderstandingSourceRun(id: string, patch: {
     nowMs?: number;
 }): UnderstandingSourceRun | null;
 export declare function upsertUserFocus(input: UserFocusInput): UserFocus;
-export declare function listUserFocuses(statuses?: UserFocus['status'][]): UserFocus[];
+export declare function listUserFocuses(statuses?: UserFocus['status'][], limit?: number): UserFocus[];
+export declare function getUserFocus(id: string): UserFocus | undefined;
 export declare function updateUserFocus(id: string, patch: Partial<Pick<UserFocus, 'title' | 'summary' | 'status' | 'validFrom' | 'validTo' | 'reviewAt'>>, nowMs?: number): UserFocus | null;
 export declare function deleteUserFocus(id: string): boolean;
 export {};

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>;