@yak-io/javascript 0.10.1 → 0.11.0

package/dist/index.cjs

@@ -0,0 +1,2043 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EMBED_PROTOCOL_VERSION: () => EMBED_PROTOCOL_VERSION,
+  INITIAL_VOICE_MACHINE: () => INITIAL_VOICE_MACHINE,
+  YakClient: () => YakClient,
+  YakEmbed: () => YakEmbed,
+  YakVoiceSession: () => YakVoiceSession,
+  createYakServerAdapter: () => createYakServerAdapter,
+  createYakToolset: () => createYakToolset,
+  disableYakLogging: () => disableYakLogging,
+  enableYakLogging: () => enableYakLogging,
+  handleRealtimeMessage: () => handleRealtimeMessage,
+  isYakLoggingEnabled: () => isYakLoggingEnabled,
+  logger: () => logger,
+  voiceReducer: () => voiceReducer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/logger.ts
+var STORAGE_KEY = "yakLogging";
+function isLoggingEnabled() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  if (typeof window.__YAK_LOGGING_ENABLED__ === "boolean") {
+    return window.__YAK_LOGGING_ENABLED__;
+  }
+  try {
+    return localStorage.getItem(STORAGE_KEY) === "true";
+  } catch {
+    return false;
+  }
+}
+function isYakLoggingEnabled() {
+  return isLoggingEnabled();
+}
+function enableYakLogging() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.__YAK_LOGGING_ENABLED__ = true;
+  try {
+    localStorage.setItem(STORAGE_KEY, "true");
+  } catch {
+  }
+  console.info("[yak] Logging enabled");
+}
+function disableYakLogging() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.__YAK_LOGGING_ENABLED__ = false;
+  try {
+    localStorage.removeItem(STORAGE_KEY);
+  } catch {
+  }
+  console.info("[yak] Logging disabled");
+}
+if (typeof window !== "undefined") {
+  window.enableYakLogging = enableYakLogging;
+  window.disableYakLogging = disableYakLogging;
+}
+var logger = {
+  debug: (message, data) => {
+    if (isLoggingEnabled()) {
+      if (data !== void 0) {
+        console.log(`[yak-host] ${message}`, data);
+      } else {
+        console.log(`[yak-host] ${message}`);
+      }
+    }
+  },
+  info: (message, data) => {
+    if (isLoggingEnabled()) {
+      if (data !== void 0) {
+        console.info(`[yak-host] ${message}`, data);
+      } else {
+        console.info(`[yak-host] ${message}`);
+      }
+    }
+  },
+  warn: (message, data) => {
+    if (data !== void 0) {
+      console.warn(`[yak-host] ${message}`, data);
+    } else {
+      console.warn(`[yak-host] ${message}`);
+    }
+  },
+  error: (message, data) => {
+    if (data !== void 0) {
+      console.error(`[yak-host] ${message}`, data);
+    } else {
+      console.error(`[yak-host] ${message}`);
+    }
+  }
+};
+
+// src/page-context.ts
+function extractPageText() {
+  if (typeof document === "undefined") return "";
+  const bodyClone = document.body.cloneNode(true);
+  const unwantedSelectors = [
+    "script",
+    "style",
+    "noscript",
+    "iframe",
+    "[style*='display: none']",
+    "[style*='display:none']",
+    "[hidden]",
+    ".yak-chat-widget"
+  ];
+  for (const selector of unwantedSelectors) {
+    const elements = bodyClone.querySelectorAll(selector);
+    for (const el of elements) {
+      el.remove();
+    }
+  }
+  let text = bodyClone.textContent || bodyClone.innerText || "";
+  text = text.replace(/\s+/g, " ").trim();
+  const maxLength = 1e5;
+  if (text.length > maxLength) {
+    text = `${text.substring(0, maxLength)}... [truncated]`;
+  }
+  return text;
+}
+function extractPageContext() {
+  if (typeof window === "undefined") {
+    return {
+      url: "",
+      title: "",
+      text: "",
+      timestamp: Date.now()
+    };
+  }
+  return {
+    url: window.location.href,
+    title: document.title,
+    text: extractPageText(),
+    timestamp: Date.now()
+  };
+}
+function debounce(func, wait) {
+  let timeout = null;
+  return function executedFunction(...args) {
+    const later = () => {
+      timeout = null;
+      func(...args);
+    };
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(later, wait);
+  };
+}
+
+// src/version.ts
+var EMBED_PROTOCOL_VERSION = "1";
+
+// src/client.ts
+var SESSION_STORAGE_KEY = (appId) => `yak:session:${appId}`;
+var CONVERSATION_POINTER_KEY = (appId) => `yak:conversation:${appId}`;
+function readStoredSessionToken(appId) {
+  if (typeof window === "undefined" || typeof window.localStorage === "undefined") return void 0;
+  try {
+    return window.localStorage.getItem(SESSION_STORAGE_KEY(appId)) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeStoredSessionToken(appId, token) {
+  if (typeof window === "undefined" || typeof window.localStorage === "undefined") return;
+  try {
+    window.localStorage.setItem(SESSION_STORAGE_KEY(appId), token);
+  } catch {
+  }
+}
+function readStoredConversationPointer(appId) {
+  if (typeof window === "undefined" || typeof window.localStorage === "undefined") return void 0;
+  try {
+    return window.localStorage.getItem(CONVERSATION_POINTER_KEY(appId)) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeStoredConversationPointer(appId, pointer) {
+  if (typeof window === "undefined" || typeof window.localStorage === "undefined") return;
+  try {
+    window.localStorage.setItem(CONVERSATION_POINTER_KEY(appId), pointer);
+  } catch {
+  }
+}
+function clearStoredConversationPointer(appId) {
+  if (typeof window === "undefined" || typeof window.localStorage === "undefined") return;
+  try {
+    window.localStorage.removeItem(CONVERSATION_POINTER_KEY(appId));
+  } catch {
+  }
+}
+var DEFAULT_CHAT_ORIGIN = "https://chat.yak.io";
+function getDefaultIframeOrigin() {
+  if (typeof window !== "undefined" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1") && typeof window.__YAK_INTERNAL_DEV__ !== "undefined") {
+    return "http://localhost:3001";
+  }
+  return DEFAULT_CHAT_ORIGIN;
+}
+var YakClient = class {
+  config;
+  iframeWindow = null;
+  isWidgetOpen = false;
+  readyTarget = null;
+  unexpectedOriginLogged = false;
+  lastUrl = " ";
+  debouncedSendContext;
+  observer = null;
+  constructor(config) {
+    this.config = config;
+    this.debouncedSendContext = debounce(() => {
+      logger.debug("DOM mutation detected, sending page context");
+      this.sendPageContext();
+    }, 2e3);
+  }
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+    if (this.readyTarget && (this.config.chatConfig || this.config.user)) {
+      this.sendConfigToIframe(this.readyTarget.window, this.readyTarget.origin);
+    }
+  }
+  /**
+   * Get the iframe origin URL (base URL for the chat widget). Recomputed on
+   * each call so environment-dependent defaults resolve correctly.
+   */
+  getIframeOrigin() {
+    return this.config.origin ?? getDefaultIframeOrigin();
+  }
+  /**
+   * Get the full iframe embed URL for the chatbot
+   *
+   * @example
+   * ```ts
+   * const client = new YakClient({ appId: "my-app" });
+   * const iframeSrc = client.getEmbedUrl();
+   * // Returns: "https://chat.yak.io/embed/v1/my-app"
+   * ```
+   */
+  getEmbedUrl() {
+    const origin = this.getIframeOrigin();
+    const baseUrl = `${origin}/embed/v${EMBED_PROTOCOL_VERSION}/${encodeURIComponent(this.config.appId)}`;
+    const params = new URLSearchParams();
+    const theme = this.config.theme;
+    if (theme?.colorMode && theme.colorMode !== "system") {
+      params.set("colorMode", theme.colorMode);
+    }
+    this.appendThemeColors(params, theme?.light, "light");
+    this.appendThemeColors(params, theme?.dark, "dark");
+    if (isYakLoggingEnabled()) {
+      params.set("yakDebug", "1");
+    }
+    const queryString = params.toString();
+    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+  }
+  /**
+   * Append theme color parameters to a URLSearchParams object
+   */
+  appendThemeColors(params, colors, prefix) {
+    if (!colors) return;
+    const map = [
+      [`${prefix}Bg`, colors.background],
+      [`${prefix}Border`, colors.border],
+      [`${prefix}MessageBg`, colors.messageBackground],
+      [`${prefix}Placeholder`, colors.placeholderColor],
+      [`${prefix}SubmitBtn`, colors.submitButtonColor],
+      [`${prefix}SubmitBtnText`, colors.submitButtonTextColor],
+      [`${prefix}HeaderIcon`, colors.headerIconColor]
+    ];
+    for (const [key, value] of map) {
+      if (value) params.set(key, value);
+    }
+  }
+  /**
+   * Get the app ID
+   */
+  getAppId() {
+    return this.config.appId;
+  }
+  /**
+   * Get the current theme configuration
+   */
+  getTheme() {
+    return this.config.theme;
+  }
+  /**
+   * Send a prompt message to the chatbot iframe
+   * Note: The iframe must be ready to receive messages (onReady callback must have fired)
+   *
+   * @example
+   * ```ts
+   * const client = new YakClient({ appId: "my-app", onReady: () => {
+   *   client.sendPrompt("Help me with my order");
+   * }});
+   * ```
+   */
+  sendPrompt(prompt) {
+    if (!this.iframeWindow) {
+      logger.warn("Cannot send prompt: iframe not ready");
+      return;
+    }
+    const message = {
+      type: "yak:prompt",
+      payload: { prompt }
+    };
+    this.iframeWindow.postMessage(message, this.getIframeOrigin());
+  }
+  /**
+   * Send a focus request to the chatbot iframe
+   * This will focus the chat input field
+   */
+  sendFocus() {
+    if (!this.iframeWindow) {
+      logger.warn("Cannot send focus: iframe not ready");
+      return;
+    }
+    const message = {
+      type: "yak:focus"
+    };
+    this.iframeWindow.postMessage(message, this.getIframeOrigin());
+  }
+  /**
+   * Check if the iframe is ready to receive messages
+   */
+  isReady() {
+    return this.readyTarget !== null;
+  }
+  setIframeWindow(window2) {
+    this.iframeWindow = window2;
+    if (!window2) {
+      this.readyTarget = null;
+    }
+  }
+  setWidgetOpen(isOpen) {
+    this.isWidgetOpen = isOpen;
+    if (isOpen && this.readyTarget && this.config.chatConfig) {
+      this.sendConfigToIframe(this.readyTarget.window, this.readyTarget.origin);
+    }
+    if (isOpen) {
+      this.startObserving();
+    } else {
+      this.stopObserving();
+    }
+  }
+  mount() {
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.handleMessage);
+      window.addEventListener("popstate", this.handlePopState);
+    }
+  }
+  unmount() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.handleMessage);
+      window.removeEventListener("popstate", this.handlePopState);
+    }
+    this.stopObserving();
+  }
+  startObserving() {
+    if (typeof window === "undefined" || !this.iframeWindow) return;
+    const currentUrl = window.location.href;
+    if (currentUrl !== this.lastUrl) {
+      this.lastUrl = currentUrl;
+      logger.debug("URL changed, sending page context");
+      this.sendPageContext();
+    }
+    if (this.observer) return;
+    this.observer = new MutationObserver((mutations) => {
+      const hasSubstantialChanges = mutations.some(
+        (mutation) => mutation.type === "childList" && (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0)
+      );
+      if (hasSubstantialChanges) {
+        this.debouncedSendContext();
+      }
+    });
+    this.observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+  }
+  stopObserving() {
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+    }
+  }
+  handlePopState = () => {
+    logger.debug("Navigation detected, sending page context");
+    this.sendPageContext();
+  };
+  handleMessage = (event) => {
+    if (typeof window === "undefined") return;
+    if (!this.isWidgetOpen && event.data?.type !== "yak:ready") {
+      return;
+    }
+    const hostOrigin = window.location.origin;
+    const allowedOrigins = /* @__PURE__ */ new Set();
+    allowedOrigins.add(this.getIframeOrigin());
+    if (hostOrigin) {
+      allowedOrigins.add(hostOrigin);
+    }
+    if (!allowedOrigins.has(event.origin)) {
+      if (!this.unexpectedOriginLogged) {
+        logger.warn(
+          `Ignoring message from unexpected origin: ${event.origin}, allowed: ${Array.from(allowedOrigins).join(", ")}`
+        );
+        this.unexpectedOriginLogged = true;
+      }
+      return;
+    }
+    if (!event.data || typeof event.data !== "object" || !("type" in event.data)) {
+      const data = event.data;
+      const isReactDevTools = data?.source === "react-devtools-content-script" || data?.source === "react-devtools-bridge" || data?.source === "react-devtools-inject-backend";
+      const isReduxDevTools = data?.source === "@devtools-page";
+      if (isReactDevTools || isReduxDevTools) {
+        return;
+      }
+      return;
+    }
+    const message = event.data;
+    const targetWindow = (event.source && "postMessage" in event.source ? event.source : null) ?? this.iframeWindow;
+    const targetOrigin = this.getIframeOrigin();
+    logger.debug("Message received from iframe:", message.type);
+    switch (message.type) {
+      case "yak:ready": {
+        logger.debug("Iframe ready, sending config");
+        if (targetWindow) {
+          this.readyTarget = { window: targetWindow, origin: targetOrigin };
+          this.sendConfigToIframe(targetWindow, targetOrigin);
+          setTimeout(() => this.sendPageContext(), 100);
+          setTimeout(() => this.config.onReady?.(), 200);
+        } else {
+          logger.warn("Unable to send config: iframe window not registered yet");
+        }
+        break;
+      }
+      case "yak:tool_call": {
+        const { id, name, args } = message.payload;
+        void this.handleToolCall(id, name, args);
+        break;
+      }
+      case "yak:redirect": {
+        const { path } = message.payload;
+        logger.debug("Redirect request received:", path);
+        if (!this.isAllowedRedirect(path)) {
+          logger.warn("Blocked potentially unsafe redirect:", path);
+          break;
+        }
+        if (this.config.onRedirect) {
+          this.config.onRedirect(path);
+        } else if (typeof window !== "undefined") {
+          window.location.assign(path);
+        }
+        break;
+      }
+      case "yak:session": {
+        const { sessionToken } = message.payload;
+        logger.debug("Session token received from iframe; persisting");
+        writeStoredSessionToken(this.config.appId, sessionToken);
+        break;
+      }
+      case "yak:conversation": {
+        const { pointer } = message.payload;
+        if (pointer === null) {
+          logger.debug("Conversation pointer cleared by iframe");
+          clearStoredConversationPointer(this.config.appId);
+        } else {
+          logger.debug("Conversation pointer received from iframe; persisting");
+          writeStoredConversationPointer(this.config.appId, pointer);
+        }
+        break;
+      }
+      case "yak:close": {
+        logger.debug("Close message received from iframe");
+        this.config.onClose?.();
+        break;
+      }
+      default:
+        logger.debug("Unknown message type:", message.type);
+        break;
+    }
+  };
+  sendConfigToIframe(targetWindow, targetOrigin) {
+    const loggingEnabled = typeof window !== "undefined" && typeof window.__YAK_LOGGING_ENABLED__ === "boolean" ? window.__YAK_LOGGING_ENABLED__ : void 0;
+    const storedSessionToken = readStoredSessionToken(this.config.appId);
+    const storedConversationPointer = readStoredConversationPointer(this.config.appId);
+    const configMessage = {
+      type: "yak:config",
+      payload: {
+        version: EMBED_PROTOCOL_VERSION,
+        appId: this.config.appId,
+        theme: this.config.theme,
+        toolManifest: this.config.chatConfig?.tools ?? void 0,
+        routeManifest: this.config.chatConfig?.routes ?? void 0,
+        options: this.config.options,
+        loggingEnabled,
+        user: this.config.user,
+        sessionToken: storedSessionToken,
+        conversationPointer: storedConversationPointer
+      }
+    };
+    logger.debug("Posting config to iframe origin:", {
+      origin: targetOrigin,
+      version: EMBED_PROTOCOL_VERSION,
+      hasToolManifest: Boolean(this.config.chatConfig?.tools),
+      toolCount: this.config.chatConfig?.tools?.tools.length ?? 0,
+      hasRouteManifest: Boolean(this.config.chatConfig?.routes)
+    });
+    targetWindow.postMessage(configMessage, targetOrigin);
+  }
+  sendPageContext() {
+    if (!this.iframeWindow) return;
+    try {
+      const pageContext = extractPageContext();
+      const message = {
+        type: "yak:page_context",
+        payload: pageContext
+      };
+      logger.debug("Sending page context to iframe:", {
+        url: pageContext.url,
+        title: pageContext.title,
+        textLength: pageContext.text.length
+      });
+      this.iframeWindow.postMessage(message, this.getIframeOrigin());
+    } catch (error) {
+      logger.error("Error extracting page context:", error);
+    }
+  }
+  async handleToolCall(id, name, args) {
+    logger.debug(`Tool call received: ${name}`, { id, args });
+    if (!this.config.onToolCall) {
+      logger.error("Tool call received but no onToolCall handler configured");
+      this.sendToolResultToIframe(id, false, void 0, "No tool call handler configured");
+      this.config.onToolCallComplete?.({
+        name,
+        args,
+        ok: false,
+        error: "No tool call handler configured"
+      });
+      return;
+    }
+    try {
+      const result = await this.config.onToolCall(name, args);
+      logger.debug(`Tool call succeeded: ${name}`, { id });
+      this.sendToolResultToIframe(id, true, result);
+      this.config.onToolCallComplete?.({ name, args, ok: true, result });
+    } catch (error) {
+      const errorMessage = this.extractErrorMessage(error);
+      logger.debug(`Tool call failed: ${name}`, { id, error });
+      this.sendToolResultToIframe(id, false, void 0, errorMessage);
+      this.config.onToolCallComplete?.({ name, args, ok: false, error: errorMessage });
+    }
+  }
+  sendToolResultToIframe(id, ok, result, error) {
+    if (!this.iframeWindow) return;
+    if (ok) {
+      const safeResult = this.toSerializable(result);
+      const message = {
+        type: "yak:tool_result",
+        payload: { id, ok: true, result: safeResult }
+      };
+      this.iframeWindow.postMessage(message, this.getIframeOrigin());
+    } else {
+      const message = {
+        type: "yak:tool_result",
+        payload: { id, ok: false, error: error ?? "Unknown error" }
+      };
+      this.iframeWindow.postMessage(message, this.getIframeOrigin());
+    }
+  }
+  /**
+   * Convert a value to a serializable form by stripping functions and other non-cloneable values.
+   * Uses JSON.parse(JSON.stringify()) which handles most cases.
+   */
+  toSerializable(value) {
+    if (value === void 0 || value === null) {
+      return value;
+    }
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch {
+      logger.warn("Failed to serialize tool result, returning string representation");
+      return String(value);
+    }
+  }
+  extractErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    return "Unknown error";
+  }
+  /**
+   * Validates that a redirect path is safe (relative path or same-origin).
+   * Blocks absolute URLs to external domains to prevent open redirect attacks.
+   */
+  isAllowedRedirect(path) {
+    if (path.startsWith("/") && !path.startsWith("//")) {
+      return true;
+    }
+    if (path.startsWith("#") || path.startsWith("?")) {
+      return true;
+    }
+    if (typeof window !== "undefined") {
+      try {
+        const url = new URL(path, window.location.origin);
+        return url.origin === window.location.origin;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+};
+
+// src/voice-machine.ts
+var INITIAL_VOICE_MACHINE = { state: "idle" };
+function voiceReducer(machine, event) {
+  switch (event.type) {
+    case "start":
+      return machine.state === "idle" ? { state: "connecting" } : machine;
+    case "connected":
+      return machine.state === "connecting" ? { state: "listening" } : machine;
+    case "response_requested":
+      return machine.state === "listening" ? { state: "thinking" } : machine;
+    case "speech_started":
+      if (machine.state === "idle" || machine.state === "error") return machine;
+      return { state: "listening" };
+    case "speech_stopped":
+      return machine.state === "listening" ? { state: "thinking" } : machine;
+    case "audio_delta":
+      if (machine.state === "thinking" || machine.state === "speaking") {
+        return { state: "speaking" };
+      }
+      return machine;
+    case "audio_stopped":
+      return machine.state === "speaking" ? { state: "listening" } : machine;
+    case "stop":
+      return { state: "idle" };
+    case "error":
+      return { state: "error", errorMessage: event.message };
+    default: {
+      const _exhaustive = event;
+      void _exhaustive;
+      return machine;
+    }
+  }
+}
+function isFunctionCall(item) {
+  return item.type === "function_call";
+}
+function parseToolArgs(raw) {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function dispatchFunctionCall(call, ctx) {
+  const callId = call.call_id;
+  const name = call.name;
+  if (!callId || !name) return;
+  if (ctx.isDispatched(callId)) return;
+  ctx.markDispatched(callId);
+  const args = parseToolArgs(call.arguments);
+  let output;
+  try {
+    const result = await ctx.dispatchToolCall(name, args);
+    output = JSON.stringify(result ?? null);
+  } catch (error) {
+    output = JSON.stringify({
+      error: error instanceof Error ? error.message : "Tool execution failed"
+    });
+  }
+  ctx.sendData({
+    type: "conversation.item.create",
+    item: { type: "function_call_output", call_id: callId, output }
+  });
+  ctx.sendData({ type: "response.create" });
+}
+function extractUsage(raw) {
+  if (!raw) return null;
+  const usage = {};
+  if (typeof raw.input_tokens === "number") usage.inputTokens = raw.input_tokens;
+  if (typeof raw.output_tokens === "number") usage.outputTokens = raw.output_tokens;
+  const inDetails = raw.input_token_details;
+  if (inDetails) {
+    if (typeof inDetails.cached_tokens === "number") {
+      usage.cachedInputTokens = inDetails.cached_tokens;
+    }
+    if (typeof inDetails.audio_tokens === "number") {
+      usage.audioInputTokens = inDetails.audio_tokens;
+    }
+    if (typeof inDetails.text_tokens === "number") {
+      usage.textInputTokens = inDetails.text_tokens;
+    }
+  }
+  const outDetails = raw.output_token_details;
+  if (outDetails) {
+    if (typeof outDetails.audio_tokens === "number") {
+      usage.audioOutputTokens = outDetails.audio_tokens;
+    }
+    if (typeof outDetails.text_tokens === "number") {
+      usage.textOutputTokens = outDetails.text_tokens;
+    }
+  }
+  return Object.keys(usage).length > 0 ? usage : null;
+}
+async function handleResponseDone(response, ctx) {
+  const usage = extractUsage(response?.usage);
+  if (usage && ctx.recordUsage) {
+    try {
+      ctx.recordUsage(usage);
+    } catch {
+    }
+  }
+  const calls = (response?.output ?? []).filter(isFunctionCall);
+  for (const call of calls) {
+    await dispatchFunctionCall(call, ctx);
+  }
+}
+async function handleRealtimeMessage(raw, ctx) {
+  let message;
+  try {
+    message = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  switch (message.type) {
+    case "input_audio_buffer.speech_started":
+      ctx.send({ type: "speech_started" });
+      return;
+    case "input_audio_buffer.speech_stopped":
+      ctx.send({ type: "speech_stopped" });
+      return;
+    case "response.output_audio_transcript.delta":
+    case "response.audio_transcript.delta":
+      ctx.send({ type: "audio_delta" });
+      return;
+    case "output_audio_buffer.stopped":
+    case "response.output_audio_buffer.stopped":
+      ctx.send({ type: "audio_stopped" });
+      return;
+    case "response.done":
+      await handleResponseDone(message.response, ctx);
+      return;
+    case "error":
+      ctx.send({
+        type: "error",
+        message: message.error?.message ?? "Voice session error"
+      });
+      return;
+    default:
+      return;
+  }
+}
+
+// src/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 64;
+function generateToolId(originalName) {
+  const sanitized = originalName.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, MAX_TOOL_NAME_LENGTH);
+  return sanitized.length > 0 ? sanitized : "tool";
+}
+var MCP_NAMESPACE_PREFIX = "mcp__";
+function uniqueToolId(originalName, used) {
+  let base = generateToolId(originalName);
+  if (base.startsWith(MCP_NAMESPACE_PREFIX)) {
+    base = `t_${base}`.slice(0, MAX_TOOL_NAME_LENGTH);
+  }
+  if (!used.has(base)) return base;
+  for (let i = 2; i < 1e3; i++) {
+    const suffix = `_${i}`;
+    const candidate = `${base.slice(0, MAX_TOOL_NAME_LENGTH - suffix.length)}${suffix}`;
+    if (!used.has(candidate)) return candidate;
+  }
+  return `${base.slice(0, 56)}_${used.size}`;
+}
+
+// src/voice-session.ts
+var DEFAULT_REALTIME_MODEL = "gpt-realtime";
+var REALTIME_CALLS_URL = "https://api.openai.com/v1/realtime/calls";
+var DEFAULT_API_ORIGIN = "https://chat.yak.io";
+function getDefaultApiOrigin() {
+  if (typeof window !== "undefined" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1") && typeof window.__YAK_INTERNAL_DEV__ !== "undefined") {
+    return "http://localhost:3001";
+  }
+  return DEFAULT_API_ORIGIN;
+}
+var EMPTY_RESOURCES = {
+  pc: null,
+  dataChannel: null,
+  micStream: null,
+  audioElement: null,
+  voiceSessionId: null
+};
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    audioInputTokens: 0,
+    audioOutputTokens: 0,
+    textInputTokens: 0,
+    textOutputTokens: 0,
+    responseCount: 0
+  };
+}
+var YakVoiceSession = class {
+  config;
+  machine = INITIAL_VOICE_MACHINE;
+  resources = EMPTY_RESOURCES;
+  dispatchedCallIds = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  pageHideHandler = null;
+  /** Per-session token totals, accumulated from each `response.done` event. */
+  usage = emptyUsage();
+  /**
+   * Reverse map: hashed tool id (what OpenAI calls back with) → original host
+   * tool name (what `onToolCall` expects). Populated on every `start()` from
+   * the resolved chat config.
+   */
+  toolNameById = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+    this.attachPageHide();
+  }
+  /**
+   * Resolve the API origin lazily on each call. Environment-dependent defaults
+   * (e.g. a local chat UI) may not be ready at construction time, so resolving
+   * eagerly would risk baking in the production URL.
+   */
+  get apiOrigin() {
+    return this.config.apiOrigin ?? getDefaultApiOrigin();
+  }
+  /** Update mutable config fields (handlers, getConfig). */
+  updateConfig(patch) {
+    this.config = { ...this.config, ...patch };
+  }
+  getState() {
+    return this.machine;
+  }
+  /**
+   * The current API origin (defaults to `https://chat.yak.io`). Useful for
+   * building URLs to static assets like the brand logo.
+   */
+  getApiOrigin() {
+    return this.apiOrigin;
+  }
+  onStateChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Begin a voice session. Should be invoked from a user gesture (button
+   * click) so `getUserMedia` and audio playback both have transient activation.
+   */
+  async start() {
+    if (this.machine.state !== "idle") return;
+    logger.debug("Voice: start() called");
+    this.usage = emptyUsage();
+    this.dispatch({ type: "start" });
+    let chatConfig = this.config.chatConfig;
+    if (this.config.getConfig) {
+      try {
+        chatConfig = await this.config.getConfig();
+        logger.debug("Voice: getConfig() resolved", {
+          toolCount: chatConfig?.tools?.tools.length ?? 0,
+          routeCount: chatConfig?.routes?.routes.length ?? 0
+        });
+      } catch (err) {
+        logger.warn("Voice: getConfig() failed", err);
+      }
+    } else if (chatConfig) {
+      logger.debug("Voice: using static chatConfig", {
+        toolCount: chatConfig.tools?.tools.length ?? 0,
+        routeCount: chatConfig.routes?.routes.length ?? 0
+      });
+    } else {
+      logger.debug("Voice: no chatConfig or getConfig \u2014 only built-in tools will be available");
+    }
+    const decoratedManifest = this.buildDecoratedManifest(chatConfig);
+    logger.debug("Voice: decorated tools", {
+      ids: decoratedManifest.tools.map((t) => `${t.id}=${t.name}`)
+    });
+    const pageContext = this.safeExtractPageContext();
+    logger.debug("Voice: page context extracted", {
+      url: pageContext?.url,
+      title: pageContext?.title,
+      textLength: pageContext?.text?.length ?? 0
+    });
+    let mint;
+    try {
+      logger.debug("Voice: requesting ephemeral token from mint endpoint");
+      mint = await this.mintToken(chatConfig, decoratedManifest, pageContext);
+      logger.debug("Voice: mint succeeded", {
+        voiceSessionId: mint.voiceSessionId,
+        expiresAt: mint.expiresAt
+      });
+    } catch (err) {
+      await this.failWith(err instanceof Error ? err.message : "Failed to start voice session");
+      return;
+    }
+    let micStream;
+    try {
+      logger.debug("Voice: requesting microphone access");
+      micStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      logger.debug("Voice: microphone access granted");
+    } catch (err) {
+      const name = err instanceof Error ? err.name : "";
+      const message = name === "NotAllowedError" || name === "PermissionDeniedError" ? "Microphone permission was denied. Enable microphone access in your browser settings to use voice mode." : "Could not access microphone.";
+      await this.failWith(message);
+      return;
+    }
+    const pc = new RTCPeerConnection();
+    const audioElement = document.createElement("audio");
+    audioElement.autoplay = true;
+    audioElement.style.display = "none";
+    document.body.appendChild(audioElement);
+    pc.ontrack = (event) => {
+      logger.debug("Voice: pc.ontrack received remote audio stream");
+      if (event.streams[0]) {
+        audioElement.srcObject = event.streams[0];
+      }
+    };
+    pc.oniceconnectionstatechange = () => {
+      const s = pc.iceConnectionState;
+      logger.debug("Voice: ICE connection state \u2192", s);
+      if (s === "failed" || s === "disconnected") {
+        void this.failWith(`WebRTC connection ${s}`);
+      }
+    };
+    pc.onconnectionstatechange = () => {
+      logger.debug("Voice: peer connection state \u2192", pc.connectionState);
+      if (pc.connectionState === "failed") {
+        void this.failWith("WebRTC connection failed");
+      }
+    };
+    for (const track of micStream.getAudioTracks()) {
+      pc.addTrack(track, micStream);
+    }
+    const dataChannel = pc.createDataChannel("oai-events");
+    dataChannel.onmessage = (event) => {
+      const raw = typeof event.data === "string" ? event.data : "";
+      if (!raw) return;
+      logger.debug("Voice: \u2190 data channel message", raw.slice(0, 200));
+      void handleRealtimeMessage(raw, this.buildMessageContext());
+    };
+    dataChannel.onopen = () => {
+      logger.debug("Voice: data channel opened");
+      this.dispatch({ type: "connected" });
+      if (mint.autoGreet !== false) {
+        this.dispatch({ type: "response_requested" });
+        this.sendOverDataChannel({ type: "response.create" });
+      }
+    };
+    dataChannel.onclose = () => {
+      logger.debug("Voice: data channel closed");
+    };
+    this.resources = {
+      pc,
+      dataChannel,
+      micStream,
+      audioElement,
+      voiceSessionId: mint.voiceSessionId
+    };
+    try {
+      logger.debug("Voice: creating WebRTC offer");
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      logger.debug("Voice: exchanging SDP with OpenAI Realtime");
+      const answerSdp = await this.exchangeSdp(offer, mint.clientSecret);
+      await pc.setRemoteDescription({ type: "answer", sdp: answerSdp });
+      logger.debug("Voice: WebRTC negotiation complete");
+    } catch (err) {
+      await this.failWith(
+        err instanceof Error ? err.message : "Failed to negotiate voice connection"
+      );
+      return;
+    }
+    void this.postSessionEvent("start", mint.voiceSessionId, pageContext);
+  }
+  /** Stop the session and tear down all resources. */
+  async stop() {
+    logger.debug("Voice: stop() called");
+    this.dispatch({ type: "stop" });
+    await this.teardown();
+  }
+  /** Tear down everything and remove listeners. Call once before discarding the instance. */
+  destroy() {
+    void this.teardown();
+    if (this.pageHideHandler) {
+      window.removeEventListener("pagehide", this.pageHideHandler);
+      this.pageHideHandler = null;
+    }
+    this.listeners.clear();
+  }
+  // ── Internals ───────────────────────────────────────────────────────────
+  buildMessageContext() {
+    return {
+      send: (event) => this.dispatch(event),
+      sendData: (payload) => this.sendOverDataChannel(payload),
+      dispatchToolCall: (name, args) => this.routeToolCall(name, args),
+      isDispatched: (id) => this.dispatchedCallIds.has(id),
+      markDispatched: (id) => {
+        this.dispatchedCallIds.add(id);
+      },
+      recordUsage: (usage) => this.accumulateUsage(usage)
+    };
+  }
+  accumulateUsage(usage) {
+    this.usage.responseCount += 1;
+    if (typeof usage.inputTokens === "number") this.usage.inputTokens += usage.inputTokens;
+    if (typeof usage.cachedInputTokens === "number") {
+      this.usage.cachedInputTokens += usage.cachedInputTokens;
+    }
+    if (typeof usage.outputTokens === "number") this.usage.outputTokens += usage.outputTokens;
+    if (typeof usage.audioInputTokens === "number") {
+      this.usage.audioInputTokens += usage.audioInputTokens;
+    }
+    if (typeof usage.audioOutputTokens === "number") {
+      this.usage.audioOutputTokens += usage.audioOutputTokens;
+    }
+    if (typeof usage.textInputTokens === "number") {
+      this.usage.textInputTokens += usage.textInputTokens;
+    }
+    if (typeof usage.textOutputTokens === "number") {
+      this.usage.textOutputTokens += usage.textOutputTokens;
+    }
+  }
+  sendOverDataChannel(payload) {
+    const channel = this.resources.dataChannel;
+    if (!channel || channel.readyState !== "open") {
+      logger.warn("Voice data channel not ready; dropping payload");
+      return;
+    }
+    try {
+      const serialized = JSON.stringify(payload);
+      logger.debug("Voice: \u2192 data channel send", serialized.slice(0, 200));
+      channel.send(serialized);
+    } catch (err) {
+      logger.warn("Failed to send on voice data channel", err);
+    }
+  }
+  async routeToolCall(idOrName, args) {
+    const name = this.toolNameById.get(idOrName) ?? idOrName;
+    logger.debug("Voice: tool call dispatched", { id: idOrName, name, args });
+    if (name.startsWith("mcp__")) {
+      return await this.execMcpTool(name, args);
+    }
+    if (name === "redirect") {
+      const path = args?.path;
+      if (typeof path !== "string") {
+        throw new Error("redirect tool requires a string `path` argument");
+      }
+      if (this.config.onRedirect) {
+        this.config.onRedirect(path);
+      } else if (typeof window !== "undefined") {
+        window.location.assign(path);
+      }
+      return { success: true, redirected: true, path };
+    }
+    if (this.config.onToolCall) {
+      return await this.config.onToolCall(name, args);
+    }
+    throw new Error(`No handler configured for tool: ${name}`);
+  }
+  /**
+   * Relay an MCP tool call to the server, which holds the org's credentials
+   * and executes against the remote MCP server. The browser only ever passes
+   * through the tool name, args, and the opaque result.
+   */
+  async execMcpTool(toolName, args) {
+    try {
+      const res = await fetch(`${this.apiOrigin}/api/voice/mcp-exec`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          appId: this.config.appId,
+          toolName,
+          args: args ?? {},
+          pageContext: this.safeExtractPageContext()
+        })
+      });
+      if (!res.ok) {
+        const body2 = await res.json().catch(() => ({}));
+        return { error: body2.error ?? `MCP tool failed (${res.status})` };
+      }
+      const body = await res.json();
+      return body.result ?? {};
+    } catch (err) {
+      logger.debug("Voice: MCP tool relay failed", err);
+      return { error: "The integration could not complete this request." };
+    }
+  }
+  async mintToken(chatConfig, decoratedManifest, pageContext) {
+    const res = await fetch(`${this.apiOrigin}/api/voice/realtime-token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        appId: this.config.appId,
+        pageContext,
+        toolManifest: decoratedManifest,
+        routeManifest: chatConfig?.routes
+      })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error ?? `Mint failed (${res.status})`);
+    }
+    return await res.json();
+  }
+  /**
+   * Decorate the host's tool manifest with readable, collision-free model-facing ids
+   * and populate `this.toolNameById` for reverse lookup. Mirrors the decoration the
+   * chat-ui iframe applies before sending tools to `/api/chat`. GraphQL/REST tools are
+   * ordinary manifest entries here (contributed by their adapters), so no special-casing
+   * is needed.
+   */
+  buildDecoratedManifest(chatConfig) {
+    this.toolNameById.clear();
+    const used = /* @__PURE__ */ new Set(["redirect"]);
+    const decoratedHostTools = (chatConfig?.tools?.tools ?? []).map((t) => {
+      const id = uniqueToolId(t.name, used);
+      used.add(id);
+      this.toolNameById.set(id, t.name);
+      return { ...t, id };
+    });
+    return { tools: decoratedHostTools };
+  }
+  async exchangeSdp(offer, clientSecret) {
+    const sdpResponse = await fetch(`${REALTIME_CALLS_URL}?model=${DEFAULT_REALTIME_MODEL}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${clientSecret}`,
+        "Content-Type": "application/sdp"
+      },
+      body: offer.sdp
+    });
+    if (!sdpResponse.ok) {
+      const body = await sdpResponse.text().catch(() => "");
+      throw new Error(`SDP exchange failed (${sdpResponse.status}): ${body}`);
+    }
+    return await sdpResponse.text();
+  }
+  buildStopEventBody(voiceSessionId, pageContext) {
+    return {
+      appId: this.config.appId,
+      voiceSessionId,
+      event: "stop",
+      clientTimestamp: Date.now(),
+      pageContext,
+      usage: { ...this.usage }
+    };
+  }
+  async postSessionEvent(event, voiceSessionId, pageContext) {
+    try {
+      const body = event === "stop" ? this.buildStopEventBody(voiceSessionId, pageContext) : {
+        appId: this.config.appId,
+        voiceSessionId,
+        event,
+        clientTimestamp: Date.now(),
+        pageContext
+      };
+      await fetch(`${this.apiOrigin}/api/voice/session-event`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        keepalive: event === "stop"
+      });
+    } catch (err) {
+      logger.warn(`Failed to post voice.session.${event}`, err);
+    }
+  }
+  async teardown() {
+    const r = this.resources;
+    this.resources = EMPTY_RESOURCES;
+    this.dispatchedCallIds = /* @__PURE__ */ new Set();
+    try {
+      r.dataChannel?.close();
+    } catch (err) {
+      logger.warn("Error closing data channel", err);
+    }
+    try {
+      for (const track of r.micStream?.getTracks() ?? []) {
+        track.stop();
+      }
+    } catch (err) {
+      logger.warn("Error stopping mic tracks", err);
+    }
+    try {
+      for (const sender of r.pc?.getSenders() ?? []) {
+        sender.track?.stop();
+      }
+      r.pc?.close();
+    } catch (err) {
+      logger.warn("Error closing peer connection", err);
+    }
+    if (r.audioElement) {
+      try {
+        r.audioElement.srcObject = null;
+        r.audioElement.remove();
+      } catch (err) {
+        logger.warn("Error removing audio element", err);
+      }
+    }
+    if (r.voiceSessionId) {
+      await this.postSessionEvent("stop", r.voiceSessionId, this.safeExtractPageContext());
+    }
+  }
+  async failWith(message) {
+    logger.warn("Voice session error:", message);
+    this.dispatch({ type: "error", message });
+    await this.teardown();
+  }
+  dispatch(event) {
+    const next = voiceReducer(this.machine, event);
+    if (next === this.machine) return;
+    this.machine = next;
+    for (const listener of this.listeners) {
+      try {
+        listener(next);
+      } catch (err) {
+        logger.warn("Voice state listener threw", err);
+      }
+    }
+  }
+  safeExtractPageContext() {
+    try {
+      return extractPageContext();
+    } catch {
+      return void 0;
+    }
+  }
+  attachPageHide() {
+    if (typeof window === "undefined") return;
+    this.pageHideHandler = () => {
+      const r = this.resources;
+      if (!r.voiceSessionId) return;
+      const body = JSON.stringify(this.buildStopEventBody(r.voiceSessionId, void 0));
+      if (navigator.sendBeacon) {
+        navigator.sendBeacon(
+          `${this.apiOrigin}/api/voice/session-event`,
+          new Blob([body], { type: "application/json" })
+        );
+      }
+    };
+    window.addEventListener("pagehide", this.pageHideHandler);
+  }
+};
+
+// src/embed.ts
+var DEFAULT_POSITION = "bottom-left";
+var MESSAGE_CIRCLE_SVG = `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"/></svg>`;
+var AUDIO_LINES_SVG = `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M2 10v3"/><path d="M6 6v11"/><path d="M10 3v18"/><path d="M14 8v7"/><path d="M18 5v13"/><path d="M22 10v3"/></svg>`;
+var STOP_SVG = `<svg viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><rect x="6" y="6" width="12" height="12" rx="2"/></svg>`;
+var VOICE_STATE_ARIA = {
+  idle: "Start voice mode",
+  connecting: "Connecting voice session",
+  listening: "Voice listening \u2014 tap to stop",
+  thinking: "Voice thinking \u2014 tap to stop",
+  speaking: "Voice speaking \u2014 tap to stop",
+  error: "Voice error \u2014 tap to retry"
+};
+function getPanelStyles() {
+  return `
+    .yak-panel-root {
+      position: fixed;
+      top: 0; left: 0; right: 0; bottom: 0;
+      width: 100vw; height: 100vh;
+      pointer-events: none;
+      z-index: 9998;
+    }
+
+    .yak-panel-container {
+      position: absolute;
+      width: 500px; height: 600px;
+      max-width: calc(100vw - 40px);
+      max-height: calc(100vh - 120px);
+      border-radius: 15px;
+      overflow: hidden;
+      background-color: transparent;
+      pointer-events: auto;
+    }
+
+    .yak-panel-container[data-position="top-left"]:not(.yak-panel-drawer)      { top: 16px; left: 16px; }
+    .yak-panel-container[data-position="top-center"]:not(.yak-panel-drawer)    { top: 16px; left: 50%; transform: translateX(-50%); }
+    .yak-panel-container[data-position="top-right"]:not(.yak-panel-drawer)     { top: 16px; right: 16px; }
+    .yak-panel-container[data-position="left-center"]:not(.yak-panel-drawer)   { top: 50%; left: 16px; transform: translateY(-50%); }
+    .yak-panel-container[data-position="right-center"]:not(.yak-panel-drawer)  { top: 50%; right: 16px; transform: translateY(-50%); }
+    .yak-panel-container[data-position="bottom-left"]:not(.yak-panel-drawer)   { bottom: 16px; left: 16px; }
+    .yak-panel-container[data-position="bottom-center"]:not(.yak-panel-drawer) { bottom: 16px; left: 50%; transform: translateX(-50%); }
+    .yak-panel-container[data-position="bottom-right"]:not(.yak-panel-drawer)  { bottom: 16px; right: 16px; }
+
+    .yak-panel-container:not(.yak-panel-drawer)                    { display: none; }
+    .yak-panel-container:not(.yak-panel-drawer)[data-open="true"]  { display: block; }
+
+    .yak-panel-container[data-expanded="true"] {
+      width: calc(100vw - 32px) !important;
+      height: calc(100vh - 32px) !important;
+      max-width: none !important; max-height: none !important;
+      top: 16px !important; left: 16px !important; right: 16px !important; bottom: 16px !important;
+      border-radius: 15px !important;
+      border: 1px solid rgba(0, 0, 0, 0.1) !important;
+      box-shadow: 0 4px 24px rgba(0, 0, 0, 0.15) !important;
+    }
+    @media (prefers-color-scheme: dark) {
+      .yak-panel-container[data-expanded="true"]:not(.yak-panel-light) { border-color: rgba(255,255,255,0.1) !important; }
+    }
+    .yak-panel-container.yak-panel-dark[data-expanded="true"]  { border-color: rgba(255,255,255,0.1) !important; }
+    .yak-panel-container.yak-panel-light[data-expanded="true"] { border-color: rgba(0,0,0,0.1) !important; }
+
+    .yak-panel-container.yak-panel-drawer {
+      height: calc(100% - 32px); max-width: 100vw; max-height: none;
+      border-radius: 15px;
+      transition: transform 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+    }
+    .yak-panel-container.yak-panel-drawer[data-position="left-center"],
+    .yak-panel-container.yak-panel-drawer[data-position="top-left"],
+    .yak-panel-container.yak-panel-drawer[data-position="bottom-left"] {
+      top: 16px; left: 16px; bottom: 16px;
+      transform: translateX(calc(-100% - 16px));
+    }
+    .yak-panel-container.yak-panel-drawer[data-position="right-center"],
+    .yak-panel-container.yak-panel-drawer[data-position="top-right"],
+    .yak-panel-container.yak-panel-drawer[data-position="bottom-right"] {
+      top: 16px; right: 16px; bottom: 16px;
+      transform: translateX(calc(100% + 16px));
+    }
+    .yak-panel-container.yak-panel-drawer[data-position="top-center"],
+    .yak-panel-container.yak-panel-drawer[data-position="bottom-center"] {
+      top: 16px; right: 16px; bottom: 16px;
+      transform: translateX(calc(100% + 16px));
+    }
+    .yak-panel-container.yak-panel-drawer[data-open="true"] { transform: translateX(0); }
+
+    .yak-panel-iframe {
+      position: absolute; inset: 0;
+      width: 100%; height: 100%; border: none;
+    }
+
+    @media (max-width: 640px) {
+      .yak-panel-container:not(.yak-panel-drawer) {
+        width: 100% !important; height: 100% !important; height: 100dvh !important;
+        max-width: none !important; max-height: none !important;
+        top: 0 !important; left: 0 !important; right: 0 !important; bottom: 0 !important;
+        border-radius: 0 !important;
+      }
+      .yak-panel-container.yak-panel-drawer { width: 100% !important; max-width: none !important; }
+    }
+  `;
+}
+function getTriggerStyles() {
+  return `
+    .yak-widget-trigger {
+      position: fixed; z-index: 9997;
+      display: inline-flex; align-items: center; gap: 8px;
+      border: none; border-radius: 30px;
+      padding: 5px; height: 45px;
+      transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+      background-color: #000; color: #fff;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+      font-family: system-ui, -apple-system, sans-serif;
+    }
+
+    .yak-widget-trigger[data-position="top-left"]      { top: 28px; left: 28px; }
+    .yak-widget-trigger[data-position="top-center"]    { top: 28px; left: 50%; transform: translateX(-50%); }
+    .yak-widget-trigger[data-position="top-right"]     { top: 28px; right: 28px; }
+    .yak-widget-trigger[data-position="left-center"]   { top: 50%; left: 28px; transform: translateY(-50%); }
+    .yak-widget-trigger[data-position="right-center"]  { top: 50%; right: 28px; transform: translateY(-50%); }
+    .yak-widget-trigger[data-position="bottom-left"]   { bottom: 28px; left: 28px; }
+    .yak-widget-trigger[data-position="bottom-center"] { bottom: 28px; left: 50%; transform: translateX(-50%); }
+    .yak-widget-trigger[data-position="bottom-right"]  { bottom: 28px; right: 28px; }
+
+    .yak-widget-icon-bg {
+      display: flex; align-items: center; justify-content: center;
+      width: 36px; height: 36px; border-radius: 50%;
+      background-color: rgba(255, 255, 255, 0.1);
+      flex-shrink: 0;
+    }
+
+    .yak-widget-icon { width: 20px; height: 20px; color: currentColor; }
+
+    .yak-widget-trigger-icon-btn {
+      display: inline-flex; align-items: center; justify-content: center;
+      width: 36px; height: 36px; border-radius: 50%;
+      border: none; padding: 0;
+      background-color: transparent;
+      color: inherit;
+      cursor: pointer;
+      position: relative;
+      transition: background-color 0.15s ease;
+      flex-shrink: 0;
+    }
+    .yak-widget-trigger-icon-btn:hover { background-color: rgba(255, 255, 255, 0.12); }
+    .yak-widget-trigger-icon-btn:disabled { cursor: wait; opacity: 0.7; }
+    .yak-widget-trigger-icon-btn svg { width: 20px; height: 20px; display: block; }
+
+    .yak-widget-trigger-icon-btn[data-action="voice"][data-state="error"] {
+      background-color: rgba(185, 28, 28, 0.18);
+    }
+    .yak-widget-trigger-icon-btn[data-action="voice"][data-state="listening"]::after,
+    .yak-widget-trigger-icon-btn[data-action="voice"][data-state="speaking"]::after {
+      content: "";
+      position: absolute; inset: 2px;
+      border-radius: 50%;
+      border: 2px solid currentColor;
+      pointer-events: none;
+    }
+    .yak-widget-trigger-icon-btn[data-action="voice"][data-state="listening"]::after {
+      opacity: 0.4; animation: yak-widget-pulse 1.2s ease-out infinite;
+    }
+    .yak-widget-trigger-icon-btn[data-action="voice"][data-state="speaking"]::after {
+      opacity: 0.5; animation: yak-widget-wave 0.8s ease-in-out infinite;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      .yak-widget-trigger:not(.yak-widget-light) .yak-widget-icon { filter: invert(1); }
+      .yak-widget-trigger:not(.yak-widget-light) .yak-widget-trigger-icon-btn:hover {
+        background-color: rgba(255, 255, 255, 0.12);
+      }
+    }
+    .yak-widget-trigger.yak-widget-dark .yak-widget-icon  { filter: invert(1); }
+    .yak-widget-trigger.yak-widget-light .yak-widget-icon  { filter: none; }
+    .yak-widget-trigger.yak-widget-light .yak-widget-trigger-icon-btn:hover {
+      background-color: rgba(0, 0, 0, 0.06);
+    }
+
+    .yak-widget-spinner {
+      width: 20px; height: 20px;
+      border: 2px solid currentColor; border-top-color: transparent; border-radius: 50%;
+      animation: yak-widget-spin 0.8s linear infinite;
+    }
+    @keyframes yak-widget-spin { to { transform: rotate(360deg); } }
+    @keyframes yak-widget-pulse {
+      0%   { transform: scale(1);    opacity: 0.5; }
+      100% { transform: scale(1.45); opacity: 0;   }
+    }
+    @keyframes yak-widget-wave {
+      0%, 100% { transform: scale(1);    opacity: 0.5; }
+      50%      { transform: scale(1.25); opacity: 0.9; }
+    }
+
+    .yak-widget-trigger.yak-widget-custom-light {
+      background-color: var(--yak-btn-light-bg, #fff); color: var(--yak-btn-light-color, #000);
+      border: 1px solid var(--yak-btn-light-border, transparent);
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+    }
+    .yak-widget-trigger.yak-widget-custom-dark {
+      background-color: var(--yak-btn-dark-bg, #000); color: var(--yak-btn-dark-color, #fff);
+      border: 1px solid var(--yak-btn-dark-border, transparent);
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    }
+
+    @media (prefers-color-scheme: light) {
+      .yak-widget-trigger[data-has-light-custom]:not(.yak-widget-dark) {
+        background-color: var(--yak-btn-light-bg, #fff); color: var(--yak-btn-light-color, #000);
+        border: 1px solid var(--yak-btn-light-border, transparent);
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+      }
+    }
+    @media (prefers-color-scheme: dark) {
+      .yak-widget-trigger[data-has-dark-custom]:not(.yak-widget-light) {
+        background-color: var(--yak-btn-dark-bg, #000); color: var(--yak-btn-dark-color, #fff);
+        border: 1px solid var(--yak-btn-dark-border, transparent);
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+      }
+    }
+
+    @media (prefers-color-scheme: light) {
+      .yak-widget-trigger:not(.yak-widget-dark):not([data-has-light-custom]) {
+        background-color: #fff; color: #000;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1); border: 1px solid #e5e5e5;
+      }
+      .yak-widget-trigger:not(.yak-widget-dark):not([data-has-light-custom]) .yak-widget-icon-bg {
+        background-color: rgba(0, 0, 0, 0.05);
+      }
+    }
+
+    @media (prefers-color-scheme: dark) {
+      .yak-widget-trigger:not(.yak-widget-light):not([data-has-dark-custom]) {
+        background-color: #000; color: #fff;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); border: none;
+      }
+      .yak-widget-trigger:not(.yak-widget-light):not([data-has-dark-custom]) .yak-widget-icon-bg {
+        background-color: rgba(255, 255, 255, 0.1);
+      }
+    }
+
+    .yak-widget-trigger.yak-widget-light:not(.yak-widget-custom-light) {
+      background-color: #fff; color: #000;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1); border: 1px solid #e5e5e5;
+    }
+    .yak-widget-trigger.yak-widget-light:not(.yak-widget-custom-light) .yak-widget-icon-bg {
+      background-color: rgba(0, 0, 0, 0.05);
+    }
+
+    .yak-widget-trigger.yak-widget-dark:not(.yak-widget-custom-dark) {
+      background-color: #000; color: #fff;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); border: none;
+    }
+    .yak-widget-trigger.yak-widget-dark:not(.yak-widget-custom-dark) .yak-widget-icon-bg {
+      background-color: rgba(255, 255, 255, 0.1);
+    }
+  `;
+}
+var YakEmbed = class {
+  client;
+  voice;
+  config;
+  mode;
+  // DOM elements
+  styleEl = null;
+  panelRoot = null;
+  container = null;
+  iframe = null;
+  triggerEl = null;
+  chatButton = null;
+  voiceButton = null;
+  // State
+  isOpen = false;
+  isReady = false;
+  isExpanded = false;
+  hasBeenOpened = false;
+  pendingPrompt = null;
+  mounted = false;
+  voiceMachine = INITIAL_VOICE_MACHINE;
+  // Listeners
+  stateListeners = /* @__PURE__ */ new Set();
+  voiceListeners = /* @__PURE__ */ new Set();
+  unsubscribeVoice = null;
+  mobileQuery = null;
+  mobileHandler = null;
+  expandHandler = null;
+  constructor(config) {
+    this.config = config;
+    this.mode = config.mode ?? "chat";
+    this.client = new YakClient({
+      ...config,
+      onReady: () => {
+        this.isReady = true;
+        this.updatePanelState();
+        this.updateChatButtonState();
+        this.sendPendingPrompt();
+        this.sendFocusIfOpen();
+        this.notifyMobileState();
+        this.notifyListeners();
+        config.onReady?.();
+      },
+      onClose: () => {
+        this.close();
+        config.onClose?.();
+      }
+    });
+    if (this.mode !== "chat") {
+      const voiceConfig = {
+        appId: config.appId,
+        // A single `origin` on the embed drives both surfaces: chat (iframe)
+        // and voice (mint endpoint).
+        apiOrigin: config.origin,
+        getConfig: config.getConfig,
+        chatConfig: config.chatConfig,
+        onToolCall: config.onToolCall,
+        onRedirect: config.onRedirect
+      };
+      this.voice = new YakVoiceSession(voiceConfig);
+    } else {
+      this.voice = null;
+    }
+  }
+  /** The underlying headless YakClient for advanced usage */
+  getClient() {
+    return this.client;
+  }
+  /** The underlying voice session — null when mode === "chat". */
+  getVoiceSession() {
+    return this.voice;
+  }
+  /** Current widget mode (immutable for the lifetime of the embed). */
+  getMode() {
+    return this.mode;
+  }
+  // ── Lifecycle ───────────────────────────────────────────────────────────
+  /**
+   * Mount the widget into the DOM. Call once after construction.
+   * Inserts styles and trigger button (if enabled). The chat iframe is
+   * lazily created on the first call to open().
+   */
+  mount(target) {
+    if (this.mounted) return;
+    this.mounted = true;
+    const parent = target ?? this.config.target ?? document.body;
+    this.styleEl = document.createElement("style");
+    this.styleEl.textContent = getPanelStyles() + getTriggerStyles();
+    parent.appendChild(this.styleEl);
+    if (this.config.trigger !== false) {
+      this.createTrigger(parent);
+    }
+    this.expandHandler = (event) => {
+      if (event.data?.type === "YAK_SET_EXPANDED") {
+        this.isExpanded = Boolean(event.data.expanded);
+        this.updatePanelState();
+        this.notifyListeners();
+      }
+    };
+    window.addEventListener("message", this.expandHandler);
+    this.client.mount();
+    if (this.voice) {
+      this.voiceMachine = this.voice.getState();
+      this.unsubscribeVoice = this.voice.onStateChange((machine) => {
+        this.voiceMachine = machine;
+        this.updateVoiceButtonState();
+        for (const listener of this.voiceListeners) {
+          try {
+            listener(machine);
+          } catch (err) {
+            logger.warn("Error in voice listener:", err);
+          }
+        }
+      });
+      this.updateVoiceButtonState();
+    }
+  }
+  /** Remove all DOM elements and event listeners. */
+  destroy() {
+    if (!this.mounted) return;
+    this.mounted = false;
+    this.client.unmount();
+    if (this.unsubscribeVoice) {
+      this.unsubscribeVoice();
+      this.unsubscribeVoice = null;
+    }
+    this.voice?.destroy();
+    if (this.expandHandler) {
+      window.removeEventListener("message", this.expandHandler);
+      this.expandHandler = null;
+    }
+    if (this.mobileQuery && this.mobileHandler) {
+      this.mobileQuery.removeEventListener("change", this.mobileHandler);
+      this.mobileQuery = null;
+      this.mobileHandler = null;
+    }
+    this.panelRoot?.remove();
+    this.triggerEl?.remove();
+    this.styleEl?.remove();
+    this.panelRoot = null;
+    this.container = null;
+    this.iframe = null;
+    this.triggerEl = null;
+    this.chatButton = null;
+    this.voiceButton = null;
+    this.styleEl = null;
+    this.isOpen = false;
+    this.isReady = false;
+    this.isExpanded = false;
+    this.hasBeenOpened = false;
+    this.stateListeners.clear();
+    this.voiceListeners.clear();
+  }
+  // ── Public chat API ─────────────────────────────────────────────────────
+  /** Open the chat widget. Creates the iframe on first call (lazy mount). */
+  open() {
+    if (!this.mounted) return;
+    if (!this.hasBeenOpened) {
+      this.hasBeenOpened = true;
+      const parent = this.config.target ?? document.body;
+      this.createPanel(parent);
+    }
+    this.isOpen = true;
+    this.client.setWidgetOpen(true);
+    this.updatePanelState();
+    this.updateChatButtonState();
+    this.sendFocusIfOpen();
+    this.notifyListeners();
+  }
+  /** Close the chat widget. The iframe remains in the DOM for instant re-open. */
+  close() {
+    this.isOpen = false;
+    this.client.setWidgetOpen(false);
+    this.updatePanelState();
+    this.updateChatButtonState();
+    this.notifyListeners();
+  }
+  /** Toggle the chat widget open/closed. */
+  toggle() {
+    if (this.isOpen) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+  /** Open the chat and immediately send a prompt. */
+  openWithPrompt(prompt) {
+    this.pendingPrompt = prompt;
+    this.open();
+    this.sendPendingPrompt();
+  }
+  /** Get the current widget state. */
+  getState() {
+    return {
+      isOpen: this.isOpen,
+      isReady: this.isReady,
+      isLoading: this.isOpen && !this.isReady,
+      isExpanded: this.isExpanded
+    };
+  }
+  /** Subscribe to state changes. Returns an unsubscribe function. */
+  onStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => {
+      this.stateListeners.delete(listener);
+    };
+  }
+  // ── Public voice API ────────────────────────────────────────────────────
+  /** Start a voice session. Must be invoked from a user gesture. */
+  voiceStart() {
+    return this.voice ? this.voice.start() : Promise.resolve();
+  }
+  /** Stop the current voice session. */
+  voiceStop() {
+    return this.voice ? this.voice.stop() : Promise.resolve();
+  }
+  /** Toggle: start if idle/error, stop if active. */
+  async voiceToggle() {
+    if (!this.voice) return;
+    const state = this.voice.getState().state;
+    if (state === "idle" || state === "error") {
+      await this.voice.start();
+    } else if (state === "listening" || state === "speaking" || state === "thinking") {
+      await this.voice.stop();
+    }
+  }
+  /** Current voice machine snapshot. */
+  getVoiceState() {
+    return this.voice ? this.voice.getState() : INITIAL_VOICE_MACHINE;
+  }
+  /** Subscribe to voice state changes. */
+  onVoiceStateChange(listener) {
+    this.voiceListeners.add(listener);
+    return () => {
+      this.voiceListeners.delete(listener);
+    };
+  }
+  // ── DOM creation ────────────────────────────────────────────────────────
+  createPanel(parent) {
+    const theme = this.config.theme;
+    const position = theme?.position ?? DEFAULT_POSITION;
+    const colorMode = theme?.colorMode;
+    const displayMode = theme?.displayMode ?? "chatbox";
+    const isDrawer = displayMode === "drawer";
+    this.panelRoot = document.createElement("div");
+    this.panelRoot.className = "yak-panel-root";
+    this.container = document.createElement("div");
+    const classes = ["yak-panel-container"];
+    if (isDrawer) classes.push("yak-panel-drawer");
+    if (colorMode === "light") classes.push("yak-panel-light");
+    else if (colorMode === "dark") classes.push("yak-panel-dark");
+    this.container.className = classes.join(" ");
+    this.container.dataset.position = position;
+    this.iframe = document.createElement("iframe");
+    this.iframe.allow = "clipboard-write";
+    this.iframe.title = "yak-chat-host";
+    this.iframe.className = "yak-panel-iframe";
+    this.iframe.src = this.client.getEmbedUrl();
+    this.iframe.addEventListener("load", () => {
+      this.client.setIframeWindow(this.iframe?.contentWindow ?? null);
+    });
+    this.container.appendChild(this.iframe);
+    this.panelRoot.appendChild(this.container);
+    parent.appendChild(this.panelRoot);
+    this.mobileQuery = window.matchMedia("(max-width: 640px)");
+    this.mobileHandler = (e) => {
+      this.notifyIframeFullscreen(e.matches);
+    };
+    this.mobileQuery.addEventListener("change", this.mobileHandler);
+  }
+  createTrigger(parent) {
+    const theme = this.config.theme;
+    const position = theme?.position ?? DEFAULT_POSITION;
+    const colorMode = theme?.colorMode;
+    const triggerConfig = typeof this.config.trigger === "object" ? this.config.trigger : {};
+    this.triggerEl = document.createElement("div");
+    this.triggerEl.dataset.position = position;
+    this.triggerEl.dataset.mode = this.mode;
+    this.triggerEl.className = this.buildTriggerClasses(colorMode, triggerConfig);
+    this.applyTriggerCustomColors(triggerConfig);
+    const iconBg = document.createElement("div");
+    iconBg.className = "yak-widget-icon-bg";
+    const logoImg = document.createElement("img");
+    logoImg.src = `${this.client.getIframeOrigin()}/logo.svg`;
+    logoImg.alt = "";
+    logoImg.width = 20;
+    logoImg.height = 20;
+    logoImg.className = "yak-widget-icon";
+    iconBg.appendChild(logoImg);
+    this.triggerEl.appendChild(iconBg);
+    if (this.mode === "chat" || this.mode === "both") {
+      this.chatButton = document.createElement("button");
+      this.chatButton.type = "button";
+      this.chatButton.className = "yak-widget-trigger-icon-btn";
+      this.chatButton.dataset.action = "chat";
+      this.chatButton.setAttribute("aria-label", "Open chat");
+      this.chatButton.innerHTML = MESSAGE_CIRCLE_SVG;
+      this.chatButton.addEventListener("click", () => this.open());
+      this.triggerEl.appendChild(this.chatButton);
+    }
+    if (this.mode === "voice" || this.mode === "both") {
+      this.voiceButton = document.createElement("button");
+      this.voiceButton.type = "button";
+      this.voiceButton.className = "yak-widget-trigger-icon-btn";
+      this.voiceButton.dataset.action = "voice";
+      this.voiceButton.dataset.state = "idle";
+      this.voiceButton.setAttribute("aria-label", VOICE_STATE_ARIA.idle);
+      this.voiceButton.innerHTML = AUDIO_LINES_SVG;
+      this.voiceButton.addEventListener("click", () => {
+        void this.voiceToggle();
+      });
+      this.triggerEl.appendChild(this.voiceButton);
+    }
+    parent.appendChild(this.triggerEl);
+  }
+  buildTriggerClasses(colorMode, triggerConfig) {
+    const classes = ["yak-widget-trigger"];
+    if (colorMode === "light") classes.push("yak-widget-light");
+    else if (colorMode === "dark") classes.push("yak-widget-dark");
+    const hasLightCustom = triggerConfig.lightButton?.background || triggerConfig.lightButton?.color || triggerConfig.lightButton?.border;
+    const hasDarkCustom = triggerConfig.darkButton?.background || triggerConfig.darkButton?.color || triggerConfig.darkButton?.border;
+    if (colorMode === "light" && hasLightCustom) classes.push("yak-widget-custom-light");
+    else if (colorMode === "dark" && hasDarkCustom) classes.push("yak-widget-custom-dark");
+    return classes.join(" ");
+  }
+  applyTriggerCustomColors(triggerConfig) {
+    if (!this.triggerEl) return;
+    const { lightButton, darkButton } = triggerConfig;
+    const hasLightCustom = lightButton?.background || lightButton?.color || lightButton?.border;
+    const hasDarkCustom = darkButton?.background || darkButton?.color || darkButton?.border;
+    if (hasLightCustom || hasDarkCustom) {
+      const vars = [
+        ["--yak-btn-light-bg", lightButton?.background],
+        ["--yak-btn-light-color", lightButton?.color],
+        ["--yak-btn-light-border", lightButton?.border],
+        ["--yak-btn-dark-bg", darkButton?.background],
+        ["--yak-btn-dark-color", darkButton?.color],
+        ["--yak-btn-dark-border", darkButton?.border]
+      ];
+      for (const [prop, value] of vars) {
+        if (value) this.triggerEl.style.setProperty(prop, value);
+      }
+    }
+    if (hasLightCustom) this.triggerEl.dataset.hasLightCustom = "true";
+    if (hasDarkCustom) this.triggerEl.dataset.hasDarkCustom = "true";
+  }
+  // ── Internal state management ───────────────────────────────────────────
+  updatePanelState() {
+    if (!this.container) return;
+    this.container.dataset.open = String(this.isOpen && this.isReady);
+    this.container.dataset.expanded = String(this.isExpanded);
+    if (this.panelRoot) {
+      this.panelRoot.dataset.expanded = String(this.isExpanded);
+    }
+  }
+  updateChatButtonState() {
+    if (!this.chatButton) return;
+    const isLoading = this.isOpen && !this.isReady;
+    this.chatButton.disabled = isLoading;
+    this.chatButton.setAttribute("aria-label", isLoading ? "Loading chat" : "Open chat");
+    if (isLoading) {
+      this.chatButton.innerHTML = `<span class="yak-widget-spinner" aria-hidden="true"></span>`;
+    } else {
+      this.chatButton.innerHTML = MESSAGE_CIRCLE_SVG;
+    }
+  }
+  updateVoiceButtonState() {
+    if (!this.voiceButton) return;
+    const state = this.voiceMachine.state;
+    this.voiceButton.dataset.state = state;
+    this.voiceButton.setAttribute("aria-label", VOICE_STATE_ARIA[state]);
+    this.voiceButton.disabled = state === "connecting";
+    this.voiceButton.innerHTML = this.iconForVoiceState(state);
+  }
+  iconForVoiceState(state) {
+    if (state === "connecting") {
+      return `<span class="yak-widget-spinner" aria-hidden="true"></span>`;
+    }
+    if (state === "listening" || state === "speaking" || state === "thinking") {
+      return STOP_SVG;
+    }
+    return AUDIO_LINES_SVG;
+  }
+  sendPendingPrompt() {
+    if (!this.pendingPrompt || !this.isReady) return;
+    logger.debug("Sending pending prompt:", this.pendingPrompt);
+    this.client.sendPrompt(this.pendingPrompt);
+    this.pendingPrompt = null;
+  }
+  sendFocusIfOpen() {
+    if (this.isOpen && this.isReady) {
+      this.client.sendFocus();
+    }
+  }
+  notifyMobileState() {
+    if (this.mobileQuery) {
+      this.notifyIframeFullscreen(this.mobileQuery.matches);
+    }
+  }
+  notifyIframeFullscreen(isFullscreen) {
+    if (!this.iframe?.contentWindow) return;
+    const msg = {
+      type: "yak:viewport",
+      payload: { fullscreen: isFullscreen }
+    };
+    this.iframe.contentWindow.postMessage(msg, this.client.getIframeOrigin());
+  }
+  notifyListeners() {
+    const state = this.getState();
+    for (const listener of this.stateListeners) {
+      try {
+        listener(state);
+      } catch (err) {
+        logger.warn("Error in state listener:", err);
+      }
+    }
+  }
+};
+
+// src/toolset.ts
+function createYakToolset(adapters) {
+  let cache = null;
+  async function resolve(force = false) {
+    if (cache && !force) return cache;
+    cache = await Promise.all(
+      adapters.map(async (adapter) => ({ adapter, tools: await adapter.getTools() }))
+    );
+    return cache;
+  }
+  async function getConfig() {
+    const resolved = await resolve(true);
+    const tools = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const { adapter, tools: adapterTools } of resolved) {
+      for (const tool of adapterTools) {
+        if (seen.has(tool.name)) {
+          logger.warn(
+            `Duplicate tool name "${tool.name}"; keeping the first and ignoring the one from adapter "${adapter.id ?? "unknown"}".`
+          );
+          continue;
+        }
+        seen.add(tool.name);
+        tools.push(tool);
+      }
+    }
+    return {
+      tools: {
+        tools,
+        sources: resolved.map(({ adapter, tools: adapterTools }, index) => ({
+          id: adapter.id ?? `adapter-${index}`,
+          count: adapterTools.length
+        }))
+      }
+    };
+  }
+  const onToolCall = async (name, args) => {
+    for (const adapter of adapters) {
+      if (adapter.ownsTool?.(name)) {
+        return adapter.execute(name, args);
+      }
+    }
+    const resolved = await resolve();
+    for (const { adapter, tools } of resolved) {
+      if (adapter.ownsTool) continue;
+      if (tools.some((tool) => tool.name === name)) {
+        return adapter.execute(name, args);
+      }
+    }
+    throw new Error(`Unknown tool: ${name}`);
+  };
+  return { getConfig, onToolCall };
+}
+async function buildHeaders(source, base) {
+  const headers = new Headers(base);
+  const resolved = typeof source === "function" ? await source() : source;
+  if (resolved) {
+    for (const [key, value] of new Headers(resolved)) {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+function createYakServerAdapter(config = {}) {
+  const endpoint = config.endpoint ?? "/api/yak";
+  return {
+    id: config.id ?? "server",
+    getTools: async () => {
+      const res = await fetch(endpoint, { headers: await buildHeaders(config.headers) });
+      if (!res.ok) {
+        throw new Error(`Failed to load tools from ${endpoint} (${res.status})`);
+      }
+      const chatConfig = await res.json();
+      return chatConfig.tools?.tools ?? [];
+    },
+    execute: async (name, args) => {
+      const res = await fetch(endpoint, {
+        method: "POST",
+        headers: await buildHeaders(config.headers, { "Content-Type": "application/json" }),
+        body: JSON.stringify({ name, args })
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok || !data.ok) {
+        throw new Error(data.error ?? `Tool "${name}" failed (${res.status})`);
+      }
+      return data.result;
+    }
+  };
+}
+//# sourceMappingURL=index.cjs.map