@voicethere/agent 0.8.3 → 0.9.0

package/dist/templates/language-switch/agent.js

@@ -0,0 +1,1050 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+
+
+// dist/runtime.js
+import { randomUUID } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// dist/session-serial-queue.js
+var SessionSerialQueueCancellationError = class extends Error {
+  sessionId;
+  generation;
+  code = "SESSION_SERIAL_QUEUE_CANCELLED";
+  constructor(sessionId, generation) {
+    super(`session serial queue cancelled (sessionId=${sessionId}, generation=${generation})`);
+    this.sessionId = sessionId;
+    this.generation = generation;
+    this.name = "SessionSerialQueueCancellationError";
+  }
+};
+var SessionSerialQueue = class {
+  sessions = /* @__PURE__ */ new Map();
+  /** Monotonic token source — never reused across clear/enqueue cycles. */
+  nextGeneration = 1;
+  /**
+   * Enqueue work for `sessionId`. Returns a promise that settles when this
+   * task finishes, is skipped as stale, or is cancelled by {@link clear}.
+   * Fire-and-forget callers may ignore the return value (compat).
+   */
+  enqueue(sessionId, task) {
+    const state = this.ensureState(sessionId);
+    const captured = state;
+    const generation = captured.generation;
+    captured.pending += 1;
+    const previous = captured.tail;
+    let taskAbort = null;
+    const settled = previous.catch(() => void 0).then(async () => {
+      if (this.sessions.get(sessionId) !== captured) {
+        return "cancelled";
+      }
+      const abort = new AbortController();
+      taskAbort = abort;
+      captured.abort = abort;
+      const context = {
+        sessionId,
+        generation,
+        signal: abort.signal
+      };
+      try {
+        await Promise.resolve(task(abort.signal, context));
+        if (this.sessions.get(sessionId) !== captured) {
+          return "cancelled";
+        }
+        return "completed";
+      } catch (error) {
+        if (abort.signal.aborted || this.sessions.get(sessionId) !== captured || error instanceof SessionSerialQueueCancellationError) {
+          return "cancelled";
+        }
+        return "failed";
+      } finally {
+        if (captured.abort === abort) {
+          captured.abort = null;
+        }
+      }
+    }).finally(() => {
+      captured.pending = Math.max(0, captured.pending - 1);
+      if (taskAbort && captured.abort === taskAbort) {
+        captured.abort = null;
+      }
+    });
+    captured.tail = settled;
+    return settled;
+  }
+  /**
+   * Invalidate queued + running work for `sessionId`. Aborts the live AbortSignal,
+   * drops the map entry, and leaves a fresh identity for the next enqueue.
+   * Old in-flight `finally` blocks only touch their captured state object.
+   */
+  clear(sessionId) {
+    const old = this.sessions.get(sessionId);
+    if (!old)
+      return;
+    old.abort?.abort();
+    old.abort = null;
+    this.sessions.delete(sessionId);
+  }
+  clearAll() {
+    for (const sessionId of [...this.sessions.keys()]) {
+      this.clear(sessionId);
+    }
+  }
+  hasPending(sessionId) {
+    return (this.sessions.get(sessionId)?.pending ?? 0) > 0;
+  }
+  /** Live generation token for a session, or `undefined` when cleared. */
+  generationOf(sessionId) {
+    return this.sessions.get(sessionId)?.generation;
+  }
+  /** True when `generation` is the live map entry for `sessionId`. */
+  isCurrentGeneration(sessionId, generation) {
+    return this.sessions.get(sessionId)?.generation === generation;
+  }
+  /**
+   * True when a queue row exists for the session (registered since first
+   * enqueue, until {@link clear}). Not the same as {@link hasPending}.
+   */
+  isLive(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  /** Registered session rows (must not grow without matching `clear` calls). */
+  get activeSessionCount() {
+    return this.sessions.size;
+  }
+  ensureState(sessionId) {
+    const existing = this.sessions.get(sessionId);
+    if (existing)
+      return existing;
+    const created = {
+      generation: this.nextGeneration++,
+      tail: Promise.resolve(),
+      abort: null,
+      pending: 0
+    };
+    this.sessions.set(sessionId, created);
+    return created;
+  }
+};
+
+// dist/runtime.js
+var SESSION_START_INIT_DELAY_ENABLED_ENV = "AGENT_SESSION_START_INIT_DELAY_ENABLED";
+var SESSION_START_INIT_DELAY_MS_ENV = "AGENT_SESSION_START_INIT_DELAY_MS";
+var DEFAULT_SESSION_START_INIT_DELAY_MS = 500;
+function isPlayAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "play_ack" && typeof msg.requestId === "string";
+}
+function isPlayStatusAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "play_status_ack" && typeof msg.requestId === "string";
+}
+function isPlayStopAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "play_stop_ack" && typeof msg.requestId === "string";
+}
+function isPlayPoseAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "play_pose_ack" && typeof msg.requestId === "string";
+}
+function isRecordingControlAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "recording_control_ack" && typeof msg.requestId === "string";
+}
+function isConversationHistoryControlAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "conversation_history_control_ack" && typeof msg.requestId === "string";
+}
+function isMixControlAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "mix_control_ack" && typeof msg.requestId === "string";
+}
+function isSttControlAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "stt_control_ack" && typeof msg.requestId === "string";
+}
+function isVoiceLanguageControlAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "voice_language_control_ack" && typeof msg.requestId === "string";
+}
+function isWebhookMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "webhook" && typeof msg.eventId === "string" && typeof msg.projectId === "string";
+}
+function coerceInboundBinary(value) {
+  if (!value)
+    return null;
+  if (Buffer.isBuffer(value))
+    return value;
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (value instanceof ArrayBuffer)
+    return Buffer.from(value);
+  if (ArrayBuffer.isView(value)) {
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value === "object") {
+    const maybeBufferLike = value;
+    if (maybeBufferLike.type === "Buffer" && Array.isArray(maybeBufferLike.data)) {
+      return Buffer.from(maybeBufferLike.data);
+    }
+  }
+  return null;
+}
+function normalizeWebhookHeaders(value) {
+  if (!value || typeof value !== "object")
+    return {};
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string") {
+      out[key] = raw;
+    }
+  }
+  return out;
+}
+function isParentMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "session_start" || msg.type === "speech_event" || msg.type === "session_end" || msg.type === "data_channel_message" || msg.type === "data_channel_binary" || msg.type === "idle_timeout" || msg.type === "recording_control_ack" || msg.type === "conversation_history_control_ack" || msg.type === "play_ack" || msg.type === "play_status_ack" || msg.type === "play_stop_ack" || msg.type === "play_pose_ack" || msg.type === "mix_control_ack" || msg.type === "stt_control_ack" || msg.type === "voice_language_control_ack" || msg.type === "webhook";
+}
+function isSessionScopedParentMessage(value) {
+  return isParentMessage(value) && !isWebhookMessage(value);
+}
+function parseDataChannelPayload(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+var peerEnvBySessionId = /* @__PURE__ */ new Map();
+var recordingAvailableBySessionId = /* @__PURE__ */ new Map();
+var conversationHistoryAvailableBySessionId = /* @__PURE__ */ new Map();
+var mixAvailableBySessionId = /* @__PURE__ */ new Map();
+var ttsPoseAvailableBySessionId = /* @__PURE__ */ new Map();
+var endedSessionIds = /* @__PURE__ */ new Set();
+var PLAY_BYTES_MAX_DECODED_LENGTH = 64 * 1024;
+var pendingRecordingAcks = /* @__PURE__ */ new Map();
+var pendingConversationHistoryAcks = /* @__PURE__ */ new Map();
+var pendingPlayAcks = /* @__PURE__ */ new Map();
+var pendingPlayStatusAcks = /* @__PURE__ */ new Map();
+var pendingPlayStopAcks = /* @__PURE__ */ new Map();
+var pendingPlayPoseAcks = /* @__PURE__ */ new Map();
+var pendingMixAcks = /* @__PURE__ */ new Map();
+var pendingSttAcks = /* @__PURE__ */ new Map();
+var VOICE_LANGUAGE_CONTROL_ACK_TIMEOUT_MS = 66e4;
+var pendingVoiceLanguageAcks = /* @__PURE__ */ new Map();
+function handleRecordingControlAck(message) {
+  const pending = pendingRecordingAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingRecordingAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    reason: message.reason,
+    requestId: message.requestId
+  });
+}
+function handleConversationHistoryControlAck(message) {
+  const pending = pendingConversationHistoryAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingConversationHistoryAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    reason: message.reason,
+    requestId: message.requestId
+  });
+}
+function handlePlayAck(message) {
+  const pending = pendingPlayAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingPlayAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    ...message.playId ? { playId: message.playId } : {},
+    reason: message.reason,
+    requestId: message.requestId
+  });
+}
+function handlePlayStatusAck(message) {
+  const pending = pendingPlayStatusAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingPlayStatusAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    playId: message.playId,
+    ...message.status ? { status: message.status } : {},
+    reason: message.reason,
+    requestId: message.requestId
+  });
+}
+function handlePlayStopAck(message) {
+  const pending = pendingPlayStopAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingPlayStopAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    playId: message.playId,
+    reason: message.reason,
+    requestId: message.requestId
+  });
+}
+function handlePlayPoseAck(message) {
+  const pending = pendingPlayPoseAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingPlayPoseAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    playId: message.playId,
+    reason: message.reason,
+    requestId: message.requestId
+  });
+}
+function handleMixControlAck(message) {
+  const pending = pendingMixAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingMixAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    reason: message.reason,
+    requestId: message.requestId,
+    ...message.statuses ? { statuses: message.statuses } : {}
+  });
+}
+function handleSttControlAck(message) {
+  const pending = pendingSttAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingSttAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    reason: message.reason,
+    requestId: message.requestId
+  });
+}
+function handleVoiceLanguageControlAck(message) {
+  const pending = pendingVoiceLanguageAcks.get(message.requestId);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingVoiceLanguageAcks.delete(message.requestId);
+  pending.resolve({
+    ok: message.ok,
+    reason: message.reason,
+    requestId: message.requestId,
+    ...message.language ? { language: message.language } : {},
+    ...message.voice ? { voice: message.voice } : {},
+    ...message.stt ? { stt: message.stt } : {},
+    ...message.scope ? { scope: message.scope } : {},
+    ...message.sttProvider ? { sttProvider: message.sttProvider } : {},
+    ...message.ttsProvider ? { ttsProvider: message.ttsProvider } : {}
+  });
+}
+function clearPendingRecordingAcksForSession(sessionId, reason) {
+  for (const [requestId, pending] of pendingRecordingAcks) {
+    if (pending.sessionId !== sessionId)
+      continue;
+    clearTimeout(pending.timer);
+    pendingRecordingAcks.delete(requestId);
+    pending.resolve({ ok: false, reason, requestId });
+  }
+}
+function clearPendingConversationHistoryAcksForSession(sessionId, reason) {
+  for (const [requestId, pending] of pendingConversationHistoryAcks) {
+    if (pending.sessionId !== sessionId)
+      continue;
+    clearTimeout(pending.timer);
+    pendingConversationHistoryAcks.delete(requestId);
+    pending.resolve({ ok: false, reason, requestId });
+  }
+}
+function isVoicethereAgentChild() {
+  return typeof process.send === "function" && process.connected !== false && typeof process.env.__CHILD_BUNDLE_PATH__ === "string" && process.env.__CHILD_BUNDLE_PATH__.trim().length > 0;
+}
+var sessionExecutionContext = new AsyncLocalStorage();
+var agentLogSessionContext = new AsyncLocalStorage();
+var inboundQueueAuthority = null;
+var childUnhandledRejectionGuardInstalled = false;
+function normalizeRejectionReason(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+function installChildUnhandledRejectionGuard() {
+  if (childUnhandledRejectionGuardInstalled) {
+    return;
+  }
+  childUnhandledRejectionGuardInstalled = true;
+  process.on("unhandledRejection", (reason) => {
+    const err = normalizeRejectionReason(reason);
+    const store = sessionExecutionContext.getStore();
+    const sessionId = store?.sessionId ?? agentLogSessionContext.getStore() ?? "";
+    if (!allowOutboundForSession(sessionId || void 0)) {
+      return;
+    }
+    agentLog("error", `unhandledRejection: ${err.message}`, sessionId || void 0);
+    sendParentMessage({
+      type: "agent_error",
+      sessionId,
+      message: err.message,
+      stack: err.stack
+    });
+  });
+}
+function allowOutboundForSession(sessionId) {
+  if (!sessionId) {
+    return true;
+  }
+  const store = sessionExecutionContext.getStore();
+  const queue = inboundQueueAuthority;
+  if (store && store.sessionId === sessionId) {
+    if (!queue)
+      return !endedSessionIds.has(sessionId);
+    return queue.isCurrentGeneration(sessionId, store.generation);
+  }
+  if (endedSessionIds.has(sessionId))
+    return false;
+  if (!queue)
+    return true;
+  return queue.isLive(sessionId);
+}
+function sendParentMessage(message) {
+  const msgType = message && typeof message === "object" && "type" in message ? message.type : void 0;
+  if (msgType === "mix_control" || msgType === "stt_control" || msgType === "voice_language_control") {
+    process.send?.(message);
+    return;
+  }
+  if (msgType === "play" || msgType === "play_status" || msgType === "play_stop" || msgType === "play_pose") {
+    process.send?.(message);
+    return;
+  }
+  const sessionId = message && typeof message === "object" && "sessionId" in message && typeof message.sessionId === "string" ? message.sessionId : void 0;
+  if (!allowOutboundForSession(sessionId))
+    return;
+  process.send?.(message);
+}
+function parseBooleanEnv(value, defaultValue) {
+  if (value === void 0)
+    return defaultValue;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "")
+    return defaultValue;
+  if (["0", "false", "off", "no"].includes(normalized))
+    return false;
+  if (["1", "true", "on", "yes"].includes(normalized))
+    return true;
+  return defaultValue;
+}
+function parseNonNegativeIntegerEnv(value, defaultValue) {
+  if (value === void 0)
+    return defaultValue;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return defaultValue;
+  return Math.floor(parsed);
+}
+function resolveSessionStartInitDelayMs() {
+  const enabled = parseBooleanEnv(process.env[SESSION_START_INIT_DELAY_ENABLED_ENV], true);
+  if (!enabled)
+    return 0;
+  return parseNonNegativeIntegerEnv(process.env[SESSION_START_INIT_DELAY_MS_ENV], DEFAULT_SESSION_START_INIT_DELAY_MS);
+}
+async function handleWebhookMessage(message, handlers) {
+  if (!handlers.onWebhook)
+    return;
+  const body = coerceInboundBinary(message.body);
+  if (!body) {
+    agentLog("warn", "webhook ipc dropped: body is not binary");
+    return;
+  }
+  const ctx = {
+    eventId: message.eventId,
+    projectId: message.projectId,
+    method: typeof message.method === "string" ? message.method : "POST",
+    path: typeof message.path === "string" ? message.path : "",
+    headers: normalizeWebhookHeaders(message.headers),
+    body,
+    contentType: typeof message.contentType === "string" ? message.contentType : null,
+    receivedAt: typeof message.receivedAt === "string" ? message.receivedAt : "",
+    sessionIds: Array.isArray(message.sessionIds) ? message.sessionIds.filter((id) => typeof id === "string" && id.length > 0) : []
+  };
+  try {
+    const started = Date.now();
+    await handlers.onWebhook(ctx);
+    sendParentMessage({
+      type: "webhook_handled",
+      projectId: message.projectId,
+      eventId: message.eventId,
+      durationMs: Date.now() - started
+    });
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    await runErrorHook(handlers, {
+      sessionId: "",
+      projectId: message.projectId,
+      env: process.env,
+      error: err
+    });
+    sendParentMessage({
+      type: "agent_error",
+      sessionId: "",
+      message: err.message,
+      stack: err.stack
+    });
+  }
+}
+function resolveUserLanguageCode(event) {
+  const withLanguage = event;
+  const candidates = [withLanguage.language, event.text];
+  for (const value of candidates) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+async function handleParentMessage(message, handlers) {
+  switch (message.type) {
+    case "session_start":
+      endedSessionIds.delete(message.sessionId);
+      peerEnvBySessionId.set(message.sessionId, message.env);
+      recordingAvailableBySessionId.set(message.sessionId, message.recordingAvailable ?? false);
+      conversationHistoryAvailableBySessionId.set(message.sessionId, message.conversationHistoryAvailable ?? false);
+      mixAvailableBySessionId.set(message.sessionId, message.mixAvailable ?? false);
+      ttsPoseAvailableBySessionId.set(message.sessionId, message.ttsPoseAvailable ?? false);
+      const sessionStartInitDelayMs = resolveSessionStartInitDelayMs();
+      if (sessionStartInitDelayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, sessionStartInitDelayMs));
+      }
+      await (handlers.onClientJoin ?? handlers.onSessionStart)?.({
+        sessionId: message.sessionId,
+        env: message.env,
+        recordingAvailable: message.recordingAvailable ?? false,
+        conversationHistoryAvailable: message.conversationHistoryAvailable ?? false,
+        mixAvailable: message.mixAvailable ?? false,
+        ttsPoseAvailable: message.ttsPoseAvailable ?? false
+      });
+      sendParentMessage({
+        type: "session_start_ack",
+        sessionId: message.sessionId
+      });
+      break;
+    case "speech_event":
+      await handlers.onSpeechEvent?.({ sessionId: message.sessionId }, message.event);
+      if (message.event.type === "user_speech_final" && typeof message.event.text === "string" && message.event.text.trim()) {
+        await handlers.onUserSpeechFinal?.({
+          sessionId: message.sessionId,
+          text: message.event.text.trim()
+        });
+      }
+      if (message.event.type === "user_language") {
+        const language = resolveUserLanguageCode(message.event);
+        if (language) {
+          await handlers.onUserLanguage?.({
+            sessionId: message.sessionId,
+            language
+          });
+        }
+      }
+      break;
+    case "data_channel_message":
+      await handlers.onDataChannelMessage?.({
+        sessionId: message.sessionId,
+        message: parseDataChannelPayload(message.payload),
+        raw: message.payload,
+        rawBinary: null,
+        channel: "control"
+      });
+      break;
+    case "data_channel_binary":
+      await handlers.onDataChannelBinary?.({
+        sessionId: message.sessionId,
+        message: null,
+        raw: null,
+        rawBinary: message.data,
+        channel: message.channel ?? "sync"
+      });
+      break;
+    case "session_end":
+      clearPendingRecordingAcksForSession(message.sessionId, "session_ended");
+      clearPendingConversationHistoryAcksForSession(message.sessionId, "session_ended");
+      peerEnvBySessionId.delete(message.sessionId);
+      recordingAvailableBySessionId.delete(message.sessionId);
+      conversationHistoryAvailableBySessionId.delete(message.sessionId);
+      mixAvailableBySessionId.delete(message.sessionId);
+      ttsPoseAvailableBySessionId.delete(message.sessionId);
+      await (handlers.onClientLeave ?? handlers.onSessionEnd)?.({
+        sessionId: message.sessionId
+      });
+      break;
+    case "idle_timeout":
+      await runIdleTimeoutHook(handlers, message);
+      break;
+  }
+}
+function defineAgent(handlers) {
+  installChildUnhandledRejectionGuard();
+  const inboundBySession = new SessionSerialQueue();
+  inboundQueueAuthority = inboundBySession;
+  const agentStartReady = runAgentStartHook(handlers);
+  process.on("message", (message) => {
+    if (isRecordingControlAckMessage(message)) {
+      handleRecordingControlAck(message);
+      return;
+    }
+    if (isConversationHistoryControlAckMessage(message)) {
+      handleConversationHistoryControlAck(message);
+      return;
+    }
+    if (isPlayAckMessage(message)) {
+      handlePlayAck(message);
+      return;
+    }
+    if (isPlayStatusAckMessage(message)) {
+      handlePlayStatusAck(message);
+      return;
+    }
+    if (isPlayStopAckMessage(message)) {
+      handlePlayStopAck(message);
+      return;
+    }
+    if (isPlayPoseAckMessage(message)) {
+      handlePlayPoseAck(message);
+      return;
+    }
+    if (isMixControlAckMessage(message)) {
+      handleMixControlAck(message);
+      return;
+    }
+    if (isSttControlAckMessage(message)) {
+      handleSttControlAck(message);
+      return;
+    }
+    if (isVoiceLanguageControlAckMessage(message)) {
+      handleVoiceLanguageControlAck(message);
+      return;
+    }
+    if (isWebhookMessage(message)) {
+      void agentStartReady.then(() => handleWebhookMessage(message, handlers));
+      return;
+    }
+    if (!isSessionScopedParentMessage(message))
+      return;
+    if (message.type === "session_end") {
+      endedSessionIds.add(message.sessionId);
+      clearPendingRecordingAcksForSession(message.sessionId, "session_ended");
+      clearPendingConversationHistoryAcksForSession(message.sessionId, "session_ended");
+      inboundBySession.clear(message.sessionId);
+    }
+    if (message.type === "session_start") {
+      endedSessionIds.delete(message.sessionId);
+      inboundBySession.clear(message.sessionId);
+    }
+    inboundBySession.enqueue(message.sessionId, async (_signal, context) => {
+      await agentStartReady;
+      try {
+        await sessionExecutionContext.run({
+          sessionId: message.sessionId,
+          generation: context.generation
+        }, async () => agentLogSessionContext.run(message.sessionId, async () => {
+          try {
+            await handleParentMessage(message, handlers);
+          } catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            const env = peerEnvBySessionId.get(message.sessionId) ?? buildIdleEnv(message.sessionId);
+            await runErrorHook(handlers, {
+              sessionId: message.sessionId,
+              projectId: env.PROJECT_ID,
+              buildId: env.BUILD_ID,
+              env,
+              error: err,
+              customerContext: parseCustomerContext(env.AGENT_CUSTOMER_CONTEXT)
+            });
+            sendParentMessage({
+              type: "agent_error",
+              sessionId: message.sessionId,
+              message: err.message,
+              stack: err.stack
+            });
+          }
+        }));
+      } finally {
+        if (message.type === "session_end" && inboundBySession.isCurrentGeneration(message.sessionId, context.generation)) {
+          inboundBySession.clear(message.sessionId);
+        }
+      }
+    });
+  });
+}
+async function runAgentStartHook(handlers) {
+  if (!handlers.onAgentStart)
+    return;
+  try {
+    await handlers.onAgentStart({
+      env: process.env
+    });
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    agentLog("error", `onAgentStart failed: ${err.message}`);
+    sendParentMessage({
+      type: "agent_error",
+      sessionId: "",
+      message: err.message,
+      stack: err.stack
+    });
+  }
+}
+function parseCustomerContext(raw) {
+  if (!raw?.trim())
+    return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function runErrorHook(handlers, ctx) {
+  if (!handlers.errorHook)
+    return;
+  try {
+    await handlers.errorHook(ctx);
+  } catch (hookError) {
+    const message = hookError instanceof Error ? hookError.message : String(hookError);
+    agentLog("error", `errorHook failed: ${message}`, ctx.sessionId);
+  }
+}
+async function runIdleTimeoutHook(handlers, message) {
+  const onIdleTimeout = handlers.onIdleTimeout;
+  agentLog("info", `idle_timeout ipc received (maxGraceMs=${message.maxGraceMs}, onIdleTimeout=${typeof onIdleTimeout === "function"})`, message.sessionId);
+  if (!onIdleTimeout) {
+    sendParentMessage({
+      type: "idle_timeout_done",
+      sessionId: message.sessionId
+    });
+    agentLog("info", "idle_timeout_done ipc sent (no onIdleTimeout handler)", message.sessionId);
+    return;
+  }
+  const env = peerEnvBySessionId.get(message.sessionId) ?? buildIdleEnv(message.sessionId);
+  const idleTimeoutSeconds = Number(env.IDLE_TIMEOUT_SEC) || 0;
+  const ctx = {
+    sessionId: message.sessionId,
+    projectId: env.PROJECT_ID,
+    buildId: env.BUILD_ID,
+    env,
+    idleTimeoutSeconds
+  };
+  let error;
+  try {
+    await onIdleTimeout(ctx);
+  } catch (hookError) {
+    error = hookError instanceof Error ? hookError.message : String(hookError);
+    agentLog("error", `onIdleTimeout failed: ${error}`, message.sessionId);
+  }
+  sendParentMessage({
+    type: "idle_timeout_done",
+    sessionId: message.sessionId,
+    error
+  });
+  agentLog("info", error ? `idle_timeout_done ipc sent (onIdleTimeout error: ${error})` : "idle_timeout_done ipc sent (onIdleTimeout completed)", message.sessionId);
+}
+function buildIdleEnv(sessionId) {
+  return {
+    SESSION_ID: sessionId,
+    ...process.env.PROJECT_ID ? { PROJECT_ID: process.env.PROJECT_ID } : {},
+    ...process.env.BUILD_ID ? { BUILD_ID: process.env.BUILD_ID } : {},
+    ...process.env.IDLE_TIMEOUT_SEC ? { IDLE_TIMEOUT_SEC: process.env.IDLE_TIMEOUT_SEC } : {}
+  };
+}
+function speak(sessionId, text) {
+  sendParentMessage({ type: "speak", sessionId, text });
+}
+function cleanVendor(selection) {
+  const provider = selection?.provider?.trim();
+  if (!provider)
+    return void 0;
+  return {
+    provider,
+    ...selection?.model?.trim() ? { model: selection.model.trim() } : {},
+    ...selection?.voice?.trim() ? { voice: selection.voice.trim() } : {},
+    ...selection?.language?.trim() ? { language: selection.language.trim() } : {}
+  };
+}
+function setVoiceLanguage(sessionId, options) {
+  const requestId = randomUUID();
+  const language = options.language?.trim() ?? "";
+  const scope = options.scope;
+  if (scope && scope !== "stt" && scope !== "tts" && scope !== "both") {
+    return Promise.resolve({
+      ok: false,
+      reason: "invalid_scope",
+      requestId
+    });
+  }
+  const sttVendor = cleanVendor(options.sttVendor);
+  const ttsVendor = cleanVendor(options.ttsVendor);
+  const hasWork = Boolean(language || options.voice?.trim() || options.stt?.trim() || sttVendor || ttsVendor);
+  if (!hasWork) {
+    return Promise.resolve({
+      ok: false,
+      reason: "nothing_to_apply",
+      requestId
+    });
+  }
+  if (!isVoicethereAgentChild()) {
+    return Promise.resolve({ ok: true, reason: "local_mock", requestId });
+  }
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      pendingVoiceLanguageAcks.delete(requestId);
+      resolve({ ok: false, reason: "timeout", requestId });
+    }, VOICE_LANGUAGE_CONTROL_ACK_TIMEOUT_MS);
+    pendingVoiceLanguageAcks.set(requestId, { resolve, timer });
+    sendParentMessage({
+      type: "voice_language_control",
+      requestId,
+      sessionId,
+      ...language ? { language } : {},
+      ...scope ? { scope } : {},
+      ...options.voice?.trim() ? { voice: options.voice.trim() } : {},
+      ...options.stt?.trim() ? { stt: options.stt.trim() } : {},
+      ...sttVendor ? { sttVendor } : {},
+      ...ttsVendor ? { ttsVendor } : {}
+    });
+  });
+}
+var AGENT_LOG_MESSAGE_MAX_CHARS = 2048;
+var AGENT_LOG_FIELDS_MAX_CHARS = 8192;
+function truncateAgentLogMessage(message) {
+  if (message.length <= AGENT_LOG_MESSAGE_MAX_CHARS) {
+    return message;
+  }
+  const suffix = "\u2026[truncated]";
+  return message.slice(0, AGENT_LOG_MESSAGE_MAX_CHARS - suffix.length) + suffix;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitizeAgentLogFields(fields) {
+  if (Object.keys(fields).length === 0) {
+    return void 0;
+  }
+  try {
+    const serialized = JSON.stringify(fields);
+    if (serialized.length <= AGENT_LOG_FIELDS_MAX_CHARS) {
+      return fields;
+    }
+    return {
+      _agentLogFieldsTruncated: true,
+      _originalBytes: serialized.length,
+      _preview: serialized.slice(0, AGENT_LOG_FIELDS_MAX_CHARS - 80) + "\u2026[truncated]"
+    };
+  } catch {
+    return { _agentLogFieldsError: "not_serializable" };
+  }
+}
+function buildAgentLogPayload(level, message, fields, sessionId) {
+  const resolvedSessionId = sessionId ?? sessionExecutionContext.getStore()?.sessionId ?? agentLogSessionContext.getStore();
+  const sanitizedFields = fields ? sanitizeAgentLogFields(fields) : void 0;
+  return {
+    type: "log",
+    level,
+    message: truncateAgentLogMessage(message),
+    ts: Date.now(),
+    ...resolvedSessionId ? { sessionId: resolvedSessionId } : {},
+    ...sanitizedFields ? { fields: sanitizedFields } : {}
+  };
+}
+function agentLog(level, message, fieldsOrSessionId, sessionId) {
+  let fields;
+  let resolvedSessionId;
+  if (typeof fieldsOrSessionId === "string") {
+    resolvedSessionId = fieldsOrSessionId;
+  } else if (isPlainObject(fieldsOrSessionId)) {
+    fields = fieldsOrSessionId;
+    resolvedSessionId = sessionId;
+  } else {
+    resolvedSessionId = sessionId;
+  }
+  sendParentMessage(buildAgentLogPayload(level, message, fields, resolvedSessionId));
+}
+function parseChatText(message) {
+  if (!message || typeof message !== "object")
+    return null;
+  const record = message;
+  if (record.type !== "chat" || typeof record.text !== "string")
+    return null;
+  const trimmed = record.text.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+// templates/language-switch/agent.ts
+var ECHO_PREFIX = "you said:";
+var ECHO_WAIT_MS = 4e3;
+var REPLIES = {
+  de: "Guten Tag. Ich antworte jetzt auf Deutsch.",
+  es: "Hola. Ahora respondo en espa\xF1ol.",
+  fr: "Bonjour. Je r\xE9ponds maintenant en fran\xE7ais.",
+  it: "Ciao. Adesso rispondo in italiano.",
+  pt: "Ol\xE1. Agora respondo em portugu\xEAs.",
+  nl: "Hallo. Ik antwoord nu in het Nederlands.",
+  pl: "Dzie\u0144 dobry. Teraz odpowiadam po polsku.",
+  ru: "\u0417\u0434\u0440\u0430\u0432\u0441\u0442\u0432\u0443\u0439\u0442\u0435. \u0422\u0435\u043F\u0435\u0440\u044C \u044F \u043E\u0442\u0432\u0435\u0447\u0430\u044E \u043F\u043E-\u0440\u0443\u0441\u0441\u043A\u0438."
+};
+var sessions = /* @__PURE__ */ new Map();
+function stateFor(sessionId) {
+  const existing = sessions.get(sessionId);
+  if (existing) return existing;
+  const created = {
+    language: "en",
+    echoTimer: void 0,
+    suppressNextFinal: false
+  };
+  sessions.set(sessionId, created);
+  return created;
+}
+function replyFor(language) {
+  return REPLIES[language] ?? `Continuing in ${language}.`;
+}
+function logSwitch(sessionId, side, result) {
+  if (!result.ok) {
+    agentLog("warn", `setVoiceLanguage ${side} failed: ${result.reason ?? "unknown"}`);
+    return;
+  }
+  const provider = side === "tts" ? result.ttsProvider : result.sttProvider;
+  const model = side === "tts" ? result.voice : result.stt;
+  agentLog(
+    "info",
+    `voice ${side} ${sessionId} ${result.language ?? ""} provider=${provider ?? "unchanged"} model=${model ?? "unchanged"}`
+  );
+}
+defineAgent({
+  onSessionStart({ sessionId }) {
+    stateFor(sessionId);
+    agentLog("info", `language-switch session_start ${sessionId}`);
+  },
+  async onUserLanguage({ sessionId, language }) {
+    const state = stateFor(sessionId);
+    if (!language || language === state.language) return;
+    if (state.echoTimer) {
+      clearTimeout(state.echoTimer);
+      state.echoTimer = void 0;
+    } else {
+      state.suppressNextFinal = true;
+    }
+    const tts = await setVoiceLanguage(sessionId, {
+      scope: "tts",
+      language,
+      voice: language
+    });
+    logSwitch(sessionId, "tts", tts);
+    const stt = await setVoiceLanguage(sessionId, {
+      scope: "stt",
+      language,
+      stt: language
+    });
+    logSwitch(sessionId, "stt", stt);
+    if (!tts.ok) {
+      state.suppressNextFinal = false;
+      return;
+    }
+    state.language = language;
+    speak(sessionId, replyFor(language));
+  },
+  async onDataChannelMessage(ctx) {
+    const text = parseChatText(ctx.message);
+    if (!text) return;
+    const [command, vendor, language] = text.trim().split(/\s+/);
+    if (command === "/tts" && vendor === "sherpa" && language) {
+      const result = await setVoiceLanguage(ctx.sessionId, {
+        scope: "tts",
+        language,
+        ttsVendor: { provider: "local-sherpa", voice: language }
+      });
+      logSwitch(ctx.sessionId, "tts", result);
+      if (result.ok) speak(ctx.sessionId, replyFor(language));
+      return;
+    }
+    if (command === "/stt" && vendor === "sherpa" && language) {
+      const result = await setVoiceLanguage(ctx.sessionId, {
+        scope: "stt",
+        language,
+        sttVendor: { provider: "local-sherpa", model: language }
+      });
+      logSwitch(ctx.sessionId, "stt", result);
+      return;
+    }
+    if (command === "/tts" && vendor === "elevenlabs") {
+      const result = await setVoiceLanguage(ctx.sessionId, {
+        scope: "tts",
+        ttsVendor: { provider: "elevenlabs", model: "eleven_multilingual_v2" }
+      });
+      logSwitch(ctx.sessionId, "tts", result);
+      if (result.ok) speak(ctx.sessionId, "Speaking with ElevenLabs.");
+      return;
+    }
+    if (command === "/stt" && vendor === "deepgram") {
+      const result = await setVoiceLanguage(ctx.sessionId, {
+        scope: "stt",
+        sttVendor: {
+          provider: "deepgram",
+          model: "nova-3",
+          language: language || "en"
+        }
+      });
+      logSwitch(ctx.sessionId, "stt", result);
+    }
+  },
+  onUserSpeechFinal({ sessionId, text }) {
+    const state = stateFor(sessionId);
+    if (state.suppressNextFinal) {
+      state.suppressNextFinal = false;
+      return;
+    }
+    if (state.echoTimer) clearTimeout(state.echoTimer);
+    state.echoTimer = setTimeout(() => {
+      state.echoTimer = void 0;
+      speak(sessionId, `${ECHO_PREFIX} ${text}`.trim());
+    }, ECHO_WAIT_MS);
+  },
+  onSessionEnd({ sessionId }) {
+    const state = sessions.get(sessionId);
+    if (state?.echoTimer) clearTimeout(state.echoTimer);
+    sessions.delete(sessionId);
+  }
+});