@gaodefa/daocore 2026.5.101 → 2026.5.102

package/dist/realtime-transcription-provider-DT819J6s.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-Ba3D96rP.js";
+import "./secret-input-s8BgZnEq.js";
+import { o as resolveApiKeyForProvider } from "./provider-auth-runtime-Ry__x8xg.js";
+import { t as createRealtimeTranscriptionWebSocketSession } from "./realtime-transcription-C6qWujEl.js";
+import "./model-definitions-Dzf2Ay5M.js";
+import { n as xaiUserAgentHeaderFor } from "./xai-user-agent-hnVApwlq.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 };

package/dist/realtime-transcription-provider-DTYtMlJi.d.ts

@@ -0,0 +1,28 @@
+import { $r as RealtimeTranscriptionProviderConfig, Un as RealtimeTranscriptionProviderPlugin, ai as RealtimeTranscriptionSessionCreateRequest } from "./types-Zj4Bq9h-2.js";
+//#region extensions/mistral/realtime-transcription-provider.d.ts
+type MistralRealtimeTranscriptionEncoding = "pcm_s16le" | "pcm_s32le" | "pcm_f16le" | "pcm_f32le" | "pcm_mulaw" | "pcm_alaw";
+type MistralRealtimeTranscriptionProviderConfig = {
+  apiKey?: string;
+  baseUrl?: string;
+  model?: string;
+  sampleRate?: number;
+  encoding?: MistralRealtimeTranscriptionEncoding;
+  targetStreamingDelayMs?: number;
+};
+type MistralRealtimeTranscriptionSessionConfig = RealtimeTranscriptionSessionCreateRequest & {
+  apiKey: string;
+  baseUrl: string;
+  model: string;
+  sampleRate: number;
+  encoding: MistralRealtimeTranscriptionEncoding;
+  targetStreamingDelayMs?: number;
+};
+declare function toMistralRealtimeWsUrl(config: MistralRealtimeTranscriptionSessionConfig): string;
+declare function normalizeProviderConfig(config: RealtimeTranscriptionProviderConfig): MistralRealtimeTranscriptionProviderConfig;
+declare function buildMistralRealtimeTranscriptionProvider(): RealtimeTranscriptionProviderPlugin;
+declare const testing: {
+  normalizeProviderConfig: typeof normalizeProviderConfig;
+  toMistralRealtimeWsUrl: typeof toMistralRealtimeWsUrl;
+};
+//#endregion
+export { testing as n, buildMistralRealtimeTranscriptionProvider as t };

package/dist/realtime-transcription-provider-DirKeOjA.d.ts

@@ -0,0 +1,32 @@
+import { $r as RealtimeTranscriptionProviderConfig, Un as RealtimeTranscriptionProviderPlugin, ai as RealtimeTranscriptionSessionCreateRequest } from "./types-Zj4Bq9h-2.js";
+//#region extensions/deepgram/realtime-transcription-provider.d.ts
+type DeepgramRealtimeTranscriptionEncoding = "linear16" | "mulaw" | "alaw";
+type DeepgramRealtimeTranscriptionProviderConfig = {
+  apiKey?: string;
+  baseUrl?: string;
+  model?: string;
+  language?: string;
+  sampleRate?: number;
+  encoding?: DeepgramRealtimeTranscriptionEncoding;
+  interimResults?: boolean;
+  endpointingMs?: number;
+};
+type DeepgramRealtimeTranscriptionSessionConfig = RealtimeTranscriptionSessionCreateRequest & {
+  apiKey: string;
+  baseUrl: string;
+  model: string;
+  sampleRate: number;
+  encoding: DeepgramRealtimeTranscriptionEncoding;
+  interimResults: boolean;
+  endpointingMs: number;
+  language?: string;
+};
+declare function toDeepgramRealtimeWsUrl(config: DeepgramRealtimeTranscriptionSessionConfig): string;
+declare function normalizeProviderConfig(config: RealtimeTranscriptionProviderConfig): DeepgramRealtimeTranscriptionProviderConfig;
+declare function buildDeepgramRealtimeTranscriptionProvider(): RealtimeTranscriptionProviderPlugin;
+declare const testing: {
+  normalizeProviderConfig: typeof normalizeProviderConfig;
+  toDeepgramRealtimeWsUrl: typeof toDeepgramRealtimeWsUrl;
+};
+//#endregion
+export { testing as n, buildDeepgramRealtimeTranscriptionProvider as t };

package/dist/realtime-transcription-provider-QHEXWhCJ.d.ts

@@ -0,0 +1,37 @@
+import { $r as RealtimeTranscriptionProviderConfig, Un as RealtimeTranscriptionProviderPlugin, ai as RealtimeTranscriptionSessionCreateRequest } from "./types-Zj4Bq9h-2.js";
+//#region extensions/elevenlabs/realtime-transcription-provider.d.ts
+type ElevenLabsRealtimeTranscriptionProviderConfig = {
+  apiKey?: string;
+  baseUrl?: string;
+  modelId?: string;
+  audioFormat?: string;
+  sampleRate?: number;
+  languageCode?: string;
+  commitStrategy?: "manual" | "vad";
+  vadSilenceThresholdSecs?: number;
+  vadThreshold?: number;
+  minSpeechDurationMs?: number;
+  minSilenceDurationMs?: number;
+};
+type ElevenLabsRealtimeTranscriptionSessionConfig = RealtimeTranscriptionSessionCreateRequest & {
+  apiKey: string;
+  baseUrl: string;
+  modelId: string;
+  audioFormat: string;
+  sampleRate: number;
+  commitStrategy: "manual" | "vad";
+  languageCode?: string;
+  vadSilenceThresholdSecs?: number;
+  vadThreshold?: number;
+  minSpeechDurationMs?: number;
+  minSilenceDurationMs?: number;
+};
+declare function normalizeProviderConfig(config: RealtimeTranscriptionProviderConfig): ElevenLabsRealtimeTranscriptionProviderConfig;
+declare function toElevenLabsRealtimeWsUrl(config: ElevenLabsRealtimeTranscriptionSessionConfig): string;
+declare function buildElevenLabsRealtimeTranscriptionProvider(): RealtimeTranscriptionProviderPlugin;
+declare const testing: {
+  normalizeProviderConfig: typeof normalizeProviderConfig;
+  toElevenLabsRealtimeWsUrl: typeof toElevenLabsRealtimeWsUrl;
+};
+//#endregion
+export { testing as n, buildElevenLabsRealtimeTranscriptionProvider as t };

package/dist/realtime-voice-Bm0GBqnc.d.ts

@@ -0,0 +1,333 @@
+import { r as DaoCoreConfig } from "./types.daocore-z1fablj2.js";
+import { r as RunEmbeddedPiAgentParams } from "./params-B9zl5aza.js";
+import { o as PluginRuntimeCore, s as RuntimeLogger } from "./types-core-Cv9NMS_3.js";
+import { Br as RealtimeVoiceBridgeEvent, Fr as RealtimeVoiceAudioFormat, Gr as RealtimeVoiceProviderConfig, Ir as RealtimeVoiceBargeInOptions, Lr as RealtimeVoiceBridge, Qr as RealtimeVoiceToolResultOptions, Ur as RealtimeVoiceCloseReason, Wn as RealtimeVoiceProviderPlugin, Xr as RealtimeVoiceTool, Yr as RealtimeVoiceRole, Zr as RealtimeVoiceToolCallEvent, qr as RealtimeVoiceProviderId } from "./types-Zj4Bq9h-2.js";
+import { Dt as TalkEventInput, Et as TalkEventContext, Ot as TalkEventSequencer, Tt as TalkEvent, r as DiagnosticEventInput } from "./diagnostic-events-40PKpvsr.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/talk/diagnostics.d.ts
+type TalkDiagnosticEventInput = Extract<DiagnosticEventInput, {
+  type: "talk.event";
+}>;
+declare function createTalkDiagnosticEvent(event: TalkEvent): TalkDiagnosticEventInput;
+declare function recordTalkDiagnosticEvent(event: TalkEvent): void;
+//#endregion
+//#region src/talk/logging.d.ts
+type TalkLogLevel = "info" | "warn";
+type TalkLogRecord = {
+  level: TalkLogLevel;
+  message: string;
+  attributes: Record<string, string | number | boolean>;
+};
+declare function createTalkLogRecord(event: TalkEvent): TalkLogRecord | undefined;
+declare function recordTalkLogEvent(event: TalkEvent): void;
+//#endregion
+//#region src/talk/observability.d.ts
+declare function recordTalkObservabilityEvent(event: TalkEvent): void;
+//#endregion
+//#region src/talk/talk-session-controller.d.ts
+type TalkTurnFailureReason = "no_active_turn" | "stale_turn";
+type TalkTurnSuccess = {
+  event: TalkEvent;
+  ok: true;
+  turnId: string;
+};
+type TalkTurnFailure = {
+  ok: false;
+  reason: TalkTurnFailureReason;
+};
+type TalkTurnResult = TalkTurnSuccess | TalkTurnFailure;
+type TalkEnsureTurnResult = {
+  event?: TalkEvent;
+  turnId: string;
+};
+type TalkSessionController = {
+  readonly activeTurnId: string | undefined;
+  readonly context: TalkEventContext;
+  readonly outputAudioActive: boolean;
+  readonly recentEvents: readonly TalkEvent[];
+  clearActiveTurn(): void;
+  emit<TPayload>(input: TalkEventInput<TPayload>): TalkEvent<TPayload>;
+  ensureTurn(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkEnsureTurnResult;
+  startTurn(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkEnsureTurnResult;
+  endTurn(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkTurnResult;
+  cancelTurn(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkTurnResult;
+  finishOutputAudio(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkEvent | undefined;
+  startOutputAudio(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkEnsureTurnResult;
+};
+type TalkSessionControllerParams = TalkEventContext & {
+  maxRecentEvents?: number;
+  turnIdPrefix?: string;
+};
+type TalkSessionControllerOptions = {
+  now?: () => Date | string;
+  onEvent?: (event: TalkEvent) => void;
+  sequencer?: TalkEventSequencer;
+};
+declare function createTalkSessionController(params: TalkSessionControllerParams, options?: TalkSessionControllerOptions): TalkSessionController;
+declare function normalizeTalkTransport(value: string | undefined): string | undefined;
+//#endregion
+//#region src/talk/agent-consult-tool.d.ts
+declare const REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME = "daocore_agent_consult";
+declare const REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES: readonly ["safe-read-only", "owner", "none"];
+type RealtimeVoiceAgentConsultToolPolicy = (typeof REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES)[number];
+type RealtimeVoiceAgentConsultArgs = {
+  question: string;
+  context?: string;
+  responseStyle?: string;
+};
+type RealtimeVoiceAgentConsultTranscriptEntry = {
+  role: "user" | "assistant";
+  text: string;
+};
+declare const REALTIME_VOICE_AGENT_CONSULT_TOOL: RealtimeVoiceTool;
+declare function buildRealtimeVoiceAgentConsultWorkingResponse(audienceLabel?: string): Record<string, unknown>;
+declare function isRealtimeVoiceAgentConsultToolPolicy(value: unknown): value is RealtimeVoiceAgentConsultToolPolicy;
+declare function resolveRealtimeVoiceAgentConsultToolPolicy(value: unknown, fallback: RealtimeVoiceAgentConsultToolPolicy): RealtimeVoiceAgentConsultToolPolicy;
+declare function resolveRealtimeVoiceAgentConsultTools(policy: RealtimeVoiceAgentConsultToolPolicy, customTools?: RealtimeVoiceTool[]): RealtimeVoiceTool[];
+declare function resolveRealtimeVoiceAgentConsultToolsAllow(policy: RealtimeVoiceAgentConsultToolPolicy): string[] | undefined;
+declare function buildRealtimeVoiceAgentConsultPolicyInstructions(config: {
+  toolPolicy: RealtimeVoiceAgentConsultToolPolicy;
+  consultPolicy?: "auto" | "substantive" | "always";
+}): string | undefined;
+declare function parseRealtimeVoiceAgentConsultArgs(args: unknown): RealtimeVoiceAgentConsultArgs;
+declare function buildRealtimeVoiceAgentConsultChatMessage(args: unknown): string;
+declare function buildRealtimeVoiceAgentConsultPrompt(params: {
+  args: unknown;
+  transcript: RealtimeVoiceAgentConsultTranscriptEntry[];
+  surface: string;
+  userLabel: string;
+  assistantLabel?: string;
+  questionSourceLabel?: string;
+}): string;
+declare function collectRealtimeVoiceAgentConsultVisibleText(payloads: Array<{
+  text?: unknown;
+  isError?: boolean;
+  isReasoning?: boolean;
+}>): string | null;
+//#endregion
+//#region src/talk/agent-consult-runtime.d.ts
+type RealtimeVoiceAgentConsultRuntime = PluginRuntimeCore["agent"];
+type RealtimeVoiceAgentConsultResult = {
+  text: string;
+};
+type RealtimeVoiceAgentConsultContextMode = "isolated" | "fork";
+declare function consultRealtimeVoiceAgent(params: {
+  cfg: DaoCoreConfig;
+  agentRuntime: RealtimeVoiceAgentConsultRuntime;
+  logger: Pick<RuntimeLogger, "warn">;
+  sessionKey: string;
+  messageProvider: string;
+  lane: string;
+  runIdPrefix: string;
+  args: unknown;
+  transcript: RealtimeVoiceAgentConsultTranscriptEntry[];
+  surface: string;
+  userLabel: string;
+  assistantLabel?: string;
+  questionSourceLabel?: string;
+  agentId?: string;
+  spawnedBy?: string | null;
+  contextMode?: RealtimeVoiceAgentConsultContextMode;
+  provider?: RunEmbeddedPiAgentParams["provider"];
+  model?: RunEmbeddedPiAgentParams["model"];
+  thinkLevel?: RunEmbeddedPiAgentParams["thinkLevel"];
+  fastMode?: RunEmbeddedPiAgentParams["fastMode"];
+  timeoutMs?: number;
+  toolsAllow?: string[];
+  extraSystemPrompt?: string;
+  fallbackText?: string;
+}): Promise<RealtimeVoiceAgentConsultResult>;
+//#endregion
+//#region src/talk/agent-talkback-runtime.d.ts
+type RealtimeVoiceAgentTalkbackResult = {
+  text: string;
+};
+type RealtimeVoiceAgentTalkbackQueue = {
+  close(): void;
+  enqueue(question: string, metadata?: unknown): void;
+};
+type RealtimeVoiceAgentTalkbackQueueParams = {
+  debounceMs: number;
+  isStopped: () => boolean;
+  logger: Pick<RuntimeLogger, "info" | "warn">;
+  logPrefix: string;
+  responseStyle: string;
+  fallbackText: string;
+  consult: (args: {
+    question: string;
+    metadata?: unknown;
+    responseStyle: string;
+    signal: AbortSignal;
+  }) => Promise<RealtimeVoiceAgentTalkbackResult>;
+  deliver: (text: string) => void;
+};
+declare function createRealtimeVoiceAgentTalkbackQueue(params: RealtimeVoiceAgentTalkbackQueueParams): RealtimeVoiceAgentTalkbackQueue;
+//#endregion
+//#region src/talk/fast-context-runtime.d.ts
+type Logger = {
+  debug?: (message: string) => void;
+};
+type RealtimeVoiceFastContextConfig = {
+  enabled: boolean;
+  maxResults: number;
+  sources: Array<"memory" | "sessions">;
+  timeoutMs: number;
+  fallbackToConsult: boolean;
+};
+type RealtimeVoiceFastContextLabels = {
+  audienceLabel: string;
+  contextName: string;
+};
+type RealtimeVoiceFastContextConsultResult = {
+  handled: false;
+} | {
+  handled: true;
+  result: RealtimeVoiceAgentConsultResult;
+};
+declare function resolveRealtimeVoiceFastContextConsult(params: {
+  cfg: DaoCoreConfig;
+  agentId: string;
+  sessionKey: string;
+  config: RealtimeVoiceFastContextConfig;
+  args: unknown;
+  logger: Logger;
+  labels?: Partial<RealtimeVoiceFastContextLabels>;
+}): Promise<RealtimeVoiceFastContextConsultResult>;
+//#endregion
+//#region src/talk/provider-registry.d.ts
+declare function normalizeRealtimeVoiceProviderId(providerId: string | undefined): RealtimeVoiceProviderId | undefined;
+declare function listRealtimeVoiceProviders(cfg?: DaoCoreConfig): RealtimeVoiceProviderPlugin[];
+declare function getRealtimeVoiceProvider(providerId: string | undefined, cfg?: DaoCoreConfig): RealtimeVoiceProviderPlugin | undefined;
+declare function canonicalizeRealtimeVoiceProviderId(providerId: string | undefined, cfg?: DaoCoreConfig): RealtimeVoiceProviderId | undefined;
+//#endregion
+//#region src/talk/provider-resolver.d.ts
+type ResolvedRealtimeVoiceProvider = {
+  provider: RealtimeVoiceProviderPlugin;
+  providerConfig: RealtimeVoiceProviderConfig;
+};
+type ResolveConfiguredRealtimeVoiceProviderParams = {
+  configuredProviderId?: string;
+  providerConfigs?: Record<string, Record<string, unknown> | undefined>;
+  providerConfigOverrides?: Record<string, unknown>;
+  cfg?: DaoCoreConfig;
+  cfgForResolve?: DaoCoreConfig;
+  providers?: RealtimeVoiceProviderPlugin[];
+  defaultModel?: string;
+  noRegisteredProviderMessage?: string;
+};
+declare function resolveConfiguredRealtimeVoiceProvider(params: ResolveConfiguredRealtimeVoiceProviderParams): ResolvedRealtimeVoiceProvider;
+//#endregion
+//#region src/talk/session-runtime.d.ts
+type RealtimeVoiceAudioSink = {
+  isOpen?: () => boolean;
+  sendAudio: (audio: Buffer) => void;
+  clearAudio?: () => void;
+  sendMark?: (markName: string) => void;
+};
+type RealtimeVoiceMarkStrategy = "transport" | "ack-immediately" | "ignore";
+type RealtimeVoiceBridgeSession = {
+  bridge: RealtimeVoiceBridge;
+  acknowledgeMark(): void;
+  close(): void;
+  connect(): Promise<void>;
+  sendAudio(audio: Buffer): void;
+  sendUserMessage(text: string): void;
+  handleBargeIn(options?: RealtimeVoiceBargeInOptions): void;
+  setMediaTimestamp(ts: number): void;
+  submitToolResult(callId: string, result: unknown, options?: RealtimeVoiceToolResultOptions): void;
+  triggerGreeting(instructions?: string): void;
+};
+type RealtimeVoiceBridgeSessionParams = {
+  provider: RealtimeVoiceProviderPlugin;
+  cfg?: DaoCoreConfig;
+  providerConfig: RealtimeVoiceProviderConfig;
+  audioFormat?: RealtimeVoiceAudioFormat;
+  audioSink: RealtimeVoiceAudioSink;
+  instructions?: string;
+  initialGreetingInstructions?: string;
+  autoRespondToAudio?: boolean;
+  interruptResponseOnInputAudio?: boolean;
+  markStrategy?: RealtimeVoiceMarkStrategy;
+  triggerGreetingOnReady?: boolean;
+  tools?: RealtimeVoiceTool[];
+  onTranscript?: (role: RealtimeVoiceRole, text: string, isFinal: boolean) => void;
+  onEvent?: (event: RealtimeVoiceBridgeEvent) => void;
+  onToolCall?: (event: RealtimeVoiceToolCallEvent, session: RealtimeVoiceBridgeSession) => void;
+  onReady?: (session: RealtimeVoiceBridgeSession) => void;
+  onError?: (error: Error) => void;
+  onClose?: (reason: RealtimeVoiceCloseReason) => void;
+};
+declare function createRealtimeVoiceBridgeSession(params: RealtimeVoiceBridgeSessionParams): RealtimeVoiceBridgeSession;
+//#endregion
+//#region src/talk/session-log-runtime.d.ts
+type RealtimeVoiceTranscriptEntry = {
+  at: string;
+  role: RealtimeVoiceRole;
+  text: string;
+};
+type RealtimeVoiceTranscriptHealth = {
+  realtimeTranscriptLines: number;
+  lastRealtimeTranscriptAt?: string;
+  lastRealtimeTranscriptRole?: RealtimeVoiceRole;
+  lastRealtimeTranscriptText?: string;
+  recentRealtimeTranscript: RealtimeVoiceTranscriptEntry[];
+};
+type RealtimeVoiceBridgeEventLogEntry = RealtimeVoiceBridgeEvent & {
+  at: string;
+};
+type RealtimeVoiceBridgeEventHealth = {
+  lastRealtimeEventAt?: string;
+  lastRealtimeEventType?: string;
+  lastRealtimeEventDetail?: string;
+  recentRealtimeEvents: RealtimeVoiceBridgeEventLogEntry[];
+};
+declare function recordRealtimeVoiceTranscript(transcript: RealtimeVoiceTranscriptEntry[], role: RealtimeVoiceRole, text: string, maxEntries?: number): RealtimeVoiceTranscriptEntry;
+declare function getRealtimeVoiceTranscriptHealth(transcript: RealtimeVoiceTranscriptEntry[]): RealtimeVoiceTranscriptHealth;
+declare function recordRealtimeVoiceBridgeEvent(events: RealtimeVoiceBridgeEventLogEntry[], event: RealtimeVoiceBridgeEvent, maxEntries?: number): void;
+declare function getRealtimeVoiceBridgeEventHealth(events: RealtimeVoiceBridgeEventLogEntry[]): RealtimeVoiceBridgeEventHealth;
+declare function isLikelyRealtimeVoiceAssistantEchoTranscript(params: {
+  transcript: RealtimeVoiceTranscriptEntry[];
+  text: string;
+  lookbackMs: number;
+  nowMs?: number;
+}): boolean;
+declare function extendRealtimeVoiceOutputEchoSuppression(params: {
+  audio: Buffer;
+  bytesPerMs: number;
+  tailMs: number;
+  nowMs: number;
+  lastOutputPlayableUntilMs: number;
+  suppressInputUntilMs: number;
+}): {
+  lastOutputPlayableUntilMs: number;
+  suppressInputUntilMs: number;
+  durationMs: number;
+};
+//#endregion
+//#region src/talk/audio-codec.d.ts
+declare function resamplePcm(input: Buffer, inputSampleRate: number, outputSampleRate: number): Buffer;
+declare function resamplePcmTo8k(input: Buffer, inputSampleRate: number): Buffer;
+declare function pcmToMulaw(pcm: Buffer): Buffer;
+declare function mulawToPcm(mulaw: Buffer): Buffer;
+declare function convertPcmToMulaw8k(pcm: Buffer, inputSampleRate: number): Buffer;
+//#endregion
+export { resolveRealtimeVoiceAgentConsultTools as $, RealtimeVoiceFastContextLabels as A, REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME as B, resolveConfiguredRealtimeVoiceProvider as C, normalizeRealtimeVoiceProviderId as D, listRealtimeVoiceProviders as E, createRealtimeVoiceAgentTalkbackQueue as F, buildRealtimeVoiceAgentConsultChatMessage as G, RealtimeVoiceAgentConsultArgs as H, RealtimeVoiceAgentConsultResult as I, buildRealtimeVoiceAgentConsultWorkingResponse as J, buildRealtimeVoiceAgentConsultPolicyInstructions as K, RealtimeVoiceAgentConsultRuntime as L, RealtimeVoiceAgentTalkbackQueue as M, RealtimeVoiceAgentTalkbackQueueParams as N, RealtimeVoiceFastContextConfig as O, RealtimeVoiceAgentTalkbackResult as P, resolveRealtimeVoiceAgentConsultToolPolicy as Q, consultRealtimeVoiceAgent as R, ResolvedRealtimeVoiceProvider as S, getRealtimeVoiceProvider as T, RealtimeVoiceAgentConsultToolPolicy as U, REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES as V, RealtimeVoiceAgentConsultTranscriptEntry as W, isRealtimeVoiceAgentConsultToolPolicy as X, collectRealtimeVoiceAgentConsultVisibleText as Y, parseRealtimeVoiceAgentConsultArgs as Z, RealtimeVoiceBridgeSession as _, resamplePcmTo8k as a, TalkTurnFailure as at, createRealtimeVoiceBridgeSession as b, RealtimeVoiceTranscriptEntry as c, TalkTurnSuccess as ct, getRealtimeVoiceBridgeEventHealth as d, recordTalkObservabilityEvent as dt, resolveRealtimeVoiceAgentConsultToolsAllow as et, getRealtimeVoiceTranscriptHealth as f, createTalkLogRecord as ft, RealtimeVoiceAudioSink as g, recordRealtimeVoiceTranscript as h, recordTalkDiagnosticEvent as ht, resamplePcm as i, TalkSessionControllerParams as it, resolveRealtimeVoiceFastContextConsult as j, RealtimeVoiceFastContextConsultResult as k, RealtimeVoiceTranscriptHealth as l, createTalkSessionController as lt, recordRealtimeVoiceBridgeEvent as m, createTalkDiagnosticEvent as mt, mulawToPcm as n, TalkSessionController as nt, RealtimeVoiceBridgeEventHealth as o, TalkTurnFailureReason as ot, isLikelyRealtimeVoiceAssistantEchoTranscript as p, recordTalkLogEvent as pt, buildRealtimeVoiceAgentConsultPrompt as q, pcmToMulaw as r, TalkSessionControllerOptions as rt, RealtimeVoiceBridgeEventLogEntry as s, TalkTurnResult as st, convertPcmToMulaw8k as t, TalkEnsureTurnResult as tt, extendRealtimeVoiceOutputEchoSuppression as u, normalizeTalkTransport as ut, RealtimeVoiceBridgeSessionParams as v, canonicalizeRealtimeVoiceProviderId as w, ResolveConfiguredRealtimeVoiceProviderParams as x, RealtimeVoiceMarkStrategy as y, REALTIME_VOICE_AGENT_CONSULT_TOOL as z };

package/dist/realtime-voice-provider-NcUDkuN4.d.ts

@@ -0,0 +1,5 @@
+import { Wn as RealtimeVoiceProviderPlugin } from "./types-Zj4Bq9h-2.js";
+//#region extensions/openai/realtime-voice-provider.d.ts
+declare function buildOpenAIRealtimeVoiceProvider(): RealtimeVoiceProviderPlugin;
+//#endregion
+export { buildOpenAIRealtimeVoiceProvider as t };