realtime-voice-agents 2.0.0

package/dist/GeminiLiveProvider-x2nyx5aO.d.mts

@@ -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-ClP8Wx1X.mjs";
+//#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 };

package/dist/InMemorySessionStore-B0_i-DOU.cjs

@@ -0,0 +1,34 @@
+//#region src/session/InMemorySessionStore.ts
+var InMemorySessionStore = class {
+	snapshots = /* @__PURE__ */ new Map();
+	maxEntries;
+	constructor(options = {}) {
+		this.maxEntries = options.maxEntries ?? 1e3;
+	}
+	async save(snapshot) {
+		this.snapshots.set(snapshot.callSid, structuredClone(snapshot));
+		while (this.snapshots.size > this.maxEntries) {
+			const oldest = this.snapshots.keys().next().value;
+			if (oldest === void 0) break;
+			this.snapshots.delete(oldest);
+		}
+	}
+	async load(callSid) {
+		const snapshot = this.snapshots.get(callSid);
+		return snapshot ? structuredClone(snapshot) : null;
+	}
+	async delete(callSid) {
+		this.snapshots.delete(callSid);
+	}
+	/** All stored snapshots (testing/debugging). */
+	list() {
+		return [...this.snapshots.values()].map((s) => structuredClone(s));
+	}
+};
+//#endregion
+Object.defineProperty(exports, "InMemorySessionStore", {
+	enumerable: true,
+	get: function() {
+		return InMemorySessionStore;
+	}
+});

package/dist/InMemorySessionStore-B5_rq61L.d.cts

@@ -0,0 +1,83 @@
+//#region src/session/transcript.d.ts
+interface TranscriptEntry {
+  role: 'user' | 'agent';
+  text: string;
+  /** Milliseconds since call start. */
+  timestampMs: number;
+  /** Which agent spoke / was active (multi-agent calls). */
+  agentId?: string;
+  /** The caller cut this utterance off mid-playback. */
+  interrupted?: boolean;
+}
+//#endregion
+//#region src/session/usage.d.ts
+/** Accumulated token consumption for a call, normalized across providers. */
+interface UsageInfo {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  inputTokenDetails: {
+    textTokens: number;
+    audioTokens: number;
+    cachedTokens: number;
+  };
+  outputTokenDetails: {
+    textTokens: number;
+    audioTokens: number;
+  };
+  /** Number of model responses accounted. */
+  responses: number;
+}
+declare function emptyUsage(): UsageInfo;
+//#endregion
+//#region src/session/snapshot.d.ts
+/** Serializable checkpoint of a call, written to the SessionStore. */
+interface CallSnapshot {
+  callSid: string;
+  streamSid: string | null;
+  state: string;
+  activeAgentId: string;
+  transcript: TranscriptEntry[];
+  usage: UsageInfo;
+  context: Record<string, unknown>;
+  handoffHistory: Array<{
+    from: string;
+    to: string;
+    atMs: number;
+  }>;
+  /** Gemini session-resumption handle, when the provider supplies one. */
+  resumptionHandle?: string;
+  startedAtMs: number;
+  endedAtMs?: number;
+  endReason?: string;
+}
+//#endregion
+//#region src/session/SessionStore.d.ts
+/**
+ * Durable checkpoint store (LangGraph-checkpointer-inspired). Snapshots are
+ * written at call start, agent handoff, tool completion, and call end — never
+ * read on the audio hot path. Implement over Redis/Postgres for multi-instance
+ * observability and post-call processing; the in-memory default suffices for
+ * single-process deployments.
+ */
+interface SessionStore {
+  save(snapshot: CallSnapshot): Promise<void>;
+  load(callSid: string): Promise<CallSnapshot | null>;
+  delete(callSid: string): Promise<void>;
+}
+//#endregion
+//#region src/session/InMemorySessionStore.d.ts
+declare class InMemorySessionStore implements SessionStore {
+  private readonly snapshots;
+  private readonly maxEntries;
+  constructor(options?: {
+    maxEntries?: number;
+  });
+  save(snapshot: CallSnapshot): Promise<void>;
+  load(callSid: string): Promise<CallSnapshot | null>;
+  delete(callSid: string): Promise<void>;
+  /** All stored snapshots (testing/debugging). */
+  list(): CallSnapshot[];
+}
+//#endregion
+export { emptyUsage as a, UsageInfo as i, SessionStore as n, TranscriptEntry as o, CallSnapshot as r, InMemorySessionStore as t };

package/dist/InMemorySessionStore-B5_rq61L.d.mts

@@ -0,0 +1,83 @@
+//#region src/session/transcript.d.ts
+interface TranscriptEntry {
+  role: 'user' | 'agent';
+  text: string;
+  /** Milliseconds since call start. */
+  timestampMs: number;
+  /** Which agent spoke / was active (multi-agent calls). */
+  agentId?: string;
+  /** The caller cut this utterance off mid-playback. */
+  interrupted?: boolean;
+}
+//#endregion
+//#region src/session/usage.d.ts
+/** Accumulated token consumption for a call, normalized across providers. */
+interface UsageInfo {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  inputTokenDetails: {
+    textTokens: number;
+    audioTokens: number;
+    cachedTokens: number;
+  };
+  outputTokenDetails: {
+    textTokens: number;
+    audioTokens: number;
+  };
+  /** Number of model responses accounted. */
+  responses: number;
+}
+declare function emptyUsage(): UsageInfo;
+//#endregion
+//#region src/session/snapshot.d.ts
+/** Serializable checkpoint of a call, written to the SessionStore. */
+interface CallSnapshot {
+  callSid: string;
+  streamSid: string | null;
+  state: string;
+  activeAgentId: string;
+  transcript: TranscriptEntry[];
+  usage: UsageInfo;
+  context: Record<string, unknown>;
+  handoffHistory: Array<{
+    from: string;
+    to: string;
+    atMs: number;
+  }>;
+  /** Gemini session-resumption handle, when the provider supplies one. */
+  resumptionHandle?: string;
+  startedAtMs: number;
+  endedAtMs?: number;
+  endReason?: string;
+}
+//#endregion
+//#region src/session/SessionStore.d.ts
+/**
+ * Durable checkpoint store (LangGraph-checkpointer-inspired). Snapshots are
+ * written at call start, agent handoff, tool completion, and call end — never
+ * read on the audio hot path. Implement over Redis/Postgres for multi-instance
+ * observability and post-call processing; the in-memory default suffices for
+ * single-process deployments.
+ */
+interface SessionStore {
+  save(snapshot: CallSnapshot): Promise<void>;
+  load(callSid: string): Promise<CallSnapshot | null>;
+  delete(callSid: string): Promise<void>;
+}
+//#endregion
+//#region src/session/InMemorySessionStore.d.ts
+declare class InMemorySessionStore implements SessionStore {
+  private readonly snapshots;
+  private readonly maxEntries;
+  constructor(options?: {
+    maxEntries?: number;
+  });
+  save(snapshot: CallSnapshot): Promise<void>;
+  load(callSid: string): Promise<CallSnapshot | null>;
+  delete(callSid: string): Promise<void>;
+  /** All stored snapshots (testing/debugging). */
+  list(): CallSnapshot[];
+}
+//#endregion
+export { emptyUsage as a, UsageInfo as i, SessionStore as n, TranscriptEntry as o, CallSnapshot as r, InMemorySessionStore as t };

package/dist/InMemorySessionStore-DYParOJO.mjs

@@ -0,0 +1,29 @@
+//#region src/session/InMemorySessionStore.ts
+var InMemorySessionStore = class {
+	snapshots = /* @__PURE__ */ new Map();
+	maxEntries;
+	constructor(options = {}) {
+		this.maxEntries = options.maxEntries ?? 1e3;
+	}
+	async save(snapshot) {
+		this.snapshots.set(snapshot.callSid, structuredClone(snapshot));
+		while (this.snapshots.size > this.maxEntries) {
+			const oldest = this.snapshots.keys().next().value;
+			if (oldest === void 0) break;
+			this.snapshots.delete(oldest);
+		}
+	}
+	async load(callSid) {
+		const snapshot = this.snapshots.get(callSid);
+		return snapshot ? structuredClone(snapshot) : null;
+	}
+	async delete(callSid) {
+		this.snapshots.delete(callSid);
+	}
+	/** All stored snapshots (testing/debugging). */
+	list() {
+		return [...this.snapshots.values()].map((s) => structuredClone(s));
+	}
+};
+//#endregion
+export { InMemorySessionStore as t };