@salesforce/platform-sdk 3.0.0

package/dist/index.js

@@ -0,0 +1,1506 @@
+import { buildServiceDescriptor as R, setHeader as S } from "@conduit-client/service-fetch-network/v1";
+import { resolvedPromiseLike as C } from "@conduit-client/utils";
+import { RetryPolicy as N, buildServiceDescriptor as U } from "@conduit-client/service-retry/v1";
+import { encodeCoreEnvelopeContentsRaw as q } from "o11y/collectors";
+import { SimpleCollector as W } from "o11y/simple_collector";
+import { registerInstrumentedApp as V } from "o11y/client";
+import { analyticsContextSchema as $, sessionSchema as B, pageViewSchema as K, errorContextSchema as j, interactionSchema as z, customEventSchema as J } from "o11y_schema/sf_mcpanalytics";
+var o = /* @__PURE__ */ ((s) => (s.WebApp = "WebApp", s.MicroFrontend = "Micro-Frontend", s.OpenAI = "OpenAI", s.SalesforceACC = "Salesforce-ACC", s.MCPApps = "MCP-Apps", s.Mosaic = "Mosaic", s))(o || {});
+const X = Y();
+function Y() {
+  if (typeof window > "u")
+    return "Mosaic";
+  if (window.openai)
+    return "OpenAI";
+  try {
+    if (window.self !== window.top)
+      return "Micro-Frontend";
+  } catch {
+    return "Micro-Frontend";
+  }
+  const s = window;
+  return s.$A || s.Aura ? "Salesforce-ACC" : "WebApp";
+}
+function T(s) {
+  return s ?? X;
+}
+function _(s) {
+  return typeof s == "object" && s !== null && "jsonrpc" in s && s.jsonrpc === "2.0";
+}
+function G(s) {
+  return _(s) && "id" in s && typeof s.id == "number" && "result" in s;
+}
+function x(s) {
+  return _(s) && "id" in s && typeof s.id == "number" && "error" in s;
+}
+function Q(s) {
+  return G(s) || x(s);
+}
+function Z(s) {
+  return _(s) && "method" in s && typeof s.method == "string" && !("id" in s);
+}
+function yt(s) {
+  return _(s) && "id" in s && typeof s.id == "number" && "method" in s && typeof s.method == "string";
+}
+class ee {
+  targetOrigin;
+  /**
+   * @param targetOrigin - origin passed as the second argument to
+   *   `window.parent.postMessage`. Defaults to `"*"` for backwards
+   *   compatibility. Pin to the known parent origin when possible to
+   *   prevent leaking messages to a cross-origin navigated parent.
+   */
+  constructor(e = "*") {
+    this.targetOrigin = e;
+  }
+  post(e) {
+    window.parent?.postMessage(e, this.targetOrigin);
+  }
+  onMessage(e) {
+    const t = (n) => {
+      e(n.data);
+    };
+    return window.addEventListener("message", t), () => window.removeEventListener("message", t);
+  }
+}
+class te {
+  nextRequestId = 1;
+  pending = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  transport;
+  /**
+   * Construct a JSON-RPC client bound to the given transport.
+   *
+   * @param transport - the transport to use; defaults to a
+   *   `WindowPostMessageTransport`, which preserves the original
+   *   `window.parent.postMessage` behaviour.
+   */
+  constructor(e = new ee()) {
+    this.transport = e, this.transport.onMessage(this.onMessage);
+  }
+  /**
+   * Register a handler for a specific JSON-RPC notification method
+   *
+   * Subclasses can register handlers to process specific notification types.
+   * When a notification with the registered method is received, the handler
+   * will be invoked with the notification params.
+   *
+   * @param method - The notification method to handle (e.g. "ui/notifications/host-context-changed")
+   * @param handler - Callback function to process the notification params
+   *
+   * @example
+   * this.registerNotificationHandler("ui/notifications/host-context-changed", (params) => {
+   *   this.handleHostContextChanged(params);
+   * });
+   */
+  registerNotificationHandler(e, t) {
+    this.notificationHandlers.has(e) || this.notificationHandlers.set(e, /* @__PURE__ */ new Set()), this.notificationHandlers.get(e).add(t);
+  }
+  /**
+   * Handle inbound JSON-RPC messages from the transport.
+   *
+   * Processes both responses (for requests) and notifications. Non-JSON-RPC
+   * payloads are silently ignored so that a shared transport can be used for
+   * multiple protocols without cross-talk.
+   */
+  onMessage = (e) => {
+    if (Q(e)) {
+      const t = this.pending.get(e.id);
+      if (!t)
+        return;
+      this.pending.delete(e.id), x(e) ? t.reject(new Error(e.error.message || "Request failed")) : t.resolve(e.result);
+      return;
+    }
+    if (Z(e)) {
+      const t = this.notificationHandlers.get(e.method);
+      t && t.forEach((n) => n(e.params));
+    }
+  };
+  /**
+   * Send a JSON-RPC request to the peer.
+   *
+   * @param method - The JSON-RPC method name
+   * @param params - The method parameters
+   * @returns Promise that resolves with the result or rejects with error
+   *
+   * @example
+   * const result = await this.request("ui/message", {
+   *   role: "user",
+   *   content: { type: "text", text: "Hello" }
+   * });
+   */
+  request(e, t) {
+    const n = this.nextRequestId++, i = {
+      jsonrpc: "2.0",
+      id: n,
+      method: e,
+      params: t
+    };
+    return new Promise((r, a) => {
+      this.pending.set(n, {
+        resolve: r,
+        reject: a
+      }), this.transport.post(i);
+    });
+  }
+  /**
+   * Send a JSON-RPC notification to the peer.
+   *
+   * Notifications are one-way messages that do not expect a response.
+   * Use notifications for:
+   * - Informing the host of state changes
+   * - Fire-and-forget operations
+   * - Events that don't require confirmation
+   *
+   * Use request() instead when you need:
+   * - A response from the host
+   * - Confirmation of success/failure
+   * - Return values from the operation
+   *
+   * @param method - The JSON-RPC method name
+   * @param params - Optional method parameters
+   *
+   * @example
+   * this.sendNotification("ui/notifications/size-changed", {
+   *   width: 800,
+   *   height: 600
+   * });
+   */
+  sendNotification(e, t) {
+    const n = {
+      jsonrpc: "2.0",
+      method: e,
+      params: t
+    };
+    this.transport.post(n);
+  }
+}
+function se() {
+}
+class Ct {
+  #e;
+  #s = /* @__PURE__ */ new Set();
+  #i = !1;
+  #n = !1;
+  /** Messages queued before `port.start()` has been called. Flushed on first subscribe. */
+  #t = [];
+  constructor(e) {
+    this.#e = e;
+  }
+  /**
+   * Post a message to the peer.
+   *
+   * Never throws on transient failure — a closed / neutered / disposed
+   * port silently drops the message. If the transport has not yet
+   * started (no `onMessage` subscriber), the message is buffered and
+   * flushed on first subscription.
+   */
+  post(e) {
+    if (!this.#n) {
+      if (!this.#i) {
+        this.#t.push(e);
+        return;
+      }
+      try {
+        this.#e.postMessage(e);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Subscribe to inbound messages from the peer. The callback receives
+   * the **unwrapped** payload (`MessageEvent.data`) — callers never see
+   * the `MessageEvent` wrapper.
+   *
+   * Starts the underlying port on first subscription and flushes any
+   * messages queued via `post` before the port was started.
+   *
+   * Returns an unsubscribe function. Calling it is idempotent.
+   */
+  onMessage(e) {
+    if (this.#n)
+      return se;
+    this.#s.add(e), this.#i || this.#o();
+    let t = !1;
+    return () => {
+      t || (t = !0, this.#s.delete(e));
+    };
+  }
+  /**
+   * Tear down the transport:
+   *  - remove the internal `message` listener
+   *  - call `port.close()`
+   *  - clear subscriber set and outbound buffer
+   *  - subsequent `post` calls silently no-op
+   *  - subsequent `onMessage` calls return a no-op unsubscribe
+   */
+  dispose() {
+    if (!this.#n) {
+      this.#n = !0;
+      try {
+        this.#e.removeEventListener("message", this.#r);
+      } catch {
+      }
+      this.#s.clear(), this.#t.length = 0;
+      try {
+        this.#e.close();
+      } catch {
+      }
+    }
+  }
+  #o() {
+    this.#i = !0, this.#e.addEventListener("message", this.#r);
+    try {
+      this.#e.start();
+    } catch {
+    }
+    if (this.#t.length > 0) {
+      const e = this.#t;
+      this.#t = [];
+      for (const t of e)
+        try {
+          this.#e.postMessage(t);
+        } catch {
+        }
+    }
+  }
+  #r = (e) => {
+    const t = [...this.#s];
+    for (const n of t)
+      try {
+        n(e.data);
+      } catch {
+      }
+  };
+}
+const ne = 500, ie = "2026-01-26";
+class g extends te {
+  static initPromise = null;
+  hostCtx = {};
+  _handshakeSucceeded = !1;
+  /**
+   * Get or create the shared session singleton.
+   *
+   * The first call performs the SEP-1865 handshake. Concurrent and subsequent
+   * calls reuse the same session and handshake result.
+   */
+  static async getInstance(e) {
+    return g.initPromise || (g.initPromise = (async () => {
+      const t = new g();
+      return await t.handshake(e), t;
+    })()), g.initPromise;
+  }
+  /**
+   * Reset the singleton (for testing only).
+   * @internal
+   */
+  static resetInstance() {
+    g.initPromise = null;
+  }
+  /**
+   * Perform the ui/initialize → hostContext → ui/notifications/initialized handshake.
+   *
+   * On success, stores the host context and sends the initialized notification.
+   * On timeout or error, falls back to an empty host context so the app can
+   * still render (graceful degradation for non-SEP-1865 hosts).
+   */
+  async handshake(e) {
+    const t = e?.handshakeTimeoutMs ?? ne, n = e?.appInfo ?? { name: "mcp-app", version: "1.0.0" };
+    try {
+      const i = /* @__PURE__ */ Symbol("timeout"), r = await Promise.race([
+        this.request("ui/initialize", {
+          protocolVersion: ie,
+          appInfo: n,
+          appCapabilities: {}
+        }),
+        new Promise((a) => setTimeout(() => a(i), t))
+      ]);
+      r !== i && (this.hostCtx = r.hostContext ?? {}, this._handshakeSucceeded = !0, this.registerNotificationHandler("ui/notifications/host-context-changed", (a) => {
+        this.hostCtx = {
+          ...this.hostCtx,
+          ...a
+        };
+      }), this.sendNotification("ui/notifications/initialized"));
+    } catch {
+    }
+  }
+  /** Returns the current host context (handshake + notification updates). */
+  getHostContext() {
+    return this.hostCtx;
+  }
+  /** Whether the ui/initialize handshake completed successfully (not timed out). */
+  get handshakeSucceeded() {
+    return this._handshakeSucceeded;
+  }
+  // ── Public wrappers ──────────────────────────────────────────────────
+  // Widen access from protected to public so SDK classes can use the
+  // shared transport without extending JsonRpcClient themselves.
+  request(e, t) {
+    return super.request(e, t);
+  }
+  sendNotification(e, t) {
+    super.sendNotification(e, t);
+  }
+  registerNotificationHandler(e, t) {
+    super.registerNotificationHandler(e, t);
+  }
+}
+const re = {
+  callTool: !0,
+  sendMessageToHost: !0,
+  readResource: !0,
+  openLink: !0,
+  accessToolInput: !0,
+  accessToolOutput: !0,
+  accessToolMetadata: !0,
+  getWidgetState: !0,
+  setWidgetState: !0,
+  onToolCanceled: !0,
+  setDisplayMode: !0,
+  getHostContext: !0,
+  subscribe: !0,
+  displayAlert: !0,
+  displayToast: !0,
+  displayModal: !1,
+  // TODO
+  getTheme: !0,
+  resize: !0
+}, oe = {
+  callTool: !0,
+  sendMessageToHost: !0,
+  readResource: !1,
+  openLink: !0,
+  accessToolInput: !0,
+  accessToolOutput: !0,
+  accessToolMetadata: !0,
+  getWidgetState: !0,
+  setWidgetState: !0,
+  onToolCanceled: !1,
+  setDisplayMode: !0,
+  getHostContext: !1,
+  subscribe: !0,
+  displayAlert: !0,
+  displayToast: !0,
+  displayModal: !0,
+  getTheme: !0,
+  resize: !1
+}, ae = {
+  callTool: !1,
+  sendMessageToHost: !0,
+  readResource: !1,
+  openLink: !0,
+  accessToolInput: !1,
+  accessToolOutput: !1,
+  accessToolMetadata: !1,
+  getWidgetState: !1,
+  setWidgetState: !1,
+  onToolCanceled: !1,
+  setDisplayMode: !1,
+  getHostContext: !1,
+  subscribe: !0,
+  displayAlert: !0,
+  displayToast: !0,
+  displayModal: !1,
+  getTheme: !0,
+  resize: !1
+}, ce = {
+  callTool: !1,
+  sendMessageToHost: !1,
+  readResource: !1,
+  openLink: !1,
+  accessToolInput: !1,
+  accessToolOutput: !1,
+  accessToolMetadata: !1,
+  getWidgetState: !1,
+  setWidgetState: !1,
+  onToolCanceled: !1,
+  setDisplayMode: !1,
+  getHostContext: !1,
+  subscribe: !1,
+  displayAlert: !1,
+  displayToast: !1,
+  displayModal: !1,
+  getTheme: !1,
+  resize: !1
+};
+function Tt(s) {
+  switch (s) {
+    case o.MCPApps:
+      return { ...re };
+    case o.OpenAI:
+      return { ...oe };
+    case o.SalesforceACC:
+      return { ...ae };
+    case o.Mosaic:
+    case o.WebApp:
+    case o.MicroFrontend:
+    default:
+      return { ...ce };
+  }
+}
+const le = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
+function A(s, e) {
+  return new Proxy(s, {
+    get(t, n, i) {
+      if (typeof n == "symbol" || le.has(n)) {
+        const r = Reflect.get(t, n, i);
+        return typeof r == "function" ? r.bind(t) : r;
+      }
+      throw new TypeError(
+        `\`${e}()\` returns a Promise — did you forget to await it?
+Use \`const sdk = await ${e}();\` before accessing SDK methods.`
+      );
+    }
+  });
+}
+class ue {
+  constructor(e) {
+    this.session = e;
+    const t = e.getHostContext();
+    t.toolOutput !== void 0 && (this.globals.toolOutput = t.toolOutput), t.toolStructuredContent !== void 0 && (this.globals.toolStructuredContent = t.toolStructuredContent), t.toolInput !== void 0 && (this.globals.toolInput = t.toolInput), t.toolResponseMetadata !== void 0 && (this.globals.toolResponseMetadata = t.toolResponseMetadata), t.widgetState !== void 0 && (this.globals.widgetState = t.widgetState), e.registerNotificationHandler(
+      "ui/notifications/host-context-changed",
+      () => this.notifySubscribers()
+    ), e.registerNotificationHandler(
+      "ui/notifications/tool-result",
+      (n) => this.handleToolResult(n)
+    ), e.registerNotificationHandler(
+      "ui/notifications/tool-input",
+      (n) => this.handleToolInput(n)
+    ), e.registerNotificationHandler(
+      "ui/notifications/tool-cancelled",
+      (n) => this.handleToolCancelled(n)
+    );
+  }
+  globals = {};
+  canceledCallbacks = /* @__PURE__ */ new Set();
+  subscriptions = /* @__PURE__ */ new Set();
+  /**
+   * Handle tool result notifications from the host
+   * @param params - Tool result data from the host
+   */
+  handleToolResult(e) {
+    const t = e;
+    let n = !1;
+    t.content !== void 0 && (this.globals.toolOutput = t.content, n = !0), t.structuredContent !== void 0 && (this.globals.toolStructuredContent = t.structuredContent, n = !0), t._meta !== void 0 && (this.globals.toolResponseMetadata = t._meta, n = !0), n && this.notifySubscribers();
+  }
+  /**
+   * Handle tool input notifications from the host
+   * @param params - Tool input data from the host
+   */
+  handleToolInput(e) {
+    const t = e;
+    t.arguments !== void 0 && Object.keys(t.arguments).length > 0 && (this.globals.toolInput = t.arguments, this.notifySubscribers());
+  }
+  /**
+   * Handle tool cancelled notifications from the host
+   * @param params - Tool cancellation data from the host
+   */
+  handleToolCancelled(e) {
+    const n = e.reason ?? "";
+    this.canceledCallbacks.forEach((i) => i(n));
+  }
+  /**
+   * Request display mode change from host
+   * @param mode - The requested display mode
+   * @returns Promise with the new display mode (confirmed by host)
+   */
+  async setDisplayMode(e) {
+    return await this.session.request("ui/request-display-mode", {
+      displayMode: e
+    });
+  }
+  async sendMessageToHost(e) {
+    await this.session.request("ui/message", {
+      role: "user",
+      content: [
+        {
+          type: "text",
+          text: e.content
+        }
+      ]
+    });
+  }
+  async callTool(e) {
+    return await this.session.request("tools/call", {
+      name: e.toolName,
+      arguments: e.params ?? {}
+    });
+  }
+  async readResource(e) {
+    return await this.session.request("resources/read", {
+      uri: e.uri
+    });
+  }
+  async openLink(e) {
+    await this.session.request("ui/open-link", { url: e });
+  }
+  accessToolInput() {
+    const e = this.globals.toolInput;
+    return e ? { data: e } : null;
+  }
+  accessToolOutput() {
+    const e = this.globals.toolStructuredContent;
+    if (e)
+      return { data: e };
+    const t = this.globals.toolOutput;
+    return t ? { data: t } : null;
+  }
+  accessToolMetadata() {
+    if (this.globals.toolResponseMetadata)
+      return this.globals.toolResponseMetadata;
+    const e = this.session.getHostContext().toolInfo;
+    return e || null;
+  }
+  getWidgetState() {
+    const e = this.globals.widgetState;
+    return e || null;
+  }
+  setWidgetState(e) {
+    this.globals.widgetState = e, this.session.request("ui/update-model-context", { state: e }).catch(() => {
+    }), this.notifySubscribers();
+  }
+  /**
+   * Get the current host context.
+   *
+   * Maps MCP Apps wire-format fields to the protocol-agnostic HostContext.
+   * Always returns an object (empty `{}` when no context has been received).
+   */
+  getHostContext() {
+    const e = this.session.getHostContext(), t = {};
+    if (e.theme !== void 0 && (t.theme = e.theme), e.displayMode !== void 0 && (t.displayMode = e.displayMode), e.containerDimensions !== void 0) {
+      const n = e.containerDimensions.maxHeight ?? e.containerDimensions.height;
+      n !== void 0 && (t.maxHeight = n);
+    }
+    return e.safeAreaInsets !== void 0 && (t.safeArea = e.safeAreaInsets), e.userAgent !== void 0 && (t.userAgent = e.userAgent), e.locale !== void 0 && (t.locale = e.locale), e.deviceCapabilities !== void 0 && (t.deviceCapabilities = e.deviceCapabilities), e.styles !== void 0 && (t.styles = e.styles), t;
+  }
+  onToolCanceled(e) {
+    return this.canceledCallbacks.add(e), () => {
+      this.canceledCallbacks.delete(e);
+    };
+  }
+  subscribe(e) {
+    return this.subscriptions.add(e), () => {
+      this.subscriptions.delete(e);
+    };
+  }
+  notifySubscribers() {
+    this.subscriptions.forEach((e) => e());
+  }
+}
+const k = "openai:set_globals";
+class de {
+  sendMessageToHost(e) {
+    return window.openai.sendFollowUpMessage({ prompt: e.content });
+  }
+  callTool(e) {
+    return window.openai.callTool(e.toolName, e.params ?? {});
+  }
+  accessToolInput() {
+    const e = window.openai.toolInput;
+    return e ? { data: e } : null;
+  }
+  accessToolOutput() {
+    const e = window.openai.toolOutput;
+    return e ? { data: e } : null;
+  }
+  accessToolMetadata() {
+    const e = window.openai.toolResponseMetadata;
+    return e || null;
+  }
+  getWidgetState() {
+    const e = window.openai.widgetState;
+    return e || null;
+  }
+  setWidgetState(e) {
+    window.openai.setWidgetState(e);
+  }
+  async openLink(e) {
+    const t = window.openai;
+    typeof t?.openExternal == "function" ? await t.openExternal({ href: e }) : window.open(e, "_blank", "noopener,noreferrer");
+  }
+  async setDisplayMode(e) {
+    return window.openai.requestDisplayMode({ mode: e });
+  }
+  subscribe(e) {
+    const t = () => e();
+    return window.addEventListener(k, t), () => {
+      window.removeEventListener(k, t);
+    };
+  }
+}
+class he {
+  async sendMessageToHost(e) {
+    throw console.warn("SalesforceACCChatSDK.sendMessageToHost: stub implementation", e), new Error("SalesforceACCChatSDK.sendMessageToHost not yet implemented");
+  }
+  followUpActions() {
+    return console.warn("SalesforceACCChatSDK.followUpActions: stub implementation"), [];
+  }
+}
+let b = null, M = null;
+function fe(s) {
+  return b || (b = pe(s).then((e) => (M = e, e))), b;
+}
+function bt() {
+  return M;
+}
+function vt() {
+  b = null, M = null;
+}
+function pe(s) {
+  return A(
+    (async () => {
+      switch (T(s?.surface)) {
+        case o.OpenAI:
+          return new de();
+        case o.WebApp:
+        case o.Mosaic:
+          return {};
+        case o.SalesforceACC:
+          return new he();
+        case o.MicroFrontend:
+        case o.MCPApps: {
+          const t = await g.getInstance(s?.mcpApps);
+          return t.handshakeSucceeded ? new ue(t) : {};
+        }
+        default:
+          return {};
+      }
+    })(),
+    "createChatSDK"
+  );
+}
+function ge(s) {
+  switch (s) {
+    case "info":
+      return "ℹ️";
+    case "success":
+      return "✅";
+    case "warning":
+      return "⚠️";
+    case "error":
+      return "❌";
+    default:
+      return "ℹ️";
+  }
+}
+function I(s, e) {
+  return `${ge(e)} ${s}`;
+}
+function D(s, e) {
+  const t = s.trim();
+  if (t === "")
+    return { success: !0, value: void 0 };
+  const n = t.match(/^(\d+(?:\.\d+)?)(px)?$/);
+  if (!n || !n[1])
+    return {
+      success: !1,
+      error: `Invalid ${e}: "${s}". Only pixel values are supported (e.g., "800px" or "800").`
+    };
+  const i = parseFloat(n[1]);
+  return i < 0 || !isFinite(i) ? {
+    success: !1,
+    error: `Invalid ${e}: "${s}". Value must be a positive number.`
+  } : { success: !0, value: i };
+}
+class me {
+  constructor(e) {
+    this.session = e;
+  }
+  /**
+   * Send a formatted message to the host via ui/message
+   * @param message - The message text
+   * @param level - The message severity level (defaults to "info")
+   */
+  async sendMessage(e, t = "info") {
+    const n = I(e, t);
+    await this.session.request("ui/message", {
+      role: "user",
+      content: [
+        {
+          type: "text",
+          text: n
+        }
+      ]
+    });
+  }
+  async displayAlert(e) {
+    await this.sendMessage(e.message, e.level);
+  }
+  async displayToast(e) {
+    await this.sendMessage(e.message, e.level);
+  }
+  async displayModal(e) {
+    return Promise.resolve();
+  }
+  getTheme() {
+    const e = this.session.getHostContext().theme;
+    return e ? { mode: e } : null;
+  }
+  async resize(e, t) {
+    const n = D(e, "width");
+    if (!n.success)
+      return Promise.reject(new Error(n.error));
+    const i = D(t, "height");
+    if (!i.success)
+      return Promise.reject(new Error(i.error));
+    const r = {};
+    return n.value !== void 0 && (r.width = n.value), i.value !== void 0 && (r.height = i.value), this.session.sendNotification("ui/notifications/size-changed", r), Promise.resolve();
+  }
+}
+class we {
+  async displayAlert(e) {
+    const t = e.level || "info", n = I(e.message, t);
+    await window.openai.sendFollowUpMessage({ prompt: n });
+  }
+  async displayToast(e) {
+    const t = e.level || "info", n = I(e.message, t);
+    await window.openai.sendFollowUpMessage({ prompt: n });
+  }
+  async displayModal(e) {
+    await window.openai.requestModal({
+      template: e.componentReference,
+      params: e.params
+    });
+  }
+  getTheme() {
+    const e = window.openai.theme;
+    return e ? { mode: e } : null;
+  }
+}
+let v = null, E = null;
+function St(s) {
+  return v || (v = ye(s).then((e) => (E = e, e))), v;
+}
+function _t() {
+  return E;
+}
+function At() {
+  v = null, E = null;
+}
+function ye(s) {
+  return A(
+    (async () => {
+      switch (T(s?.surface)) {
+        case o.OpenAI:
+          return new we();
+        case o.WebApp:
+        case o.Mosaic:
+          return {};
+        case o.SalesforceACC:
+          return {};
+        case o.MicroFrontend:
+        case o.MCPApps: {
+          const t = await g.getInstance(s?.mcpApps);
+          return t.handshakeSucceeded ? new me(t) : {};
+        }
+        default:
+          return {};
+      }
+    })(),
+    "createViewSDK"
+  );
+}
+function Ce(s) {
+  return (e) => {
+    const [t, n] = e;
+    if (typeof t == "string" && !t.startsWith("http")) {
+      const i = t.startsWith("/") ? t : `/${t}`;
+      return C([`${s}${i}`, n]);
+    }
+    return C(e);
+  };
+}
+function Te(s) {
+  return (e) => C(S("Authorization", `Bearer ${s}`, e));
+}
+function be(s, e) {
+  const t = [];
+  return s && t.push(Ce(s)), e && t.push(Te(e)), R({
+    request: t
+  }).service;
+}
+const ve = typeof __SF_API_VERSION__ < "u" ? __SF_API_VERSION__ : "65.0";
+function H(s = ve) {
+  return `/services/data/v${s}`;
+}
+class Se {
+  clientFetch;
+  pathData;
+  constructor(e) {
+    const t = _e(), n = Ae(e?.instanceUrl ?? t.instanceUrl), i = e?.accessToken ?? t.accessToken;
+    this.pathData = H(e?.apiVersion ?? t.apiVersion), this.clientFetch = be(n || void 0, i);
+  }
+  async graphql({
+    query: e,
+    variables: t,
+    operationName: n
+  }) {
+    return (await this.clientFetch(`${this.pathData}/graphql`, {
+      method: "POST",
+      body: JSON.stringify({ query: e, variables: t, operationName: n }),
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    })).json();
+  }
+}
+function _e() {
+  const s = globalThis.MOSAIC_ENV;
+  return {
+    instanceUrl: s?.instanceUrl,
+    accessToken: s?.accessToken,
+    apiVersion: s?.apiVersion
+  };
+}
+function Ae(s) {
+  if (!s || s === "/") return "";
+  let e = s;
+  return !e.startsWith("/") && !e.startsWith("http") && (e = `/${e}`), e.endsWith("/") && (e = e.slice(0, -1)), e;
+}
+const Ie = "graphqlQuery";
+class Me {
+  async graphql({
+    query: e,
+    variables: t,
+    operationName: n
+  }) {
+    return (await window.openai.callTool(Ie, {
+      query: e,
+      ...t != null ? { variables: t } : {},
+      ...n != null ? { operationName: n } : {}
+    })).structuredContent;
+  }
+}
+const Ee = "X-SFDC-Client-Name", ke = "X-SFDC-Client-Version", De = "@salesforce/platform-sdk", Pe = "3.0.0", Le = (s) => {
+  let e = S(Ee, De, s);
+  return e = S(ke, Pe, e), C(e);
+}, Re = "X-CSRF-Token";
+function xe(s, e = {}) {
+  const { protectedUrls: t = [], alwaysProtectedUrls: n = [] } = e;
+  return async (i) => {
+    const [r, a] = i, c = new Request(r, a);
+    if (P(n, c.url) || He(c.method) && P(t, c.url)) {
+      const d = await s.getToken();
+      i = S(Re, d, i);
+    }
+    return C(i);
+  };
+}
+function He(s) {
+  const e = s.toLowerCase();
+  return e === "post" || e === "put" || e === "patch" || e === "delete";
+}
+function P(s, e) {
+  const t = new URL(e);
+  return s.some((n) => t.pathname.includes(n));
+}
+function Oe(s, e = {}) {
+  const t = xe(s, e);
+  async function n(i) {
+    const r = await t(i);
+    return fetch(r[0], r[1]);
+  }
+  return (i, r) => r ? r.applyRetry(async () => n(i)) : n(i);
+}
+const Fe = [400, 401, 403];
+class Ne extends N {
+  constructor(e) {
+    super(e), this.csrfTokenManager = e;
+  }
+  /**
+   * Determines if a failed request should be retried due to CSRF token issues.
+   */
+  async shouldRetry(e, t) {
+    return t.attempt >= 1 ? !1 : Fe.includes(e.status);
+  }
+  /**
+   * CSRF token refresh should happen immediately with no delay.
+   */
+  async calculateDelay(e, t) {
+    return 0;
+  }
+  /**
+   * Called by retry service before each retry attempt.
+   *
+   * @param _result - The failed response that triggered the retry (unused, already validated)
+   * @param _context - Current retry context (unused but part of interface)
+   */
+  async prepareRetry(e, t) {
+    await this.csrfTokenManager.refreshToken();
+  }
+}
+class Ue {
+  constructor(e, t) {
+    this.endpoint = e, this.cacheName = t, this.tokenPromise = this.obtainToken();
+  }
+  tokenPromise;
+  refreshPromise;
+  /**
+   * Returns the current token value as a Promise.
+   * Lazy-loads the token on first call (from cache or by fetching).
+   */
+  async getToken() {
+    return this.tokenPromise;
+  }
+  /**
+   * Obtains and returns a new token value as a promise.
+   * This will clear the cached token and fetch a fresh one.
+   * If a refresh is already in progress, all callers share the same in-flight promise.
+   */
+  refreshToken() {
+    return this.refreshPromise || (this.refreshPromise = this.withCache((e) => e.delete(this.endpoint)).then(() => (this.tokenPromise = this.obtainToken(), this.tokenPromise)).finally(() => {
+      this.refreshPromise = void 0;
+    })), this.refreshPromise;
+  }
+  /**
+   * Obtains a CSRF token, using cache when available or fetching a new one.
+   *
+   * @returns Promise that resolves to the CSRF token string
+   */
+  async obtainToken() {
+    let e = await this.withCache((i) => i.match(this.endpoint)), t = !1;
+    e || (e = await fetch(this.endpoint, { method: "get" }), t = !0);
+    const n = (await e.clone().json()).csrfToken;
+    return t && await this.withCache((i) => i.put(this.endpoint, e)), n;
+  }
+  /**
+   * Provides a safe way to interact with the Cache API with fallback for unsupported environments.
+   *
+   * @param callback - Function that receives the cache instance and returns a promise
+   * @returns The result of the callback, or undefined if caches API is not available
+   */
+  async withCache(e) {
+    if (this.cacheName && caches) {
+      const t = await caches.open(this.cacheName);
+      return e(t);
+    } else
+      return;
+  }
+}
+const L = /* @__PURE__ */ new Map();
+function qe(s) {
+  const { endpoint: e, cacheName: t, ...n } = s.csrf;
+  let i = L.get(e);
+  return i || (i = new Ue(e, t), L.set(e, i)), R(
+    {
+      retry: Oe(i, n),
+      request: [Le]
+    },
+    U(new Ne(i)).service
+  ).service;
+}
+function We() {
+  return {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "X-Chatter-Entity-Encoding": "false"
+  };
+}
+const Ve = 1, $e = `@salesforce/platform-sdk_v${Ve}`, O = H(), Be = `${O}/ui-api`;
+class Ke {
+  baseUrl;
+  clientFetch;
+  onStatus;
+  constructor(e) {
+    const t = je();
+    this.baseUrl = ze(e?.basePath ?? t.apiPath), this.onStatus = e?.onStatus ?? {}, this.clientFetch = qe({
+      csrf: {
+        endpoint: `${this.baseUrl}${Be}/session/csrf`,
+        cacheName: $e,
+        protectedUrls: ["services/data/v", "services/apexrest"],
+        alwaysProtectedUrls: ["services/apexrest"]
+      }
+    });
+  }
+  async graphql({
+    query: e,
+    variables: t,
+    operationName: n
+  }) {
+    return (await this.fetch(`${O}/graphql`, {
+      method: "POST",
+      body: JSON.stringify({ query: e, variables: t, operationName: n }),
+      headers: We()
+    })).json();
+  }
+  async fetch(e, t) {
+    const n = this.applySalesforceBase(e), i = await this.clientFetch(n, t);
+    return await this.onStatus[i.status]?.(), i;
+  }
+  /**
+   * If the url is relative, convert to it to an absolute Salesforce URL.  This is due to the way Code
+   * Builder deployments structure the url for Salesforce
+   */
+  applySalesforceBase(e) {
+    if (typeof e == "string") {
+      if (e.startsWith("http"))
+        return e;
+      const t = e.startsWith("/") ? e : `/${e}`;
+      return `${this.baseUrl}${t}`;
+    }
+    return e;
+  }
+}
+function je() {
+  return {
+    apiPath: globalThis.SFDC_ENV?.apiPath
+  };
+}
+function ze(s) {
+  if (!s || s === "/") return "";
+  let e = s;
+  return e.startsWith("/") || (e = `/${e}`), e.endsWith("/") && (e = e.slice(0, -1)), e;
+}
+function It(s, ...e) {
+  let t = s[0] ?? "";
+  for (let n = 0; n < e.length; n += 1)
+    t += String(e[n]) + (s[n + 1] ?? "");
+  return t;
+}
+function Mt(s) {
+  return A(
+    (async () => {
+      switch (T(s?.surface)) {
+        case o.OpenAI:
+          return new Me();
+        case o.WebApp:
+        case o.MicroFrontend:
+          return new Ke(s?.webapp);
+        case o.Mosaic:
+          return new Se(s?.mosaic);
+        case o.SalesforceACC:
+        case o.MCPApps:
+          return {};
+        default:
+          return {};
+      }
+    })(),
+    "createDataSDK"
+  );
+}
+function Et(s) {
+  return A(
+    (async () => {
+      switch (T(s?.surface)) {
+        case o.OpenAI:
+          return {};
+        case o.WebApp:
+          return {};
+        case o.MicroFrontend:
+          return {};
+        case o.SalesforceACC:
+          return {};
+        case o.MCPApps:
+          return {};
+        case o.Mosaic:
+          return {};
+        default:
+          return {};
+      }
+    })(),
+    "createLightningSDK"
+  );
+}
+class Je {
+  buffer;
+  constructor(e) {
+    this.buffer = e;
+  }
+  wrapAction(e) {
+    if (this.buffer.isEmpty)
+      return e;
+    const t = { envelopes: this.buffer.drain() };
+    return { ...e, _telemetry: t };
+  }
+}
+function Xe(s) {
+  let e = "";
+  for (let n = 0; n < s.length; n += 8192)
+    e += String.fromCharCode.apply(null, Array.from(s.subarray(n, n + 8192)));
+  return btoa(e);
+}
+class Ye {
+  entries = [];
+  totalBytes = 0;
+  maxBufferSize;
+  onError;
+  constructor(e) {
+    this.maxBufferSize = e.maxBufferSize, this.onError = e.onError;
+  }
+  get size() {
+    return this.totalBytes;
+  }
+  get isEmpty() {
+    return this.entries.length === 0;
+  }
+  enqueue(e, t) {
+    const n = Xe(e), i = {
+      data: n,
+      traceId: t?.traceId,
+      instanceId: t?.instanceId,
+      componentRef: t?.componentRef,
+      timestamp: Date.now()
+    }, r = n.length;
+    this.entries.push(i), this.totalBytes += r, this.totalBytes > this.maxBufferSize && this.evict();
+  }
+  drain() {
+    const e = this.entries;
+    return this.entries = [], this.totalBytes = 0, e;
+  }
+  evict() {
+    let e = 0;
+    for (; this.totalBytes > this.maxBufferSize && this.entries.length > 1; ) {
+      const t = this.entries.shift();
+      this.totalBytes -= t.data.length, e++;
+    }
+    e > 0 && this.onError?.({ reason: "buffer_overflow", droppedCount: e });
+  }
+}
+class Ge {
+  buffer;
+  sdk;
+  timerId = null;
+  disposed = !1;
+  handleVisibilityChange = () => {
+    document.visibilityState === "hidden" && this.flush();
+  };
+  handlePageHide = () => {
+    this.flush();
+  };
+  constructor(e, t, n) {
+    this.buffer = e, this.sdk = t, this.timerId = setInterval(() => this.flush(), n), document.addEventListener("visibilitychange", this.handleVisibilityChange), window.addEventListener("pagehide", this.handlePageHide);
+  }
+  flush() {
+    if (this.buffer.isEmpty || !this.sdk.setWidgetState)
+      return;
+    const e = { envelopes: this.buffer.drain() }, t = this.sdk.getWidgetState?.() ?? {};
+    this.sdk.setWidgetState({ ...t, _telemetry: e });
+  }
+  dispose() {
+    this.disposed || (this.disposed = !0, this.timerId !== null && (clearInterval(this.timerId), this.timerId = null), document.removeEventListener("visibilitychange", this.handleVisibilityChange), window.removeEventListener("pagehide", this.handlePageHide), this.flush());
+  }
+}
+const Qe = 65536, Ze = 3e4;
+function kt(s) {
+  const {
+    sdk: e,
+    flushOnAction: t = !0,
+    maxBufferSize: n = Qe,
+    flushInterval: i = Ze,
+    onError: r
+  } = s, a = new Ye({ maxBufferSize: n, onError: r }), c = new Je(a), h = new Ge(a, e, i);
+  return {
+    enqueue(d, m) {
+      a.enqueue(d, m);
+    },
+    wrapAction(d) {
+      return t ? c.wrapAction(d) : d;
+    },
+    dispose() {
+      h.dispose();
+    }
+  };
+}
+const et = 1e4, tt = 10, st = 10, nt = 250, it = 1e3;
+function y(s, e) {
+  if (s !== void 0 && (typeof s != "number" || !Number.isFinite(s) || s <= 0))
+    throw new Error(`${e}, if defined, must be a finite number greater than 0`);
+}
+function rt(s, e) {
+  if (typeof s != "function")
+    throw new Error(`${e} must be a function`);
+}
+class ot {
+  _collector;
+  _onEnvelope;
+  _onError;
+  _enableClickTrigger;
+  _enableVisibilityTrigger;
+  _messagesLimit;
+  _metricsLimit;
+  _uploadInterval;
+  _clickUploadDelay;
+  _clickTriggerCooldown;
+  _boundClickListener = this._handleClick.bind(this);
+  _boundVisibilityChangeListener = this._handleVisibilityChange.bind(this);
+  _boundPageHideListener = this._handlePageHide.bind(this);
+  _intervalHandle;
+  _clickTimeoutHandle;
+  _flushPromise;
+  _pendingFlushReason;
+  _lastClickTriggeredAt = 0;
+  _isDisposed = !1;
+  constructor(e) {
+    rt(e?.onEnvelope, "options.onEnvelope"), y(e.uploadInterval, "options.uploadInterval"), y(e.messagesLimit, "options.messagesLimit"), y(e.metricsLimit, "options.metricsLimit"), y(e.maxUniqueSchemas, "options.maxUniqueSchemas"), y(e.clickUploadDelay, "options.clickUploadDelay"), y(e.clickTriggerCooldown, "options.clickTriggerCooldown"), this._onEnvelope = e.onEnvelope, this._onError = e.onError, this._messagesLimit = e.messagesLimit ?? tt, this._metricsLimit = e.metricsLimit ?? st, this._uploadInterval = e.uploadInterval ?? et, this._clickUploadDelay = e.clickUploadDelay ?? nt, this._clickTriggerCooldown = e.clickTriggerCooldown ?? it, this._enableClickTrigger = e.enableClickTrigger !== !1, this._enableVisibilityTrigger = e.enableVisibilityTrigger !== !1, this._collector = new W({
+      environment: e.environment,
+      maxUniqueSchemas: e.maxUniqueSchemas
+    }), this._restartInterval(), this._attachWindowListeners();
+  }
+  get hasData() {
+    return this._collector.hasData;
+  }
+  get estimatedByteSize() {
+    return this._collector.estimatedByteSize;
+  }
+  get messagesCount() {
+    return this._collector.messagesCount;
+  }
+  get metricsCount() {
+    return this._collector.metricsCount;
+  }
+  getIsCollectDisabled() {
+    return this._isDisposed;
+  }
+  collect(e, t, n) {
+    this._collector.collect(e, t, n), this._shouldFlushForThreshold() && this.flush("threshold");
+  }
+  receiveMetricsExtractors(e) {
+    this._collector.receiveMetricsExtractors(e);
+  }
+  async flush(e = "manual") {
+    return this._flushPromise ? (this._pendingFlushReason = this._pendingFlushReason ?? e, this._flushPromise) : (this._flushPromise = this._flushInternal(e).then(() => {
+      const t = this._pendingFlushReason;
+      this._pendingFlushReason = void 0, t && this.hasData && !this._isDisposed && this.flush(t);
+    }).finally(() => {
+      this._flushPromise = void 0;
+    }), this._flushPromise);
+  }
+  async dispose(e) {
+    this._isDisposed = !0, this._detachWindowListeners(), this._stopInterval(), this._clickTimeoutHandle !== void 0 && (clearTimeout(this._clickTimeoutHandle), this._clickTimeoutHandle = void 0), e?.flush !== !1 && this.hasData && await this.flush("dispose");
+  }
+  _attachWindowListeners() {
+    typeof document == "object" && this._enableClickTrigger && document.addEventListener("click", this._boundClickListener, !0), typeof window == "object" && this._enableVisibilityTrigger && (document.addEventListener("visibilitychange", this._boundVisibilityChangeListener, !0), window.addEventListener("pagehide", this._boundPageHideListener, !0));
+  }
+  _detachWindowListeners() {
+    typeof document == "object" && (document.removeEventListener("click", this._boundClickListener, !0), document.removeEventListener("visibilitychange", this._boundVisibilityChangeListener, !0)), typeof window == "object" && window.removeEventListener("pagehide", this._boundPageHideListener, !0);
+  }
+  _handleClick() {
+    !this.hasData || this._isDisposed || Date.now() - this._lastClickTriggeredAt < this._clickTriggerCooldown || (this._clickTimeoutHandle !== void 0 && clearTimeout(this._clickTimeoutHandle), this._clickTimeoutHandle = setTimeout(() => {
+      this._clickTimeoutHandle = void 0, !(!this.hasData || this._isDisposed) && (this._lastClickTriggeredAt = Date.now(), this.flush("click"));
+    }, this._clickUploadDelay));
+  }
+  _handleVisibilityChange() {
+    typeof document != "object" || document.visibilityState !== "hidden" || !this.hasData || this.flush("visibilitychange");
+  }
+  _handlePageHide() {
+    this.hasData && this.flush("pagehide");
+  }
+  _restartInterval() {
+    this._stopInterval(), this._intervalHandle = setInterval(() => {
+      this.hasData && !this._isDisposed && this.flush("interval");
+    }, this._uploadInterval);
+  }
+  _stopInterval() {
+    this._intervalHandle !== void 0 && (clearInterval(this._intervalHandle), this._intervalHandle = void 0);
+  }
+  _shouldFlushForThreshold() {
+    return this.messagesCount >= this._messagesLimit || this.metricsCount >= this._metricsLimit;
+  }
+  async _flushInternal(e) {
+    if (!this.hasData)
+      return;
+    const t = {
+      reason: e,
+      messagesCount: this.messagesCount,
+      metricsCount: this.metricsCount,
+      estimatedByteSize: this.estimatedByteSize,
+      triggeredAt: Date.now()
+    }, n = this._collector.getRawContentsOfCoreEnvelope(), i = q(n);
+    this._restartInterval();
+    try {
+      await this._onEnvelope(i, t);
+    } catch (r) {
+      const a = {
+        ...t,
+        error: r
+      };
+      throw this._onError?.(a), r;
+    }
+  }
+}
+function at(s, e) {
+  if (!s)
+    throw new Error("instrumentedApp is required");
+  const t = new ot(e);
+  return s.registerLogCollector(t), s.registerMetricsCollector(t), e.enableClickTrigger !== !1 && s.activateClickTracker?.(), t;
+}
+function ct(s) {
+  const e = (n, i, r, a, c) => {
+    s.error(c ?? n);
+  }, t = (n) => {
+    s.error(n.reason);
+  };
+  return window.addEventListener("error", e), window.addEventListener("unhandledrejection", t), () => {
+    window.removeEventListener("error", e), window.removeEventListener("unhandledrejection", t);
+  };
+}
+function p(s, e) {
+  return { surface: e };
+}
+const lt = {
+  callTool: {
+    isAsync: !0,
+    extractTags: (s, e) => ({ toolName: s[0]?.toolName ?? "unknown", surface: e })
+  },
+  setWidgetState: {
+    isAsync: !1,
+    extractTags: p
+  },
+  getWidgetState: {
+    isAsync: !1,
+    extractTags: p
+  },
+  sendMessageToHost: {
+    isAsync: !0,
+    extractTags: p
+  },
+  openLink: {
+    isAsync: !0,
+    extractTags: p
+  },
+  subscribe: {
+    isAsync: !1,
+    extractTags: p,
+    wrapArgs: (s, e) => {
+      const t = s[0];
+      return [
+        () => {
+          e.activity("sdk.subscribe_callback", () => t());
+        }
+      ];
+    }
+  },
+  readResource: {
+    isAsync: !0,
+    extractTags: (s, e) => ({ uri: s[0]?.uri ?? "unknown", surface: e })
+  },
+  setDisplayMode: {
+    isAsync: !0,
+    extractTags: (s, e) => ({ mode: s[0] ?? "unknown", surface: e })
+  },
+  accessToolOutput: {
+    isAsync: !1,
+    extractTags: p
+  },
+  accessToolInput: {
+    isAsync: !1,
+    extractTags: p
+  },
+  accessToolMetadata: {
+    isAsync: !1,
+    extractTags: p
+  }
+};
+function ut(s, e, t) {
+  return new Proxy(s, {
+    get(n, i, r) {
+      const a = Reflect.get(n, i, r), c = lt[i];
+      return !c || typeof a != "function" ? a : (...h) => {
+        const d = c.extractTags(h, t), m = c.wrapArgs ? c.wrapArgs(h, e) : h, w = `sdk.${String(i)}`;
+        return c.isAsync ? e.activityAsync(w, async () => {
+          try {
+            const f = await a.apply(
+              n,
+              m
+            );
+            return e.incrementCounter(w, 1, !1, d), f;
+          } catch (f) {
+            throw e.incrementCounter(w, 1, !0, d), f;
+          }
+        }) : (e.incrementCounter(w, 1, !1, d), a.apply(n, m));
+      };
+    }
+  });
+}
+async function Dt(s) {
+  const { appId: e, clientSessionId: t } = s, n = T(), i = Date.now(), r = s.sdk ?? await fe(), a = V("mcp-widget", {
+    appPayloadProvider: {
+      getPayload: () => ({
+        schema: $,
+        payload: { appId: e, surface: n }
+      })
+    },
+    clientSessionId: t
+  }), c = a, h = ut(r, c, n), d = ct(c);
+  let m;
+  if (s.transport) {
+    m = at(a, {
+      onEnvelope: (u) => {
+        s.transport.enqueue(u);
+      }
+    });
+    const l = h.callTool;
+    l && (h.callTool = (u) => {
+      const F = s.transport.wrapAction(u.params ?? {});
+      return l.call(h, {
+        ...u,
+        params: F
+      });
+    });
+  }
+  let w, f = !1;
+  return {
+    instrumentedSDK: h,
+    app: a,
+    trackEvent(l, u) {
+      f || c.log(J, {
+        eventName: l,
+        properties: u ? JSON.stringify(u) : ""
+      });
+    },
+    trackInteraction(l, u) {
+      f || c.log(z, {
+        elementId: l,
+        properties: u ? JSON.stringify(u) : ""
+      });
+    },
+    trackError(l, u) {
+      f || c.error(l, j, {
+        properties: u ? JSON.stringify(u) : ""
+      });
+    },
+    trackPageView(l) {
+      f || l !== w && (w = l, c.log(K, { componentRef: l }));
+    },
+    dispose() {
+      if (f) return;
+      f = !0, d();
+      const l = Date.now() - i;
+      c.log(B, { durationMs: l }), m?.dispose();
+    }
+  };
+}
+export {
+  te as JsonRpcClient,
+  ue as MCPAppsChatSDK,
+  me as MCPAppsViewSDK,
+  g as McpAppsSession,
+  Ct as MessageChannelTransport,
+  o as Surface,
+  ot as TelemetryUploader,
+  ee as WindowPostMessageTransport,
+  Dt as createAnalytics,
+  pe as createChatSDK,
+  Mt as createDataSDK,
+  Et as createLightningSDK,
+  kt as createTelemetryTransport,
+  ye as createViewSDK,
+  fe as getChatSDK,
+  bt as getChatSDKSync,
+  T as getSurface,
+  Tt as getSurfaceCapabilities,
+  St as getViewSDK,
+  _t as getViewSDKSync,
+  It as gql,
+  _ as isJsonRpcBase,
+  x as isJsonRpcErrorResponse,
+  Z as isJsonRpcNotification,
+  yt as isJsonRpcRequest,
+  Q as isJsonRpcResponse,
+  G as isJsonRpcSuccessResponse,
+  at as registerTelemetryUploader,
+  vt as resetChatSDK,
+  At as resetViewSDK,
+  A as wrapSDKPromise
+};