@ai-ecoverse/pi-audio 1.7.0 → 1.9.0

package/README.md

@@ -29,6 +29,8 @@ pi-audio does not apply that patch. Hosts such as slicc-agent record monkeypatch
 
 `planDelivery` reads `RealtimeModel.delivery`. An `unsupported` mode throws `VoiceRequestError`. `when_idle` with `approximate` support waits while the model is producing output and runs on `response_done`, `interrupt`, or `close`. Native `when_idle` is sent immediately so the server can schedule it. `planTruncation` adds `{ itemId, audioEndMs }` only when `truncation` is `client` and `interrupt` was given what the listener heard.
 
+`@ai-ecoverse/pi-audio/openai-realtime` registers `gpt-realtime-2` and `gpt-realtime-2.1`. `@ai-ecoverse/pi-audio/xai` registers `grok-voice-latest`, an OpenAI Realtime dialect: input transcripts arrive as cumulative `updated` snapshots, `inject` speaks with `force_message` (no `response.create`), and `session.update` opts into `resumption` and an optional `replace` map. Reconnect with `resumeHandle`. Output audio is tagged with the transcript range spoken since the previous delta. Both adapters take a recorded `wire` in tests and never call a provider. WebRTC uses that same event protocol on a caller-supplied data-channel wire.
+
 `RealtimeLedger` meters one session. Input seconds come from `appendAudio`. Output seconds come from each `output_audio` event: PCM, mulaw, and alaw from the byte length, and a compressed encoding from character alignment. `sendText` and each delivered `inject` add one text message. Tool results do not. `close()` prices those meters with `priceAudio`. Sum that usage once. `response_done.usage` is the adapter's per-response figure, not a second copy of the session total.
 
 `talkerTools` is `ask_agent` and `read`. pi-audio defines `askAgent` (a pi `Tool` whose parameters are `request` and optional `context`) and the `Thinker` interface. The host implements `Thinker` and supplies `read`. `bindThinker` runs direct tools with `directTimeoutMs` and truncates their text to `directMaxChars`. On a blocking `ask_agent` it answers with `ack` immediately and injects the result later. On an async call it `respond`s with the result and `options.result`. Progress is injected with `options.progress`. `tool_call_cancelled` aborts the thinker. The binding also yields `thinker_progress` / `thinker_result` captions and `thinking` / `tool` / `idle` phases.

package/dist/index.js

@@ -25,6 +25,7 @@ import {
 import { SpeechEventStream } from "./speech.js";
 import { askAgent, bindThinker, talkerTools } from "./talker.js";
 import { TranscriptionEventStream } from "./transcription.js";
+import { voiceTurns } from "./turns.js";
 import { addAudioCounters, priceAudio } from "./usage.js";
 import { energyVad } from "./vad.js";
 export {
@@ -56,6 +57,7 @@ export {
   resolveVoiceAuth,
   speak,
   talkerTools,
-  transcribe
+  transcribe,
+  voiceTurns
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["export type {\n  AudioChunk,\n  AudioEncoding,\n  AudioFormat,\n  AudioSink,\n  AudioSource,\n  AudioTag,\n  CharAlignment,\n  TextSpan,\n} from './audio.ts';\nexport { resolveVoiceAuth } from './auth.ts';\nexport { blankUsage } from './blank-usage.ts';\nexport {\n  convertAudio,\n  convertAudioSource,\n  decodeAudioBase64,\n  encodeAudioBase64,\n} from './convert.ts';\nexport { VoiceRequestError } from './errors.ts';\nexport type {\n  Delivery,\n  DeliverySupport,\n  KnownRealtimeApi,\n  KnownSpeechApi,\n  KnownTranscriptionApi,\n  RealtimeApi,\n  RealtimeModel,\n  SpeechApi,\n  SpeechModel,\n  TranscriptionApi,\n  TranscriptionModel,\n  VoiceInfo,\n  VoiceModel,\n  VoiceModelType,\n} from './models.ts';\nexport {\n  getVoiceModel,\n  listVoiceModels,\n  registerVoiceModel,\n} from './models.ts';\nexport type {\n  DeliveryPlan,\n  RealtimeApiProvider,\n  RealtimeContext,\n  RealtimeEvent,\n  RealtimeOptions,\n  RealtimeSession,\n  RealtimeSocket,\n  RealtimeToken,\n  TruncationPlan,\n} from './realtime.ts';\nexport { planDelivery, planTruncation, RealtimeLedger, realtimeSocket } from './realtime.ts';\nexport {\n  connectRealtime,\n  listen,\n  registerRealtimeApiProvider,\n  registerSpeechApiProvider,\n  registerTranscriptionApiProvider,\n  speak,\n  transcribe,\n} from './registry.ts';\nexport type { SpeechApiProvider, SpeechEvent, SpeechInput } from './speech.ts';\nexport { SpeechEventStream } from './speech.ts';\nexport type {\n  BindThinkerOptions,\n  BoundThinker,\n  Thinker,\n  ThinkerCaption,\n  ThinkerPhase,\n  ThinkerUpdate,\n} from './talker.ts';\nexport { askAgent, bindThinker, talkerTools } from './talker.ts';\nexport type {\n  AudioInput,\n  ListenOptions,\n  Transcript,\n  TranscriptionApiProvider,\n  TranscriptionEvent,\n  TranscriptSegment,\n} from './transcription.ts';\nexport { TranscriptionEventStream } from './transcription.ts';\nexport type {\n  AudioCost,\n  AudioCounters,\n  AudioUsage,\n  RealtimeAudioCost,\n  SpeechAudioCost,\n  TranscriptionAudioCost,\n} from './usage.ts';\nexport { addAudioCounters, priceAudio } from './usage.ts';\nexport type { VadHook, VadUpdate } from './vad.ts';\nexport { energyVad } from './vad.ts';\n"],
-  "mappings": "AAUA,SAAS,wBAAwB;AACjC,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAiBlC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAYP,SAAS,cAAc,gBAAgB,gBAAgB,sBAAsB;AAC7E;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yBAAyB;AASlC,SAAS,UAAU,aAAa,mBAAmB;AASnD,SAAS,gCAAgC;AASzC,SAAS,kBAAkB,kBAAkB;AAE7C,SAAS,iBAAiB;",
+  "sourcesContent": ["export type {\n  AudioChunk,\n  AudioEncoding,\n  AudioFormat,\n  AudioSink,\n  AudioSource,\n  AudioTag,\n  CharAlignment,\n  TextSpan,\n} from './audio.ts';\nexport { resolveVoiceAuth } from './auth.ts';\nexport { blankUsage } from './blank-usage.ts';\nexport {\n  convertAudio,\n  convertAudioSource,\n  decodeAudioBase64,\n  encodeAudioBase64,\n} from './convert.ts';\nexport { VoiceRequestError } from './errors.ts';\nexport type {\n  Delivery,\n  DeliverySupport,\n  KnownRealtimeApi,\n  KnownSpeechApi,\n  KnownTranscriptionApi,\n  RealtimeApi,\n  RealtimeModel,\n  SpeechApi,\n  SpeechModel,\n  TranscriptionApi,\n  TranscriptionModel,\n  VoiceInfo,\n  VoiceModel,\n  VoiceModelType,\n} from './models.ts';\nexport {\n  getVoiceModel,\n  listVoiceModels,\n  registerVoiceModel,\n} from './models.ts';\nexport type {\n  DeliveryPlan,\n  RealtimeApiProvider,\n  RealtimeContext,\n  RealtimeEvent,\n  RealtimeOptions,\n  RealtimeSession,\n  RealtimeSocket,\n  RealtimeToken,\n  TruncationPlan,\n} from './realtime.ts';\nexport { planDelivery, planTruncation, RealtimeLedger, realtimeSocket } from './realtime.ts';\nexport {\n  connectRealtime,\n  listen,\n  registerRealtimeApiProvider,\n  registerSpeechApiProvider,\n  registerTranscriptionApiProvider,\n  speak,\n  transcribe,\n} from './registry.ts';\nexport type { SpeechApiProvider, SpeechEvent, SpeechInput } from './speech.ts';\nexport { SpeechEventStream } from './speech.ts';\nexport type { VoiceAgentEvent, VoiceMessageChange } from './spoken.ts';\nexport type {\n  BindThinkerOptions,\n  BoundThinker,\n  Thinker,\n  ThinkerCaption,\n  ThinkerPhase,\n  ThinkerUpdate,\n} from './talker.ts';\nexport { askAgent, bindThinker, talkerTools } from './talker.ts';\nexport type {\n  AudioInput,\n  ListenOptions,\n  Transcript,\n  TranscriptionApiProvider,\n  TranscriptionEvent,\n  TranscriptSegment,\n} from './transcription.ts';\nexport { TranscriptionEventStream } from './transcription.ts';\nexport type {\n  BargeIn,\n  CaptionEvent,\n  EchoRecommendation,\n  VoiceConversation,\n  VoiceCut,\n  VoiceModels,\n  VoicePhase,\n  VoiceSession,\n  VoiceTurnMeta,\n  VoiceTurnOptions,\n} from './turns.ts';\nexport { voiceTurns } from './turns.ts';\nexport type {\n  AudioCost,\n  AudioCounters,\n  AudioUsage,\n  RealtimeAudioCost,\n  SpeechAudioCost,\n  TranscriptionAudioCost,\n} from './usage.ts';\nexport { addAudioCounters, priceAudio } from './usage.ts';\nexport type { VadHook, VadUpdate } from './vad.ts';\nexport { energyVad } from './vad.ts';\n"],
+  "mappings": "AAUA,SAAS,wBAAwB;AACjC,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAiBlC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAYP,SAAS,cAAc,gBAAgB,gBAAgB,sBAAsB;AAC7E;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yBAAyB;AAUlC,SAAS,UAAU,aAAa,mBAAmB;AASnD,SAAS,gCAAgC;AAazC,SAAS,kBAAkB;AAS3B,SAAS,kBAAkB,kBAAkB;AAE7C,SAAS,iBAAiB;",
   "names": []
 }

package/dist/openai-realtime/index.js

@@ -0,0 +1,58 @@
+import { registerVoiceModel } from "../models.js";
+import { registerRealtimeApiProvider } from "../registry.js";
+import { connectVendorSession, pcmFormat } from "./session.js";
+const voices = [
+  { id: "marin", name: "Marin" },
+  { id: "cedar", name: "Cedar" },
+  { id: "alloy", name: "Alloy" },
+  { id: "ash", name: "Ash" },
+  { id: "ballad", name: "Ballad" },
+  { id: "coral", name: "Coral" },
+  { id: "echo", name: "Echo" },
+  { id: "sage", name: "Sage" },
+  { id: "shimmer", name: "Shimmer" },
+  { id: "verse", name: "Verse" }
+];
+const audioCost = { perInputMinute: 0.0192, perOutputMinute: 0.0384 };
+function realtimeModel(id, name) {
+  return {
+    id,
+    name,
+    api: "openai-realtime",
+    provider: "openai",
+    baseUrl: "wss://api.openai.com/v1/realtime",
+    type: "realtime",
+    transports: ["websocket", "webrtc"],
+    toolCalls: "blocking",
+    inputFormat: pcmFormat(24e3),
+    outputFormat: pcmFormat(24e3),
+    resumable: false,
+    ephemeralAuth: true,
+    voices,
+    provisioning: "none",
+    delivery: { interrupt: "native", when_idle: "approximate", silent: "native" },
+    truncation: "client",
+    liveToolUpdate: true,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    audioCost
+  };
+}
+const gptRealtime2 = realtimeModel("gpt-realtime-2", "GPT Realtime 2");
+const gptRealtime21 = realtimeModel("gpt-realtime-2.1", "GPT Realtime 2.1");
+function registerOpenAIRealtime(options = {}) {
+  const unregisterModels = [gptRealtime2, gptRealtime21].map(registerVoiceModel);
+  const unregisterApi = registerRealtimeApiProvider({
+    api: "openai-realtime",
+    connect: (model, context, connectOptions) => connectVendorSession(model, context, connectOptions, { ...options, dialect: "openai" })
+  });
+  return () => {
+    for (const unregister of unregisterModels) unregister();
+    unregisterApi();
+  };
+}
+export {
+  gptRealtime2,
+  gptRealtime21,
+  registerOpenAIRealtime
+};
+//# sourceMappingURL=index.js.map

package/dist/openai-realtime/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/openai-realtime/index.ts"],
+  "sourcesContent": ["import type { RealtimeModel } from '../models.ts';\nimport { registerVoiceModel } from '../models.ts';\nimport { registerRealtimeApiProvider } from '../registry.ts';\nimport { type AdapterOptions, connectVendorSession, pcmFormat } from './session.ts';\n\nconst voices = [\n  { id: 'marin', name: 'Marin' },\n  { id: 'cedar', name: 'Cedar' },\n  { id: 'alloy', name: 'Alloy' },\n  { id: 'ash', name: 'Ash' },\n  { id: 'ballad', name: 'Ballad' },\n  { id: 'coral', name: 'Coral' },\n  { id: 'echo', name: 'Echo' },\n  { id: 'sage', name: 'Sage' },\n  { id: 'shimmer', name: 'Shimmer' },\n  { id: 'verse', name: 'Verse' },\n];\n\nconst audioCost = { perInputMinute: 0.0192, perOutputMinute: 0.0384 };\n\nfunction realtimeModel(id: string, name: string): RealtimeModel<'openai-realtime'> {\n  return {\n    id,\n    name,\n    api: 'openai-realtime',\n    provider: 'openai',\n    baseUrl: 'wss://api.openai.com/v1/realtime',\n    type: 'realtime',\n    transports: ['websocket', 'webrtc'],\n    toolCalls: 'blocking',\n    inputFormat: pcmFormat(24000),\n    outputFormat: pcmFormat(24000),\n    resumable: false,\n    ephemeralAuth: true,\n    voices,\n    provisioning: 'none',\n    delivery: { interrupt: 'native', when_idle: 'approximate', silent: 'native' },\n    truncation: 'client',\n    liveToolUpdate: true,\n    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },\n    audioCost,\n  };\n}\n\nexport const gptRealtime2 = realtimeModel('gpt-realtime-2', 'GPT Realtime 2');\n\nexport const gptRealtime21 = realtimeModel('gpt-realtime-2.1', 'GPT Realtime 2.1');\n\nexport function registerOpenAIRealtime(options: AdapterOptions = {}): () => void {\n  const unregisterModels = [gptRealtime2, gptRealtime21].map(registerVoiceModel);\n  const unregisterApi = registerRealtimeApiProvider({\n    api: 'openai-realtime',\n    connect: (model, context, connectOptions) =>\n      connectVendorSession(model, context, connectOptions, { ...options, dialect: 'openai' }),\n  });\n  return () => {\n    for (const unregister of unregisterModels) unregister();\n    unregisterApi();\n  };\n}\n\nexport type { AdapterOptions, VoiceWireFactory } from './session.ts';\nexport type { VoiceSocketConstructor, VoiceWire, VoiceWireTarget } from './socket.ts';\n"],
+  "mappings": "AACA,SAAS,0BAA0B;AACnC,SAAS,mCAAmC;AAC5C,SAA8B,sBAAsB,iBAAiB;AAErE,MAAM,SAAS;AAAA,EACb,EAAE,IAAI,SAAS,MAAM,QAAQ;AAAA,EAC7B,EAAE,IAAI,SAAS,MAAM,QAAQ;AAAA,EAC7B,EAAE,IAAI,SAAS,MAAM,QAAQ;AAAA,EAC7B,EAAE,IAAI,OAAO,MAAM,MAAM;AAAA,EACzB,EAAE,IAAI,UAAU,MAAM,SAAS;AAAA,EAC/B,EAAE,IAAI,SAAS,MAAM,QAAQ;AAAA,EAC7B,EAAE,IAAI,QAAQ,MAAM,OAAO;AAAA,EAC3B,EAAE,IAAI,QAAQ,MAAM,OAAO;AAAA,EAC3B,EAAE,IAAI,WAAW,MAAM,UAAU;AAAA,EACjC,EAAE,IAAI,SAAS,MAAM,QAAQ;AAC/B;AAEA,MAAM,YAAY,EAAE,gBAAgB,QAAQ,iBAAiB,OAAO;AAEpE,SAAS,cAAc,IAAY,MAAgD;AACjF,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,KAAK;AAAA,IACL,UAAU;AAAA,IACV,SAAS;AAAA,IACT,MAAM;AAAA,IACN,YAAY,CAAC,aAAa,QAAQ;AAAA,IAClC,WAAW;AAAA,IACX,aAAa,UAAU,IAAK;AAAA,IAC5B,cAAc,UAAU,IAAK;AAAA,IAC7B,WAAW;AAAA,IACX,eAAe;AAAA,IACf;AAAA,IACA,cAAc;AAAA,IACd,UAAU,EAAE,WAAW,UAAU,WAAW,eAAe,QAAQ,SAAS;AAAA,IAC5E,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,YAAY,EAAE;AAAA,IACzD;AAAA,EACF;AACF;AAEO,MAAM,eAAe,cAAc,kBAAkB,gBAAgB;AAErE,MAAM,gBAAgB,cAAc,oBAAoB,kBAAkB;AAE1E,SAAS,uBAAuB,UAA0B,CAAC,GAAe;AAC/E,QAAM,mBAAmB,CAAC,cAAc,aAAa,EAAE,IAAI,kBAAkB;AAC7E,QAAM,gBAAgB,4BAA4B;AAAA,IAChD,KAAK;AAAA,IACL,SAAS,CAAC,OAAO,SAAS,mBACxB,qBAAqB,OAAO,SAAS,gBAAgB,EAAE,GAAG,SAAS,SAAS,SAAS,CAAC;AAAA,EAC1F,CAAC;AACD,SAAO,MAAM;AACX,eAAW,cAAc,iBAAkB,YAAW;AACtD,kBAAc;AAAA,EAChB;AACF;",
+  "names": []
+}

package/dist/openai-realtime/session.js

@@ -0,0 +1,494 @@
+import { blankUsage } from "../blank-usage.js";
+import { decodeAudioBase64, encodeAudioBase64 } from "../convert.js";
+import { VoiceRequestError } from "../errors.js";
+import { planTruncation, RealtimeLedger, realtimeSocket } from "../realtime.js";
+import {
+  openVoiceSocket
+} from "./socket.js";
+function record(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function credential(options) {
+  const token = options?.token?.value;
+  if (typeof token === "string" && token.length > 0) return token;
+  const apiKey = options?.apiKey;
+  if (typeof apiKey === "string" && apiKey.length > 0) return apiKey;
+  throw new VoiceRequestError("error", "missing realtime credential");
+}
+function headersFor(options, secret, bearer) {
+  const headers = {};
+  if (bearer) headers.Authorization = `Bearer ${secret}`;
+  const extra = options?.headers;
+  if (extra === void 0) return headers;
+  for (const [key, value] of Object.entries(extra)) {
+    if (value === null) delete headers[key];
+    else headers[key] = value;
+  }
+  return headers;
+}
+function sessionUrl(model, resumeHandle) {
+  const params = new URLSearchParams({ model: model.id });
+  if (resumeHandle !== void 0) params.set("conversation_id", resumeHandle);
+  return `${model.baseUrl}?${params.toString()}`;
+}
+function functionTool(tool) {
+  return {
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  };
+}
+function openaiSession(context, model) {
+  return {
+    type: "realtime",
+    instructions: context.instructions,
+    tools: context.tools.map(functionTool),
+    audio: {
+      input: {
+        format: { type: "audio/pcm", rate: model.inputFormat.sampleRate },
+        turn_detection: { type: "server_vad" }
+      },
+      output: {
+        format: { type: "audio/pcm", rate: model.outputFormat.sampleRate },
+        voice: context.voice
+      }
+    }
+  };
+}
+function xaiSession(context, model, replace) {
+  const session = {
+    voice: context.voice,
+    instructions: context.instructions,
+    turn_detection: { type: "server_vad" },
+    tools: context.tools.map(functionTool),
+    resumption: { enabled: true },
+    audio: {
+      input: { format: { type: "audio/pcm", rate: model.inputFormat.sampleRate } },
+      output: { format: { type: "audio/pcm", rate: model.outputFormat.sampleRate } }
+    }
+  };
+  if (replace !== void 0) session.replace = replace;
+  return session;
+}
+function userItem(value) {
+  return {
+    type: "conversation.item.create",
+    item: {
+      type: "message",
+      role: "user",
+      content: [{ type: "input_text", text: value }]
+    }
+  };
+}
+function responseCreate() {
+  return { type: "response.create" };
+}
+function resultText(result) {
+  const parts = [];
+  for (const part of result.content) {
+    if (part.type === "text") parts.push(part.text);
+  }
+  return parts.join("\n");
+}
+function toolOutput(callId, result) {
+  return {
+    type: "conversation.item.create",
+    item: { type: "function_call_output", call_id: callId, output: resultText(result) }
+  };
+}
+function forceMessage(value) {
+  return {
+    type: "conversation.item.create",
+    item: {
+      type: "force_message",
+      role: "assistant",
+      content: [{ type: "output_text", text: value }]
+    }
+  };
+}
+function spanFor(itemId, start, end) {
+  return { itemId, start, end };
+}
+function takeAudio(pending, itemId, format, end) {
+  const chunks = pending.chunks;
+  pending.chunks = [];
+  if (chunks.length === 0) return [];
+  const start = pending.cursor;
+  if (end !== void 0) pending.cursor = end;
+  const width = end === void 0 ? 0 : end - start;
+  const total = chunks.reduce((sum, chunk) => sum + chunk.data.length, 0);
+  let used = 0;
+  let cursor = start;
+  return chunks.map((chunk, index) => {
+    const event = {
+      type: "output_audio",
+      itemId,
+      chunk: { data: chunk.data, format, timestamp: chunk.timestamp }
+    };
+    if (end === void 0 || total === 0) return event;
+    const last = index === chunks.length - 1;
+    const next = last ? end : start + Math.round((used + chunk.data.length) / total * width);
+    used += chunk.data.length;
+    event.span = spanFor(itemId, cursor, next);
+    cursor = next;
+    return event;
+  });
+}
+function argumentsOf(value) {
+  if (typeof value !== "string") return {};
+  try {
+    const parsed = JSON.parse(value);
+    const object = record(parsed);
+    if (object === void 0) return {};
+    return object;
+  } catch {
+    return {};
+  }
+}
+function responseUsage(value) {
+  const usage = record(value);
+  if (usage === void 0) return blankUsage();
+  const input = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+  const output = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+  return {
+    input,
+    output,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: input + output,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+}
+class VendorSession {
+  model;
+  #dialect;
+  #context;
+  #replace;
+  #wire;
+  #ledger = new RealtimeLedger();
+  #format;
+  #pending = /* @__PURE__ */ new Map();
+  #inputText = /* @__PURE__ */ new Map();
+  #queue = [];
+  #waiters = [];
+  #closed = false;
+  #usage;
+  #lastItem = "";
+  constructor(model, context, dialect, replace, wire) {
+    this.model = model;
+    this.#context = context;
+    this.#dialect = dialect;
+    this.#replace = replace;
+    this.#wire = wire;
+    this.#format = model.outputFormat;
+  }
+  start(options) {
+    this.#send(this.#sessionUpdate(this.#context));
+    const signal = options?.signal;
+    if (signal !== void 0) signal.addEventListener("abort", () => void this.close());
+    void this.#read();
+  }
+  appendAudio(chunk) {
+    this.#assertOpen();
+    this.#ledger.addInput(chunk);
+    this.#send({ type: "input_audio_buffer.append", audio: encodeAudioBase64(chunk.data) });
+  }
+  sendText(textValue) {
+    this.#assertOpen();
+    this.#ledger.addText();
+    this.#send(userItem(textValue));
+    this.#send(responseCreate());
+  }
+  inject(textValue, delivery) {
+    this.#assertOpen();
+    this.#ledger.submit(this.model.delivery, delivery, () => {
+      this.#assertOpen();
+      this.#ledger.addText();
+      this.#sendInject(textValue, delivery);
+    });
+  }
+  respond(callId, result, delivery) {
+    this.#assertOpen();
+    const send = () => {
+      this.#send(toolOutput(callId, result));
+      if (delivery !== "silent") this.#send(responseCreate());
+    };
+    if (delivery === void 0) {
+      send();
+      return;
+    }
+    this.#ledger.submit(this.model.delivery, delivery, () => {
+      this.#assertOpen();
+      send();
+    });
+  }
+  interrupt(heard) {
+    this.#assertOpen();
+    this.#send({ type: "response.cancel" });
+    const plan = planTruncation(this.model.truncation, heard);
+    if (plan.item !== void 0) {
+      this.#send({
+        type: "conversation.item.truncate",
+        item_id: plan.item.itemId,
+        content_index: 0,
+        audio_end_ms: plan.item.audioEndMs
+      });
+    }
+    this.#ledger.settle();
+  }
+  update(patch) {
+    this.#assertOpen();
+    if (patch.tools !== void 0 && !this.model.liveToolUpdate) {
+      throw new VoiceRequestError("error", "live tool update is unsupported");
+    }
+    let instructions = this.#context.instructions;
+    if (patch.instructions !== void 0) instructions = patch.instructions;
+    let tools = this.#context.tools;
+    if (patch.tools !== void 0) tools = patch.tools;
+    let voice = this.#context.voice;
+    if (patch.voice !== void 0) voice = patch.voice;
+    const context = { instructions, tools, voice };
+    if (patch.instructions !== void 0) this.#context.instructions = context.instructions;
+    if (patch.tools !== void 0) this.#context.tools = context.tools;
+    if (patch.voice !== void 0) this.#context.voice = context.voice;
+    this.#send(this.#sessionUpdate(context));
+  }
+  async close() {
+    if (this.#usage !== void 0) return { usage: this.#usage };
+    this.#ledger.settle();
+    this.#closed = true;
+    this.#wire.close();
+    this.#end();
+    this.#usage = this.#ledger.usage(this.model.audioCost);
+    return { usage: this.#usage };
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      const queued = this.#queue.shift();
+      if (queued !== void 0) {
+        yield queued;
+        continue;
+      }
+      if (this.#closed) return;
+      const next = await new Promise((resolve) => {
+        this.#waiters.push(resolve);
+      });
+      if (next.done === true || next.value === void 0) return;
+      yield next.value;
+    }
+  }
+  #sessionUpdate(context) {
+    if (this.#dialect === "openai") {
+      return { type: "session.update", session: openaiSession(context, this.model) };
+    }
+    return { type: "session.update", session: xaiSession(context, this.model, this.#replace) };
+  }
+  #sendInject(textValue, delivery) {
+    if (this.#dialect === "xai" && delivery !== "silent") {
+      this.#send(forceMessage(textValue));
+      return;
+    }
+    this.#send(userItem(textValue));
+    if (delivery !== "silent") this.#send(responseCreate());
+  }
+  #send(event) {
+    this.#wire.send(JSON.stringify(event));
+  }
+  #assertOpen() {
+    if (this.#closed) throw new VoiceRequestError("error", "session is closed");
+  }
+  #push(event) {
+    if (this.#closed) return;
+    this.#ledger.observe(event);
+    const waiter = this.#waiters.shift();
+    if (waiter !== void 0) waiter({ value: event, done: false });
+    else this.#queue.push(event);
+  }
+  #end() {
+    for (const waiter of this.#waiters) waiter({ value: void 0, done: true });
+    this.#waiters.length = 0;
+  }
+  #pendingFor(itemId) {
+    const existing = this.#pending.get(itemId);
+    if (existing !== void 0) return existing;
+    const created = { chunks: [], cursor: 0 };
+    this.#pending.set(itemId, created);
+    return created;
+  }
+  #audio(itemId, encoded) {
+    this.#lastItem = itemId;
+    const pending = this.#pendingFor(itemId);
+    pending.chunks.push({
+      data: decodeAudioBase64(encoded),
+      format: this.#format,
+      timestamp: 0
+    });
+  }
+  #transcript(itemId, delta, final) {
+    const pending = this.#pendingFor(itemId);
+    const end = pending.cursor + delta.length;
+    const tagged = delta.length === 0 ? void 0 : end;
+    for (const event of takeAudio(pending, itemId, this.#format, tagged)) this.#push(event);
+    this.#push({ type: "output_transcript", itemId, text: delta, final });
+  }
+  #input(itemId, transcript, mode, final) {
+    const previous = this.#inputText.get(itemId) ?? "";
+    const next = mode === "append" ? `${previous}${transcript}` : transcript;
+    this.#inputText.set(itemId, next);
+    this.#push({ type: "input_transcript", itemId, text: next, final });
+  }
+  #field(value, key) {
+    const object = record(value);
+    if (object === void 0) return "";
+    return text(object[key]);
+  }
+  #functionCall(event) {
+    this.#push({
+      type: "tool_call",
+      blocking: this.model.toolCalls === "blocking",
+      call: {
+        type: "toolCall",
+        id: text(event.call_id),
+        name: text(event.name),
+        arguments: argumentsOf(event.arguments)
+      }
+    });
+  }
+  #responseDone(event) {
+    const response = record(event.response);
+    const output = response === void 0 ? void 0 : response.output;
+    const first = Array.isArray(output) ? record(output[0]) : void 0;
+    let itemId = this.#lastItem;
+    if (first !== void 0 && text(first.id).length > 0) itemId = text(first.id);
+    const pending = this.#pendingFor(itemId);
+    for (const audioEvent of takeAudio(pending, itemId, this.#format, void 0)) {
+      this.#push(audioEvent);
+    }
+    const status = response === void 0 ? "" : text(response.status);
+    const usage = response === void 0 ? void 0 : response.usage;
+    this.#push({
+      type: "response_done",
+      itemId,
+      interrupted: status === "cancelled",
+      usage: responseUsage(usage)
+    });
+  }
+  #serverError(event) {
+    const detail = record(event.error);
+    const code = detail === void 0 ? "" : text(detail.code);
+    const message = detail === void 0 ? "" : text(detail.message);
+    let fatal = false;
+    if (code === "max_duration") fatal = true;
+    if (code === "session_expired") fatal = true;
+    this.#push({ type: "error", error: message, fatal });
+  }
+  #apply(event) {
+    const type = text(event.type);
+    if (type === "session.created") {
+      this.#push({ type: "session_start", sessionId: this.#field(event.session, "id") });
+      return;
+    }
+    if (type === "conversation.created") {
+      this.#push({ type: "resumption", handle: this.#field(event.conversation, "id") });
+      return;
+    }
+    if (type === "input_audio_buffer.speech_started") {
+      this.#push({ type: "input_speech_start" });
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.delta") {
+      this.#input(text(event.item_id), text(event.delta), "append", false);
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.updated") {
+      this.#input(text(event.item_id), text(event.transcript), "replace", false);
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.completed") {
+      this.#input(text(event.item_id), text(event.transcript), "replace", true);
+      return;
+    }
+    if (type === "response.output_audio.delta") {
+      this.#audio(text(event.item_id), text(event.delta));
+      return;
+    }
+    if (type === "response.output_audio_transcript.delta") {
+      this.#transcript(text(event.item_id), text(event.delta), false);
+      return;
+    }
+    if (type === "response.output_audio_transcript.done") {
+      this.#transcript(text(event.item_id), text(event.transcript), true);
+      return;
+    }
+    if (type === "response.function_call_arguments.done") {
+      this.#functionCall(event);
+      return;
+    }
+    if (type === "response.done") {
+      this.#responseDone(event);
+      return;
+    }
+    if (type === "error") this.#serverError(event);
+  }
+  async #read() {
+    try {
+      for await (const raw of this.#wire.incoming) {
+        let parsed;
+        try {
+          parsed = JSON.parse(raw);
+        } catch {
+          this.#push({ type: "error", error: "invalid realtime event", fatal: false });
+          continue;
+        }
+        const event = record(parsed);
+        if (event === void 0 || typeof event.type !== "string") continue;
+        this.#apply(event);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.#push({ type: "error", error: message, fatal: true });
+    } finally {
+      this.#closed = true;
+      this.#end();
+    }
+  }
+}
+async function connectVendorSession(model, context, options, vendor) {
+  if (options?.signal?.aborted === true) {
+    throw new VoiceRequestError("aborted", "session aborted");
+  }
+  if (options?.transport === "webrtc" && vendor.wire === void 0) {
+    throw new VoiceRequestError("error", "webrtc requires a data channel wire");
+  }
+  const secret = credential(options);
+  const token = options?.token?.value;
+  const ephemeral = typeof token === "string" && token.length > 0;
+  const protocols = [];
+  if (vendor.dialect === "openai") protocols.push(`openai-insecure-api-key.${secret}`, "realtime");
+  else if (ephemeral) protocols.push(`xai-client-secret.${secret}`);
+  else protocols.push("realtime");
+  const resumeHandle = vendor.dialect === "xai" ? options?.resumeHandle : void 0;
+  const socket = realtimeSocket(sessionUrl(model, resumeHandle), options, protocols);
+  const target = {
+    url: socket.url,
+    protocols: socket.protocols,
+    headers: headersFor(options, secret, vendor.dialect === "openai" || !ephemeral)
+  };
+  const open = vendor.wire !== void 0 ? vendor.wire : (wireTarget) => openVoiceSocket(wireTarget, vendor.socket);
+  const session = new VendorSession(model, context, vendor.dialect, vendor.replace, open(target));
+  session.start(options);
+  return session;
+}
+function pcmFormat(sampleRate) {
+  return { encoding: "pcm16", sampleRate, channels: 1 };
+}
+export {
+  connectVendorSession,
+  pcmFormat
+};
+//# sourceMappingURL=session.js.map