@gaodefa/daocore 2026.5.50 → 2026.5.51

package/dist/pw-role-snapshot-BPi5ipRX.js

@@ -0,0 +1,333 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { _ as INTERACTIVE_ROLES, g as CONTENT_ROLES, v as STRUCTURAL_ROLES } from "./chrome-YaZdp6CU.js";
+//#region extensions/browser/src/browser/url-pattern.ts
+function wildcardPatternToRegExp(pattern) {
+	let source = "^";
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index] ?? "";
+		if (char === "*") {
+			if (pattern[index + 1] === "*") {
+				source += ".*";
+				index += 1;
+			} else source += "[^/]*";
+			continue;
+		}
+		source += char.replace(/[\\^$+?.()|[\]{}]/gu, "\\$&");
+	}
+	source += "$";
+	return new RegExp(source, "u");
+}
+function matchBrowserUrlPattern(pattern, url) {
+	const trimmedPattern = pattern.trim();
+	if (!trimmedPattern) return false;
+	if (trimmedPattern === url) return true;
+	if (trimmedPattern === "*") return true;
+	if (trimmedPattern.includes("*")) return wildcardPatternToRegExp(trimmedPattern).test(url);
+	return url.includes(trimmedPattern);
+}
+//#endregion
+//#region extensions/browser/src/browser/act-policy.ts
+const ACT_MAX_CLICK_DELAY_MS = 5e3;
+const ACT_MAX_WAIT_TIME_MS = 3e4;
+const ACT_MIN_TIMEOUT_MS = 500;
+const ACT_MAX_INTERACTION_TIMEOUT_MS = 6e4;
+const ACT_MAX_WAIT_TIMEOUT_MS = 12e4;
+const ACT_DEFAULT_INTERACTION_TIMEOUT_MS = 8e3;
+const ACT_DEFAULT_WAIT_TIMEOUT_MS = 2e4;
+function normalizeActBoundedNonNegativeMs(value, fieldName, maxMs) {
+	if (value === void 0) return;
+	if (!Number.isFinite(value) || value < 0) throw new Error(`${fieldName} must be >= 0`);
+	const normalized = Math.floor(value);
+	if (normalized > maxMs) throw new Error(`${fieldName} exceeds maximum of ${maxMs}ms`);
+	return normalized;
+}
+function resolveActInteractionTimeoutMs(timeoutMs) {
+	return Math.max(ACT_MIN_TIMEOUT_MS, Math.min(ACT_MAX_INTERACTION_TIMEOUT_MS, typeof timeoutMs === "number" && Number.isFinite(timeoutMs) ? Math.floor(timeoutMs) : ACT_DEFAULT_INTERACTION_TIMEOUT_MS));
+}
+function resolveActWaitTimeoutMs(timeoutMs) {
+	return Math.max(ACT_MIN_TIMEOUT_MS, Math.min(ACT_MAX_WAIT_TIMEOUT_MS, typeof timeoutMs === "number" && Number.isFinite(timeoutMs) ? Math.floor(timeoutMs) : ACT_DEFAULT_WAIT_TIMEOUT_MS));
+}
+//#endregion
+//#region extensions/browser/src/browser/form-fields.ts
+const DEFAULT_FILL_FIELD_TYPE = "text";
+function normalizeBrowserFormFieldRef(value) {
+	return normalizeOptionalString(value) ?? "";
+}
+function normalizeBrowserFormFieldType(value) {
+	return (normalizeOptionalString(value) ?? "") || "text";
+}
+function normalizeBrowserFormFieldValue(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : void 0;
+}
+function normalizeBrowserFormField(record) {
+	const ref = normalizeBrowserFormFieldRef(record.ref);
+	if (!ref) return null;
+	const type = normalizeBrowserFormFieldType(record.type);
+	const value = normalizeBrowserFormFieldValue(record.value);
+	return value === void 0 ? {
+		ref,
+		type
+	} : {
+		ref,
+		type,
+		value
+	};
+}
+//#endregion
+//#region extensions/browser/src/browser/pw-role-snapshot.ts
+function getRoleSnapshotStats(snapshot, refs) {
+	const interactive = Object.values(refs).filter((r) => INTERACTIVE_ROLES.has(r.role)).length;
+	return {
+		lines: snapshot.split("\n").length,
+		chars: snapshot.length,
+		refs: Object.keys(refs).length,
+		interactive
+	};
+}
+function getIndentLevel(line) {
+	const match = line.match(/^(\s*)/);
+	return match ? Math.floor(match[1].length / 2) : 0;
+}
+function matchInteractiveSnapshotLine(line, options) {
+	const depth = getIndentLevel(line);
+	if (options.maxDepth !== void 0 && depth > options.maxDepth) return null;
+	const match = line.match(/^(\s*-\s*)(\w+)(?:\s+"([^"]*)")?(.*)$/);
+	if (!match) return null;
+	const [, , roleRaw, name, suffix] = match;
+	if (roleRaw.startsWith("/")) return null;
+	return {
+		roleRaw,
+		role: normalizeLowercaseStringOrEmpty(roleRaw),
+		...name ? { name } : {},
+		suffix
+	};
+}
+function createRoleNameTracker() {
+	const counts = /* @__PURE__ */ new Map();
+	const refsByKey = /* @__PURE__ */ new Map();
+	return {
+		counts,
+		refsByKey,
+		getKey(role, name) {
+			return `${role}:${name ?? ""}`;
+		},
+		getNextIndex(role, name) {
+			const key = this.getKey(role, name);
+			const current = counts.get(key) ?? 0;
+			counts.set(key, current + 1);
+			return current;
+		},
+		trackRef(role, name, ref) {
+			const key = this.getKey(role, name);
+			const list = refsByKey.get(key) ?? [];
+			list.push(ref);
+			refsByKey.set(key, list);
+		},
+		getDuplicateKeys() {
+			const out = /* @__PURE__ */ new Set();
+			for (const [key, refs] of refsByKey) if (refs.length > 1) out.add(key);
+			return out;
+		}
+	};
+}
+function removeNthFromNonDuplicates(refs, tracker) {
+	const duplicates = tracker.getDuplicateKeys();
+	for (const [ref, data] of Object.entries(refs)) {
+		const key = tracker.getKey(data.role, data.name);
+		if (!duplicates.has(key)) delete refs[ref]?.nth;
+	}
+}
+function compactTree(tree) {
+	const lines = tree.split("\n");
+	const result = [];
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i];
+		if (line.includes("[ref=")) {
+			result.push(line);
+			continue;
+		}
+		if (line.includes(":") && !line.trimEnd().endsWith(":")) {
+			result.push(line);
+			continue;
+		}
+		const currentIndent = getIndentLevel(line);
+		let hasRelevantChildren = false;
+		for (let j = i + 1; j < lines.length; j += 1) {
+			if (getIndentLevel(lines[j]) <= currentIndent) break;
+			if (lines[j]?.includes("[ref=")) {
+				hasRelevantChildren = true;
+				break;
+			}
+		}
+		if (hasRelevantChildren) result.push(line);
+	}
+	return result.join("\n");
+}
+function processLine(line, refs, options, tracker, nextRef) {
+	const depth = getIndentLevel(line);
+	if (options.maxDepth !== void 0 && depth > options.maxDepth) return null;
+	const match = line.match(/^(\s*-\s*)(\w+)(?:\s+"([^"]*)")?(.*)$/);
+	if (!match) return options.interactive ? null : line;
+	const [, prefix, roleRaw, name, suffix] = match;
+	if (roleRaw.startsWith("/")) return options.interactive ? null : line;
+	const role = normalizeLowercaseStringOrEmpty(roleRaw);
+	const isInteractive = INTERACTIVE_ROLES.has(role);
+	const isContent = CONTENT_ROLES.has(role);
+	const isStructural = STRUCTURAL_ROLES.has(role);
+	if (options.interactive && !isInteractive) return null;
+	if (options.compact && isStructural && !name) return null;
+	if (!(isInteractive || isContent && name)) return line;
+	const ref = nextRef();
+	const nth = tracker.getNextIndex(role, name);
+	tracker.trackRef(role, name, ref);
+	refs[ref] = {
+		role,
+		name,
+		nth
+	};
+	let enhanced = `${prefix}${roleRaw}`;
+	if (name) enhanced += ` "${name}"`;
+	enhanced += ` [ref=${ref}]`;
+	if (nth > 0) enhanced += ` [nth=${nth}]`;
+	if (suffix) enhanced += suffix;
+	return enhanced;
+}
+function buildInteractiveSnapshotLines(params) {
+	const out = [];
+	for (const line of params.lines) {
+		const parsed = matchInteractiveSnapshotLine(line, params.options);
+		if (!parsed) continue;
+		if (!INTERACTIVE_ROLES.has(parsed.role)) continue;
+		const resolved = params.resolveRef(parsed);
+		if (!resolved?.ref) continue;
+		params.recordRef(parsed, resolved.ref, resolved.nth);
+		let enhanced = `- ${parsed.roleRaw}`;
+		if (parsed.name) enhanced += ` "${parsed.name}"`;
+		enhanced += ` [ref=${resolved.ref}]`;
+		if ((resolved.nth ?? 0) > 0) enhanced += ` [nth=${resolved.nth}]`;
+		if (params.includeSuffix(parsed.suffix)) enhanced += parsed.suffix;
+		out.push(enhanced);
+	}
+	return out;
+}
+function parseRoleRef(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const normalized = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed.startsWith("ref=") ? trimmed.slice(4) : trimmed;
+	if (/^e\d+$/i.test(normalized)) return normalized;
+	if (/^\d{1,9}$/.test(normalized)) return normalized;
+	return null;
+}
+function buildRoleSnapshotFromAriaSnapshot(ariaSnapshot, options = {}) {
+	const lines = ariaSnapshot.split("\n");
+	const refs = {};
+	const tracker = createRoleNameTracker();
+	let counter = 0;
+	const nextRef = () => {
+		counter += 1;
+		return `e${counter}`;
+	};
+	if (options.interactive) {
+		const result = buildInteractiveSnapshotLines({
+			lines,
+			options,
+			resolveRef: ({ role, name }) => {
+				const ref = nextRef();
+				const nth = tracker.getNextIndex(role, name);
+				tracker.trackRef(role, name, ref);
+				return {
+					ref,
+					nth
+				};
+			},
+			recordRef: ({ role, name }, ref, nth) => {
+				refs[ref] = {
+					role,
+					name,
+					nth
+				};
+			},
+			includeSuffix: (suffix) => suffix.includes("[")
+		});
+		removeNthFromNonDuplicates(refs, tracker);
+		return {
+			snapshot: result.join("\n") || "(no interactive elements)",
+			refs
+		};
+	}
+	const result = [];
+	for (const line of lines) {
+		const processed = processLine(line, refs, options, tracker, nextRef);
+		if (processed !== null) result.push(processed);
+	}
+	removeNthFromNonDuplicates(refs, tracker);
+	const tree = result.join("\n") || "(empty)";
+	return {
+		snapshot: options.compact ? compactTree(tree) : tree,
+		refs
+	};
+}
+function parseAiSnapshotRef(suffix) {
+	const eMatch = suffix.match(/\[ref=(e\d+)\]/i);
+	if (eMatch) return eMatch[1];
+	const numMatch = suffix.match(/\[ref=(\d{1,9})\]/);
+	return numMatch ? numMatch[1] : null;
+}
+/**
+* Build a role snapshot from Playwright's AI snapshot output while preserving Playwright's own
+* aria-ref ids (e.g. ref=e13). This makes the refs self-resolving across calls.
+*/
+function buildRoleSnapshotFromAiSnapshot(aiSnapshot, options = {}) {
+	const lines = aiSnapshot.split("\n");
+	const refs = {};
+	if (options.interactive) return {
+		snapshot: buildInteractiveSnapshotLines({
+			lines,
+			options,
+			resolveRef: ({ suffix }) => {
+				const ref = parseAiSnapshotRef(suffix);
+				return ref ? { ref } : null;
+			},
+			recordRef: ({ role, name }, ref) => {
+				refs[ref] = {
+					role,
+					...name ? { name } : {}
+				};
+			},
+			includeSuffix: () => true
+		}).join("\n") || "(no interactive elements)",
+		refs
+	};
+	const out = [];
+	for (const line of lines) {
+		const depth = getIndentLevel(line);
+		if (options.maxDepth !== void 0 && depth > options.maxDepth) continue;
+		const match = line.match(/^(\s*-\s*)(\w+)(?:\s+"([^"]*)")?(.*)$/);
+		if (!match) {
+			out.push(line);
+			continue;
+		}
+		const [, , roleRaw, name, suffix] = match;
+		if (roleRaw.startsWith("/")) {
+			out.push(line);
+			continue;
+		}
+		const role = normalizeLowercaseStringOrEmpty(roleRaw);
+		const isStructural = STRUCTURAL_ROLES.has(role);
+		if (options.compact && isStructural && !name) continue;
+		const ref = parseAiSnapshotRef(suffix);
+		if (ref) refs[ref] = {
+			role,
+			...name ? { name } : {}
+		};
+		out.push(line);
+	}
+	const tree = out.join("\n") || "(empty)";
+	return {
+		snapshot: options.compact ? compactTree(tree) : tree,
+		refs
+	};
+}
+//#endregion
+export { DEFAULT_FILL_FIELD_TYPE as a, ACT_MAX_CLICK_DELAY_MS as c, resolveActInteractionTimeoutMs as d, resolveActWaitTimeoutMs as f, parseRoleRef as i, ACT_MAX_WAIT_TIME_MS as l, buildRoleSnapshotFromAriaSnapshot as n, normalizeBrowserFormField as o, matchBrowserUrlPattern as p, getRoleSnapshotStats as r, normalizeBrowserFormFieldValue as s, buildRoleSnapshotFromAiSnapshot as t, normalizeActBoundedNonNegativeMs as u };

package/dist/reaction-level-CSHisLIF.js

@@ -0,0 +1,19 @@
+import { t as resolveReactionLevel } from "./reaction-level-Djuz3vHr.js";
+import "./status-helpers-nyf_mfYa.js";
+import { o as resolveTelegramAccount } from "./accounts-xBYbyTsZ.js";
+//#region extensions/telegram/src/reaction-level.ts
+/**
+* Resolve the effective reaction level and its implications.
+*/
+function resolveTelegramReactionLevel(params) {
+	return resolveReactionLevel({
+		value: resolveTelegramAccount({
+			cfg: params.cfg,
+			accountId: params.accountId
+		}).config.reactionLevel,
+		defaultLevel: "minimal",
+		invalidFallback: "ack"
+	});
+}
+//#endregion
+export { resolveTelegramReactionLevel as t };

package/dist/reaction-runtime-api-D5YNDU-7.js

@@ -0,0 +1,116 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DyL154ka.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { t as requireRuntimeConfig } from "./plugin-config-runtime-BhkqZ7bA.js";
+import { i as resolveSignalAccount } from "./accounts-Cya7YPL4.js";
+import { n as signalRpcRequest } from "./client-adapter-BKZ5qBVY.js";
+import { t as resolveSignalRpcContext } from "./rpc-context-D3-lLVdI.js";
+//#region extensions/signal/src/send-reactions.ts
+function normalizeSignalId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	return trimmed.replace(/^signal:/i, "").trim();
+}
+function normalizeSignalUuid(raw) {
+	const trimmed = normalizeSignalId(raw);
+	if (!trimmed) return "";
+	if (normalizeLowercaseStringOrEmpty(trimmed).startsWith("uuid:")) return trimmed.slice(5).trim();
+	return trimmed;
+}
+function resolveTargetAuthorParams(params) {
+	const candidates = [
+		params.targetAuthor,
+		params.targetAuthorUuid,
+		params.fallback
+	];
+	for (const candidate of candidates) {
+		const raw = candidate?.trim();
+		if (!raw) continue;
+		const normalized = normalizeSignalUuid(raw);
+		if (normalized) return { targetAuthor: normalized };
+	}
+	return {};
+}
+async function sendReactionSignalCore(params) {
+	const cfg = requireRuntimeConfig(params.opts.cfg, "Signal reactions");
+	const apiMode = cfg.channels?.signal?.apiMode;
+	const accountInfo = resolveSignalAccount({
+		cfg,
+		accountId: params.opts.accountId
+	});
+	const { baseUrl, account } = resolveSignalRpcContext(params.opts, accountInfo);
+	const normalizedRecipient = normalizeSignalUuid(params.recipient);
+	const groupId = params.opts.groupId?.trim();
+	if (!normalizedRecipient && !groupId) throw new Error(params.errors.missingRecipient);
+	if (!Number.isFinite(params.targetTimestamp) || params.targetTimestamp <= 0) throw new Error(params.errors.invalidTargetTimestamp);
+	const normalizedEmoji = params.emoji?.trim();
+	if (!normalizedEmoji) throw new Error(params.errors.missingEmoji);
+	const targetAuthorParams = resolveTargetAuthorParams({
+		targetAuthor: params.opts.targetAuthor,
+		targetAuthorUuid: params.opts.targetAuthorUuid,
+		fallback: normalizedRecipient
+	});
+	if (groupId && !targetAuthorParams.targetAuthor) throw new Error(params.errors.missingTargetAuthor);
+	const requestParams = {
+		emoji: normalizedEmoji,
+		targetTimestamp: params.targetTimestamp,
+		...params.remove ? { remove: true } : {},
+		...targetAuthorParams
+	};
+	if (normalizedRecipient) requestParams.recipients = [normalizedRecipient];
+	if (groupId) requestParams.groupIds = [groupId];
+	if (account) requestParams.account = account;
+	return {
+		ok: true,
+		timestamp: (await signalRpcRequest("sendReaction", requestParams, {
+			baseUrl,
+			timeoutMs: params.opts.timeoutMs,
+			apiMode
+		}))?.timestamp
+	};
+}
+/**
+* Send a Signal reaction to a message
+* @param recipient - UUID or E.164 phone number of the message author
+* @param targetTimestamp - Message ID (timestamp) to react to
+* @param emoji - Emoji to react with
+* @param opts - Optional account/connection overrides
+*/
+async function sendReactionSignal(recipient, targetTimestamp, emoji, opts) {
+	return await sendReactionSignalCore({
+		recipient,
+		targetTimestamp,
+		emoji,
+		remove: false,
+		opts,
+		errors: {
+			missingRecipient: "Recipient or groupId is required for Signal reaction",
+			invalidTargetTimestamp: "Valid targetTimestamp is required for Signal reaction",
+			missingEmoji: "Emoji is required for Signal reaction",
+			missingTargetAuthor: "targetAuthor is required for group reactions"
+		}
+	});
+}
+/**
+* Remove a Signal reaction from a message
+* @param recipient - UUID or E.164 phone number of the message author
+* @param targetTimestamp - Message ID (timestamp) to remove reaction from
+* @param emoji - Emoji to remove
+* @param opts - Optional account/connection overrides
+*/
+async function removeReactionSignal(recipient, targetTimestamp, emoji, opts) {
+	return await sendReactionSignalCore({
+		recipient,
+		targetTimestamp,
+		emoji,
+		remove: true,
+		opts,
+		errors: {
+			missingRecipient: "Recipient or groupId is required for Signal reaction removal",
+			invalidTargetTimestamp: "Valid targetTimestamp is required for Signal reaction removal",
+			missingEmoji: "Emoji is required for Signal reaction removal",
+			missingTargetAuthor: "targetAuthor is required for group reaction removal"
+		}
+	});
+}
+//#endregion
+export { sendReactionSignal as n, removeReactionSignal as t };

package/dist/realtime-transcription-provider-B6-wne03.js

@@ -0,0 +1,205 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { u as normalizeResolvedSecretInputString } from "./types.secrets-Ct1DNG7D.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { i as isProviderAuthProfileConfigured } from "./provider-auth-B-d9TlzW.js";
+import "./secret-input-s8BgZnEq.js";
+import { o as resolveApiKeyForProvider } from "./provider-auth-runtime-Dv3hywsv.js";
+import { t as createRealtimeTranscriptionWebSocketSession } from "./realtime-transcription-Blcdj2oQ.js";
+import "./model-definitions-Dzf2Ay5M.js";
+import { n as xaiUserAgentHeaderFor } from "./xai-user-agent-BE2MgJak.js";
+//#region extensions/xai/realtime-transcription-provider.ts
+const XAI_REALTIME_STT_DEFAULT_SAMPLE_RATE = 8e3;
+const XAI_REALTIME_STT_DEFAULT_ENCODING = "mulaw";
+const XAI_REALTIME_STT_DEFAULT_ENDPOINTING_MS = 800;
+const XAI_REALTIME_STT_CONNECT_TIMEOUT_MS = 1e4;
+const XAI_REALTIME_STT_CLOSE_TIMEOUT_MS = 5e3;
+const XAI_REALTIME_STT_MAX_RECONNECT_ATTEMPTS = 5;
+const XAI_REALTIME_STT_RECONNECT_DELAY_MS = 1e3;
+const XAI_REALTIME_STT_MAX_QUEUED_BYTES = 2 * 1024 * 1024;
+function readRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+function readNestedXaiConfig(rawConfig) {
+	const raw = readRecord(rawConfig);
+	return readRecord(readRecord(raw?.providers)?.xai ?? raw?.xai ?? raw) ?? {};
+}
+function readFiniteNumber(value) {
+	const next = typeof value === "number" ? value : typeof value === "string" ? Number.parseFloat(value) : void 0;
+	return Number.isFinite(next) ? next : void 0;
+}
+function readBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return;
+	const normalized = value.trim().toLowerCase();
+	if ([
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(normalized)) return true;
+	if ([
+		"0",
+		"false",
+		"no",
+		"off"
+	].includes(normalized)) return false;
+}
+function normalizeEncoding(value) {
+	const normalized = normalizeOptionalString(value)?.toLowerCase();
+	if (!normalized) return;
+	if (normalized === "ulaw" || normalized === "g711_ulaw" || normalized === "g711-mulaw") return "mulaw";
+	if (normalized === "g711_alaw" || normalized === "g711-alaw") return "alaw";
+	if (normalized === "pcm" || normalized === "mulaw" || normalized === "alaw") return normalized;
+	throw new Error(`Invalid xAI realtime transcription encoding: ${normalized}`);
+}
+function normalizeXaiRealtimeBaseUrl(value) {
+	return normalizeOptionalString(value ?? process.env.XAI_BASE_URL) ?? "https://api.x.ai/v1";
+}
+function toXaiRealtimeWsUrl(config) {
+	const url = new URL(normalizeXaiRealtimeBaseUrl(config.baseUrl));
+	url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+	url.pathname = `${url.pathname.replace(/\/+$/, "")}/stt`;
+	url.searchParams.set("sample_rate", String(config.sampleRate));
+	url.searchParams.set("encoding", config.encoding);
+	url.searchParams.set("interim_results", String(config.interimResults));
+	url.searchParams.set("endpointing", String(config.endpointingMs));
+	if (config.language) url.searchParams.set("language", config.language);
+	return url.toString();
+}
+function normalizeProviderConfig(config) {
+	const raw = readNestedXaiConfig(config);
+	return {
+		apiKey: normalizeResolvedSecretInputString({
+			value: raw.apiKey,
+			path: "plugins.entries.voice-call.config.streaming.providers.xai.apiKey"
+		}),
+		baseUrl: normalizeOptionalString(raw.baseUrl),
+		sampleRate: readFiniteNumber(raw.sampleRate ?? raw.sample_rate),
+		encoding: normalizeEncoding(raw.encoding),
+		interimResults: readBoolean(raw.interimResults ?? raw.interim_results),
+		endpointingMs: readFiniteNumber(raw.endpointingMs ?? raw.endpointing ?? raw.silenceDurationMs),
+		language: normalizeOptionalString(raw.language)
+	};
+}
+function readErrorDetail(value) {
+	if (typeof value === "string") return value;
+	const record = readRecord(value);
+	const message = normalizeOptionalString(record?.message);
+	const code = normalizeOptionalString(record?.code);
+	return message ?? code ?? "xAI realtime transcription error";
+}
+function readTranscriptText(event) {
+	return normalizeOptionalString(event.text ?? event.transcript);
+}
+function createXaiRealtimeTranscriptionSession(config) {
+	let lastTranscript;
+	let speechStarted = false;
+	const emitTranscript = (text) => {
+		if (text === lastTranscript) return;
+		lastTranscript = text;
+		config.onTranscript?.(text);
+	};
+	const handleEvent = (event, transport) => {
+		if (event.type === "transcript.created") {
+			transport.markReady();
+			return;
+		}
+		if (!transport.isReady() && event.type === "error") {
+			transport.failConnect(new Error(readErrorDetail(event.error ?? event.message)));
+			return;
+		}
+		switch (event.type) {
+			case "transcript.partial": {
+				const text = readTranscriptText(event);
+				if (!text) return;
+				if (!speechStarted) {
+					speechStarted = true;
+					config.onSpeechStart?.();
+				}
+				if (event.is_final && event.speech_final) {
+					emitTranscript(text);
+					speechStarted = false;
+					return;
+				}
+				config.onPartial?.(text);
+				return;
+			}
+			case "transcript.done": {
+				const text = readTranscriptText(event);
+				if (text) emitTranscript(text);
+				transport.closeNow();
+				return;
+			}
+			case "error":
+				config.onError?.(new Error(readErrorDetail(event.error ?? event.message)));
+				return;
+			default: return;
+		}
+	};
+	return createRealtimeTranscriptionWebSocketSession({
+		providerId: "xai",
+		callbacks: config,
+		url: () => toXaiRealtimeWsUrl(config),
+		headers: async () => {
+			return {
+				Authorization: `Bearer ${config.resolveApiKey ? await config.resolveApiKey() : config.apiKey}`,
+				...xaiUserAgentHeaderFor(config.baseUrl)
+			};
+		},
+		connectTimeoutMs: XAI_REALTIME_STT_CONNECT_TIMEOUT_MS,
+		closeTimeoutMs: XAI_REALTIME_STT_CLOSE_TIMEOUT_MS,
+		maxReconnectAttempts: XAI_REALTIME_STT_MAX_RECONNECT_ATTEMPTS,
+		reconnectDelayMs: XAI_REALTIME_STT_RECONNECT_DELAY_MS,
+		maxQueuedBytes: XAI_REALTIME_STT_MAX_QUEUED_BYTES,
+		connectTimeoutMessage: "xAI realtime transcription connection timeout",
+		connectClosedBeforeReadyMessage: "xAI realtime transcription connection closed before ready",
+		reconnectLimitMessage: "xAI realtime transcription reconnect limit reached",
+		sendAudio: (audio, transport) => {
+			transport.sendBinary(audio);
+		},
+		onClose: (transport) => {
+			transport.sendJson({ type: "audio.done" });
+		},
+		onMessage: handleEvent
+	});
+}
+function buildXaiRealtimeTranscriptionProvider() {
+	return {
+		id: "xai",
+		label: "xAI Realtime Transcription",
+		aliases: ["xai-realtime", "grok-stt-streaming"],
+		autoSelectOrder: 25,
+		resolveConfig: ({ rawConfig }) => normalizeProviderConfig(rawConfig),
+		isConfigured: ({ providerConfig, cfg }) => Boolean(normalizeProviderConfig(providerConfig).apiKey || process.env.XAI_API_KEY) || isProviderAuthProfileConfigured({
+			provider: "xai",
+			cfg
+		}),
+		createSession: (req) => {
+			const config = normalizeProviderConfig(req.providerConfig);
+			const seedApiKey = normalizeOptionalString(config.apiKey) ?? normalizeOptionalString(process.env.XAI_API_KEY);
+			return createXaiRealtimeTranscriptionSession({
+				...req,
+				apiKey: seedApiKey ?? "",
+				resolveApiKey: () => resolveXaiRealtimeApiKey(config.apiKey, req.cfg),
+				baseUrl: normalizeXaiRealtimeBaseUrl(config.baseUrl),
+				sampleRate: config.sampleRate ?? XAI_REALTIME_STT_DEFAULT_SAMPLE_RATE,
+				encoding: config.encoding ?? XAI_REALTIME_STT_DEFAULT_ENCODING,
+				interimResults: config.interimResults ?? true,
+				endpointingMs: config.endpointingMs ?? XAI_REALTIME_STT_DEFAULT_ENDPOINTING_MS,
+				language: config.language
+			});
+		}
+	};
+}
+async function resolveXaiRealtimeApiKey(configApiKey, cfg) {
+	const direct = normalizeOptionalString(configApiKey) ?? normalizeOptionalString(process.env.XAI_API_KEY);
+	if (direct) return direct;
+	const oauthKey = normalizeOptionalString((await resolveApiKeyForProvider({
+		provider: "xai",
+		cfg
+	}))?.apiKey);
+	if (oauthKey) return oauthKey;
+	throw new Error("xAI credentials missing for realtime STT. Sign in with `daocore onboard --auth-choice xai-oauth`, or run `daocore onboard --auth-choice xai-api-key`, or set XAI_API_KEY.");
+}
+//#endregion
+export { buildXaiRealtimeTranscriptionProvider as t };