realtime-voice-agents 2.0.0

package/dist/BaseRealtimeProvider-BehPNT1r.d.cts

@@ -0,0 +1,239 @@
+import { t as TypedEmitter } from "./events-BUMYdETO.cjs";
+//#region src/logging/logger.d.ts
+/**
+ * Minimal structured logger seam. Pino/winston/console all adapt in one line;
+ * the default is silent so the library never spams a host app's stdout.
+ */
+interface Logger {
+  debug(message: string, data?: Record<string, unknown>): void;
+  info(message: string, data?: Record<string, unknown>): void;
+  warn(message: string, data?: Record<string, unknown>): void;
+  error(message: string, data?: Record<string, unknown>): void;
+  /** Derive a logger with bound context (e.g. callSid). */
+  child?(context: Record<string, unknown>): Logger;
+}
+declare const noopLogger: Logger;
+/** Console-backed logger, useful in examples and debugging. */
+declare function consoleLogger(context?: Record<string, unknown>): Logger;
+//#endregion
+//#region src/providers/base/capabilities.d.ts
+/**
+ * Capability flags per provider. The engine branches on these — never on a
+ * provider's name — so new providers slot in without touching session logic.
+ */
+interface ProviderCapabilities {
+  /** Supports trimming the last assistant item to what was actually heard. */
+  truncate: boolean;
+  /** Supports mid-session instruction/tool swaps (session.update). */
+  sessionUpdate: boolean;
+  /** Voice can change after audio has been emitted in the session. */
+  voiceChangeMidSession: boolean;
+  /** Provider speaks PCM — the μ-law wire format must be transcoded. */
+  transcodeRequired: boolean;
+  /** Supports server-side session resumption handles. */
+  resumption: boolean;
+  /** Streams assistant transcript deltas (enables first-sentence detection). */
+  agentTranscriptDeltas: boolean;
+  /**
+   * Server VAD's auto-interrupt can be disabled (`interrupt_response: false`),
+   * letting the bridge own barge-in: cancel/clear/truncate only when the
+   * interruption guard allows. Without it, the provider cancels generation on
+   * speech onset regardless of the guard — the guard then protects only the
+   * already-buffered Twilio audio (documented fallback, see parity tests).
+   * Optional so existing third-party providers keep compiling (absent = false).
+   */
+  vadInterruptControl?: boolean;
+}
+//#endregion
+//#region src/providers/base/events.d.ts
+/** Normalized events every provider emits, regardless of wire protocol. */
+interface RawUsage {
+  [key: string]: unknown;
+}
+interface ProviderUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  inputTokenDetails?: {
+    textTokens?: number;
+    audioTokens?: number;
+    cachedTokens?: number;
+  };
+  outputTokenDetails?: {
+    textTokens?: number;
+    audioTokens?: number;
+  };
+  /** Provider-native payload for advanced analytics. */
+  raw?: RawUsage;
+}
+interface ProviderAudioDelta {
+  /** Base64 μ-law 8 kHz — already in Twilio wire format. */
+  base64Mulaw: string;
+  responseId: string;
+  itemId?: string;
+}
+interface ProviderToolCall {
+  /** Provider call id used to correlate the result (function name on providers without ids). */
+  id: string;
+  name: string;
+  argumentsJson: string;
+  responseId?: string;
+  itemId?: string;
+}
+interface ProviderCloseInfo {
+  code?: number;
+  reason?: string;
+  /** False for auth/config failures where retrying is pointless. */
+  retriable: boolean;
+}
+interface ProviderEvents {
+  open: () => void;
+  close: (info: ProviderCloseInfo) => void;
+  error: (error: Error) => void;
+  /** Assistant audio chunk, normalized to base64 μ-law. */
+  audio: (delta: ProviderAudioDelta) => void;
+  /** A new assistant response began generating. */
+  responseStarted: (info: {
+    responseId: string;
+  }) => void;
+  /** The assistant response finished generating (audio may still be playing out). */
+  responseDone: (info: {
+    responseId: string;
+    usage?: ProviderUsage;
+  }) => void;
+  /** An output item was added — carries the itemId needed for truncation. */
+  outputItemAdded: (info: {
+    itemId: string;
+    responseId: string;
+  }) => void;
+  toolCall: (call: ProviderToolCall) => void;
+  userSpeechStarted: () => void;
+  userSpeechStopped: () => void;
+  userTranscript: (entry: {
+    text: string;
+  }) => void;
+  agentTranscriptDelta: (entry: {
+    responseId: string;
+    delta: string;
+  }) => void;
+  agentTranscript: (entry: {
+    responseId: string;
+    text: string;
+  }) => void;
+  usage: (usage: ProviderUsage) => void;
+  /** Session-resumption handle refresh (Gemini). */
+  resumptionUpdate: (handle: string) => void;
+  /** Provider announced imminent disconnect (Gemini GoAway). */
+  goAway: (info: {
+    timeLeftMs?: number;
+  }) => void;
+}
+//#endregion
+//#region src/providers/base/BaseRealtimeProvider.d.ts
+/** Normalized VAD config, mapped onto each provider's native shape. */
+interface VadConfig {
+  /** 'server' = provider-side VAD; 'semantic' where supported; null disables turn detection. */
+  type?: 'server' | 'semantic';
+  threshold?: number;
+  silenceDurationMs?: number;
+  prefixPaddingMs?: number;
+  /** Semantic VAD eagerness (OpenAI). */
+  eagerness?: 'low' | 'medium' | 'high' | 'auto';
+  /** Gemini-only sensitivities. */
+  startSensitivity?: 'high' | 'low';
+  endSensitivity?: 'high' | 'low';
+  /**
+   * Server-side auto-cancel of the active response on speech onset (OpenAI
+   * `interrupt_response`). Leave unset: the bridge manages it via
+   * `bridgeOwnsInterruptions` so the interruption guard actually holds.
+   */
+  interruptResponse?: boolean;
+  /** Server-side auto-response on turn commit (OpenAI `create_response`). */
+  createResponse?: boolean;
+}
+interface ProviderToolSchema {
+  name: string;
+  description?: string;
+  /** JSON Schema for the tool parameters. */
+  parameters: Record<string, unknown>;
+}
+/** Everything a provider needs to open (or re-open) a live session. */
+interface ProviderSessionInit {
+  instructions: string;
+  voice?: string;
+  tools?: ProviderToolSchema[];
+  vad?: VadConfig | null;
+  temperature?: number;
+  transcription?: {
+    model?: string;
+    language?: string;
+  } | false;
+  /** Session-resumption handle from a previous connection (capability-gated). */
+  resumptionHandle?: string;
+  /**
+   * Force a brand-new server session: ignore any stored resumption handle.
+   * Used for handoffs, where the session config itself changes.
+   */
+  freshSession?: boolean;
+  /**
+   * The bridge arbitrates barge-ins (interruption guard). Providers with
+   * `vadInterruptControl` disable their server-side auto-interrupt unless the
+   * vad config sets `interruptResponse` explicitly; others ignore this flag
+   * (documented fallback: guard protects buffered audio only).
+   */
+  bridgeOwnsInterruptions?: boolean;
+  /** Provider-native session options, deep-merged last (escape hatch). */
+  providerOptions?: Record<string, unknown>;
+}
+interface SendTextOptions {
+  /** `assistant` is used for history re-injection after reconnect/handoff. */
+  role?: 'user' | 'system' | 'assistant';
+  /** Ask the model to respond immediately after the text lands. Default true. */
+  triggerResponse?: boolean;
+}
+interface SendToolResultOptions {
+  triggerResponse?: boolean;
+}
+/**
+ * The provider contract: μ-law in, μ-law out, normalized events.
+ * Transcoding (when the provider speaks PCM) lives inside the provider, so
+ * the engine stays codec-free. `connect()` is re-invokable on the same
+ * instance — the session layer owns reconnect policy and context re-injection.
+ */
+declare abstract class BaseRealtimeProvider extends TypedEmitter<ProviderEvents> {
+  abstract readonly name: string;
+  abstract readonly capabilities: ProviderCapabilities;
+  /** Resolves when the session is configured and ready for audio. */
+  abstract connect(init: ProviderSessionInit): Promise<void>;
+  abstract close(): Promise<void>;
+  abstract get isConnected(): boolean;
+  /** Forward caller audio (base64 μ-law 8 kHz). */
+  abstract sendAudio(base64Mulaw: string): void;
+  /** Inject a text turn into the conversation. */
+  abstract sendText(text: string, options?: SendTextOptions): void;
+  /** Return a tool result to the model. */
+  abstract sendToolResult(callId: string, output: unknown, options?: SendToolResultOptions): void;
+  /** Trigger an out-of-band assistant response (greeting, nudge, announcement). */
+  abstract createResponse(options?: {
+    instructions?: string;
+  }): void;
+  /** Mid-session config change (instructions/tools/voice) where supported. */
+  abstract updateSession(patch: Partial<ProviderSessionInit>): Promise<void>;
+  /** Interrupt in-flight generation (where the wire protocol supports it). */
+  cancelResponse(): void;
+  /** Trim the last assistant item to what the caller actually heard. */
+  truncatePlayback(_itemId: string, _audioEndMs: number): void;
+  /**
+   * Whether the most recent connect restored server-side context (session
+   * resumption). When true, the engine skips transcript re-injection.
+   */
+  get didResume(): boolean;
+}
+interface ProviderFactoryContext {
+  logger: Logger;
+  callSid: string;
+}
+/** A fresh provider per call; connection config is captured in the factory closure. */
+type ProviderFactory = (context: ProviderFactoryContext) => BaseRealtimeProvider;
+//#endregion
+export { noopLogger as _, ProviderToolSchema as a, VadConfig as c, ProviderEvents as d, ProviderToolCall as f, consoleLogger as g, Logger as h, ProviderSessionInit as i, ProviderAudioDelta as l, ProviderCapabilities as m, ProviderFactory as n, SendTextOptions as o, ProviderUsage as p, ProviderFactoryContext as r, SendToolResultOptions as s, BaseRealtimeProvider as t, ProviderCloseInfo as u };

package/dist/BaseRealtimeProvider-ClP8Wx1X.d.mts

@@ -0,0 +1,239 @@
+import { t as TypedEmitter } from "./events-BUMYdETO.mjs";
+//#region src/logging/logger.d.ts
+/**
+ * Minimal structured logger seam. Pino/winston/console all adapt in one line;
+ * the default is silent so the library never spams a host app's stdout.
+ */
+interface Logger {
+  debug(message: string, data?: Record<string, unknown>): void;
+  info(message: string, data?: Record<string, unknown>): void;
+  warn(message: string, data?: Record<string, unknown>): void;
+  error(message: string, data?: Record<string, unknown>): void;
+  /** Derive a logger with bound context (e.g. callSid). */
+  child?(context: Record<string, unknown>): Logger;
+}
+declare const noopLogger: Logger;
+/** Console-backed logger, useful in examples and debugging. */
+declare function consoleLogger(context?: Record<string, unknown>): Logger;
+//#endregion
+//#region src/providers/base/capabilities.d.ts
+/**
+ * Capability flags per provider. The engine branches on these — never on a
+ * provider's name — so new providers slot in without touching session logic.
+ */
+interface ProviderCapabilities {
+  /** Supports trimming the last assistant item to what was actually heard. */
+  truncate: boolean;
+  /** Supports mid-session instruction/tool swaps (session.update). */
+  sessionUpdate: boolean;
+  /** Voice can change after audio has been emitted in the session. */
+  voiceChangeMidSession: boolean;
+  /** Provider speaks PCM — the μ-law wire format must be transcoded. */
+  transcodeRequired: boolean;
+  /** Supports server-side session resumption handles. */
+  resumption: boolean;
+  /** Streams assistant transcript deltas (enables first-sentence detection). */
+  agentTranscriptDeltas: boolean;
+  /**
+   * Server VAD's auto-interrupt can be disabled (`interrupt_response: false`),
+   * letting the bridge own barge-in: cancel/clear/truncate only when the
+   * interruption guard allows. Without it, the provider cancels generation on
+   * speech onset regardless of the guard — the guard then protects only the
+   * already-buffered Twilio audio (documented fallback, see parity tests).
+   * Optional so existing third-party providers keep compiling (absent = false).
+   */
+  vadInterruptControl?: boolean;
+}
+//#endregion
+//#region src/providers/base/events.d.ts
+/** Normalized events every provider emits, regardless of wire protocol. */
+interface RawUsage {
+  [key: string]: unknown;
+}
+interface ProviderUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  inputTokenDetails?: {
+    textTokens?: number;
+    audioTokens?: number;
+    cachedTokens?: number;
+  };
+  outputTokenDetails?: {
+    textTokens?: number;
+    audioTokens?: number;
+  };
+  /** Provider-native payload for advanced analytics. */
+  raw?: RawUsage;
+}
+interface ProviderAudioDelta {
+  /** Base64 μ-law 8 kHz — already in Twilio wire format. */
+  base64Mulaw: string;
+  responseId: string;
+  itemId?: string;
+}
+interface ProviderToolCall {
+  /** Provider call id used to correlate the result (function name on providers without ids). */
+  id: string;
+  name: string;
+  argumentsJson: string;
+  responseId?: string;
+  itemId?: string;
+}
+interface ProviderCloseInfo {
+  code?: number;
+  reason?: string;
+  /** False for auth/config failures where retrying is pointless. */
+  retriable: boolean;
+}
+interface ProviderEvents {
+  open: () => void;
+  close: (info: ProviderCloseInfo) => void;
+  error: (error: Error) => void;
+  /** Assistant audio chunk, normalized to base64 μ-law. */
+  audio: (delta: ProviderAudioDelta) => void;
+  /** A new assistant response began generating. */
+  responseStarted: (info: {
+    responseId: string;
+  }) => void;
+  /** The assistant response finished generating (audio may still be playing out). */
+  responseDone: (info: {
+    responseId: string;
+    usage?: ProviderUsage;
+  }) => void;
+  /** An output item was added — carries the itemId needed for truncation. */
+  outputItemAdded: (info: {
+    itemId: string;
+    responseId: string;
+  }) => void;
+  toolCall: (call: ProviderToolCall) => void;
+  userSpeechStarted: () => void;
+  userSpeechStopped: () => void;
+  userTranscript: (entry: {
+    text: string;
+  }) => void;
+  agentTranscriptDelta: (entry: {
+    responseId: string;
+    delta: string;
+  }) => void;
+  agentTranscript: (entry: {
+    responseId: string;
+    text: string;
+  }) => void;
+  usage: (usage: ProviderUsage) => void;
+  /** Session-resumption handle refresh (Gemini). */
+  resumptionUpdate: (handle: string) => void;
+  /** Provider announced imminent disconnect (Gemini GoAway). */
+  goAway: (info: {
+    timeLeftMs?: number;
+  }) => void;
+}
+//#endregion
+//#region src/providers/base/BaseRealtimeProvider.d.ts
+/** Normalized VAD config, mapped onto each provider's native shape. */
+interface VadConfig {
+  /** 'server' = provider-side VAD; 'semantic' where supported; null disables turn detection. */
+  type?: 'server' | 'semantic';
+  threshold?: number;
+  silenceDurationMs?: number;
+  prefixPaddingMs?: number;
+  /** Semantic VAD eagerness (OpenAI). */
+  eagerness?: 'low' | 'medium' | 'high' | 'auto';
+  /** Gemini-only sensitivities. */
+  startSensitivity?: 'high' | 'low';
+  endSensitivity?: 'high' | 'low';
+  /**
+   * Server-side auto-cancel of the active response on speech onset (OpenAI
+   * `interrupt_response`). Leave unset: the bridge manages it via
+   * `bridgeOwnsInterruptions` so the interruption guard actually holds.
+   */
+  interruptResponse?: boolean;
+  /** Server-side auto-response on turn commit (OpenAI `create_response`). */
+  createResponse?: boolean;
+}
+interface ProviderToolSchema {
+  name: string;
+  description?: string;
+  /** JSON Schema for the tool parameters. */
+  parameters: Record<string, unknown>;
+}
+/** Everything a provider needs to open (or re-open) a live session. */
+interface ProviderSessionInit {
+  instructions: string;
+  voice?: string;
+  tools?: ProviderToolSchema[];
+  vad?: VadConfig | null;
+  temperature?: number;
+  transcription?: {
+    model?: string;
+    language?: string;
+  } | false;
+  /** Session-resumption handle from a previous connection (capability-gated). */
+  resumptionHandle?: string;
+  /**
+   * Force a brand-new server session: ignore any stored resumption handle.
+   * Used for handoffs, where the session config itself changes.
+   */
+  freshSession?: boolean;
+  /**
+   * The bridge arbitrates barge-ins (interruption guard). Providers with
+   * `vadInterruptControl` disable their server-side auto-interrupt unless the
+   * vad config sets `interruptResponse` explicitly; others ignore this flag
+   * (documented fallback: guard protects buffered audio only).
+   */
+  bridgeOwnsInterruptions?: boolean;
+  /** Provider-native session options, deep-merged last (escape hatch). */
+  providerOptions?: Record<string, unknown>;
+}
+interface SendTextOptions {
+  /** `assistant` is used for history re-injection after reconnect/handoff. */
+  role?: 'user' | 'system' | 'assistant';
+  /** Ask the model to respond immediately after the text lands. Default true. */
+  triggerResponse?: boolean;
+}
+interface SendToolResultOptions {
+  triggerResponse?: boolean;
+}
+/**
+ * The provider contract: μ-law in, μ-law out, normalized events.
+ * Transcoding (when the provider speaks PCM) lives inside the provider, so
+ * the engine stays codec-free. `connect()` is re-invokable on the same
+ * instance — the session layer owns reconnect policy and context re-injection.
+ */
+declare abstract class BaseRealtimeProvider extends TypedEmitter<ProviderEvents> {
+  abstract readonly name: string;
+  abstract readonly capabilities: ProviderCapabilities;
+  /** Resolves when the session is configured and ready for audio. */
+  abstract connect(init: ProviderSessionInit): Promise<void>;
+  abstract close(): Promise<void>;
+  abstract get isConnected(): boolean;
+  /** Forward caller audio (base64 μ-law 8 kHz). */
+  abstract sendAudio(base64Mulaw: string): void;
+  /** Inject a text turn into the conversation. */
+  abstract sendText(text: string, options?: SendTextOptions): void;
+  /** Return a tool result to the model. */
+  abstract sendToolResult(callId: string, output: unknown, options?: SendToolResultOptions): void;
+  /** Trigger an out-of-band assistant response (greeting, nudge, announcement). */
+  abstract createResponse(options?: {
+    instructions?: string;
+  }): void;
+  /** Mid-session config change (instructions/tools/voice) where supported. */
+  abstract updateSession(patch: Partial<ProviderSessionInit>): Promise<void>;
+  /** Interrupt in-flight generation (where the wire protocol supports it). */
+  cancelResponse(): void;
+  /** Trim the last assistant item to what the caller actually heard. */
+  truncatePlayback(_itemId: string, _audioEndMs: number): void;
+  /**
+   * Whether the most recent connect restored server-side context (session
+   * resumption). When true, the engine skips transcript re-injection.
+   */
+  get didResume(): boolean;
+}
+interface ProviderFactoryContext {
+  logger: Logger;
+  callSid: string;
+}
+/** A fresh provider per call; connection config is captured in the factory closure. */
+type ProviderFactory = (context: ProviderFactoryContext) => BaseRealtimeProvider;
+//#endregion
+export { noopLogger as _, ProviderToolSchema as a, VadConfig as c, ProviderEvents as d, ProviderToolCall as f, consoleLogger as g, Logger as h, ProviderSessionInit as i, ProviderAudioDelta as l, ProviderCapabilities as m, ProviderFactory as n, SendTextOptions as o, ProviderUsage as p, ProviderFactoryContext as r, SendToolResultOptions as s, BaseRealtimeProvider as t, ProviderCloseInfo as u };

package/dist/BaseRealtimeProvider-DI4pKtOb.cjs

@@ -0,0 +1,91 @@
+const require_events = require("./events-BxDTIKKq.cjs");
+//#region src/logging/logger.ts
+const noopLogger = {
+	debug: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	child: () => noopLogger
+};
+/** Console-backed logger, useful in examples and debugging. */
+function consoleLogger(context = {}) {
+	const prefix = Object.keys(context).length ? ` ${JSON.stringify(context)}` : "";
+	return {
+		debug: (msg, data) => console.debug(`[debug]${prefix} ${msg}`, data ?? ""),
+		info: (msg, data) => console.info(`[info]${prefix} ${msg}`, data ?? ""),
+		warn: (msg, data) => console.warn(`[warn]${prefix} ${msg}`, data ?? ""),
+		error: (msg, data) => console.error(`[error]${prefix} ${msg}`, data ?? ""),
+		child: (extra) => consoleLogger({
+			...context,
+			...extra
+		})
+	};
+}
+function childLogger(logger, context) {
+	return logger.child ? logger.child(context) : logger;
+}
+//#endregion
+//#region src/internal/merge.ts
+/** Recursive plain-object merge; arrays and non-objects replace wholesale. */
+function deepMerge(base, patch) {
+	if (!patch) return base;
+	const out = { ...base };
+	for (const [key, value] of Object.entries(patch)) {
+		const existing = out[key];
+		if (value !== null && typeof value === "object" && !Array.isArray(value) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) out[key] = deepMerge(existing, value);
+		else out[key] = value;
+	}
+	return out;
+}
+//#endregion
+//#region src/providers/base/BaseRealtimeProvider.ts
+/**
+* The provider contract: μ-law in, μ-law out, normalized events.
+* Transcoding (when the provider speaks PCM) lives inside the provider, so
+* the engine stays codec-free. `connect()` is re-invokable on the same
+* instance — the session layer owns reconnect policy and context re-injection.
+*/
+var BaseRealtimeProvider = class extends require_events.TypedEmitter {
+	/** Interrupt in-flight generation (where the wire protocol supports it). */
+	cancelResponse() {}
+	/** Trim the last assistant item to what the caller actually heard. */
+	truncatePlayback(_itemId, _audioEndMs) {}
+	/**
+	* Whether the most recent connect restored server-side context (session
+	* resumption). When true, the engine skips transcript re-injection.
+	*/
+	get didResume() {
+		return false;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "BaseRealtimeProvider", {
+	enumerable: true,
+	get: function() {
+		return BaseRealtimeProvider;
+	}
+});
+Object.defineProperty(exports, "childLogger", {
+	enumerable: true,
+	get: function() {
+		return childLogger;
+	}
+});
+Object.defineProperty(exports, "consoleLogger", {
+	enumerable: true,
+	get: function() {
+		return consoleLogger;
+	}
+});
+Object.defineProperty(exports, "deepMerge", {
+	enumerable: true,
+	get: function() {
+		return deepMerge;
+	}
+});
+Object.defineProperty(exports, "noopLogger", {
+	enumerable: true,
+	get: function() {
+		return noopLogger;
+	}
+});

package/dist/GeminiLiveProvider-DvkTgzjG.d.cts

@@ -0,0 +1,101 @@
+import { c as VadConfig, h as Logger, i as ProviderSessionInit, m as ProviderCapabilities, o as SendTextOptions, s as SendToolResultOptions, t as BaseRealtimeProvider } from "./BaseRealtimeProvider-BehPNT1r.cjs";
+//#region src/providers/gemini/GeminiLiveProvider.d.ts
+/** Structural slice of @google/genai's live session (also what fakes implement). */
+interface GeminiLiveSessionLike {
+  sendRealtimeInput(input: {
+    audio: {
+      data: string;
+      mimeType: string;
+    };
+  }): void;
+  sendClientContent(content: {
+    turns: Array<Record<string, unknown>>;
+    turnComplete?: boolean;
+  }): void;
+  sendToolResponse(response: {
+    functionResponses: Array<Record<string, unknown>>;
+  }): void;
+  close(): void;
+}
+interface GeminiConnectParams {
+  model: string;
+  config: Record<string, unknown>;
+  callbacks: {
+    onopen?: () => void;
+    onmessage: (message: any) => void;
+    onerror?: (error: any) => void;
+    onclose?: (event: {
+      code?: number;
+      reason?: string;
+    }) => void;
+  };
+}
+type GeminiLiveConnector = (params: GeminiConnectParams) => Promise<GeminiLiveSessionLike>;
+interface GeminiLiveProviderConfig {
+  /** API-key auth (Google AI Studio). Ignored when `vertex` is set. */
+  apiKey?: string;
+  /** Vertex AI auth (uses Application Default Credentials). */
+  vertex?: {
+    project: string;
+    location: string;
+  };
+  model: string;
+  voice?: string;
+  languageCode?: string;
+  defaultVad?: VadConfig | null;
+  /** Input/output transcription toggles. Default both on. */
+  transcription?: {
+    input?: boolean;
+    output?: boolean;
+  } | false;
+  /** Use session resumption handles across reconnects. Default true. */
+  resumption?: boolean;
+  /** Ask Gemini to compress old context instead of dying at the token limit. */
+  contextWindowCompression?: boolean;
+  /** Provider-native `config` fields, deep-merged last (escape hatch). */
+  extraConfig?: Record<string, unknown>;
+  connectTimeoutMs?: number;
+  /** Test seam: replaces `new GoogleGenAI(...).live.connect`. */
+  connector?: GeminiLiveConnector;
+}
+declare class GeminiLiveProvider extends BaseRealtimeProvider {
+  readonly name = "gemini";
+  readonly capabilities: ProviderCapabilities;
+  private readonly config;
+  private readonly logger;
+  private session;
+  private sessionInit;
+  private ready;
+  private intentionalClose;
+  private readonly inbound;
+  private readonly outbound;
+  private turnCounter;
+  private currentTurnId;
+  private userTranscriptBuffer;
+  private agentTranscriptBuffer;
+  private resumptionHandle;
+  private resumed;
+  constructor(config: GeminiLiveProviderConfig, logger?: Logger);
+  get isConnected(): boolean;
+  /** True when the last connect restored server-side context via a handle. */
+  get didResume(): boolean;
+  connect(init: ProviderSessionInit): Promise<void>;
+  private defaultConnector;
+  private buildConfig;
+  close(): Promise<void>;
+  sendAudio(base64Mulaw: string): void;
+  sendText(text: string, options?: SendTextOptions): void;
+  sendToolResult(callId: string, output: unknown, options?: SendToolResultOptions): void;
+  createResponse(options?: {
+    instructions?: string;
+  }): void;
+  updateSession(_patch: Partial<ProviderSessionInit>): Promise<void>;
+  private handleMessage;
+  private readonly callNames;
+  private toolNameForCall;
+  private ensureTurn;
+  private flushUserTranscript;
+  private flushAgentTranscript;
+}
+//#endregion
+export { GeminiLiveSessionLike as a, GeminiLiveProviderConfig as i, GeminiLiveConnector as n, GeminiLiveProvider as r, GeminiConnectParams as t };