@voicethere/agent 0.5.3 → 0.5.5

package/dist/templates/voice-showcase/agent.js

@@ -0,0 +1,1397 @@
+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 isRecordingControlAckMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const msg = value;
+  return msg.type === "recording_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 === "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 endedSessionIds = /* @__PURE__ */ new Set();
+var pendingRecordingAcks = /* @__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 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 });
+  }
+}
+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 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
+    });
+  }
+}
+async function handleParentMessage(message, handlers) {
+  switch (message.type) {
+    case "session_start":
+      endedSessionIds.delete(message.sessionId);
+      peerEnvBySessionId.set(message.sessionId, message.env);
+      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
+      });
+      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()
+        });
+      }
+      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");
+      peerEnvBySessionId.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 (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");
+      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 sendToClient(sessionId, payload) {
+  sendParentMessage({ type: "send_to_client", sessionId, payload });
+}
+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/voice-showcase/recipes.ts
+var RECIPES = [
+  {
+    title: "Quick garlic pasta",
+    keywords: ["pasta", "noodle", "spaghetti", "italian"],
+    steps: "Boil pasta until al dente. Saut\xE9 minced garlic in olive oil, toss with pasta, parmesan, and black pepper. Serve hot."
+  },
+  {
+    title: "Simple vegetable soup",
+    keywords: ["soup", "broth", "stew"],
+    steps: "Saut\xE9 onion and carrot in a pot. Add vegetable stock, diced potatoes, and simmer twenty minutes. Season with salt and herbs."
+  },
+  {
+    title: "Easy breakfast scramble",
+    keywords: ["breakfast", "eggs", "morning", "brunch"],
+    steps: "Whisk three eggs with a splash of milk. Cook in a buttered pan with spinach and cheese. Fold and serve with toast."
+  },
+  {
+    title: "Classic chocolate chip cookies",
+    keywords: ["cookie", "cookies", "dessert", "sweet", "bake"],
+    steps: "Cream butter and sugar, mix in flour, egg, and chocolate chips. Drop spoonfuls on a tray and bake at one seventy five Celsius for ten minutes."
+  },
+  {
+    title: "Fresh garden salad",
+    keywords: ["salad", "greens", "vegetable", "healthy"],
+    steps: "Toss mixed greens with cherry tomatoes, cucumber, and feta. Dress with olive oil, lemon juice, salt, and pepper."
+  }
+];
+var DEFAULT_RECIPE = RECIPES[0];
+function pickRecipe(utterance) {
+  const lower = utterance.toLowerCase();
+  for (const recipe of RECIPES) {
+    if (recipe.keywords.some((kw) => lower.includes(kw))) {
+      return recipe;
+    }
+  }
+  return DEFAULT_RECIPE;
+}
+function formatRecipeSpeech(recipe) {
+  return `${recipe.title}. ${recipe.steps}`;
+}
+
+// templates/voice-showcase/fun-facts.ts
+var FUN_FACTS = [
+  "Honey never spoils \u2014 archaeologists have found edible honey in ancient Egyptian tombs.",
+  "Octopuses have three hearts and blue blood.",
+  "A day on Venus is longer than a year on Venus.",
+  "Bananas are berries, but strawberries are not.",
+  "The Eiffel Tower can grow about six inches taller in summer heat.",
+  "Sharks existed before trees appeared on Earth."
+];
+var factIndex = 0;
+function pickFunFact() {
+  const fact = FUN_FACTS[factIndex % FUN_FACTS.length];
+  factIndex += 1;
+  return fact;
+}
+
+// templates/voice-showcase/weather.ts
+var GEOCODE_URL = "https://geocoding-api.open-meteo.com/v1/search";
+var FORECAST_URL = "https://api.open-meteo.com/v1/forecast";
+var FETCH_TIMEOUT_MS = 8e3;
+var DIGIT_WORDS = {
+  zero: "0",
+  oh: "0",
+  o: "0",
+  one: "1",
+  two: "2",
+  three: "3",
+  four: "4",
+  five: "5",
+  six: "6",
+  seven: "7",
+  eight: "8",
+  nine: "9"
+};
+var COUNTRY_ALIASES = {
+  thailand: "Thailand",
+  us: "United States",
+  usa: "United States",
+  america: "United States",
+  "united states": "United States",
+  "united states of america": "United States",
+  uk: "United Kingdom",
+  britain: "United Kingdom",
+  england: "United Kingdom",
+  "united kingdom": "United Kingdom",
+  "great britain": "United Kingdom",
+  germany: "Germany",
+  france: "France",
+  spain: "Spain",
+  italy: "Italy",
+  japan: "Japan",
+  china: "China",
+  india: "India",
+  australia: "Australia",
+  canada: "Canada",
+  brazil: "Brazil",
+  mexico: "Mexico",
+  netherlands: "Netherlands",
+  holland: "Netherlands",
+  "the netherlands": "Netherlands",
+  belgium: "Belgium",
+  switzerland: "Switzerland",
+  sweden: "Sweden",
+  norway: "Norway",
+  denmark: "Denmark",
+  finland: "Finland",
+  poland: "Poland",
+  portugal: "Portugal",
+  greece: "Greece",
+  turkey: "Turkey",
+  egypt: "Egypt",
+  "south africa": "South Africa",
+  "new zealand": "New Zealand",
+  ireland: "Ireland",
+  singapore: "Singapore",
+  malaysia: "Malaysia",
+  indonesia: "Indonesia",
+  vietnam: "Vietnam",
+  philippines: "Philippines",
+  "south korea": "South Korea",
+  korea: "South Korea",
+  taiwan: "Taiwan",
+  "hong kong": "Hong Kong",
+  israel: "Israel",
+  uae: "United Arab Emirates",
+  "united arab emirates": "United Arab Emirates",
+  "saudi arabia": "Saudi Arabia",
+  pakistan: "Pakistan",
+  bangladesh: "Bangladesh",
+  nigeria: "Nigeria",
+  kenya: "Kenya",
+  argentina: "Argentina",
+  chile: "Chile",
+  colombia: "Colombia",
+  peru: "Peru",
+  austria: "Austria",
+  "czech republic": "Czechia",
+  czechia: "Czechia",
+  romania: "Romania",
+  hungary: "Hungary",
+  ukraine: "Ukraine"
+};
+function matchCountryName(text) {
+  const key = text.trim().toLowerCase().replace(/[.,!?]+$/g, "").replace(/\s+/g, " ");
+  if (!key) return null;
+  return COUNTRY_ALIASES[key] ?? null;
+}
+function spokenDigitsToPostal(text) {
+  const tokens = text.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  const digits = [];
+  for (const token of tokens) {
+    if (/^\d$/.test(token)) {
+      digits.push(token);
+      continue;
+    }
+    const mapped = DIGIT_WORDS[token];
+    if (mapped) {
+      digits.push(mapped);
+    }
+  }
+  if (digits.length >= 4 && digits.length <= 6) {
+    return digits.join("");
+  }
+  return null;
+}
+function splitTrailingCountry(text) {
+  const words = text.trim().split(/\s+/).filter(Boolean);
+  if (words.length < 2) return null;
+  for (let n = Math.min(3, words.length - 1); n >= 1; n -= 1) {
+    const tail = words.slice(-n).join(" ");
+    const country = matchCountryName(tail);
+    if (country) {
+      return { rest: words.slice(0, -n).join(" "), country };
+    }
+  }
+  return null;
+}
+function cityFromRemainder(rest) {
+  const trimmed = rest.trim().replace(/[.,!?;:]+$/g, "").replace(/\s+(?:in the|in|of)$/i, "").trim();
+  if (!trimmed) return null;
+  if (/^\d{4,6}(-\d{4})?$/.test(trimmed)) {
+    return trimmed;
+  }
+  const spoken = spokenDigitsToPostal(trimmed);
+  if (spoken) return spoken;
+  if (trimmed.length >= 2 && trimmed.length <= 60) {
+    return trimmed;
+  }
+  return null;
+}
+function wmoCodeToPhrase(code) {
+  if (code === 0) return "clear sky";
+  if (code <= 3) return "partly cloudy";
+  if (code <= 48) return "foggy";
+  if (code <= 57) return "drizzle";
+  if (code <= 67) return "rain";
+  if (code <= 77) return "snow";
+  if (code <= 82) return "rain showers";
+  if (code <= 86) return "snow showers";
+  if (code <= 99) return "thunderstorm";
+  return "variable conditions";
+}
+function formatWeatherSpeech(result) {
+  const temp = Math.round(result.temperatureC);
+  const wind = Math.round(result.windKmh);
+  return `In ${result.place}, it is ${temp} degrees Celsius with ${result.condition} and winds around ${wind} kilometers per hour.`;
+}
+function parseLocationUtterance(utterance) {
+  const text = utterance.trim();
+  if (!text) return null;
+  const countryOnly = matchCountryName(text);
+  if (countryOnly) {
+    return { country: countryOnly };
+  }
+  const trailing = splitTrailingCountry(text);
+  if (trailing) {
+    const city = cityFromRemainder(trailing.rest);
+    if (city) {
+      return { city, country: trailing.country };
+    }
+    return { country: trailing.country };
+  }
+  const inMatch = text.match(
+    /^(?:in\s+)?(.+?)\s+in\s+([a-zA-Z][\w\s.-]{1,40})$/i
+  );
+  if (inMatch) {
+    const country = matchCountryName(inMatch[2]) ?? inMatch[2].trim();
+    return { city: inMatch[1].trim(), country };
+  }
+  const commaMatch = text.match(/^(.+?),\s*([a-zA-Z][\w\s.-]{1,40})$/);
+  if (commaMatch) {
+    const country = matchCountryName(commaMatch[2]) ?? commaMatch[2].trim();
+    return { city: commaMatch[1].trim(), country };
+  }
+  const countryMatch = text.match(
+    /^(.+?)\s+(?:country\s+)?([a-zA-Z][\w\s.-]{2,40})$/i
+  );
+  if (countryMatch && countryMatch[2].split(/\s+/).length <= 3) {
+    const city = countryMatch[1].trim();
+    const countryRaw = countryMatch[2].trim();
+    const country = matchCountryName(countryRaw) ?? countryRaw;
+    if (city.length >= 2 && country.length >= 2) {
+      return { city, country };
+    }
+  }
+  if (/^\d{4,6}(-\d{4})?$/.test(text)) {
+    return { city: text };
+  }
+  const spokenPostal = spokenDigitsToPostal(text);
+  if (spokenPostal) {
+    return { city: spokenPostal };
+  }
+  if (text.length >= 2 && text.length <= 60) {
+    return { city: text };
+  }
+  return null;
+}
+async function geocodeLocation(city, country, fetchFn = fetch) {
+  const query = country ? `${city}, ${country}` : city;
+  const url = new URL(GEOCODE_URL);
+  url.searchParams.set("name", query);
+  url.searchParams.set("count", "1");
+  url.searchParams.set("language", "en");
+  url.searchParams.set("format", "json");
+  const response = await fetchFn(url.toString(), {
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok) return null;
+  const data = await response.json();
+  const hit = data.results?.[0];
+  if (!hit || typeof hit.latitude !== "number" || typeof hit.longitude !== "number") {
+    return null;
+  }
+  return {
+    name: hit.name ?? city,
+    country: hit.country ?? country ?? "",
+    latitude: hit.latitude,
+    longitude: hit.longitude
+  };
+}
+async function fetchCurrentWeather(geo, fetchFn = fetch) {
+  const url = new URL(FORECAST_URL);
+  url.searchParams.set("latitude", String(geo.latitude));
+  url.searchParams.set("longitude", String(geo.longitude));
+  url.searchParams.set("current", "temperature_2m,weather_code,wind_speed_10m");
+  url.searchParams.set("wind_speed_unit", "kmh");
+  const response = await fetchFn(url.toString(), {
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok) return null;
+  const data = await response.json();
+  const current = data.current;
+  if (!current || typeof current.temperature_2m !== "number" || typeof current.weather_code !== "number") {
+    return null;
+  }
+  const place = geo.country ? `${geo.name}, ${geo.country}` : geo.name;
+  return {
+    place,
+    temperatureC: current.temperature_2m,
+    condition: wmoCodeToPhrase(current.weather_code),
+    windKmh: current.wind_speed_10m ?? 0
+  };
+}
+async function lookupWeather(city, country, fetchFn = fetch) {
+  const geo = await geocodeLocation(city, country, fetchFn);
+  if (!geo) return null;
+  return fetchCurrentWeather(geo, fetchFn);
+}
+
+// templates/voice-showcase/conversation.ts
+var GREETING = "Hi and welcome to the Voicethere voice chat, may I know your name?";
+var HUMAN_ESCALATION_REPLY = "This is only a showcase conversation and unfortunately there is no human support connected.";
+var NAME_DECLINE_REPLY = "OK we will continue without your name";
+var MENU_ITEMS = [
+  { id: 1, label: "Check the weather" },
+  { id: 2, label: "Count" },
+  { id: 3, label: "Hear a recipe" },
+  { id: 4, label: "Hear a fun fact" }
+];
+var MENU_CHAT_TEXT = `Here is our menu:
+1. Check the weather
+2. Count
+3. Hear a recipe
+4. Hear a fun fact`;
+function createInitialState() {
+  return {
+    phase: "listeningForName",
+    nameDeclined: false,
+    weatherRetries: 0,
+    countFailures: 0
+  };
+}
+function buildMenuMessages() {
+  return [
+    { type: "chat_reply", text: MENU_CHAT_TEXT },
+    {
+      type: "menu",
+      items: MENU_ITEMS.map((item) => ({ id: item.id, label: item.label }))
+    }
+  ];
+}
+function speakAndChat(text) {
+  return {
+    speakLines: [text],
+    messages: [{ type: "chat_reply", text }]
+  };
+}
+function isHumanEscalation(utterance) {
+  const lower = utterance.toLowerCase();
+  const patterns = [
+    /\bhuman\b/,
+    /\boperator\b/,
+    /\breal\s+person\b/,
+    /\btalk\s+to\s+(?:a\s+)?(?:human|person|someone|agent)\b/,
+    /\bcustomer\s+support\b/,
+    /\bspeak\s+to\s+(?:a\s+)?(?:human|person|someone|agent)\b/,
+    /\bneed\s+(?:a\s+)?(?:human|person|agent)\b/,
+    /\bconnect\s+me\s+(?:to|with)\b/,
+    /\blive\s+agent\b/,
+    /\brepresentative\b/
+  ];
+  return patterns.some((p) => p.test(lower));
+}
+function isNameDecline(utterance) {
+  const lower = utterance.toLowerCase().trim();
+  const declinePhrases = [
+    "i do not want to say my name",
+    "i don't want to say my name",
+    "i don't want to say",
+    "i do not want to say",
+    "i'd rather not",
+    "id rather not",
+    "prefer not",
+    "skip",
+    "anonymous",
+    "none"
+  ];
+  if (declinePhrases.some((p) => lower.includes(p))) return true;
+  if (/\bno\b/i.test(utterance) && !/\bknow\b/i.test(utterance)) {
+    const words = lower.split(/\s+/);
+    if (words.includes("no")) return true;
+  }
+  return false;
+}
+function extractName(utterance) {
+  const trimmed = utterance.trim();
+  const patterns = [/(?:my name is|i'm|i am|call me)\s+(.+)/i];
+  for (const pattern of patterns) {
+    const match = trimmed.match(pattern);
+    if (match?.[1]) {
+      return sanitizeName(match[1]);
+    }
+  }
+  if (trimmed.length > 0 && trimmed.length <= 60) {
+    return sanitizeName(trimmed);
+  }
+  return null;
+}
+function sanitizeName(raw) {
+  let name = raw.trim().replace(/[.,!?;:]+$/g, "").trim();
+  if (name.length > 40) {
+    name = name.slice(0, 40).trim();
+  }
+  return name;
+}
+function helloAfterName(state) {
+  if (state.name && !state.nameDeclined) {
+    return `Hello, ${state.name}, how can I help you today? I just sent you our menu, what do you want to do?`;
+  }
+  return "Hello, how can I help you today? I just sent you our menu, what do you want to do?";
+}
+function transitionAfterName(state, name, declined) {
+  const next = {
+    ...state,
+    phase: "awaitingMenuChoice",
+    nameDeclined: declined,
+    name: declined ? void 0 : name ?? void 0
+  };
+  const lines = [];
+  const messages = [];
+  if (declined) {
+    const decline = speakAndChat(NAME_DECLINE_REPLY);
+    lines.push(...decline.speakLines);
+    messages.push(...decline.messages);
+  } else if (name) {
+    const thanks = speakAndChat(`Great, thank you ${name}`);
+    lines.push(...thanks.speakLines);
+    messages.push(...thanks.messages);
+  }
+  const hello = speakAndChat(helloAfterName(next));
+  lines.push(...hello.speakLines);
+  messages.push(...hello.messages);
+  messages.push(...buildMenuMessages());
+  return { state: next, speakLines: lines, messages };
+}
+function parseMenuChoice(utterance) {
+  const lower = utterance.toLowerCase().trim();
+  if (/\bmenu\b/.test(lower) || /\bhelp\b/.test(lower) || /\bgo\s+back\b/.test(lower) || /\bstart\s+over\b/.test(lower)) {
+    return "menu";
+  }
+  if (lower === "1" || /\bweather\b/.test(lower) || /\bfirst\b/.test(lower) || /\bcheck\s+the\s+weather\b/.test(lower)) {
+    return "weather";
+  }
+  if (lower === "2" || /\bcount\b/.test(lower) || /\bsecond\b/.test(lower)) {
+    return "count";
+  }
+  if (lower === "3" || /\brecipe\b/.test(lower) || /\bthird\b/.test(lower)) {
+    return "recipe";
+  }
+  if (lower === "4" || /\bfun\s+fact\b/.test(lower) || /\bfact\b/.test(lower) || /\bfourth\b/.test(lower)) {
+    return "fun_fact";
+  }
+  return null;
+}
+var WORD_TO_NUMBER = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10
+};
+function parseCountNumber(utterance) {
+  const trimmed = utterance.trim().toLowerCase();
+  const digit = trimmed.match(/\b(\d+)\b/);
+  if (digit) {
+    const n = Number(digit[1]);
+    if (Number.isFinite(n)) return n;
+  }
+  for (const [word, value] of Object.entries(WORD_TO_NUMBER)) {
+    if (new RegExp(`\\b${word}\\b`).test(trimmed)) {
+      return value;
+    }
+  }
+  return null;
+}
+function formatCountingSpeech(n) {
+  const parts = [];
+  for (let i = 1; i <= n; i += 1) {
+    parts.push(String(i));
+  }
+  return parts.join(", ");
+}
+function resendMenu(state) {
+  const menu = speakAndChat("Here is the menu again.");
+  return {
+    state: { ...state, phase: "awaitingMenuChoice" },
+    speakLines: menu.speakLines,
+    messages: [...menu.messages, ...buildMenuMessages()]
+  };
+}
+function returnToMenu(state, line) {
+  const spoken = speakAndChat(line);
+  return {
+    state: {
+      ...state,
+      phase: "awaitingMenuChoice",
+      weatherRetries: 0,
+      countFailures: 0,
+      weatherCity: void 0,
+      weatherCountry: void 0
+    },
+    speakLines: spoken.speakLines,
+    messages: [...spoken.messages, ...buildMenuMessages()]
+  };
+}
+function handleUtterance(state, utterance) {
+  const text = utterance.trim();
+  if (!text) {
+    return { state, speakLines: [], messages: [] };
+  }
+  if (isHumanEscalation(text)) {
+    const reply = speakAndChat(HUMAN_ESCALATION_REPLY);
+    return {
+      state,
+      speakLines: reply.speakLines,
+      messages: reply.messages
+    };
+  }
+  if (state.phase !== "listeningForName" && parseMenuChoice(text) === "menu") {
+    return resendMenu({
+      ...state,
+      phase: "awaitingMenuChoice",
+      weatherRetries: 0,
+      countFailures: 0,
+      weatherCity: void 0,
+      weatherCountry: void 0
+    });
+  }
+  switch (state.phase) {
+    case "listeningForName": {
+      if (isNameDecline(text)) {
+        return transitionAfterName(state, null, true);
+      }
+      const name = extractName(text);
+      return transitionAfterName(state, name, false);
+    }
+    case "awaitingMenuChoice": {
+      const choice = parseMenuChoice(text);
+      if (choice === "menu") return resendMenu(state);
+      if (choice === "weather") {
+        const ask = speakAndChat(
+          "Sure. Please tell me a city or ZIP code and the country."
+        );
+        return {
+          state: {
+            ...state,
+            phase: "weatherAwaitingLocation",
+            weatherRetries: 0,
+            weatherCity: void 0,
+            weatherCountry: void 0
+          },
+          speakLines: ask.speakLines,
+          messages: ask.messages
+        };
+      }
+      if (choice === "count") {
+        const ask = speakAndChat(
+          "Pick a number from 1 to 10 and I will count up to it."
+        );
+        return {
+          state: {
+            ...state,
+            phase: "countAwaitingNumber",
+            countFailures: 0
+          },
+          speakLines: ask.speakLines,
+          messages: ask.messages
+        };
+      }
+      if (choice === "recipe") {
+        const ask = speakAndChat(
+          "What do you fancy? Try pasta, soup, breakfast, cookies, or salad."
+        );
+        return {
+          state: { ...state, phase: "recipeAwaitingChoice" },
+          speakLines: ask.speakLines,
+          messages: ask.messages
+        };
+      }
+      if (choice === "fun_fact") {
+        const fact = pickFunFact();
+        return returnToMenu(state, `Here is a fun fact. ${fact}`);
+      }
+      const retry = speakAndChat(
+        "I did not catch that. Pick 1 through 4 from the menu, or say weather, count, recipe, or fun fact."
+      );
+      return {
+        state,
+        speakLines: retry.speakLines,
+        messages: retry.messages
+      };
+    }
+    case "weatherAwaitingLocation": {
+      const parsed = parseLocationUtterance(text);
+      let city = parsed?.city || state.weatherCity;
+      let country = parsed?.country || state.weatherCountry;
+      if (state.weatherCity && !country) {
+        const followUp = matchCountryName(text) ?? (parsed?.city ? matchCountryName(parsed.city) : null);
+        if (followUp) {
+          city = state.weatherCity;
+          country = followUp;
+        }
+      }
+      if (!city) {
+        const ask = speakAndChat(
+          "Please tell me a city or ZIP code and the country."
+        );
+        return {
+          state: { ...state, phase: "weatherAwaitingLocation" },
+          speakLines: ask.speakLines,
+          messages: ask.messages
+        };
+      }
+      if (!country) {
+        return {
+          state: {
+            ...state,
+            phase: "weatherAwaitingLocation",
+            weatherCity: city
+          },
+          speakLines: ["Got it. Which country is that in?"],
+          messages: [
+            { type: "chat_reply", text: "Got it. Which country is that in?" }
+          ]
+        };
+      }
+      return {
+        state: { ...state, weatherCity: city, weatherCountry: country },
+        speakLines: [],
+        messages: [],
+        pendingWeather: { city, country }
+      };
+    }
+    case "countAwaitingNumber": {
+      const n = parseCountNumber(text);
+      if (n === null || n < 1 || n > 10) {
+        const failures = state.countFailures + 1;
+        if (failures >= 2) {
+          return returnToMenu(state, "Sorry, I cannot do this.");
+        }
+        const retry = speakAndChat(
+          "I did not understand you. Please say a number from 1 to 10."
+        );
+        return {
+          state: { ...state, countFailures: failures },
+          speakLines: retry.speakLines,
+          messages: retry.messages
+        };
+      }
+      const counting = formatCountingSpeech(n);
+      return returnToMenu(state, `Counting: ${counting}.`);
+    }
+    case "recipeAwaitingChoice": {
+      const recipe = pickRecipe(text);
+      const speech = formatRecipeSpeech(recipe);
+      return returnToMenu(state, speech);
+    }
+    default:
+      return { state, speakLines: [], messages: [] };
+  }
+}
+function applyWeatherSuccess(state, weather) {
+  const line = formatWeatherSpeech(weather);
+  return returnToMenu(state, line);
+}
+function applyWeatherFailure(state) {
+  const retries = state.weatherRetries + 1;
+  if (retries >= 2) {
+    return returnToMenu(
+      { ...state, weatherRetries: retries },
+      "Sorry, I could not look up the weather right now."
+    );
+  }
+  const retry = speakAndChat(
+    "I could not find that location. Please try again with a city or ZIP and country."
+  );
+  return {
+    state: {
+      ...state,
+      phase: "weatherAwaitingLocation",
+      weatherRetries: retries,
+      weatherCity: void 0,
+      weatherCountry: void 0
+    },
+    speakLines: retry.speakLines,
+    messages: retry.messages
+  };
+}
+async function resolveWeatherTurn(state, city, country, fetchFn) {
+  try {
+    const weather = await lookupWeather(city, country, fetchFn);
+    if (!weather) {
+      return applyWeatherFailure(state);
+    }
+    return applyWeatherSuccess(state, weather);
+  } catch {
+    return applyWeatherFailure(state);
+  }
+}
+
+// templates/voice-showcase/agent.ts
+var sessions = /* @__PURE__ */ new Map();
+function getState(sessionId) {
+  let state = sessions.get(sessionId);
+  if (!state) {
+    state = createInitialState();
+    sessions.set(sessionId, state);
+  }
+  return state;
+}
+function relaySpeechEvent(sessionId, event) {
+  sendToClient(sessionId, {
+    type: "agent_event",
+    event: event.type,
+    text: event.text,
+    raw: event
+  });
+}
+function deliverMessages(sessionId, messages) {
+  for (const message of messages) {
+    sendToClient(sessionId, message);
+  }
+}
+function speakLines(sessionId, lines) {
+  for (const line of lines) {
+    speak(sessionId, line);
+  }
+}
+async function applyTurn(sessionId, result) {
+  sessions.set(sessionId, result.state);
+  speakLines(sessionId, result.speakLines);
+  deliverMessages(sessionId, result.messages);
+  if (result.pendingWeather) {
+    const weatherResult = await resolveWeatherTurn(
+      result.state,
+      result.pendingWeather.city,
+      result.pendingWeather.country
+    );
+    sessions.set(sessionId, weatherResult.state);
+    speakLines(sessionId, weatherResult.speakLines);
+    deliverMessages(sessionId, weatherResult.messages);
+  }
+}
+async function onUserText(sessionId, text) {
+  const state = getState(sessionId);
+  const result = handleUtterance(state, text);
+  await applyTurn(sessionId, result);
+}
+defineAgent({
+  onSessionStart({ sessionId }) {
+    sessions.set(sessionId, createInitialState());
+    sendToClient(sessionId, {
+      type: "agent_event",
+      event: "session_start",
+      sessionId
+    });
+    speak(sessionId, GREETING);
+    sendToClient(sessionId, { type: "chat_reply", text: GREETING });
+    agentLog("info", `voice-showcase session_start ${sessionId}`);
+  },
+  onSpeechEvent({ sessionId }, event) {
+    relaySpeechEvent(sessionId, event);
+  },
+  onUserSpeechFinal({ sessionId, text }) {
+    void onUserText(sessionId, text);
+  },
+  onDataChannelMessage(ctx) {
+    const text = parseChatText(ctx.message);
+    if (!text) return;
+    void onUserText(ctx.sessionId, text);
+  },
+  onSessionEnd({ sessionId }) {
+    sessions.delete(sessionId);
+    sendToClient(sessionId, {
+      type: "agent_event",
+      event: "session_end",
+      sessionId
+    });
+    agentLog("info", `voice-showcase session_end ${sessionId}`);
+  }
+});