@salesforce/platform-sdk 9.14.0 → 9.16.0

package/dist/lightning/index.js

@@ -0,0 +1,27 @@
+import { w as a, g as c, S as e } from "../sdk-promise-7SpSqah5.js";
+function s(r) {
+  return a(
+    (async () => {
+      switch (c(r?.surface)) {
+        case e.OpenAI:
+          return {};
+        case e.WebApp:
+          return {};
+        case e.MicroFrontend:
+          return {};
+        case e.SalesforceACC:
+          return {};
+        case e.MCPApps:
+          return {};
+        case e.Mosaic:
+          return {};
+        default:
+          return {};
+      }
+    })(),
+    "createLightningSDK"
+  );
+}
+export {
+  s as createLightningSDK
+};

package/dist/mcpapps-session-BOT5CvWa.js

@@ -0,0 +1,241 @@
+function d(n) {
+  return typeof n == "object" && n !== null && !Array.isArray(n);
+}
+function u(n) {
+  return typeof n.id == "number" && Number.isInteger(n.id) && n.id >= 0;
+}
+function c(n) {
+  return d(n) && n.jsonrpc === "2.0";
+}
+function f(n) {
+  if (!c(n)) return !1;
+  const t = n;
+  return !("id" in t) && typeof t.method == "string";
+}
+function l(n) {
+  if (!c(n)) return !1;
+  const t = n;
+  return u(t) && "result" in t && !("error" in t) && !("method" in t);
+}
+function h(n) {
+  if (!c(n)) return !1;
+  const t = n;
+  if (!u(t) || "result" in t || "method" in t) return !1;
+  const e = t.error;
+  return d(e) && typeof e.code == "number";
+}
+function g(n) {
+  return l(n) || h(n);
+}
+class m {
+  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.
+   */
+  constructor(t) {
+    this.transport = t, 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(t, e) {
+    this.notificationHandlers.has(t) || this.notificationHandlers.set(t, /* @__PURE__ */ new Set()), this.notificationHandlers.get(t).add(e);
+  }
+  /**
+   * 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 = (t) => {
+    if (g(t)) {
+      const e = this.pending.get(t.id);
+      if (!e)
+        return;
+      this.pending.delete(t.id), h(t) ? e.reject(new Error(t.error.message || "Request failed")) : e.resolve(t.result);
+      return;
+    }
+    if (f(t)) {
+      const e = this.notificationHandlers.get(t.method);
+      e && e.forEach((i) => i(t.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(t, e) {
+    const i = this.nextRequestId++, o = {
+      jsonrpc: "2.0",
+      id: i,
+      method: t,
+      params: e
+    };
+    return new Promise((a, s) => {
+      this.pending.set(i, {
+        resolve: a,
+        reject: s
+      }), this.transport.post(o);
+    });
+  }
+  /**
+   * 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(t, e) {
+    const i = {
+      jsonrpc: "2.0",
+      method: t,
+      params: e
+    };
+    this.transport.post(i);
+  }
+}
+class p {
+  targetOrigin;
+  /**
+   * @param targetOrigin - origin passed as the second argument to
+   *   `window.parent.postMessage`.
+   */
+  constructor(t) {
+    this.targetOrigin = t;
+  }
+  post(t) {
+    window.parent?.postMessage(t, this.targetOrigin);
+  }
+  onMessage(t) {
+    const e = (i) => {
+      t(i.data);
+    };
+    return window.addEventListener("message", e), () => window.removeEventListener("message", e);
+  }
+}
+const w = 500, x = "2026-01-26";
+class r extends m {
+  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.
+   *
+   * @param options - Optional configuration. `targetOrigin` defaults to `"*"`
+   *   when omitted; pin to the concrete MCP host origin whenever known.
+   */
+  static async getInstance(t) {
+    if (!r.initPromise) {
+      const e = t?.targetOrigin ?? "*";
+      r.initPromise = (async () => {
+        const i = new r(new p(e));
+        return await i.handshake(t), i;
+      })();
+    }
+    return r.initPromise;
+  }
+  /**
+   * Reset the singleton (for testing only).
+   * @internal
+   */
+  static resetInstance() {
+    r.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(t) {
+    const e = t?.handshakeTimeoutMs ?? w, i = t?.appInfo ?? { name: "mcp-app", version: "1.0.0" };
+    try {
+      const o = /* @__PURE__ */ Symbol("timeout"), a = await Promise.race([
+        this.request("ui/initialize", {
+          protocolVersion: x,
+          appInfo: i,
+          appCapabilities: {}
+        }),
+        new Promise((s) => setTimeout(() => s(o), e))
+      ]);
+      a !== o && (this.hostCtx = a.hostContext ?? {}, this._handshakeSucceeded = !0, this.registerNotificationHandler("ui/notifications/host-context-changed", (s) => {
+        this.hostCtx = {
+          ...this.hostCtx,
+          ...s
+        };
+      }), 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(t, e) {
+    return super.request(t, e);
+  }
+  sendNotification(t, e) {
+    super.sendNotification(t, e);
+  }
+  registerNotificationHandler(t, e) {
+    super.registerNotificationHandler(t, e);
+  }
+}
+export {
+  r as M
+};

package/dist/sdk-promise-7SpSqah5.js

@@ -0,0 +1,39 @@
+var s = /* @__PURE__ */ ((e) => (e.WebApp = "WebApp", e.MicroFrontend = "Micro-Frontend", e.OpenAI = "OpenAI", e.SalesforceACC = "Salesforce-ACC", e.MCPApps = "MCP-Apps", e.Mosaic = "Mosaic", e))(s || {});
+const c = a();
+function a() {
+  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 e = window;
+  return e.$A || e.Aura ? "Salesforce-ACC" : "WebApp";
+}
+function f(e) {
+  return e ?? c;
+}
+const w = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
+function d(e, o) {
+  return new Proxy(e, {
+    get(r, n, i) {
+      if (typeof n == "symbol" || w.has(n)) {
+        const t = Reflect.get(r, n, i);
+        return typeof t == "function" ? t.bind(r) : t;
+      }
+      throw new TypeError(
+        `\`${o}()\` returns a Promise — did you forget to await it?
+Use \`const sdk = await ${o}();\` before accessing SDK methods.`
+      );
+    }
+  });
+}
+export {
+  s as S,
+  f as g,
+  d as w
+};

package/dist/telemetry/index.js

@@ -0,0 +1,7 @@
+import { c as t } from "../transport-D8xgRy7y.js";
+import { T as o, r as l } from "../TelemetryUploader-DKkdppe9.js";
+export {
+  o as TelemetryUploader,
+  t as createTelemetryTransport,
+  l as registerTelemetryUploader
+};

package/dist/transport-D8xgRy7y.js

@@ -0,0 +1,95 @@
+function l(s) {
+  let e = "";
+  for (let t = 0; t < s.length; t += 8192)
+    e += String.fromCharCode.apply(null, Array.from(s.subarray(t, t + 8192)));
+  return btoa(e);
+}
+class d {
+  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, i) {
+    const t = l(e), r = {
+      data: t,
+      traceId: i?.traceId,
+      instanceId: i?.instanceId,
+      componentRef: i?.componentRef,
+      timestamp: Date.now()
+    }, n = t.length;
+    this.entries.push(r), this.totalBytes += n, 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 i = this.entries.shift();
+      this.totalBytes -= i.data.length, e++;
+    }
+    e > 0 && this.onError?.({ reason: "buffer_overflow", droppedCount: e });
+  }
+}
+const u = "telemetry/upload";
+class f {
+  buffer;
+  sdk;
+  onError;
+  timerId = null;
+  disposed = !1;
+  handleVisibilityChange = () => {
+    document.visibilityState === "hidden" && this.flush();
+  };
+  handlePageHide = () => {
+    this.flush();
+  };
+  constructor(e, i, t) {
+    this.buffer = e, this.sdk = i, this.onError = t.onError, this.timerId = setInterval(() => this.flush(), t.flushInterval), document.addEventListener("visibilitychange", this.handleVisibilityChange), window.addEventListener("pagehide", this.handlePageHide);
+  }
+  flush() {
+    if (this.buffer.isEmpty || !this.sdk.callTool)
+      return;
+    const i = this.buffer.drain().map(c);
+    this.sdk.callTool({ toolName: u, params: { inputs: [{ envelopes: i }] } }).catch((t) => {
+      this.onError?.({ reason: "tool_call_failed", error: t });
+    });
+  }
+  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());
+  }
+}
+function c(s) {
+  const e = { base64Env: s.data };
+  return s.traceId !== void 0 && (e.traceId = s.traceId), e;
+}
+const m = 65536, p = 3e4;
+function y(s) {
+  const {
+    sdk: e,
+    maxBufferSize: i = m,
+    flushInterval: t = p,
+    onError: r
+  } = s, n = new d({ maxBufferSize: i, onError: r }), o = new f(n, e, { flushInterval: t, onError: r });
+  return {
+    enqueue(a, h) {
+      n.enqueue(a, h);
+    },
+    dispose() {
+      o.dispose();
+    }
+  };
+}
+export {
+  y as c
+};

package/dist/view/index.js

@@ -0,0 +1,140 @@
+import { w as p, g as d, S as a } from "../sdk-promise-7SpSqah5.js";
+import { M as m } from "../mcpapps-session-BOT5CvWa.js";
+function f(s) {
+  switch (s) {
+    case "info":
+      return "ℹ️";
+    case "success":
+      return "✅";
+    case "warning":
+      return "⚠️";
+    case "error":
+      return "❌";
+    default:
+      return "ℹ️";
+  }
+}
+function c(s, e) {
+  return `${f(e)} ${s}`;
+}
+function l(s, e) {
+  const t = s.trim();
+  if (t === "")
+    return { success: !0, value: void 0 };
+  const r = t.match(/^(\d+(?:\.\d+)?)(px)?$/);
+  if (!r || !r[1])
+    return {
+      success: !1,
+      error: `Invalid ${e}: "${s}". Only pixel values are supported (e.g., "800px" or "800").`
+    };
+  const n = parseFloat(r[1]);
+  return n < 0 || !isFinite(n) ? {
+    success: !1,
+    error: `Invalid ${e}: "${s}". Value must be a positive number.`
+  } : { success: !0, value: n };
+}
+class w {
+  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 r = c(e, t);
+    await this.session.request("ui/message", {
+      role: "user",
+      content: [
+        {
+          type: "text",
+          text: r
+        }
+      ]
+    });
+  }
+  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 r = l(e, "width");
+    if (!r.success)
+      return Promise.reject(new Error(r.error));
+    const n = l(t, "height");
+    if (!n.success)
+      return Promise.reject(new Error(n.error));
+    const o = {};
+    return r.value !== void 0 && (o.width = r.value), n.value !== void 0 && (o.height = n.value), this.session.sendNotification("ui/notifications/size-changed", o), Promise.resolve();
+  }
+}
+class h {
+  async displayAlert(e) {
+    const t = e.level || "info", r = c(e.message, t);
+    await window.openai.sendFollowUpMessage({ prompt: r });
+  }
+  async displayToast(e) {
+    const t = e.level || "info", r = c(e.message, t);
+    await window.openai.sendFollowUpMessage({ prompt: r });
+  }
+  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 i = null, u = null;
+function M(s) {
+  return i || (i = g(s).then((e) => (u = e, e))), i;
+}
+function S() {
+  return u;
+}
+function A() {
+  i = null, u = null;
+}
+function g(s) {
+  return p(
+    (async () => {
+      switch (d(s?.surface)) {
+        case a.OpenAI:
+          return new h();
+        case a.WebApp:
+        case a.Mosaic:
+          return {};
+        case a.SalesforceACC:
+          return {};
+        case a.MicroFrontend:
+        case a.MCPApps: {
+          const t = await m.getInstance(s?.mcpApps);
+          return t.handshakeSucceeded ? new w(t) : {};
+        }
+        default:
+          return {};
+      }
+    })(),
+    "createViewSDK"
+  );
+}
+export {
+  w as MCPAppsViewSDK,
+  g as createViewSDK,
+  M as getViewSDK,
+  S as getViewSDKSync,
+  A as resetViewSDK
+};

package/package.json

@@ -1,19 +1,79 @@
 {
   "name": "@salesforce/platform-sdk",
-  "version": "9.14.0",
+  "version": "9.16.0",
   "license": "SEE LICENSE IN LICENSE.txt",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "sideEffects": false,
+  "typesVersions": {
+    "*": {
+      "core": [
+        "./dist/core/index.d.ts"
+      ],
+      "chat": [
+        "./dist/chat/index.d.ts"
+      ],
+      "view": [
+        "./dist/view/index.d.ts"
+      ],
+      "data": [
+        "./dist/data/index.d.ts"
+      ],
+      "lightning": [
+        "./dist/lightning/index.d.ts"
+      ],
+      "telemetry": [
+        "./dist/telemetry/index.d.ts"
+      ],
+      "analytics": [
+        "./dist/analytics/index.d.ts"
+      ]
+    }
+  },
   "exports": {
-    "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
-    }
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js",
+      "default": "./dist/core/index.js"
+    },
+    "./chat": {
+      "types": "./dist/chat/index.d.ts",
+      "import": "./dist/chat/index.js",
+      "default": "./dist/chat/index.js"
+    },
+    "./view": {
+      "types": "./dist/view/index.d.ts",
+      "import": "./dist/view/index.js",
+      "default": "./dist/view/index.js"
+    },
+    "./data": {
+      "types": "./dist/data/index.d.ts",
+      "import": "./dist/data/index.js",
+      "default": "./dist/data/index.js"
+    },
+    "./lightning": {
+      "types": "./dist/lightning/index.d.ts",
+      "import": "./dist/lightning/index.js",
+      "default": "./dist/lightning/index.js"
+    },
+    "./telemetry": {
+      "types": "./dist/telemetry/index.d.ts",
+      "import": "./dist/telemetry/index.js",
+      "default": "./dist/telemetry/index.js"
+    },
+    "./analytics": {
+      "types": "./dist/analytics/index.d.ts",
+      "import": "./dist/analytics/index.js",
+      "default": "./dist/analytics/index.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist"
@@ -36,7 +96,7 @@
     "@conduit-client/service-pubsub": "3.19.6",
     "@conduit-client/service-retry": "3.19.6",
     "@conduit-client/utils": "3.19.6",
-    "@salesforce/jsonrpc": "^9.14.0"
+    "@salesforce/jsonrpc": "^9.16.0"
   },
   "peerDependencies": {
     "o11y": ">=260.0.0",