@frontmcp/testing 0.12.1 → 1.0.0-beta.1

package/index.js

@@ -39,14 +39,16 @@ __export(index_exports, {
   DefaultMockRegistry: () => DefaultMockRegistry,
   EXPECTED_EXTAPPS_TOOLS_LIST_META_KEYS: () => EXPECTED_EXTAPPS_TOOLS_LIST_META_KEYS,
   EXPECTED_EXTAPPS_TOOL_CALL_META_KEYS: () => EXPECTED_EXTAPPS_TOOL_CALL_META_KEYS,
-  EXPECTED_FRONTMCP_TOOLS_LIST_META_KEYS: () => EXPECTED_FRONTMCP_TOOLS_LIST_META_KEYS,
-  EXPECTED_FRONTMCP_TOOL_CALL_META_KEYS: () => EXPECTED_FRONTMCP_TOOL_CALL_META_KEYS,
+  EXPECTED_GENERIC_TOOLS_LIST_META_KEYS: () => EXPECTED_GENERIC_TOOLS_LIST_META_KEYS,
+  EXPECTED_GENERIC_TOOL_CALL_META_KEYS: () => EXPECTED_GENERIC_TOOL_CALL_META_KEYS,
   EXPECTED_OPENAI_TOOLS_LIST_META_KEYS: () => EXPECTED_OPENAI_TOOLS_LIST_META_KEYS,
   EXPECTED_OPENAI_TOOL_CALL_META_KEYS: () => EXPECTED_OPENAI_TOOL_CALL_META_KEYS,
   FULL_UI_TOOL_CONFIG: () => FULL_UI_TOOL_CONFIG,
   LeakDetector: () => LeakDetector,
   McpAssertions: () => McpAssertions,
+  McpClient: () => import_protocol.Client,
   McpProtocolError: () => McpProtocolError,
+  McpStdioClientTransport: () => import_protocol2.StdioClientTransport,
   McpTestClient: () => McpTestClient,
   McpTestClientBuilder: () => McpTestClientBuilder,
   MetricsCollector: () => MetricsCollector,
@@ -206,7 +208,7 @@ function getPlatformCapabilities(platform) {
       ...baseCapabilities,
       experimental: {
         [MCP_APPS_EXTENSION_KEY]: {
-          mimeTypes: ["text/html+mcp"]
+          mimeTypes: ["text/html;profile=mcp-app"]
         }
       }
     };
@@ -327,7 +329,7 @@ var McpTestClientBuilder = class {
    *   .withCapabilities({
    *     sampling: {},
    *     experimental: {
-   *       'io.modelcontextprotocol/ui': { mimeTypes: ['text/html+mcp'] }
+   *       'io.modelcontextprotocol/ui': { mimeTypes: ['text/html;profile=mcp-app'] }
    *     }
    *   })
    *   .buildAndConnect();
@@ -1373,11 +1375,24 @@ var McpTestClient = class {
     this.log("debug", `Connecting to ${this.config.baseUrl}...`);
     this.transport = this.createTransport();
     await this.transport.connect();
-    const initResponse = await this.initialize();
-    if (!initResponse.success || !initResponse.data) {
-      throw new Error(`Failed to initialize MCP connection: ${initResponse.error?.message ?? "Unknown error"}`);
+    const maxRetries = 3;
+    const retryDelayMs = 500;
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const initResponse = await this.initialize();
+      if (initResponse.success && initResponse.data) {
+        this.initResult = initResponse.data;
+        break;
+      }
+      lastError = initResponse.error?.message ?? "Unknown error";
+      if (attempt < maxRetries) {
+        this.log("debug", `MCP init attempt ${attempt} failed (${lastError}), retrying in ${retryDelayMs}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      }
+    }
+    if (!this.initResult) {
+      throw new Error(`Failed to initialize MCP connection after ${maxRetries} attempts: ${lastError}`);
     }
-    this.initResult = initResponse.data;
     this._sessionId = this.transport.getSessionId();
     this._sessionInfo = {
       id: this._sessionId ?? `session-${Date.now()}`,
@@ -2068,7 +2083,7 @@ var McpTestClient = class {
     const raw = response.data ?? { content: [] };
     const isError2 = !response.success || raw.isError === true;
     const meta = raw._meta;
-    const hasUI = meta?.["ui/html"] !== void 0 || meta?.["ui/component"] !== void 0 || meta?.["openai/html"] !== void 0 || meta?.["frontmcp/html"] !== void 0;
+    const hasUI = meta?.["ui/html"] !== void 0 || meta?.["ui/component"] !== void 0;
     const structuredContent = raw["structuredContent"];
     return {
       raw,
@@ -3922,6 +3937,7 @@ var MockCimdServer = class {
 
 // libs/testing/src/server/test-server.ts
 var import_child_process = require("child_process");
+var import_utils = require("@frontmcp/utils");
 
 // libs/testing/src/errors/index.ts
 var TestClientError = class extends Error {
@@ -4001,9 +4017,16 @@ var E2E_PORT_RANGES = {
   "demo-e2e-agents": { start: 50270, size: 10 },
   "demo-e2e-transport-recreation": { start: 50280, size: 10 },
   "demo-e2e-jobs": { start: 50290, size: 10 },
-  // Infrastructure E2E tests (50300-50399)
+  // Infrastructure E2E tests (50300-50409)
   "demo-e2e-redis": { start: 50300, size: 10 },
   "demo-e2e-serverless": { start: 50310, size: 10 },
+  "demo-e2e-uipack": { start: 50320, size: 10 },
+  "demo-e2e-agent-adapters": { start: 50330, size: 10 },
+  "demo-e2e-guard": { start: 50340, size: 10 },
+  // ESM E2E tests (50400-50449)
+  "esm-package-server": { start: 50400, size: 10 },
+  "esm-package-server-hot-reload": { start: 50410, size: 10 },
+  "esm-package-server-cli": { start: 50420, size: 10 },
   // Mock servers and utilities (50900-50999)
   "mock-oauth": { start: 50900, size: 10 },
   "mock-api": { start: 50910, size: 10 },
@@ -4075,7 +4098,7 @@ async function tryReservePort(port, project) {
     server.once("error", () => {
       resolve(false);
     });
-    server.listen(port, "::", () => {
+    server.listen(port, () => {
       reservedPorts.set(port, {
         port,
         project,
@@ -4116,7 +4139,7 @@ async function isPortAvailable(port) {
     server.once("error", () => {
       resolve(false);
     });
-    server.listen(port, "::", () => {
+    server.listen(port, () => {
       server.close(() => {
         resolve(true);
       });
@@ -4154,15 +4177,37 @@ var TestServer = class _TestServer {
    */
   static async start(options) {
     const project = options.project ?? "default";
-    const { port, release } = await reservePort(project, options.port);
-    const server = new _TestServer(options, port, release);
-    try {
-      await server.startProcess();
-    } catch (error) {
-      await server.stop();
-      throw error;
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const { port, release } = await reservePort(project, options.port);
+      const server = new _TestServer(options, port, release);
+      try {
+        await server.startProcess();
+        return server;
+      } catch (error) {
+        try {
+          await server.stop();
+        } catch (cleanupError) {
+          if (options.debug || DEBUG_SERVER) {
+            const msg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+            console.warn(`[TestServer] Cleanup failed after startup error: ${msg}`);
+          }
+        }
+        const isEADDRINUSE = error instanceof Error && (error.message.includes("EADDRINUSE") || server.getLogs().some((l) => l.includes("EADDRINUSE")));
+        if (isEADDRINUSE && attempt < maxAttempts) {
+          const delayMs = attempt * 500;
+          if (options.debug || DEBUG_SERVER) {
+            console.warn(
+              `[TestServer] EADDRINUSE on port ${port}, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts})`
+            );
+          }
+          await sleep2(delayMs);
+          continue;
+        }
+        throw error;
+      }
     }
-    return server;
+    throw new Error(`[TestServer] Failed to start after ${maxAttempts} attempts`);
   }
   /**
    * Start an Nx project as test server
@@ -4173,22 +4218,44 @@ var TestServer = class _TestServer {
         `Invalid project name: ${project}. Must contain only alphanumeric, underscore, and hyphen characters.`
       );
     }
-    const { port, release } = await reservePort(project, options.port);
-    const serverOptions = {
-      ...options,
-      port,
-      project,
-      command: `npx nx serve ${project} --port ${port}`,
-      cwd: options.cwd ?? process.cwd()
-    };
-    const server = new _TestServer(serverOptions, port, release);
-    try {
-      await server.startProcess();
-    } catch (error) {
-      await server.stop();
-      throw error;
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const { port, release } = await reservePort(project, options.port);
+      const serverOptions = {
+        ...options,
+        port,
+        project,
+        command: `npx nx serve ${project} --port ${port}`,
+        cwd: options.cwd ?? process.cwd()
+      };
+      const server = new _TestServer(serverOptions, port, release);
+      try {
+        await server.startProcess();
+        return server;
+      } catch (error) {
+        try {
+          await server.stop();
+        } catch (cleanupError) {
+          if (options.debug || DEBUG_SERVER) {
+            const msg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+            console.warn(`[TestServer] Cleanup failed after startup error: ${msg}`);
+          }
+        }
+        const isEADDRINUSE = error instanceof Error && (error.message.includes("EADDRINUSE") || server.getLogs().some((l) => l.includes("EADDRINUSE")));
+        if (isEADDRINUSE && attempt < maxAttempts) {
+          const delayMs = attempt * 500;
+          if (options.debug || DEBUG_SERVER) {
+            console.warn(
+              `[TestServer] EADDRINUSE on port ${port}, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts})`
+            );
+          }
+          await sleep2(delayMs);
+          continue;
+        }
+        throw error;
+      }
     }
-    return server;
+    throw new Error(`[TestServer] Failed to start after ${maxAttempts} attempts`);
   }
   /**
    * Create a test server connected to an already running server
@@ -4225,7 +4292,21 @@ var TestServer = class _TestServer {
     }
     if (this.process) {
       this.log("Stopping server...");
-      this.process.kill("SIGTERM");
+      if (this.process.exitCode !== null || this.process.signalCode !== null) {
+        this.log(`Server already exited (code: ${this.process.exitCode}, signal: ${this.process.signalCode})`);
+        this.process = null;
+        return;
+      }
+      const pid = this.process.pid;
+      try {
+        if (pid !== void 0) {
+          process.kill(-pid, "SIGTERM");
+        } else {
+          this.process.kill("SIGTERM");
+        }
+      } catch {
+        this.process.kill("SIGTERM");
+      }
       const exitPromise = new Promise((resolve) => {
         if (this.process) {
           this.process.once("exit", () => resolve());
@@ -4236,7 +4317,16 @@ var TestServer = class _TestServer {
       const killTimeout = setTimeout(() => {
         if (this.process) {
           this.log("Force killing server after timeout...");
-          this.process.kill("SIGKILL");
+          const killPid = this.process.pid;
+          try {
+            if (killPid !== void 0) {
+              process.kill(-killPid, "SIGKILL");
+            } else {
+              this.process.kill("SIGKILL");
+            }
+          } catch {
+            this.process.kill("SIGKILL");
+          }
         }
       }, 5e3);
       await exitPromise;
@@ -4301,14 +4391,17 @@ var TestServer = class _TestServer {
       ...this.options.env,
       PORT: String(this.options.port)
     };
+    const runtimeEnv = withWorkspaceProtocolFallback(env, this.options.cwd);
     if (this.portRelease) {
       await this.portRelease();
       this.portRelease = null;
+      await sleep2(300);
     }
     this.process = (0, import_child_process.spawn)(this.options.command, [], {
       cwd: this.options.cwd,
-      env,
+      env: runtimeEnv,
       shell: true,
+      detached: true,
       stdio: ["pipe", "pipe", "pipe"]
     });
     if (this.process.pid !== void 0) {
@@ -4460,6 +4553,111 @@ TIP: Set DEBUG_SERVER=1 or DEBUG=1 environment variable for verbose output`
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function withWorkspaceProtocolFallback(env, cwd) {
+  if (findInstalledProtocolPackageDir(cwd)) {
+    return env;
+  }
+  try {
+    const workspacePackageDir = findWorkspaceProtocolDir(cwd);
+    if (!workspacePackageDir) {
+      return env;
+    }
+    ensureWorkspaceProtocolLink(cwd, workspacePackageDir);
+    if (findInstalledProtocolPackageDir(cwd)) {
+      return env;
+    }
+    return withProtocolNodePathAlias(env, cwd, workspacePackageDir);
+  } catch (err) {
+    if (DEBUG_SERVER) {
+      console.error(
+        `[TestServer] Workspace protocol fallback failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return env;
+  }
+}
+function ensureWorkspaceProtocolLink(cwd, workspacePackageDir) {
+  const fs = require("node:fs");
+  const path = require("node:path");
+  const nodeModulesDir = findWorkspaceNodeModulesDir(cwd);
+  if (!nodeModulesDir) {
+    return;
+  }
+  const scopeDir = path.join(nodeModulesDir, "@frontmcp");
+  const aliasPackageDir = path.join(scopeDir, "protocol");
+  if (fs.existsSync(aliasPackageDir)) {
+    return;
+  }
+  fs.mkdirSync(scopeDir, { recursive: true });
+  try {
+    fs.symlinkSync(workspacePackageDir, aliasPackageDir, process.platform === "win32" ? "junction" : "dir");
+  } catch (error) {
+    const err = error;
+    if (err.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function withProtocolNodePathAlias(env, cwd, workspacePackageDir) {
+  const fs = require("node:fs");
+  const os = require("node:os");
+  const path = require("node:path");
+  const aliasRoot = path.join(os.tmpdir(), "frontmcp-test-node-path", (0, import_utils.sha256Hex)(cwd).slice(0, 12));
+  const scopeDir = path.join(aliasRoot, "@frontmcp");
+  const aliasPackageDir = path.join(scopeDir, "protocol");
+  fs.mkdirSync(scopeDir, { recursive: true });
+  try {
+    if (!fs.existsSync(aliasPackageDir)) {
+      fs.symlinkSync(workspacePackageDir, aliasPackageDir, process.platform === "win32" ? "junction" : "dir");
+    }
+  } catch (error) {
+    const err = error;
+    if (err.code !== "EEXIST") throw error;
+  }
+  const existingNodePath = env["NODE_PATH"];
+  const nodePathEntries = [aliasRoot, ...existingNodePath ? existingNodePath.split(path.delimiter) : []].filter(
+    Boolean
+  );
+  return {
+    ...env,
+    NODE_PATH: [...new Set(nodePathEntries)].join(path.delimiter)
+  };
+}
+function findUp(startDir, testFn) {
+  const path = require("node:path");
+  let currentDir = startDir;
+  while (true) {
+    const result = testFn(currentDir);
+    if (result !== void 0) return result;
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) return void 0;
+    currentDir = parentDir;
+  }
+}
+function findWorkspaceProtocolDir(startDir) {
+  const fs = require("node:fs");
+  const path = require("node:path");
+  return findUp(startDir, (dir) => {
+    const candidate = path.join(dir, "libs", "protocol");
+    return fs.existsSync(path.join(candidate, "dist", "index.js")) ? candidate : void 0;
+  });
+}
+function findInstalledProtocolPackageDir(startDir) {
+  const fs = require("node:fs");
+  const path = require("node:path");
+  return findUp(startDir, (dir) => {
+    const candidate = path.join(dir, "node_modules", "@frontmcp", "protocol");
+    return fs.existsSync(path.join(candidate, "package.json")) ? candidate : void 0;
+  });
+}
+function findWorkspaceNodeModulesDir(startDir) {
+  const fs = require("node:fs");
+  const path = require("node:path");
+  return findUp(startDir, (dir) => {
+    const candidate = path.join(dir, "node_modules");
+    return fs.existsSync(candidate) ? candidate : void 0;
+  });
+}
 
 // libs/testing/src/assertions/mcp-assertions.ts
 var McpAssertions = {
@@ -4865,15 +5063,10 @@ var expect = import_globals.expect;
 
 // libs/testing/src/platform/platform-types.ts
 function getPlatformMetaNamespace(platform) {
-  switch (platform) {
-    case "openai":
-      return "openai";
-    default:
-      return "ui";
-  }
+  return "ui";
 }
 function getPlatformMimeType(platform) {
-  return platform === "openai" ? "text/html+skybridge" : "text/html+mcp";
+  return "text/html;profile=mcp-app";
 }
 function isOpenAIPlatform(platform) {
   return platform === "openai";
@@ -4882,31 +5075,16 @@ function isExtAppsPlatform(platform) {
   return platform === "ext-apps";
 }
 function isUiPlatform(platform) {
-  return platform !== "openai";
+  return true;
 }
 function getToolsListMetaPrefixes(platform) {
-  switch (platform) {
-    case "openai":
-      return ["openai/"];
-    default:
-      return ["ui/"];
-  }
+  return ["ui/"];
 }
 function getToolCallMetaPrefixes(platform) {
-  switch (platform) {
-    case "openai":
-      return ["openai/"];
-    default:
-      return ["ui/"];
-  }
+  return ["ui/"];
 }
 function getForbiddenMetaPrefixes(platform) {
-  switch (platform) {
-    case "openai":
-      return ["ui/", "frontmcp/"];
-    default:
-      return ["openai/", "frontmcp/"];
-  }
+  return ["openai/", "frontmcp/"];
 }
 
 // libs/testing/src/ui/ui-matchers.ts
@@ -5013,12 +5191,12 @@ var toHaveWidgetMetadata = function(received) {
     };
   }
   const hasUiHtml = Boolean(meta["ui/html"]);
-  const hasOutputTemplate = Boolean(meta["openai/outputTemplate"]);
   const hasMimeType2 = Boolean(meta["ui/mimeType"]);
-  const pass = hasUiHtml || hasOutputTemplate || hasMimeType2;
+  const hasUiObject = Boolean(meta["ui"] && typeof meta["ui"] === "object");
+  const pass = hasUiHtml || hasMimeType2 || hasUiObject;
   return {
     pass,
-    message: () => pass ? "Expected result not to have widget metadata" : "Expected _meta to have widget metadata (ui/html, openai/outputTemplate, or ui/mimeType)"
+    message: () => pass ? "Expected result not to have widget metadata" : "Expected _meta to have widget metadata (ui/html, ui/mimeType, or ui object)"
   };
 };
 var toHaveCssClass = function(received, className) {
@@ -5181,14 +5359,7 @@ var toHavePlatformMimeType = function(received, platform) {
       message: () => `Expected _meta to have MIME type "${expectedMimeType}" for platform "${platform}", but no _meta found`
     };
   }
-  let mimeTypeKey;
-  switch (platform) {
-    case "openai":
-      mimeTypeKey = "openai/mimeType";
-      break;
-    default:
-      mimeTypeKey = "ui/mimeType";
-  }
+  const mimeTypeKey = "ui/mimeType";
   const actualMimeType = meta[mimeTypeKey];
   const pass = actualMimeType === expectedMimeType;
   return {
@@ -5204,14 +5375,7 @@ var toHavePlatformHtml = function(received, platform) {
       message: () => `Expected _meta to have platform HTML for "${platform}", but no _meta found`
     };
   }
-  let htmlKey;
-  switch (platform) {
-    case "openai":
-      htmlKey = "openai/html";
-      break;
-    default:
-      htmlKey = "ui/html";
-  }
+  const htmlKey = "ui/html";
   const html = meta[htmlKey];
   const pass = typeof html === "string" && html.length > 0;
   return {
@@ -6075,7 +6239,7 @@ var UIAssertions = {
   },
   /**
    * Assert that widget metadata is present in the result.
-   * Checks for ui/html, openai/outputTemplate, or ui/mimeType.
+   * Checks for ui/html, ui/mimeType, or nested ui object with resourceUri.
    * @param result - The tool result wrapper
    * @throws Error if widget metadata is missing
    */
@@ -6085,10 +6249,10 @@ var UIAssertions = {
       throw new Error("Expected tool result to have _meta with widget metadata");
     }
     const hasUiHtml = Boolean(meta["ui/html"]);
-    const hasOutputTemplate = Boolean(meta["openai/outputTemplate"]);
     const hasMimeType2 = Boolean(meta["ui/mimeType"]);
-    if (!hasUiHtml && !hasOutputTemplate && !hasMimeType2) {
-      throw new Error("Expected _meta to have widget metadata (ui/html, openai/outputTemplate, or ui/mimeType)");
+    const hasUiObject = Boolean(meta["ui"] && typeof meta["ui"] === "object");
+    if (!hasUiHtml && !hasMimeType2 && !hasUiObject) {
+      throw new Error("Expected _meta to have widget metadata (ui/html, ui/mimeType, or ui object)");
     }
   },
   /**
@@ -6116,7 +6280,7 @@ var UIAssertions = {
   // ═══════════════════════════════════════════════════════════════════
   /**
    * Assert tool result has correct meta keys for OpenAI platform.
-   * Verifies openai/* keys are present and ui/*, frontmcp/* keys are absent.
+   * Verifies ui/* keys are present and openai/*, frontmcp/* keys are absent.
    * @param result - The tool result wrapper
    * @throws Error if meta keys don't match OpenAI expectations
    */
@@ -6199,14 +6363,7 @@ var UIAssertions = {
     if (!meta) {
       throw new Error(`Expected tool result to have _meta with MIME type for platform "${platform}"`);
     }
-    let mimeTypeKey;
-    switch (platform) {
-      case "openai":
-        mimeTypeKey = "openai/mimeType";
-        break;
-      default:
-        mimeTypeKey = "ui/mimeType";
-    }
+    const mimeTypeKey = "ui/mimeType";
     const actualMimeType = meta[mimeTypeKey];
     if (actualMimeType !== expectedMimeType) {
       throw new Error(
@@ -6226,14 +6383,7 @@ var UIAssertions = {
     if (!meta) {
       throw new Error(`Expected tool result to have _meta with platform HTML for "${platform}"`);
     }
-    let htmlKey;
-    switch (platform) {
-      case "openai":
-        htmlKey = "openai/html";
-        break;
-      default:
-        htmlKey = "ui/html";
-    }
+    const htmlKey = "ui/html";
     const html = meta[htmlKey];
     if (typeof html !== "string" || html.length === 0) {
       throw new Error(
@@ -6373,18 +6523,12 @@ function generateFullUIToolOutput(input) {
     timestamp: Date.now()
   };
 }
-var EXPECTED_OPENAI_TOOLS_LIST_META_KEYS = [
-  "openai/outputTemplate",
-  "openai/resultCanProduceWidget",
-  "openai/widgetAccessible"
-];
-var EXPECTED_OPENAI_TOOL_CALL_META_KEYS = ["openai/html", "openai/mimeType", "openai/type"];
+var EXPECTED_OPENAI_TOOLS_LIST_META_KEYS = ["ui/resourceUri", "ui/mimeType", "ui/cdn", "ui/type"];
+var EXPECTED_OPENAI_TOOL_CALL_META_KEYS = ["ui/html", "ui/mimeType", "ui/type"];
 var EXPECTED_EXTAPPS_TOOLS_LIST_META_KEYS = ["ui/resourceUri", "ui/mimeType", "ui/cdn", "ui/type"];
 var EXPECTED_EXTAPPS_TOOL_CALL_META_KEYS = ["ui/html", "ui/mimeType", "ui/type"];
 var EXPECTED_GENERIC_TOOLS_LIST_META_KEYS = ["ui/resourceUri", "ui/mimeType", "ui/cdn", "ui/type"];
 var EXPECTED_GENERIC_TOOL_CALL_META_KEYS = ["ui/html", "ui/mimeType", "ui/type"];
-var EXPECTED_FRONTMCP_TOOLS_LIST_META_KEYS = EXPECTED_GENERIC_TOOLS_LIST_META_KEYS;
-var EXPECTED_FRONTMCP_TOOL_CALL_META_KEYS = EXPECTED_GENERIC_TOOL_CALL_META_KEYS;
 
 // libs/testing/src/perf/metrics-collector.ts
 function isGcAvailable() {
@@ -7929,6 +8073,10 @@ async function saveReports(measurements, outputDir, baseline, gitInfo) {
 function createReportGenerator() {
   return new ReportGenerator();
 }
+
+// libs/testing/src/raw-client/index.ts
+var import_protocol = require("@frontmcp/protocol");
+var import_protocol2 = require("@frontmcp/protocol");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssertionError,
@@ -7940,14 +8088,16 @@ function createReportGenerator() {
   DefaultMockRegistry,
   EXPECTED_EXTAPPS_TOOLS_LIST_META_KEYS,
   EXPECTED_EXTAPPS_TOOL_CALL_META_KEYS,
-  EXPECTED_FRONTMCP_TOOLS_LIST_META_KEYS,
-  EXPECTED_FRONTMCP_TOOL_CALL_META_KEYS,
+  EXPECTED_GENERIC_TOOLS_LIST_META_KEYS,
+  EXPECTED_GENERIC_TOOL_CALL_META_KEYS,
   EXPECTED_OPENAI_TOOLS_LIST_META_KEYS,
   EXPECTED_OPENAI_TOOL_CALL_META_KEYS,
   FULL_UI_TOOL_CONFIG,
   LeakDetector,
   McpAssertions,
+  McpClient,
   McpProtocolError,
+  McpStdioClientTransport,
   McpTestClient,
   McpTestClientBuilder,
   MetricsCollector,

package/matchers/index.js

@@ -26,23 +26,13 @@ module.exports = __toCommonJS(matchers_exports);
 
 // libs/testing/src/platform/platform-types.ts
 function getPlatformMimeType(platform) {
-  return platform === "openai" ? "text/html+skybridge" : "text/html+mcp";
+  return "text/html;profile=mcp-app";
 }
 function getToolCallMetaPrefixes(platform) {
-  switch (platform) {
-    case "openai":
-      return ["openai/"];
-    default:
-      return ["ui/"];
-  }
+  return ["ui/"];
 }
 function getForbiddenMetaPrefixes(platform) {
-  switch (platform) {
-    case "openai":
-      return ["ui/", "frontmcp/"];
-    default:
-      return ["openai/", "frontmcp/"];
-  }
+  return ["openai/", "frontmcp/"];
 }
 
 // libs/testing/src/ui/ui-matchers.ts
@@ -149,12 +139,12 @@ var toHaveWidgetMetadata = function(received) {
     };
   }
   const hasUiHtml = Boolean(meta["ui/html"]);
-  const hasOutputTemplate = Boolean(meta["openai/outputTemplate"]);
   const hasMimeType = Boolean(meta["ui/mimeType"]);
-  const pass = hasUiHtml || hasOutputTemplate || hasMimeType;
+  const hasUiObject = Boolean(meta["ui"] && typeof meta["ui"] === "object");
+  const pass = hasUiHtml || hasMimeType || hasUiObject;
   return {
     pass,
-    message: () => pass ? "Expected result not to have widget metadata" : "Expected _meta to have widget metadata (ui/html, openai/outputTemplate, or ui/mimeType)"
+    message: () => pass ? "Expected result not to have widget metadata" : "Expected _meta to have widget metadata (ui/html, ui/mimeType, or ui object)"
   };
 };
 var toHaveCssClass = function(received, className) {
@@ -317,14 +307,7 @@ var toHavePlatformMimeType = function(received, platform) {
       message: () => `Expected _meta to have MIME type "${expectedMimeType}" for platform "${platform}", but no _meta found`
     };
   }
-  let mimeTypeKey;
-  switch (platform) {
-    case "openai":
-      mimeTypeKey = "openai/mimeType";
-      break;
-    default:
-      mimeTypeKey = "ui/mimeType";
-  }
+  const mimeTypeKey = "ui/mimeType";
   const actualMimeType = meta[mimeTypeKey];
   const pass = actualMimeType === expectedMimeType;
   return {
@@ -340,14 +323,7 @@ var toHavePlatformHtml = function(received, platform) {
       message: () => `Expected _meta to have platform HTML for "${platform}", but no _meta found`
     };
   }
-  let htmlKey;
-  switch (platform) {
-    case "openai":
-      htmlKey = "openai/html";
-      break;
-    default:
-      htmlKey = "ui/html";
-  }
+  const htmlKey = "ui/html";
   const html = meta[htmlKey];
   const pass = typeof html === "string" && html.length > 0;
   return {