@frontmcp/testing 0.6.1 → 0.6.3

package/esm/index.mjs

@@ -0,0 +1,4768 @@
+// libs/testing/src/platform/platform-client-info.ts
+var MCP_APPS_EXTENSION_KEY = "io.modelcontextprotocol/ui";
+function getPlatformClientInfo(platform) {
+  switch (platform) {
+    case "openai":
+      return {
+        name: "ChatGPT",
+        version: "1.0"
+      };
+    case "ext-apps":
+      return {
+        name: "mcp-ext-apps",
+        version: "1.0"
+      };
+    case "claude":
+      return {
+        name: "claude-desktop",
+        version: "1.0"
+      };
+    case "cursor":
+      return {
+        name: "cursor",
+        version: "1.0"
+      };
+    case "continue":
+      return {
+        name: "continue",
+        version: "1.0"
+      };
+    case "cody":
+      return {
+        name: "cody",
+        version: "1.0"
+      };
+    case "gemini":
+      return {
+        name: "gemini",
+        version: "1.0"
+      };
+    case "generic-mcp":
+      return {
+        name: "generic-mcp-client",
+        version: "1.0"
+      };
+    case "unknown":
+    default:
+      return {
+        name: "mcp-test-client",
+        version: "1.0"
+      };
+  }
+}
+function buildUserAgent(clientInfo) {
+  return `${clientInfo.name}/${clientInfo.version}`;
+}
+function getPlatformUserAgent(platform) {
+  return buildUserAgent(getPlatformClientInfo(platform));
+}
+var PLATFORM_DETECTION_PATTERNS = {
+  openai: /chatgpt/i,
+  "ext-apps": /mcp-ext-apps/i,
+  // Note: Actual detection uses capabilities
+  claude: /claude|claude-desktop/i,
+  cursor: /cursor/i,
+  continue: /continue/i,
+  cody: /cody/i,
+  gemini: /gemini/i,
+  "generic-mcp": /generic-mcp/i,
+  unknown: /.*/
+  // Matches anything (fallback)
+};
+function getPlatformCapabilities(platform) {
+  const baseCapabilities = {
+    sampling: {}
+  };
+  if (platform === "ext-apps") {
+    return {
+      ...baseCapabilities,
+      experimental: {
+        [MCP_APPS_EXTENSION_KEY]: {
+          mimeTypes: ["text/html+mcp"]
+        }
+      }
+    };
+  }
+  return baseCapabilities;
+}
+
+// libs/testing/src/client/mcp-test-client.builder.ts
+var McpTestClientBuilder = class {
+  config;
+  constructor(config) {
+    this.config = { ...config };
+  }
+  /**
+   * Set the authentication configuration
+   */
+  withAuth(auth) {
+    this.config.auth = { ...this.config.auth, ...auth };
+    return this;
+  }
+  /**
+   * Set the bearer token for authentication
+   */
+  withToken(token) {
+    this.config.auth = { ...this.config.auth, token };
+    return this;
+  }
+  /**
+   * Add custom headers to all requests
+   */
+  withHeaders(headers) {
+    this.config.auth = {
+      ...this.config.auth,
+      headers: { ...this.config.auth?.headers, ...headers }
+    };
+    return this;
+  }
+  /**
+   * Set the transport type
+   */
+  withTransport(transport) {
+    this.config.transport = transport;
+    return this;
+  }
+  /**
+   * Set the request timeout in milliseconds
+   */
+  withTimeout(timeoutMs) {
+    this.config.timeout = timeoutMs;
+    return this;
+  }
+  /**
+   * Enable debug logging
+   */
+  withDebug(enabled = true) {
+    this.config.debug = enabled;
+    return this;
+  }
+  /**
+   * Enable public mode - skip authentication entirely.
+   * When true, no Authorization header is sent and anonymous token is not requested.
+   * Use this for testing public/unauthenticated endpoints in CI/CD pipelines.
+   */
+  withPublicMode(enabled = true) {
+    this.config.publicMode = enabled;
+    return this;
+  }
+  /**
+   * Set the MCP protocol version to request
+   */
+  withProtocolVersion(version) {
+    this.config.protocolVersion = version;
+    return this;
+  }
+  /**
+   * Set the client info sent during initialization
+   */
+  withClientInfo(info) {
+    this.config.clientInfo = info;
+    return this;
+  }
+  /**
+   * Set the platform type for testing platform-specific meta keys.
+   * Automatically configures clientInfo and capabilities for platform detection.
+   *
+   * Platform-specific behavior:
+   * - `openai`: Uses openai/* meta keys, sets User-Agent to "ChatGPT/1.0"
+   * - `ext-apps`: Uses ui/* meta keys per SEP-1865, sets io.modelcontextprotocol/ui capability
+   * - `claude`: Uses frontmcp/* + ui/* keys, sets User-Agent to "claude-desktop/1.0"
+   * - `cursor`: Uses frontmcp/* + ui/* keys, sets User-Agent to "cursor/1.0"
+   * - Other platforms follow similar patterns
+   *
+   * @example
+   * ```typescript
+   * const client = await McpTestClient.create({ baseUrl })
+   *   .withPlatform('openai')
+   *   .buildAndConnect();
+   *
+   * // ext-apps automatically sets the io.modelcontextprotocol/ui capability
+   * const extAppsClient = await McpTestClient.create({ baseUrl })
+   *   .withPlatform('ext-apps')
+   *   .buildAndConnect();
+   * ```
+   */
+  withPlatform(platform) {
+    this.config.platform = platform;
+    this.config.clientInfo = getPlatformClientInfo(platform);
+    this.config.capabilities = getPlatformCapabilities(platform);
+    return this;
+  }
+  /**
+   * Set custom client capabilities for MCP initialization.
+   * Use this for fine-grained control over capabilities sent during initialization.
+   *
+   * @example
+   * ```typescript
+   * const client = await McpTestClient.create({ baseUrl })
+   *   .withCapabilities({
+   *     sampling: {},
+   *     experimental: {
+   *       'io.modelcontextprotocol/ui': { mimeTypes: ['text/html+mcp'] }
+   *     }
+   *   })
+   *   .buildAndConnect();
+   * ```
+   */
+  withCapabilities(capabilities) {
+    this.config.capabilities = capabilities;
+    return this;
+  }
+  /**
+   * Build the McpTestClient instance (does not connect)
+   */
+  build() {
+    return new McpTestClient(this.config);
+  }
+  /**
+   * Build the McpTestClient and connect to the server
+   */
+  async buildAndConnect() {
+    const client = this.build();
+    await client.connect();
+    return client;
+  }
+};
+
+// libs/testing/src/transport/streamable-http.transport.ts
+var DEFAULT_TIMEOUT = 3e4;
+var StreamableHttpTransport = class {
+  config;
+  state = "disconnected";
+  sessionId;
+  authToken;
+  connectionCount = 0;
+  reconnectCount = 0;
+  lastRequestHeaders = {};
+  interceptors;
+  publicMode;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl.replace(/\/$/, ""),
+      // Remove trailing slash
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      auth: config.auth ?? {},
+      publicMode: config.publicMode ?? false,
+      debug: config.debug ?? false,
+      interceptors: config.interceptors,
+      clientInfo: config.clientInfo
+    };
+    this.authToken = config.auth?.token;
+    this.interceptors = config.interceptors;
+    this.publicMode = config.publicMode ?? false;
+  }
+  async connect() {
+    this.state = "connecting";
+    this.connectionCount++;
+    try {
+      if (this.publicMode) {
+        this.log("Public mode: connecting without authentication");
+        this.state = "connected";
+        return;
+      }
+      if (!this.authToken) {
+        await this.requestAnonymousToken();
+      }
+      this.state = "connected";
+      this.log("Connected to StreamableHTTP transport");
+    } catch (error) {
+      this.state = "error";
+      throw error;
+    }
+  }
+  /**
+   * Request an anonymous token from the FrontMCP OAuth endpoint
+   * This allows the test client to authenticate without user interaction
+   */
+  async requestAnonymousToken() {
+    const clientId = crypto.randomUUID();
+    const tokenUrl = `${this.config.baseUrl}/oauth/token`;
+    this.log(`Requesting anonymous token from ${tokenUrl}`);
+    try {
+      const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          grant_type: "anonymous",
+          client_id: clientId,
+          resource: this.config.baseUrl
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.log(`Failed to get anonymous token: ${response.status} ${errorText}`);
+        return;
+      }
+      const tokenResponse = await response.json();
+      if (tokenResponse.access_token) {
+        this.authToken = tokenResponse.access_token;
+        this.log("Anonymous token acquired successfully");
+      }
+    } catch (error) {
+      this.log(`Error requesting anonymous token: ${error}`);
+    }
+  }
+  async request(message) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    if (this.interceptors) {
+      const interceptResult = await this.interceptors.processRequest(message, {
+        timestamp: /* @__PURE__ */ new Date(),
+        transport: "streamable-http",
+        sessionId: this.sessionId
+      });
+      switch (interceptResult.type) {
+        case "mock": {
+          const mockResponse2 = await this.interceptors.processResponse(
+            message,
+            interceptResult.response,
+            Date.now() - startTime
+          );
+          return mockResponse2;
+        }
+        case "error":
+          throw interceptResult.error;
+        case "continue":
+          message = interceptResult.request;
+          break;
+      }
+    }
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    const url = `${this.config.baseUrl}/`;
+    this.log(`POST ${url}`, message);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const newSessionId = response.headers.get("mcp-session-id");
+      if (newSessionId) {
+        this.sessionId = newSessionId;
+      }
+      let jsonResponse;
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.log(`HTTP Error ${response.status}: ${errorText}`);
+        jsonResponse = {
+          jsonrpc: "2.0",
+          id: message.id ?? null,
+          error: {
+            code: -32e3,
+            message: `HTTP ${response.status}: ${response.statusText}`,
+            data: errorText
+          }
+        };
+      } else {
+        const contentType = response.headers.get("content-type") ?? "";
+        const text = await response.text();
+        this.log("Response:", text);
+        if (!text.trim()) {
+          jsonResponse = {
+            jsonrpc: "2.0",
+            id: message.id ?? null,
+            result: void 0
+          };
+        } else if (contentType.includes("text/event-stream")) {
+          const { response: sseResponse, sseSessionId } = this.parseSSEResponseWithSession(text, message.id);
+          jsonResponse = sseResponse;
+          if (sseSessionId && !this.sessionId) {
+            this.sessionId = sseSessionId;
+            this.log("Session ID from SSE:", this.sessionId);
+          }
+        } else {
+          jsonResponse = JSON.parse(text);
+        }
+      }
+      if (this.interceptors) {
+        jsonResponse = await this.interceptors.processResponse(message, jsonResponse, Date.now() - startTime);
+      }
+      return jsonResponse;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        return {
+          jsonrpc: "2.0",
+          id: message.id ?? null,
+          error: {
+            code: -32e3,
+            message: `Request timeout after ${this.config.timeout}ms`
+          }
+        };
+      }
+      throw error;
+    }
+  }
+  async notify(message) {
+    this.ensureConnected();
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    const url = `${this.config.baseUrl}/`;
+    this.log(`POST ${url} (notification)`, message);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const newSessionId = response.headers.get("mcp-session-id");
+      if (newSessionId) {
+        this.sessionId = newSessionId;
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.log(`HTTP Error ${response.status} on notification: ${errorText}`);
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name !== "AbortError") {
+        throw error;
+      }
+    }
+  }
+  async sendRaw(data) {
+    this.ensureConnected();
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    const url = `${this.config.baseUrl}/`;
+    this.log(`POST ${url} (raw)`, data);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: data,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const text = await response.text();
+      if (!text.trim()) {
+        return {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32700,
+            message: "Parse error"
+          }
+        };
+      }
+      return JSON.parse(text);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      return {
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32700,
+          message: "Parse error",
+          data: error instanceof Error ? error.message : "Unknown error"
+        }
+      };
+    }
+  }
+  async close() {
+    this.state = "disconnected";
+    this.sessionId = void 0;
+    this.log("StreamableHTTP transport closed");
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  getState() {
+    return this.state;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  setTimeout(ms) {
+    this.config.timeout = ms;
+  }
+  setInterceptors(interceptors2) {
+    this.interceptors = interceptors2;
+  }
+  getInterceptors() {
+    return this.interceptors;
+  }
+  getConnectionCount() {
+    return this.connectionCount;
+  }
+  getReconnectCount() {
+    return this.reconnectCount;
+  }
+  getLastRequestHeaders() {
+    return { ...this.lastRequestHeaders };
+  }
+  async simulateDisconnect() {
+    this.state = "disconnected";
+    this.sessionId = void 0;
+  }
+  async waitForReconnect(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    this.reconnectCount++;
+    await this.connect();
+    while (Date.now() < deadline) {
+      if (this.state === "connected") {
+        return;
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    throw new Error("Timeout waiting for reconnection");
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE HELPERS
+  // ═══════════════════════════════════════════════════════════════════
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream"
+    };
+    if (this.config.clientInfo) {
+      headers["User-Agent"] = `${this.config.clientInfo.name}/${this.config.clientInfo.version}`;
+    }
+    if (this.authToken && !this.publicMode) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    if (this.config.auth.headers) {
+      Object.assign(headers, this.config.auth.headers);
+    }
+    return headers;
+  }
+  ensureConnected() {
+    if (this.state !== "connected") {
+      throw new Error("Transport not connected. Call connect() first.");
+    }
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.log(`[StreamableHTTP] ${message}`, data ?? "");
+    }
+  }
+  /**
+   * Parse SSE (Server-Sent Events) response format with session ID extraction
+   * SSE format is:
+   * event: message
+   * id: sessionId:messageId
+   * data: {"jsonrpc":"2.0",...}
+   *
+   * The id field contains the session ID followed by a colon and the message ID.
+   *
+   * @param text - The raw SSE response text
+   * @param requestId - The original request ID
+   * @returns Object with parsed JSON-RPC response and session ID (if found)
+   */
+  parseSSEResponseWithSession(text, requestId) {
+    const lines = text.split("\n");
+    const dataLines = [];
+    let sseSessionId;
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        dataLines.push(line.slice(6));
+      } else if (line === "data:") {
+        dataLines.push("");
+      } else if (line.startsWith("id: ")) {
+        const idValue = line.slice(4);
+        const colonIndex = idValue.lastIndexOf(":");
+        if (colonIndex > 0) {
+          sseSessionId = idValue.substring(0, colonIndex);
+        } else {
+          sseSessionId = idValue;
+        }
+      }
+    }
+    if (dataLines.length > 0) {
+      const jsonData = dataLines.join("\n");
+      try {
+        return {
+          response: JSON.parse(jsonData),
+          sseSessionId
+        };
+      } catch {
+        this.log("Failed to parse SSE data as JSON:", jsonData);
+      }
+    }
+    return {
+      response: {
+        jsonrpc: "2.0",
+        id: requestId ?? null,
+        error: {
+          code: -32700,
+          message: "Failed to parse SSE response",
+          data: text
+        }
+      },
+      sseSessionId
+    };
+  }
+};
+
+// libs/testing/src/interceptor/mock-registry.ts
+var DefaultMockRegistry = class {
+  mocks = [];
+  add(mock) {
+    const entry = {
+      definition: mock,
+      callCount: 0,
+      calls: [],
+      remainingUses: mock.times ?? Infinity
+    };
+    this.mocks.push(entry);
+    return {
+      remove: () => {
+        const index = this.mocks.indexOf(entry);
+        if (index !== -1) {
+          this.mocks.splice(index, 1);
+        }
+      },
+      callCount: () => entry.callCount,
+      calls: () => [...entry.calls]
+    };
+  }
+  clear() {
+    this.mocks = [];
+  }
+  getAll() {
+    return this.mocks.map((e) => e.definition);
+  }
+  match(request) {
+    for (const entry of this.mocks) {
+      if (entry.remainingUses <= 0) continue;
+      const { definition } = entry;
+      if (definition.method !== request.method) continue;
+      if (definition.params !== void 0) {
+        const params = request.params ?? {};
+        if (typeof definition.params === "function") {
+          if (!definition.params(params)) continue;
+        } else {
+          if (!this.paramsMatch(definition.params, params)) continue;
+        }
+      }
+      entry.callCount++;
+      entry.calls.push(request);
+      entry.remainingUses--;
+      return definition;
+    }
+    return void 0;
+  }
+  /**
+   * Check if request params match the mock params definition
+   */
+  paramsMatch(expected, actual) {
+    for (const [key, value] of Object.entries(expected)) {
+      if (!(key in actual)) return false;
+      const actualValue = actual[key];
+      if (Array.isArray(value)) {
+        if (!Array.isArray(actualValue)) return false;
+        if (value.length !== actualValue.length) return false;
+        for (let i = 0; i < value.length; i++) {
+          const expectedItem = value[i];
+          const actualItem = actualValue[i];
+          if (typeof expectedItem === "object" && expectedItem !== null) {
+            if (typeof actualItem !== "object" || actualItem === null) return false;
+            if (!this.paramsMatch(expectedItem, actualItem)) {
+              return false;
+            }
+          } else if (actualItem !== expectedItem) {
+            return false;
+          }
+        }
+      } else if (typeof value === "object" && value !== null) {
+        if (typeof actualValue !== "object" || actualValue === null) return false;
+        if (!this.paramsMatch(value, actualValue)) {
+          return false;
+        }
+      } else if (actualValue !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+var mockResponse = {
+  /**
+   * Create a successful JSON-RPC response
+   */
+  success(result, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result
+    };
+  },
+  /**
+   * Create an error JSON-RPC response
+   */
+  error(code, message, data, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: { code, message, data }
+    };
+  },
+  /**
+   * Create a tool result response
+   */
+  toolResult(content, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { content }
+    };
+  },
+  /**
+   * Create a tools/list response
+   */
+  toolsList(tools, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { tools }
+    };
+  },
+  /**
+   * Create a resources/list response
+   */
+  resourcesList(resources, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { resources }
+    };
+  },
+  /**
+   * Create a resources/read response
+   */
+  resourceRead(contents, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { contents }
+    };
+  },
+  /**
+   * Common MCP errors
+   */
+  errors: {
+    methodNotFound: (method, id = 1) => mockResponse.error(-32601, `Method not found: ${method}`, void 0, id),
+    invalidParams: (message, id = 1) => mockResponse.error(-32602, message, void 0, id),
+    internalError: (message, id = 1) => mockResponse.error(-32603, message, void 0, id),
+    resourceNotFound: (uri, id = 1) => mockResponse.error(-32002, `Resource not found: ${uri}`, { uri }, id),
+    toolNotFound: (name, id = 1) => mockResponse.error(-32601, `Tool not found: ${name}`, { name }, id),
+    unauthorized: (id = 1) => mockResponse.error(-32001, "Unauthorized", void 0, id),
+    forbidden: (id = 1) => mockResponse.error(-32003, "Forbidden", void 0, id)
+  }
+};
+
+// libs/testing/src/interceptor/interceptor-chain.ts
+var DefaultInterceptorChain = class {
+  request = [];
+  response = [];
+  mocks;
+  constructor() {
+    this.mocks = new DefaultMockRegistry();
+  }
+  /**
+   * Add a request interceptor
+   */
+  addRequestInterceptor(interceptor) {
+    this.request.push(interceptor);
+    return () => {
+      const index = this.request.indexOf(interceptor);
+      if (index !== -1) {
+        this.request.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Add a response interceptor
+   */
+  addResponseInterceptor(interceptor) {
+    this.response.push(interceptor);
+    return () => {
+      const index = this.response.indexOf(interceptor);
+      if (index !== -1) {
+        this.response.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Process a request through the interceptor chain
+   * Returns either:
+   * - { type: 'continue', request } - continue with (possibly modified) request
+   * - { type: 'mock', response } - return mock response immediately
+   * - { type: 'error', error } - throw error
+   */
+  async processRequest(request, meta) {
+    let currentRequest = request;
+    const mockDef = this.mocks.match(request);
+    if (mockDef) {
+      if (mockDef.delay && mockDef.delay > 0) {
+        await sleep(mockDef.delay);
+      }
+      let mockResponse2;
+      if (typeof mockDef.response === "function") {
+        mockResponse2 = await mockDef.response(request);
+      } else {
+        mockResponse2 = mockDef.response;
+      }
+      return {
+        type: "mock",
+        response: { ...mockResponse2, id: request.id ?? mockResponse2.id }
+      };
+    }
+    for (const interceptor of this.request) {
+      const ctx = {
+        request: currentRequest,
+        meta
+      };
+      const result = await interceptor(ctx);
+      switch (result.action) {
+        case "passthrough":
+          break;
+        case "modify":
+          currentRequest = result.request;
+          break;
+        case "mock":
+          return {
+            type: "mock",
+            response: { ...result.response, id: request.id ?? result.response.id }
+          };
+        case "error":
+          return { type: "error", error: result.error };
+      }
+    }
+    return { type: "continue", request: currentRequest };
+  }
+  /**
+   * Process a response through the interceptor chain
+   */
+  async processResponse(request, response, durationMs) {
+    let currentResponse = response;
+    for (const interceptor of this.response) {
+      const ctx = {
+        request,
+        response: currentResponse,
+        durationMs
+      };
+      const result = await interceptor(ctx);
+      switch (result.action) {
+        case "passthrough":
+          break;
+        case "modify":
+          currentResponse = result.response;
+          break;
+      }
+    }
+    return currentResponse;
+  }
+  /**
+   * Clear all interceptors and mocks
+   */
+  clear() {
+    this.request = [];
+    this.response = [];
+    this.mocks.clear();
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var interceptors = {
+  /**
+   * Create an interceptor that logs all requests
+   */
+  logger(logFn = console.log) {
+    return (ctx) => {
+      logFn(`[MCP Request] ${ctx.request.method}`, ctx.request.params);
+      return { action: "passthrough" };
+    };
+  },
+  /**
+   * Create an interceptor that adds latency to all requests
+   */
+  delay(ms) {
+    return async () => {
+      await sleep(ms);
+      return { action: "passthrough" };
+    };
+  },
+  /**
+   * Create an interceptor that fails requests matching a condition
+   */
+  failWhen(condition, error) {
+    return (ctx) => {
+      if (condition(ctx)) {
+        const err = typeof error === "string" ? new Error(error) : error;
+        return { action: "error", error: err };
+      }
+      return { action: "passthrough" };
+    };
+  },
+  /**
+   * Create an interceptor that modifies specific methods
+   */
+  modifyMethod(method, modifier) {
+    return (ctx) => {
+      if (ctx.request.method === method) {
+        return { action: "modify", request: modifier(ctx.request) };
+      }
+      return { action: "passthrough" };
+    };
+  },
+  /**
+   * Create a response interceptor that logs responses
+   */
+  responseLogger(logFn = console.log) {
+    return (ctx) => {
+      const status = ctx.response.error ? "ERROR" : "OK";
+      logFn(`[MCP Response] ${ctx.request.method} ${status} (${ctx.durationMs}ms)`, ctx.response);
+      return { action: "passthrough" };
+    };
+  },
+  /**
+   * Create a response interceptor that modifies specific responses
+   */
+  modifyResponse(method, modifier) {
+    return (ctx) => {
+      if (ctx.request.method === method) {
+        return { action: "modify", response: modifier(ctx.response) };
+      }
+      return { action: "passthrough" };
+    };
+  }
+};
+
+// libs/testing/src/client/mcp-test-client.ts
+var DEFAULT_TIMEOUT2 = 3e4;
+var DEFAULT_PROTOCOL_VERSION = "2025-06-18";
+var DEFAULT_CLIENT_INFO = {
+  name: "@frontmcp/testing",
+  version: "0.4.0"
+};
+var McpTestClient = class {
+  // Platform and capabilities are optional - only set when testing platform-specific behavior
+  config;
+  transport = null;
+  initResult = null;
+  requestIdCounter = 0;
+  _lastRequestId = 0;
+  _sessionId;
+  _sessionInfo = null;
+  _authState = { isAnonymous: true, scopes: [] };
+  // Logging and tracing
+  _logs = [];
+  _traces = [];
+  _notifications = [];
+  _progressUpdates = [];
+  // Interceptor chain
+  _interceptors;
+  // ═══════════════════════════════════════════════════════════════════
+  // CONSTRUCTOR & FACTORY
+  // ═══════════════════════════════════════════════════════════════════
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      transport: config.transport ?? "streamable-http",
+      auth: config.auth ?? {},
+      publicMode: config.publicMode ?? false,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT2,
+      debug: config.debug ?? false,
+      protocolVersion: config.protocolVersion ?? DEFAULT_PROTOCOL_VERSION,
+      clientInfo: config.clientInfo ?? DEFAULT_CLIENT_INFO,
+      platform: config.platform,
+      capabilities: config.capabilities
+    };
+    if (config.auth?.token) {
+      this._authState = {
+        isAnonymous: false,
+        token: config.auth.token,
+        scopes: this.parseScopesFromToken(config.auth.token),
+        user: this.parseUserFromToken(config.auth.token)
+      };
+    }
+    this._interceptors = new DefaultInterceptorChain();
+  }
+  /**
+   * Create a new McpTestClientBuilder for fluent configuration
+   */
+  static create(config) {
+    return new McpTestClientBuilder(config);
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // CONNECTION & LIFECYCLE
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * Connect to the MCP server and perform initialization
+   */
+  async connect() {
+    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"}`);
+    }
+    this.initResult = initResponse.data;
+    this._sessionId = this.transport.getSessionId();
+    this._sessionInfo = {
+      id: this._sessionId ?? `session-${Date.now()}`,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastActivityAt: /* @__PURE__ */ new Date(),
+      requestCount: 1
+    };
+    await this.transport.notify({
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    });
+    this.log("info", `Connected to ${this.initResult.serverInfo?.name ?? "MCP Server"}`);
+    return this.initResult;
+  }
+  /**
+   * Disconnect from the MCP server
+   */
+  async disconnect() {
+    if (this.transport) {
+      await this.transport.close();
+      this.transport = null;
+    }
+    this.initResult = null;
+    this.log("info", "Disconnected from MCP server");
+  }
+  /**
+   * Reconnect to the server, optionally with an existing session ID
+   */
+  async reconnect(options) {
+    await this.disconnect();
+    if (options?.sessionId && this.transport) {
+      this._sessionId = options.sessionId;
+    }
+    await this.connect();
+  }
+  /**
+   * Check if the client is currently connected
+   */
+  isConnected() {
+    return this.transport?.isConnected() ?? false;
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // SESSION & AUTH PROPERTIES
+  // ═══════════════════════════════════════════════════════════════════
+  get sessionId() {
+    return this._sessionId ?? "";
+  }
+  get session() {
+    const info = this._sessionInfo ?? {
+      id: "",
+      createdAt: /* @__PURE__ */ new Date(),
+      lastActivityAt: /* @__PURE__ */ new Date(),
+      requestCount: 0
+    };
+    return {
+      ...info,
+      expire: async () => {
+        this._sessionId = void 0;
+        this._sessionInfo = null;
+      }
+    };
+  }
+  get auth() {
+    return this._authState;
+  }
+  /**
+   * Authenticate with a token
+   */
+  async authenticate(token) {
+    this._authState = {
+      isAnonymous: false,
+      token,
+      scopes: this.parseScopesFromToken(token),
+      user: this.parseUserFromToken(token)
+    };
+    if (this.transport) {
+      this.transport.setAuthToken(token);
+    }
+    this.log("debug", "Authentication updated");
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // SERVER INFO & CAPABILITIES
+  // ═══════════════════════════════════════════════════════════════════
+  get serverInfo() {
+    return {
+      name: this.initResult?.serverInfo?.name ?? "",
+      version: this.initResult?.serverInfo?.version ?? ""
+    };
+  }
+  get protocolVersion() {
+    return this.initResult?.protocolVersion ?? "";
+  }
+  get instructions() {
+    return this.initResult?.instructions ?? "";
+  }
+  get capabilities() {
+    return this.initResult?.capabilities ?? {};
+  }
+  /**
+   * Check if server has a specific capability
+   */
+  hasCapability(name) {
+    return !!this.capabilities[name];
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // TOOLS API
+  // ═══════════════════════════════════════════════════════════════════
+  tools = {
+    /**
+     * List all available tools
+     */
+    list: async () => {
+      const response = await this.listTools();
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list tools: ${response.error?.message}`);
+      }
+      return response.data.tools;
+    },
+    /**
+     * Call a tool by name with arguments
+     */
+    call: async (name, args) => {
+      const response = await this.callTool(name, args);
+      return this.wrapToolResult(response);
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // RESOURCES API
+  // ═══════════════════════════════════════════════════════════════════
+  resources = {
+    /**
+     * List all static resources
+     */
+    list: async () => {
+      const response = await this.listResources();
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list resources: ${response.error?.message}`);
+      }
+      return response.data.resources;
+    },
+    /**
+     * List all resource templates
+     */
+    listTemplates: async () => {
+      const response = await this.listResourceTemplates();
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list resource templates: ${response.error?.message}`);
+      }
+      return response.data.resourceTemplates;
+    },
+    /**
+     * Read a resource by URI
+     */
+    read: async (uri) => {
+      const response = await this.readResource(uri);
+      return this.wrapResourceContent(response);
+    },
+    /**
+     * Subscribe to resource changes (placeholder for future implementation)
+     */
+    subscribe: async (_uri) => {
+      this.log("warn", "Resource subscription not yet implemented");
+    },
+    /**
+     * Unsubscribe from resource changes (placeholder for future implementation)
+     */
+    unsubscribe: async (_uri) => {
+      this.log("warn", "Resource unsubscription not yet implemented");
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // PROMPTS API
+  // ═══════════════════════════════════════════════════════════════════
+  prompts = {
+    /**
+     * List all available prompts
+     */
+    list: async () => {
+      const response = await this.listPrompts();
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list prompts: ${response.error?.message}`);
+      }
+      return response.data.prompts;
+    },
+    /**
+     * Get a prompt with arguments
+     */
+    get: async (name, args) => {
+      const response = await this.getPrompt(name, args);
+      return this.wrapPromptResult(response);
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // RAW PROTOCOL ACCESS
+  // ═══════════════════════════════════════════════════════════════════
+  raw = {
+    /**
+     * Send any JSON-RPC request
+     */
+    request: async (message) => {
+      this.ensureConnected();
+      const start = Date.now();
+      const response = await this.transport.request(message);
+      this.traceRequest(message.method, message.params, message.id, response, Date.now() - start);
+      return response;
+    },
+    /**
+     * Send a notification (no response expected)
+     */
+    notify: async (message) => {
+      this.ensureConnected();
+      await this.transport.notify(message);
+    },
+    /**
+     * Send raw string data (for error testing)
+     */
+    sendRaw: async (data) => {
+      this.ensureConnected();
+      return this.transport.sendRaw(data);
+    }
+  };
+  get lastRequestId() {
+    return this._lastRequestId;
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // TRANSPORT INFO
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * Get transport information and utilities
+   */
+  get transport_info() {
+    return {
+      type: this.config.transport,
+      isConnected: () => this.transport?.isConnected() ?? false,
+      messageEndpoint: this.transport?.getMessageEndpoint?.(),
+      connectionCount: this.transport?.getConnectionCount?.() ?? 0,
+      reconnectCount: this.transport?.getReconnectCount?.() ?? 0,
+      lastRequestHeaders: this.transport?.getLastRequestHeaders?.() ?? {},
+      simulateDisconnect: async () => {
+        await this.transport?.simulateDisconnect?.();
+      },
+      waitForReconnect: async (timeoutMs) => {
+        await this.transport?.waitForReconnect?.(timeoutMs);
+      }
+    };
+  }
+  // Alias for transport info
+  get transport_() {
+    return this.transport_info;
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // NOTIFICATIONS
+  // ═══════════════════════════════════════════════════════════════════
+  notifications = {
+    /**
+     * Start collecting server notifications
+     */
+    collect: () => {
+      return new NotificationCollector(this._notifications);
+    },
+    /**
+     * Collect progress notifications specifically
+     */
+    collectProgress: () => {
+      return new ProgressCollector(this._progressUpdates);
+    },
+    /**
+     * Send a notification to the server
+     */
+    send: async (method, params) => {
+      await this.raw.notify({ jsonrpc: "2.0", method, params });
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // LOGGING & DEBUGGING
+  // ═══════════════════════════════════════════════════════════════════
+  logs = {
+    all: () => [...this._logs],
+    filter: (level) => this._logs.filter((l) => l.level === level),
+    search: (text) => this._logs.filter((l) => l.message.includes(text)),
+    last: () => this._logs[this._logs.length - 1],
+    clear: () => {
+      this._logs = [];
+    }
+  };
+  trace = {
+    all: () => [...this._traces],
+    last: () => this._traces[this._traces.length - 1],
+    clear: () => {
+      this._traces = [];
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // MOCKING & INTERCEPTION
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * API for mocking MCP requests
+   *
+   * @example
+   * ```typescript
+   * // Mock a specific tool call
+   * const handle = mcp.mock.tool('my-tool', { result: 'mocked!' });
+   *
+   * // Mock with params matching
+   * mcp.mock.add({
+   *   method: 'tools/call',
+   *   params: { name: 'my-tool' },
+   *   response: mockResponse.toolResult([{ type: 'text', text: 'mocked' }]),
+   * });
+   *
+   * // Clear all mocks after test
+   * mcp.mock.clear();
+   * ```
+   */
+  mock = {
+    /**
+     * Add a mock definition
+     */
+    add: (mock) => {
+      return this._interceptors.mocks.add(mock);
+    },
+    /**
+     * Mock a tools/call request for a specific tool
+     */
+    tool: (name, result, options) => {
+      return this._interceptors.mocks.add({
+        method: "tools/call",
+        params: { name },
+        response: mockResponse.toolResult([
+          { type: "text", text: typeof result === "string" ? result : JSON.stringify(result) }
+        ]),
+        times: options?.times,
+        delay: options?.delay
+      });
+    },
+    /**
+     * Mock a tools/call request to return an error
+     */
+    toolError: (name, code, message, options) => {
+      return this._interceptors.mocks.add({
+        method: "tools/call",
+        params: { name },
+        response: mockResponse.error(code, message),
+        times: options?.times
+      });
+    },
+    /**
+     * Mock a resources/read request
+     */
+    resource: (uri, content, options) => {
+      const contentObj = typeof content === "string" ? { uri, text: content } : { uri, ...content };
+      return this._interceptors.mocks.add({
+        method: "resources/read",
+        params: { uri },
+        response: mockResponse.resourceRead([contentObj]),
+        times: options?.times,
+        delay: options?.delay
+      });
+    },
+    /**
+     * Mock a resources/read request to return an error
+     */
+    resourceError: (uri, options) => {
+      return this._interceptors.mocks.add({
+        method: "resources/read",
+        params: { uri },
+        response: mockResponse.errors.resourceNotFound(uri),
+        times: options?.times
+      });
+    },
+    /**
+     * Mock the tools/list response
+     */
+    toolsList: (tools, options) => {
+      return this._interceptors.mocks.add({
+        method: "tools/list",
+        response: mockResponse.toolsList(tools),
+        times: options?.times
+      });
+    },
+    /**
+     * Mock the resources/list response
+     */
+    resourcesList: (resources, options) => {
+      return this._interceptors.mocks.add({
+        method: "resources/list",
+        response: mockResponse.resourcesList(resources),
+        times: options?.times
+      });
+    },
+    /**
+     * Clear all mocks
+     */
+    clear: () => {
+      this._interceptors.mocks.clear();
+    },
+    /**
+     * Get all active mocks
+     */
+    all: () => {
+      return this._interceptors.mocks.getAll();
+    }
+  };
+  /**
+   * API for intercepting requests and responses
+   *
+   * @example
+   * ```typescript
+   * // Log all requests
+   * const remove = mcp.intercept.request((ctx) => {
+   *   console.log('Request:', ctx.request.method);
+   *   return { action: 'passthrough' };
+   * });
+   *
+   * // Modify requests
+   * mcp.intercept.request((ctx) => {
+   *   if (ctx.request.method === 'tools/call') {
+   *     return {
+   *       action: 'modify',
+   *       request: { ...ctx.request, params: { ...ctx.request.params, extra: true } },
+   *     };
+   *   }
+   *   return { action: 'passthrough' };
+   * });
+   *
+   * // Add latency to all requests
+   * mcp.intercept.delay(100);
+   *
+   * // Clean up
+   * remove();
+   * mcp.intercept.clear();
+   * ```
+   */
+  intercept = {
+    /**
+     * Add a request interceptor
+     * @returns Function to remove the interceptor
+     */
+    request: (interceptor) => {
+      return this._interceptors.addRequestInterceptor(interceptor);
+    },
+    /**
+     * Add a response interceptor
+     * @returns Function to remove the interceptor
+     */
+    response: (interceptor) => {
+      return this._interceptors.addResponseInterceptor(interceptor);
+    },
+    /**
+     * Add latency to all requests
+     * @returns Function to remove the interceptor
+     */
+    delay: (ms) => {
+      return this._interceptors.addRequestInterceptor(async () => {
+        await new Promise((r) => setTimeout(r, ms));
+        return { action: "passthrough" };
+      });
+    },
+    /**
+     * Fail requests matching a method
+     * @returns Function to remove the interceptor
+     */
+    failMethod: (method, error) => {
+      return this._interceptors.addRequestInterceptor((ctx) => {
+        if (ctx.request.method === method) {
+          return { action: "error", error: new Error(error ?? `Intercepted: ${method}`) };
+        }
+        return { action: "passthrough" };
+      });
+    },
+    /**
+     * Clear all interceptors (but not mocks)
+     */
+    clear: () => {
+      this._interceptors.request = [];
+      this._interceptors.response = [];
+    },
+    /**
+     * Clear everything (interceptors and mocks)
+     */
+    clearAll: () => {
+      this._interceptors.clear();
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // TIMEOUT
+  // ═══════════════════════════════════════════════════════════════════
+  setTimeout(ms) {
+    this.config.timeout = ms;
+    if (this.transport) {
+      this.transport.setTimeout(ms);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: MCP OPERATIONS
+  // ═══════════════════════════════════════════════════════════════════
+  async initialize() {
+    const capabilities = this.config.capabilities ?? {
+      sampling: {}
+    };
+    return this.request("initialize", {
+      protocolVersion: this.config.protocolVersion,
+      capabilities,
+      clientInfo: this.config.clientInfo
+    });
+  }
+  async listTools() {
+    return this.request("tools/list", {});
+  }
+  async callTool(name, args) {
+    return this.request("tools/call", {
+      name,
+      arguments: args ?? {}
+    });
+  }
+  async listResources() {
+    return this.request("resources/list", {});
+  }
+  async listResourceTemplates() {
+    return this.request("resources/templates/list", {});
+  }
+  async readResource(uri) {
+    return this.request("resources/read", { uri });
+  }
+  async listPrompts() {
+    return this.request("prompts/list", {});
+  }
+  async getPrompt(name, args) {
+    return this.request("prompts/get", {
+      name,
+      arguments: args ?? {}
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: TRANSPORT & REQUEST HELPERS
+  // ═══════════════════════════════════════════════════════════════════
+  createTransport() {
+    switch (this.config.transport) {
+      case "streamable-http":
+        return new StreamableHttpTransport({
+          baseUrl: this.config.baseUrl,
+          timeout: this.config.timeout,
+          auth: this.config.auth,
+          publicMode: this.config.publicMode,
+          debug: this.config.debug,
+          interceptors: this._interceptors,
+          clientInfo: this.config.clientInfo
+        });
+      case "sse":
+        throw new Error("SSE transport not yet implemented");
+      default:
+        throw new Error(`Unknown transport type: ${this.config.transport}`);
+    }
+  }
+  async request(method, params) {
+    this.ensureConnected();
+    const id = ++this.requestIdCounter;
+    this._lastRequestId = id;
+    const start = Date.now();
+    try {
+      const response = await this.transport.request({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      });
+      const durationMs = Date.now() - start;
+      this.updateSessionActivity();
+      if ("error" in response && response.error) {
+        const error = response.error;
+        this.traceRequest(method, params, id, response, durationMs);
+        return {
+          success: false,
+          error,
+          durationMs,
+          requestId: id
+        };
+      }
+      this.traceRequest(method, params, id, response, durationMs);
+      return {
+        success: true,
+        data: response.result,
+        durationMs,
+        requestId: id
+      };
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      const error = {
+        code: -32603,
+        message: err instanceof Error ? err.message : "Unknown error"
+      };
+      return {
+        success: false,
+        error,
+        durationMs,
+        requestId: id
+      };
+    }
+  }
+  ensureConnected() {
+    if (!this.transport?.isConnected()) {
+      throw new Error("Not connected to MCP server. Call connect() first.");
+    }
+  }
+  updateSessionActivity() {
+    if (this._sessionInfo) {
+      this._sessionInfo.lastActivityAt = /* @__PURE__ */ new Date();
+      this._sessionInfo.requestCount++;
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: RESULT WRAPPERS
+  // ═══════════════════════════════════════════════════════════════════
+  wrapToolResult(response) {
+    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 structuredContent = raw["structuredContent"];
+    return {
+      raw,
+      isSuccess: !isError2,
+      isError: isError2,
+      error: response.error,
+      durationMs: response.durationMs,
+      json() {
+        if (hasUI && structuredContent !== void 0) {
+          return structuredContent;
+        }
+        const textContent = raw.content?.find((c) => c.type === "text");
+        if (textContent && "text" in textContent) {
+          return JSON.parse(textContent.text);
+        }
+        throw new Error("No text content to parse as JSON");
+      },
+      text() {
+        const textContent = raw.content?.find((c) => c.type === "text");
+        if (textContent && "text" in textContent) {
+          return textContent.text;
+        }
+        return void 0;
+      },
+      hasTextContent() {
+        return raw.content?.some((c) => c.type === "text") ?? false;
+      },
+      hasImageContent() {
+        return raw.content?.some((c) => c.type === "image") ?? false;
+      },
+      hasResourceContent() {
+        return raw.content?.some((c) => c.type === "resource") ?? false;
+      },
+      hasToolUI() {
+        return hasUI;
+      }
+    };
+  }
+  wrapResourceContent(response) {
+    const raw = response.data ?? { contents: [] };
+    const isError2 = !response.success;
+    const firstContent = raw.contents?.[0];
+    return {
+      raw,
+      isSuccess: !isError2,
+      isError: isError2,
+      error: response.error,
+      durationMs: response.durationMs,
+      json() {
+        if (firstContent && "text" in firstContent) {
+          return JSON.parse(firstContent.text);
+        }
+        throw new Error("No text content to parse as JSON");
+      },
+      text() {
+        if (firstContent && "text" in firstContent) {
+          return firstContent.text;
+        }
+        return void 0;
+      },
+      mimeType() {
+        return firstContent?.mimeType;
+      },
+      hasMimeType(type) {
+        return firstContent?.mimeType === type;
+      }
+    };
+  }
+  wrapPromptResult(response) {
+    const raw = response.data ?? { messages: [] };
+    const isError2 = !response.success;
+    return {
+      raw,
+      isSuccess: !isError2,
+      isError: isError2,
+      error: response.error,
+      durationMs: response.durationMs,
+      messages: raw.messages ?? [],
+      description: raw.description
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: LOGGING & TRACING
+  // ═══════════════════════════════════════════════════════════════════
+  log(level, message, data) {
+    const entry = {
+      level,
+      message,
+      timestamp: /* @__PURE__ */ new Date(),
+      data
+    };
+    this._logs.push(entry);
+    if (this.config.debug) {
+      console.log(`[${level.toUpperCase()}] ${message}`, data ?? "");
+    }
+  }
+  traceRequest(method, params, id, response, durationMs) {
+    this._traces.push({
+      request: { method, params, id },
+      response: {
+        result: "result" in response ? response.result : void 0,
+        error: "error" in response ? response.error : void 0
+      },
+      durationMs,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: TOKEN PARSING
+  // ═══════════════════════════════════════════════════════════════════
+  parseScopesFromToken(token) {
+    try {
+      const payload = this.decodeJwtPayload(token);
+      if (!payload) return [];
+      const scope = payload["scope"];
+      const scopes = payload["scopes"];
+      if (typeof scope === "string") {
+        return scope.split(" ");
+      }
+      if (Array.isArray(scopes)) {
+        return scopes;
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  parseUserFromToken(token) {
+    try {
+      const payload = this.decodeJwtPayload(token);
+      const sub = payload?.["sub"];
+      if (!sub || typeof sub !== "string") return void 0;
+      return {
+        sub,
+        email: payload["email"],
+        name: payload["name"]
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  decodeJwtPayload(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) return null;
+      const payload = Buffer.from(parts[1], "base64url").toString("utf-8");
+      return JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+};
+var NotificationCollector = class {
+  constructor(notifications) {
+    this.notifications = notifications;
+  }
+  get received() {
+    return [...this.notifications];
+  }
+  has(method) {
+    return this.notifications.some((n) => n.method === method);
+  }
+  async waitFor(method, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const found = this.notifications.find((n) => n.method === method);
+      if (found) return found;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    throw new Error(`Timeout waiting for notification: ${method}`);
+  }
+};
+var ProgressCollector = class {
+  constructor(updates) {
+    this.updates = updates;
+  }
+  get all() {
+    return [...this.updates];
+  }
+  async waitForComplete(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const last = this.updates[this.updates.length - 1];
+      if (last && last.total !== void 0 && last.progress >= last.total) {
+        return;
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    throw new Error("Timeout waiting for progress to complete");
+  }
+};
+
+// libs/testing/src/auth/token-factory.ts
+import { SignJWT, generateKeyPair, exportJWK } from "jose";
+var TestTokenFactory = class {
+  issuer;
+  audience;
+  privateKey = null;
+  publicKey = null;
+  jwk = null;
+  keyId;
+  constructor(options = {}) {
+    this.issuer = options.issuer ?? "https://test.frontmcp.local";
+    this.audience = options.audience ?? "frontmcp-test";
+    this.keyId = `test-key-${Date.now()}`;
+  }
+  /**
+   * Initialize the key pair (called automatically on first use)
+   */
+  async ensureKeys() {
+    if (this.privateKey && this.publicKey) return;
+    const { publicKey, privateKey } = await generateKeyPair("RS256", {
+      extractable: true
+    });
+    this.privateKey = privateKey;
+    this.publicKey = publicKey;
+    this.jwk = await exportJWK(publicKey);
+    this.jwk.kid = this.keyId;
+    this.jwk.use = "sig";
+    this.jwk.alg = "RS256";
+  }
+  /**
+   * Create a JWT token with the specified claims
+   */
+  async createTestToken(options) {
+    await this.ensureKeys();
+    const now = Math.floor(Date.now() / 1e3);
+    const exp = options.exp ?? 3600;
+    const payload = {
+      iss: options.iss ?? this.issuer,
+      sub: options.sub,
+      aud: options.aud ?? this.audience,
+      iat: now,
+      exp: now + exp,
+      scope: options.scopes?.join(" "),
+      ...options.claims
+    };
+    const token = await new SignJWT(payload).setProtectedHeader({ alg: "RS256", kid: this.keyId }).sign(this.privateKey);
+    return token;
+  }
+  /**
+   * Create an admin token with full access
+   */
+  async createAdminToken(sub = "admin-001") {
+    return this.createTestToken({
+      sub,
+      scopes: ["admin:*", "read", "write", "delete"],
+      claims: {
+        email: "admin@test.local",
+        name: "Test Admin",
+        role: "admin"
+      }
+    });
+  }
+  /**
+   * Create a regular user token
+   */
+  async createUserToken(sub = "user-001", scopes = ["read", "write"]) {
+    return this.createTestToken({
+      sub,
+      scopes,
+      claims: {
+        email: "user@test.local",
+        name: "Test User",
+        role: "user"
+      }
+    });
+  }
+  /**
+   * Create an anonymous user token
+   */
+  async createAnonymousToken() {
+    return this.createTestToken({
+      sub: `anon:${Date.now()}`,
+      scopes: ["anonymous"],
+      claims: {
+        name: "Anonymous",
+        role: "anonymous"
+      }
+    });
+  }
+  /**
+   * Create an expired token (for testing token expiration)
+   */
+  async createExpiredToken(options) {
+    await this.ensureKeys();
+    const now = Math.floor(Date.now() / 1e3);
+    const payload = {
+      iss: this.issuer,
+      sub: options.sub,
+      aud: this.audience,
+      iat: now - 7200,
+      // 2 hours ago
+      exp: now - 3600
+      // Expired 1 hour ago
+    };
+    const token = await new SignJWT(payload).setProtectedHeader({ alg: "RS256", kid: this.keyId }).sign(this.privateKey);
+    return token;
+  }
+  /**
+   * Create a token with an invalid signature (for testing signature validation)
+   */
+  createTokenWithInvalidSignature(options) {
+    const now = Math.floor(Date.now() / 1e3);
+    const header = Buffer.from(JSON.stringify({ alg: "RS256", kid: this.keyId })).toString("base64url");
+    const payload = Buffer.from(
+      JSON.stringify({
+        iss: this.issuer,
+        sub: options.sub,
+        aud: this.audience,
+        iat: now,
+        exp: now + 3600
+      })
+    ).toString("base64url");
+    const signature = Buffer.from("invalid-signature-" + Date.now()).toString("base64url");
+    return `${header}.${payload}.${signature}`;
+  }
+  /**
+   * Get the public JWKS for verifying tokens
+   */
+  async getPublicJwks() {
+    await this.ensureKeys();
+    return {
+      keys: [this.jwk]
+    };
+  }
+  /**
+   * Get the issuer URL
+   */
+  getIssuer() {
+    return this.issuer;
+  }
+  /**
+   * Get the audience
+   */
+  getAudience() {
+    return this.audience;
+  }
+};
+
+// libs/testing/src/auth/auth-headers.ts
+var AuthHeaders = {
+  /**
+   * Create Authorization header with Bearer token
+   */
+  bearer(token) {
+    return {
+      Authorization: `Bearer ${token}`
+    };
+  },
+  /**
+   * Create headers with no authentication
+   */
+  noAuth() {
+    return {};
+  },
+  /**
+   * Create full MCP request headers with auth and session
+   */
+  mcpRequest(token, sessionId) {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`
+    };
+    if (sessionId) {
+      headers["mcp-session-id"] = sessionId;
+    }
+    return headers;
+  },
+  /**
+   * Create headers for public mode (no auth required)
+   */
+  publicMode(sessionId) {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (sessionId) {
+      headers["mcp-session-id"] = sessionId;
+    }
+    return headers;
+  },
+  /**
+   * Create headers with custom auth header value
+   */
+  custom(headerName, headerValue) {
+    return {
+      [headerName]: headerValue
+    };
+  }
+};
+
+// libs/testing/src/auth/user-fixtures.ts
+var TestUsers = {
+  /**
+   * Admin user with full access
+   */
+  admin: {
+    sub: "admin-001",
+    email: "admin@test.local",
+    name: "Test Admin",
+    scopes: ["admin:*", "read", "write", "delete"],
+    role: "admin"
+  },
+  /**
+   * Regular user with read/write access
+   */
+  user: {
+    sub: "user-001",
+    email: "user@test.local",
+    name: "Test User",
+    scopes: ["read", "write"],
+    role: "user"
+  },
+  /**
+   * Read-only user
+   */
+  readOnly: {
+    sub: "readonly-001",
+    email: "readonly@test.local",
+    name: "Read Only User",
+    scopes: ["read"],
+    role: "readonly"
+  },
+  /**
+   * Anonymous user
+   */
+  anonymous: {
+    sub: "anon:001",
+    name: "Anonymous",
+    scopes: ["anonymous"],
+    role: "anonymous"
+  },
+  /**
+   * User with no scopes (for testing access denied)
+   */
+  noScopes: {
+    sub: "noscopes-001",
+    email: "noscopes@test.local",
+    name: "No Scopes User",
+    scopes: [],
+    role: "user"
+  },
+  /**
+   * User with only tool execution scope
+   */
+  toolsOnly: {
+    sub: "toolsonly-001",
+    email: "toolsonly@test.local",
+    name: "Tools Only User",
+    scopes: ["tools:execute"],
+    role: "user"
+  },
+  /**
+   * User with only resource read scope
+   */
+  resourcesOnly: {
+    sub: "resourcesonly-001",
+    email: "resourcesonly@test.local",
+    name: "Resources Only User",
+    scopes: ["resources:read"],
+    role: "user"
+  }
+};
+function createTestUser(overrides) {
+  return {
+    scopes: [],
+    ...overrides
+  };
+}
+
+// libs/testing/src/auth/mock-oauth-server.ts
+import { createServer } from "http";
+var MockOAuthServer = class {
+  tokenFactory;
+  options;
+  server = null;
+  _info = null;
+  connections = /* @__PURE__ */ new Set();
+  constructor(tokenFactory2, options = {}) {
+    this.tokenFactory = tokenFactory2;
+    this.options = options;
+  }
+  /**
+   * Start the mock OAuth server
+   */
+  async start() {
+    if (this.server) {
+      throw new Error("Mock OAuth server is already running");
+    }
+    const port = this.options.port ?? 0;
+    return new Promise((resolve, reject) => {
+      const server = createServer(this.handleRequest.bind(this));
+      this.server = server;
+      server.on("connection", (socket) => {
+        this.connections.add(socket);
+        socket.on("close", () => this.connections.delete(socket));
+      });
+      server.on("error", (err) => {
+        this.log(`Server error: ${err.message}`);
+        reject(err);
+      });
+      server.listen(port, () => {
+        const address = server.address();
+        if (!address || typeof address === "string") {
+          reject(new Error("Failed to get server address"));
+          return;
+        }
+        const actualPort = address.port;
+        const issuer = this.options.issuer ?? `http://localhost:${actualPort}`;
+        this._info = {
+          baseUrl: `http://localhost:${actualPort}`,
+          port: actualPort,
+          issuer,
+          jwksUrl: `http://localhost:${actualPort}/.well-known/jwks.json`
+        };
+        this.log(`Mock OAuth server started at ${this._info.baseUrl}`);
+        resolve(this._info);
+      });
+    });
+  }
+  /**
+   * Stop the mock OAuth server
+   */
+  async stop() {
+    const server = this.server;
+    if (!server) {
+      return;
+    }
+    for (const socket of this.connections) {
+      socket.destroy();
+    }
+    this.connections.clear();
+    return new Promise((resolve, reject) => {
+      server.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.server = null;
+          this._info = null;
+          this.log("Mock OAuth server stopped");
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Get server info
+   */
+  get info() {
+    if (!this._info) {
+      throw new Error("Mock OAuth server is not running");
+    }
+    return this._info;
+  }
+  /**
+   * Get the token factory (for creating tokens)
+   */
+  getTokenFactory() {
+    return this.tokenFactory;
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE
+  // ═══════════════════════════════════════════════════════════════════
+  async handleRequest(req, res) {
+    const url = req.url ?? "/";
+    this.log(`${req.method} ${url}`);
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      if (url === "/.well-known/jwks.json" || url === "/.well-known/jwks") {
+        await this.handleJwks(req, res);
+      } else if (url === "/.well-known/openid-configuration") {
+        await this.handleOidcConfig(req, res);
+      } else if (url === "/.well-known/oauth-authorization-server") {
+        await this.handleOAuthMetadata(req, res);
+      } else if (url === "/oauth/token") {
+        await this.handleTokenEndpoint(req, res);
+      } else {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "not_found", error_description: "Endpoint not found" }));
+      }
+    } catch (error) {
+      this.log(`Error handling request: ${error}`);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "server_error", error_description: "Internal server error" }));
+    }
+  }
+  async handleJwks(_req, res) {
+    const jwks = await this.tokenFactory.getPublicJwks();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(jwks));
+    this.log("Served JWKS");
+  }
+  async handleOidcConfig(_req, res) {
+    const issuer = this._info?.issuer ?? "http://localhost";
+    const config = {
+      issuer,
+      authorization_endpoint: `${issuer}/oauth/authorize`,
+      token_endpoint: `${issuer}/oauth/token`,
+      jwks_uri: `${issuer}/.well-known/jwks.json`,
+      response_types_supported: ["code", "token"],
+      subject_types_supported: ["public"],
+      id_token_signing_alg_values_supported: ["RS256"],
+      scopes_supported: ["openid", "profile", "email"],
+      token_endpoint_auth_methods_supported: ["client_secret_basic", "client_secret_post", "none"],
+      claims_supported: ["sub", "iss", "aud", "exp", "iat", "email", "name"],
+      grant_types_supported: ["authorization_code", "refresh_token", "client_credentials", "anonymous"]
+    };
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(config));
+    this.log("Served OIDC configuration");
+  }
+  async handleOAuthMetadata(_req, res) {
+    const issuer = this._info?.issuer ?? "http://localhost";
+    const metadata = {
+      issuer,
+      authorization_endpoint: `${issuer}/oauth/authorize`,
+      token_endpoint: `${issuer}/oauth/token`,
+      jwks_uri: `${issuer}/.well-known/jwks.json`,
+      response_types_supported: ["code", "token"],
+      grant_types_supported: ["authorization_code", "refresh_token", "client_credentials", "anonymous"],
+      token_endpoint_auth_methods_supported: ["client_secret_basic", "client_secret_post", "none"],
+      scopes_supported: ["openid", "profile", "email", "anonymous"]
+    };
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(metadata));
+    this.log("Served OAuth metadata");
+  }
+  async handleTokenEndpoint(req, res) {
+    const body = await this.readBody(req);
+    const params = new URLSearchParams(body);
+    const grantType = params.get("grant_type");
+    if (grantType === "anonymous") {
+      const token = await this.tokenFactory.createAnonymousToken();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          access_token: token,
+          token_type: "Bearer",
+          expires_in: 3600
+        })
+      );
+      this.log("Issued anonymous token");
+    } else {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "unsupported_grant_type",
+          error_description: "Only anonymous grant type is supported in mock server"
+        })
+      );
+    }
+  }
+  readBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+      req.on("error", reject);
+    });
+  }
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[MockOAuthServer] ${message}`);
+    }
+  }
+};
+
+// libs/testing/src/auth/mock-api-server.ts
+import { createServer as createServer2 } from "http";
+var MockAPIServer = class {
+  options;
+  server = null;
+  _info = null;
+  routes;
+  constructor(options) {
+    this.options = options;
+    this.routes = options.routes ?? [];
+  }
+  /**
+   * Start the mock API server
+   */
+  async start() {
+    if (this.server) {
+      throw new Error("Mock API server is already running");
+    }
+    const port = this.options.port ?? 0;
+    return new Promise((resolve, reject) => {
+      this.server = createServer2(this.handleRequest.bind(this));
+      this.server.on("error", (err) => {
+        this.log(`Server error: ${err.message}`);
+        reject(err);
+      });
+      this.server.listen(port, () => {
+        const address = this.server.address();
+        if (!address || typeof address === "string") {
+          reject(new Error("Failed to get server address"));
+          return;
+        }
+        const actualPort = address.port;
+        this._info = {
+          baseUrl: `http://localhost:${actualPort}`,
+          port: actualPort,
+          specUrl: `http://localhost:${actualPort}/openapi.json`
+        };
+        this.log(`Mock API server started at ${this._info.baseUrl}`);
+        resolve(this._info);
+      });
+    });
+  }
+  /**
+   * Stop the mock API server
+   */
+  async stop() {
+    if (!this.server) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.server.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.server = null;
+          this._info = null;
+          this.log("Mock API server stopped");
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Get server info
+   */
+  get info() {
+    if (!this._info) {
+      throw new Error("Mock API server is not running");
+    }
+    return this._info;
+  }
+  /**
+   * Add a route dynamically
+   */
+  addRoute(route) {
+    this.routes.push(route);
+  }
+  /**
+   * Clear all routes
+   */
+  clearRoutes() {
+    this.routes = [];
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE
+  // ═══════════════════════════════════════════════════════════════════
+  async handleRequest(req, res) {
+    const url = req.url ?? "/";
+    const method = (req.method ?? "GET").toUpperCase();
+    this.log(`${method} ${url}`);
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      if (url === "/openapi.json" || url === "/openapi.yaml") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(this.options.openApiSpec));
+        this.log("Served OpenAPI spec");
+        return;
+      }
+      const route = this.findRoute(method, url);
+      if (route) {
+        const status = route.response.status ?? 200;
+        const headers = {
+          "Content-Type": "application/json",
+          ...route.response.headers
+        };
+        res.writeHead(status, headers);
+        res.end(JSON.stringify(route.response.body));
+        this.log(`Matched route: ${method} ${route.path} -> ${status}`);
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "not_found", message: `No mock for ${method} ${url}` }));
+    } catch (error) {
+      this.log(`Error handling request: ${error}`);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "server_error", message: "Internal server error" }));
+    }
+  }
+  findRoute(method, url) {
+    const path = url.split("?")[0];
+    return this.routes.find((route) => {
+      if (route.method !== method) return false;
+      if (route.path === path) return true;
+      const routeParts = route.path.split("/");
+      const urlParts = path.split("/");
+      if (routeParts.length !== urlParts.length) return false;
+      return routeParts.every((part, i) => {
+        if (part.startsWith(":")) return true;
+        return part === urlParts[i];
+      });
+    });
+  }
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[MockAPIServer] ${message}`);
+    }
+  }
+};
+
+// libs/testing/src/server/test-server.ts
+import { spawn } from "child_process";
+var TestServer = class _TestServer {
+  process = null;
+  options;
+  _info;
+  logs = [];
+  constructor(options, port) {
+    this.options = {
+      port,
+      command: options.command ?? "",
+      cwd: options.cwd ?? process.cwd(),
+      env: options.env ?? {},
+      startupTimeout: options.startupTimeout ?? 3e4,
+      healthCheckPath: options.healthCheckPath ?? "/health",
+      debug: options.debug ?? false
+    };
+    this._info = {
+      baseUrl: `http://localhost:${port}`,
+      port
+    };
+  }
+  /**
+   * Start a test server with custom command
+   */
+  static async start(options) {
+    const port = options.port ?? await findAvailablePort();
+    const server = new _TestServer(options, port);
+    try {
+      await server.startProcess();
+    } catch (error) {
+      await server.stop();
+      throw error;
+    }
+    return server;
+  }
+  /**
+   * Start an Nx project as test server
+   */
+  static async startNx(project, options = {}) {
+    if (!/^[\w-]+$/.test(project)) {
+      throw new Error(
+        `Invalid project name: ${project}. Must contain only alphanumeric, underscore, and hyphen characters.`
+      );
+    }
+    const port = options.port ?? await findAvailablePort();
+    const serverOptions = {
+      ...options,
+      port,
+      command: `npx nx serve ${project} --port ${port}`,
+      cwd: options.cwd ?? process.cwd()
+    };
+    const server = new _TestServer(serverOptions, port);
+    try {
+      await server.startProcess();
+    } catch (error) {
+      await server.stop();
+      throw error;
+    }
+    return server;
+  }
+  /**
+   * Create a test server connected to an already running server
+   */
+  static connect(baseUrl) {
+    const url = new URL(baseUrl);
+    const port = parseInt(url.port, 10) || (url.protocol === "https:" ? 443 : 80);
+    const server = new _TestServer(
+      {
+        command: "",
+        port
+      },
+      port
+    );
+    server._info = {
+      baseUrl: baseUrl.replace(/\/$/, ""),
+      port
+    };
+    return server;
+  }
+  /**
+   * Get server information
+   */
+  get info() {
+    return { ...this._info };
+  }
+  /**
+   * Stop the test server
+   */
+  async stop() {
+    if (this.process) {
+      this.log("Stopping server...");
+      this.process.kill("SIGTERM");
+      const exitPromise = new Promise((resolve) => {
+        if (this.process) {
+          this.process.once("exit", () => resolve());
+        } else {
+          resolve();
+        }
+      });
+      const killTimeout = setTimeout(() => {
+        if (this.process) {
+          this.log("Force killing server after timeout...");
+          this.process.kill("SIGKILL");
+        }
+      }, 5e3);
+      await exitPromise;
+      clearTimeout(killTimeout);
+      this.process = null;
+      this.log("Server stopped");
+    }
+  }
+  /**
+   * Wait for server to be ready
+   */
+  async waitForReady(timeout) {
+    const timeoutMs = timeout ?? this.options.startupTimeout;
+    const deadline = Date.now() + timeoutMs;
+    const checkInterval = 100;
+    while (Date.now() < deadline) {
+      try {
+        const response = await fetch(`${this._info.baseUrl}${this.options.healthCheckPath}`, {
+          method: "GET",
+          signal: AbortSignal.timeout(1e3)
+        });
+        if (response.ok || response.status === 404) {
+          this.log("Server is ready");
+          return;
+        }
+      } catch {
+      }
+      await sleep2(checkInterval);
+    }
+    throw new Error(`Server did not become ready within ${timeoutMs}ms`);
+  }
+  /**
+   * Restart the server
+   */
+  async restart() {
+    await this.stop();
+    await this.startProcess();
+  }
+  /**
+   * Get captured server logs
+   */
+  getLogs() {
+    return [...this.logs];
+  }
+  /**
+   * Clear captured logs
+   */
+  clearLogs() {
+    this.logs = [];
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE METHODS
+  // ═══════════════════════════════════════════════════════════════════
+  async startProcess() {
+    if (!this.options.command) {
+      await this.waitForReady();
+      return;
+    }
+    this.log(`Starting server: ${this.options.command}`);
+    const env = {
+      ...process.env,
+      ...this.options.env,
+      PORT: String(this.options.port)
+    };
+    this.process = spawn(this.options.command, [], {
+      cwd: this.options.cwd,
+      env,
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (this.process.pid !== void 0) {
+      this._info.pid = this.process.pid;
+    }
+    let processExited = false;
+    let exitCode = null;
+    let exitError = null;
+    this.process.stdout?.on("data", (data) => {
+      const text = data.toString();
+      this.logs.push(text);
+      if (this.options.debug) {
+        console.log("[SERVER]", text);
+      }
+    });
+    this.process.stderr?.on("data", (data) => {
+      const text = data.toString();
+      this.logs.push(`[ERROR] ${text}`);
+      if (this.options.debug) {
+        console.error("[SERVER ERROR]", text);
+      }
+    });
+    this.process.on("error", (err) => {
+      this.logs.push(`[SPAWN ERROR] ${err.message}`);
+      exitError = err;
+      if (this.options.debug) {
+        console.error("[SERVER SPAWN ERROR]", err);
+      }
+    });
+    this.process.once("exit", (code) => {
+      processExited = true;
+      exitCode = code;
+      this.log(`Server process exited with code ${code}`);
+    });
+    await this.waitForReadyWithExitDetection(() => {
+      if (exitError) {
+        return { exited: true, error: exitError };
+      }
+      if (processExited) {
+        const recentLogs = this.logs.slice(-10).join("\n");
+        return {
+          exited: true,
+          error: new Error(`Server process exited unexpectedly with code ${exitCode}.
+
+Recent logs:
+${recentLogs}`)
+        };
+      }
+      return { exited: false };
+    });
+  }
+  /**
+   * Wait for server to be ready, but also detect early process exit
+   */
+  async waitForReadyWithExitDetection(checkExit) {
+    const timeoutMs = this.options.startupTimeout;
+    const deadline = Date.now() + timeoutMs;
+    const checkInterval = 100;
+    while (Date.now() < deadline) {
+      const exitStatus = checkExit();
+      if (exitStatus.exited) {
+        throw exitStatus.error ?? new Error("Server process exited unexpectedly");
+      }
+      try {
+        const response = await fetch(`${this._info.baseUrl}${this.options.healthCheckPath}`, {
+          method: "GET",
+          signal: AbortSignal.timeout(1e3)
+        });
+        if (response.ok || response.status === 404) {
+          this.log("Server is ready");
+          return;
+        }
+      } catch {
+      }
+      await sleep2(checkInterval);
+    }
+    const finalExitStatus = checkExit();
+    if (finalExitStatus.exited) {
+      throw finalExitStatus.error ?? new Error("Server process exited unexpectedly");
+    }
+    throw new Error(`Server did not become ready within ${timeoutMs}ms`);
+  }
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[TestServer] ${message}`);
+    }
+  }
+};
+async function findAvailablePort() {
+  const { createServer: createServer3 } = await import("net");
+  return new Promise((resolve, reject) => {
+    const server = createServer3();
+    server.listen(0, () => {
+      const address = server.address();
+      if (address && typeof address !== "string") {
+        const port = address.port;
+        server.close(() => resolve(port));
+      } else {
+        reject(new Error("Could not get port"));
+      }
+    });
+    server.on("error", reject);
+  });
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// libs/testing/src/assertions/mcp-assertions.ts
+var McpAssertions = {
+  /**
+   * Assert that an MCP response was successful and return the data
+   * @throws Error if response was not successful
+   */
+  assertSuccess(response, message) {
+    if (!response.success) {
+      const errorMsg = response.error?.message ?? "Unknown error";
+      throw new Error(message ?? `Expected success but got error: ${errorMsg} (code: ${response.error?.code})`);
+    }
+    if (response.data === void 0) {
+      throw new Error(message ?? "Expected data but got undefined");
+    }
+    return response.data;
+  },
+  /**
+   * Assert that an MCP response was an error
+   * @param expectedCode Optional expected error code
+   */
+  assertError(response, expectedCode) {
+    if (response.success) {
+      throw new Error("Expected error but got success");
+    }
+    if (!response.error) {
+      throw new Error("Expected error info but got undefined");
+    }
+    if (expectedCode !== void 0 && response.error.code !== expectedCode) {
+      throw new Error(`Expected error code ${expectedCode} but got ${response.error.code}: ${response.error.message}`);
+    }
+    return response.error;
+  },
+  /**
+   * Assert that a tool call was successful (not isError)
+   */
+  assertToolSuccess(result) {
+    if ("raw" in result) {
+      if (result.isError) {
+        throw new Error(`Tool call failed: ${result.error?.message ?? "Unknown error"}`);
+      }
+    } else {
+      if (!result.success) {
+        throw new Error(`Tool call failed: ${result.error?.message ?? "Unknown error"}`);
+      }
+      if (result.data?.isError) {
+        throw new Error("Tool returned isError=true");
+      }
+    }
+  },
+  /**
+   * Assert that a tool result has specific content type
+   */
+  assertToolContent(result, type) {
+    let content;
+    if ("raw" in result) {
+      content = result.raw.content;
+    } else {
+      if (!result.success || !result.data) {
+        throw new Error("Tool call was not successful");
+      }
+      content = result.data.content;
+    }
+    const hasContent = content?.some((c) => c.type === type);
+    if (!hasContent) {
+      throw new Error(`Expected tool result to have ${type} content`);
+    }
+  },
+  /**
+   * Assert that a resource read was successful and return the text content
+   */
+  assertTextResource(response) {
+    if ("raw" in response) {
+      if (response.isError) {
+        throw new Error(`Resource read failed: ${response.error?.message ?? "Unknown error"}`);
+      }
+      const text = response.text();
+      if (text === void 0) {
+        throw new Error("Expected text content but got undefined");
+      }
+      return text;
+    } else {
+      if (!response.success || !response.data) {
+        throw new Error(`Resource read failed: ${response.error?.message ?? "Unknown error"}`);
+      }
+      const content = response.data.contents?.[0];
+      if (!content || !("text" in content)) {
+        throw new Error("Expected text content but got undefined");
+      }
+      return content.text;
+    }
+  },
+  /**
+   * Assert that tools array contains a tool with given name
+   */
+  assertContainsTool(tools, name) {
+    const tool = tools.find((t) => t.name === name);
+    if (!tool) {
+      const available = tools.map((t) => t.name).join(", ");
+      throw new Error(`Expected to find tool "${name}" but got: [${available}]`);
+    }
+    return tool;
+  },
+  /**
+   * Assert that resources array contains a resource with given URI
+   */
+  assertContainsResource(resources, uri) {
+    const resource = resources.find((r) => r.uri === uri);
+    if (!resource) {
+      const available = resources.map((r) => r.uri).join(", ");
+      throw new Error(`Expected to find resource "${uri}" but got: [${available}]`);
+    }
+    return resource;
+  },
+  /**
+   * Assert that resource templates array contains a template with given URI template
+   */
+  assertContainsResourceTemplate(templates, uriTemplate) {
+    const template = templates.find((t) => t.uriTemplate === uriTemplate);
+    if (!template) {
+      const available = templates.map((t) => t.uriTemplate).join(", ");
+      throw new Error(`Expected to find resource template "${uriTemplate}" but got: [${available}]`);
+    }
+    return template;
+  },
+  /**
+   * Assert that prompts array contains a prompt with given name
+   */
+  assertContainsPrompt(prompts, name) {
+    const prompt = prompts.find((p) => p.name === name);
+    if (!prompt) {
+      const available = prompts.map((p) => p.name).join(", ");
+      throw new Error(`Expected to find prompt "${name}" but got: [${available}]`);
+    }
+    return prompt;
+  }
+};
+function containsTool(tools, name) {
+  return tools.some((t) => t.name === name);
+}
+function containsResource(resources, uri) {
+  return resources.some((r) => r.uri === uri);
+}
+function containsResourceTemplate(templates, uriTemplate) {
+  return templates.some((t) => t.uriTemplate === uriTemplate);
+}
+function containsPrompt(prompts, name) {
+  return prompts.some((p) => p.name === name);
+}
+function isSuccessful(result) {
+  return result.isSuccess;
+}
+function isError(result, expectedCode) {
+  if (!result.isError) return false;
+  if (expectedCode !== void 0) {
+    return result.error?.code === expectedCode;
+  }
+  return true;
+}
+function hasTextContent(result) {
+  return result.hasTextContent();
+}
+function hasMimeType(result, mimeType) {
+  return result.hasMimeType(mimeType);
+}
+
+// libs/testing/src/errors/index.ts
+var TestClientError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TestClientError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ConnectionError = class extends TestClientError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ConnectionError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var TimeoutError = class extends TestClientError {
+  constructor(message, timeoutMs) {
+    super(message);
+    this.timeoutMs = timeoutMs;
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var McpProtocolError = class extends TestClientError {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "McpProtocolError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ServerStartError = class extends TestClientError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ServerStartError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AssertionError = class extends TestClientError {
+  constructor(message) {
+    super(message);
+    this.name = "AssertionError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// libs/testing/src/fixtures/test-fixture.ts
+var currentConfig = {};
+var serverInstance = null;
+var tokenFactory = null;
+var serverStartedByUs = false;
+async function initializeSharedResources() {
+  if (!tokenFactory) {
+    tokenFactory = new TestTokenFactory();
+  }
+  if (!serverInstance) {
+    if (currentConfig.baseUrl) {
+      serverInstance = TestServer.connect(currentConfig.baseUrl);
+      serverStartedByUs = false;
+    } else if (currentConfig.server) {
+      serverInstance = await TestServer.start({
+        port: currentConfig.port,
+        command: resolveServerCommand(currentConfig.server),
+        env: currentConfig.env,
+        startupTimeout: currentConfig.startupTimeout ?? 3e4,
+        debug: currentConfig.logLevel === "debug"
+      });
+      serverStartedByUs = true;
+    } else {
+      throw new Error(
+        'test.use() requires either "server" (entry file path) or "baseUrl" (for external server) option'
+      );
+    }
+  }
+}
+async function createTestFixtures() {
+  await initializeSharedResources();
+  const clientInstance = await McpTestClient.create({
+    baseUrl: serverInstance.info.baseUrl,
+    transport: currentConfig.transport ?? "streamable-http",
+    publicMode: currentConfig.publicMode
+  }).buildAndConnect();
+  const auth = createAuthFixture(tokenFactory);
+  const server = createServerFixture(serverInstance);
+  return {
+    mcp: clientInstance,
+    auth,
+    server
+  };
+}
+async function cleanupTestFixtures(fixtures, _testFailed = false) {
+  if (fixtures.mcp.isConnected()) {
+    await fixtures.mcp.disconnect();
+  }
+}
+async function cleanupSharedResources() {
+  if (serverInstance && serverStartedByUs) {
+    await serverInstance.stop();
+  }
+  serverInstance = null;
+  tokenFactory = null;
+  serverStartedByUs = false;
+}
+function createAuthFixture(factory) {
+  const users = {
+    admin: {
+      sub: "admin-001",
+      scopes: ["admin:*", "read", "write", "delete"],
+      email: "admin@test.local",
+      name: "Test Admin"
+    },
+    user: {
+      sub: "user-001",
+      scopes: ["read", "write"],
+      email: "user@test.local",
+      name: "Test User"
+    },
+    readOnly: {
+      sub: "readonly-001",
+      scopes: ["read"],
+      email: "readonly@test.local",
+      name: "Read Only User"
+    }
+  };
+  return {
+    createToken: (opts) => factory.createTestToken({
+      sub: opts.sub,
+      scopes: opts.scopes,
+      claims: {
+        email: opts.email,
+        name: opts.name,
+        ...opts.claims
+      },
+      exp: opts.expiresIn
+    }),
+    createExpiredToken: (opts) => factory.createExpiredToken(opts),
+    createInvalidToken: (opts) => factory.createTokenWithInvalidSignature(opts),
+    users: {
+      admin: users["admin"],
+      user: users["user"],
+      readOnly: users["readOnly"]
+    },
+    getJwks: () => factory.getPublicJwks(),
+    getIssuer: () => factory.getIssuer(),
+    getAudience: () => factory.getAudience()
+  };
+}
+function createServerFixture(server) {
+  return {
+    info: server.info,
+    createClient: async (opts) => {
+      return McpTestClient.create({
+        baseUrl: server.info.baseUrl,
+        transport: opts?.transport ?? "streamable-http",
+        auth: opts?.token ? { token: opts.token } : void 0,
+        clientInfo: opts?.clientInfo,
+        publicMode: currentConfig.publicMode
+      }).buildAndConnect();
+    },
+    createClientBuilder: () => {
+      const builder = new McpTestClientBuilder({
+        baseUrl: server.info.baseUrl,
+        publicMode: currentConfig.publicMode
+      });
+      return builder;
+    },
+    restart: () => server.restart(),
+    getLogs: () => server.getLogs(),
+    clearLogs: () => server.clearLogs()
+  };
+}
+function resolveServerCommand(server) {
+  if (server.includes(" ")) {
+    return server;
+  }
+  return `npx tsx ${server}`;
+}
+function testWithFixtures(name, fn) {
+  it(name, async () => {
+    const fixtures = await createTestFixtures();
+    let testFailed = false;
+    try {
+      await fn(fixtures);
+    } catch (error) {
+      testFailed = true;
+      throw error;
+    } finally {
+      await cleanupTestFixtures(fixtures, testFailed);
+    }
+  });
+}
+function use(config) {
+  currentConfig = { ...currentConfig, ...config };
+  afterAll(async () => {
+    await cleanupSharedResources();
+  });
+}
+function skip(name, fn) {
+  it.skip(name, async () => {
+    const fixtures = await createTestFixtures();
+    let testFailed = false;
+    try {
+      await fn(fixtures);
+    } catch (error) {
+      testFailed = true;
+      throw error;
+    } finally {
+      await cleanupTestFixtures(fixtures, testFailed);
+    }
+  });
+}
+function only(name, fn) {
+  it.only(name, async () => {
+    const fixtures = await createTestFixtures();
+    let testFailed = false;
+    try {
+      await fn(fixtures);
+    } catch (error) {
+      testFailed = true;
+      throw error;
+    } finally {
+      await cleanupTestFixtures(fixtures, testFailed);
+    }
+  });
+}
+function todo(name) {
+  it.todo(name);
+}
+var test = testWithFixtures;
+test.use = use;
+test.describe = describe;
+test.beforeAll = beforeAll;
+test.beforeEach = beforeEach;
+test.afterEach = afterEach;
+test.afterAll = afterAll;
+test.skip = skip;
+test.only = only;
+test.todo = todo;
+
+// libs/testing/src/expect.ts
+import { expect as jestExpect } from "@jest/globals";
+var expect = jestExpect;
+
+// libs/testing/src/platform/platform-types.ts
+function getPlatformMetaNamespace(platform) {
+  switch (platform) {
+    case "openai":
+      return "openai";
+    case "ext-apps":
+      return "ui";
+    default:
+      return "frontmcp";
+  }
+}
+function getPlatformMimeType(platform) {
+  return platform === "openai" ? "text/html+skybridge" : "text/html+mcp";
+}
+function isOpenAIPlatform(platform) {
+  return platform === "openai";
+}
+function isExtAppsPlatform(platform) {
+  return platform === "ext-apps";
+}
+function isFrontmcpPlatform(platform) {
+  return platform !== "openai" && platform !== "ext-apps";
+}
+function getToolsListMetaPrefixes(platform) {
+  switch (platform) {
+    case "openai":
+      return ["openai/"];
+    case "ext-apps":
+      return ["ui/"];
+    default:
+      return ["frontmcp/", "ui/"];
+  }
+}
+function getToolCallMetaPrefixes(platform) {
+  switch (platform) {
+    case "openai":
+      return ["openai/"];
+    case "ext-apps":
+      return ["ui/"];
+    default:
+      return ["frontmcp/", "ui/"];
+  }
+}
+function getForbiddenMetaPrefixes(platform) {
+  switch (platform) {
+    case "openai":
+      return ["ui/", "frontmcp/"];
+    case "ext-apps":
+      return ["openai/", "frontmcp/"];
+    default:
+      return ["openai/"];
+  }
+}
+
+// libs/testing/src/ui/ui-matchers.ts
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractUiHtml(received) {
+  if (typeof received === "string") {
+    return received;
+  }
+  const wrapper = received;
+  const meta = wrapper?.raw?._meta || wrapper?._meta;
+  if (meta && typeof meta === "object") {
+    const uiHtml = meta["ui/html"];
+    if (typeof uiHtml === "string") {
+      return uiHtml;
+    }
+  }
+  return void 0;
+}
+function extractMeta(received) {
+  const wrapper = received;
+  const meta = wrapper?.raw?._meta || wrapper?._meta;
+  if (meta && typeof meta === "object") {
+    return meta;
+  }
+  return void 0;
+}
+var toHaveRenderedHtml = function(received) {
+  const html = extractUiHtml(received);
+  const hasHtml = html !== void 0 && html.length > 0;
+  const isFallback = hasHtml && html.includes("mdx-fallback");
+  const pass = hasHtml && !isFallback;
+  return {
+    pass,
+    message: () => {
+      if (isFallback) {
+        return "Expected rendered HTML but got mdx-fallback (raw escaped content). MDX rendering may have failed.";
+      }
+      if (!hasHtml) {
+        return "Expected _meta to have ui/html property with rendered HTML";
+      }
+      return "Expected result not to have rendered HTML";
+    }
+  };
+};
+var toContainHtmlElement = function(received, tag) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: false,
+      message: () => `Expected to find <${tag}> element, but no HTML content found`
+    };
+  }
+  const regex = new RegExp(`<${escapeRegex(tag)}[\\s>]`, "i");
+  const pass = regex.test(html);
+  return {
+    pass,
+    message: () => pass ? `Expected HTML not to contain <${tag}> element` : `Expected HTML to contain <${tag}> element`
+  };
+};
+var toContainBoundValue = function(received, value) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: false,
+      message: () => `Expected HTML to contain bound value "${value}", but no HTML content found`
+    };
+  }
+  const stringValue = String(value);
+  const pass = html.includes(stringValue);
+  return {
+    pass,
+    message: () => pass ? `Expected HTML not to contain bound value "${stringValue}"` : `Expected HTML to contain bound value "${stringValue}"`
+  };
+};
+var toBeXssSafe = function(received) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: true,
+      message: () => "Expected HTML to be XSS unsafe (no HTML found)"
+    };
+  }
+  const hasScript = /<script[\s>]/i.test(html);
+  const hasOnHandler = /\son\w+\s*=/i.test(html);
+  const hasJavascriptUri = /javascript:/i.test(html);
+  const issues = [];
+  if (hasScript) issues.push("<script> tag");
+  if (hasOnHandler) issues.push("inline event handler (onclick, etc.)");
+  if (hasJavascriptUri) issues.push("javascript: URI");
+  const pass = !hasScript && !hasOnHandler && !hasJavascriptUri;
+  return {
+    pass,
+    message: () => pass ? "Expected HTML not to be XSS safe" : `Expected HTML to be XSS safe, but found: ${issues.join(", ")}`
+  };
+};
+var toHaveWidgetMetadata = function(received) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => "Expected _meta to have widget metadata, but no _meta found"
+    };
+  }
+  const hasUiHtml = Boolean(meta["ui/html"]);
+  const hasOutputTemplate = Boolean(meta["openai/outputTemplate"]);
+  const hasMimeType2 = Boolean(meta["ui/mimeType"]);
+  const pass = hasUiHtml || hasOutputTemplate || hasMimeType2;
+  return {
+    pass,
+    message: () => pass ? "Expected result not to have widget metadata" : "Expected _meta to have widget metadata (ui/html, openai/outputTemplate, or ui/mimeType)"
+  };
+};
+var toHaveCssClass = function(received, className) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: false,
+      message: () => `Expected HTML to have CSS class "${className}", but no HTML content found`
+    };
+  }
+  const classRegex = new RegExp(`class(?:Name)?\\s*=\\s*["'][^"']*\\b${escapeRegex(className)}\\b[^"']*["']`, "i");
+  const pass = classRegex.test(html);
+  return {
+    pass,
+    message: () => pass ? `Expected HTML not to have CSS class "${className}"` : `Expected HTML to have CSS class "${className}"`
+  };
+};
+var toNotContainRawContent = function(received, content) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: true,
+      message: () => `Expected HTML to contain raw content "${content}", but no HTML found`
+    };
+  }
+  const pass = !html.includes(content);
+  return {
+    pass,
+    message: () => pass ? `Expected HTML to contain raw content "${content}"` : `Expected HTML not to contain raw content "${content}" (may indicate rendering failure)`
+  };
+};
+var toHaveProperHtmlStructure = function(received) {
+  const html = extractUiHtml(received);
+  if (!html) {
+    return {
+      pass: false,
+      message: () => "Expected proper HTML structure, but no HTML content found"
+    };
+  }
+  const hasEscapedTags = html.includes("&lt;") && html.includes("&gt;");
+  const hasHtmlTags = /<[a-z]/i.test(html);
+  const pass = hasHtmlTags && !hasEscapedTags;
+  return {
+    pass,
+    message: () => {
+      if (hasEscapedTags) {
+        return "Expected proper HTML structure, but found escaped HTML entities - content may not have been rendered";
+      }
+      if (!hasHtmlTags) {
+        return "Expected proper HTML structure, but found no HTML tags";
+      }
+      return "Expected result not to have proper HTML structure";
+    }
+  };
+};
+var toHavePlatformMeta = function(received, platform) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have platform meta for "${platform}", but no _meta found`
+    };
+  }
+  const expectedPrefixes = getToolCallMetaPrefixes(platform);
+  const forbiddenPrefixes = getForbiddenMetaPrefixes(platform);
+  const metaKeys = Object.keys(meta);
+  const hasExpectedPrefix = metaKeys.some((key) => expectedPrefixes.some((prefix) => key.startsWith(prefix)));
+  const forbiddenKeys = metaKeys.filter((key) => forbiddenPrefixes.some((prefix) => key.startsWith(prefix)));
+  const pass = hasExpectedPrefix && forbiddenKeys.length === 0;
+  return {
+    pass,
+    message: () => {
+      if (!hasExpectedPrefix) {
+        return `Expected _meta to have keys with prefixes [${expectedPrefixes.join(
+          ", "
+        )}] for platform "${platform}", but found: [${metaKeys.join(", ")}]`;
+      }
+      if (forbiddenKeys.length > 0) {
+        return `Expected _meta NOT to have keys [${forbiddenKeys.join(
+          ", "
+        )}] for platform "${platform}" (forbidden prefixes: [${forbiddenPrefixes.join(", ")}])`;
+      }
+      return `Expected result not to have platform meta for "${platform}"`;
+    }
+  };
+};
+var toHaveMetaKey = function(received, key) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have key "${key}", but no _meta found`
+    };
+  }
+  const pass = key in meta;
+  return {
+    pass,
+    message: () => pass ? `Expected _meta not to have key "${key}"` : `Expected _meta to have key "${key}"`
+  };
+};
+var toHaveMetaValue = function(received, key, value) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta["${key}"] to equal ${JSON.stringify(value)}, but no _meta found`
+    };
+  }
+  const actualValue = meta[key];
+  const pass = JSON.stringify(actualValue) === JSON.stringify(value);
+  return {
+    pass,
+    message: () => pass ? `Expected _meta["${key}"] not to equal ${JSON.stringify(value)}` : `Expected _meta["${key}"] to equal ${JSON.stringify(value)}, but got ${JSON.stringify(actualValue)}`
+  };
+};
+var toNotHaveMetaKey = function(received, key) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: true,
+      message: () => `Expected _meta to have key "${key}", but no _meta found`
+    };
+  }
+  const pass = !(key in meta);
+  return {
+    pass,
+    message: () => pass ? `Expected _meta to have key "${key}"` : `Expected _meta not to have key "${key}"`
+  };
+};
+var toHaveOnlyNamespacedMeta = function(received, namespace) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have keys with namespace "${namespace}", but no _meta found`
+    };
+  }
+  const metaKeys = Object.keys(meta);
+  const wrongKeys = metaKeys.filter((key) => !key.startsWith(namespace));
+  const pass = wrongKeys.length === 0 && metaKeys.length > 0;
+  return {
+    pass,
+    message: () => {
+      if (metaKeys.length === 0) {
+        return `Expected _meta to have keys with namespace "${namespace}", but _meta is empty`;
+      }
+      if (wrongKeys.length > 0) {
+        return `Expected _meta to ONLY have keys with namespace "${namespace}", but found: [${wrongKeys.join(", ")}]`;
+      }
+      return `Expected _meta not to have only keys with namespace "${namespace}"`;
+    }
+  };
+};
+var toHavePlatformMimeType = function(received, platform) {
+  const meta = extractMeta(received);
+  const expectedMimeType = getPlatformMimeType(platform);
+  if (!meta) {
+    return {
+      pass: false,
+      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;
+    case "ext-apps":
+      mimeTypeKey = "ui/mimeType";
+      break;
+    default:
+      mimeTypeKey = "frontmcp/mimeType";
+  }
+  const actualMimeType = meta[mimeTypeKey];
+  const pass = actualMimeType === expectedMimeType;
+  return {
+    pass,
+    message: () => pass ? `Expected _meta["${mimeTypeKey}"] not to be "${expectedMimeType}"` : `Expected _meta["${mimeTypeKey}"] to be "${expectedMimeType}" for platform "${platform}", but got "${actualMimeType}"`
+  };
+};
+var toHavePlatformHtml = function(received, platform) {
+  const meta = extractMeta(received);
+  if (!meta) {
+    return {
+      pass: false,
+      message: () => `Expected _meta to have platform HTML for "${platform}", but no _meta found`
+    };
+  }
+  let htmlKey;
+  switch (platform) {
+    case "openai":
+      htmlKey = "openai/html";
+      break;
+    case "ext-apps":
+      htmlKey = "ui/html";
+      break;
+    default:
+      htmlKey = "frontmcp/html";
+  }
+  const html = meta[htmlKey];
+  const pass = typeof html === "string" && html.length > 0;
+  return {
+    pass,
+    message: () => pass ? `Expected _meta not to have platform HTML in "${htmlKey}"` : `Expected _meta["${htmlKey}"] to contain HTML for platform "${platform}", but ${html === void 0 ? "key not found" : `got ${typeof html}`}`
+  };
+};
+var uiMatchers = {
+  // Existing HTML matchers
+  toHaveRenderedHtml,
+  toContainHtmlElement,
+  toContainBoundValue,
+  toBeXssSafe,
+  toHaveWidgetMetadata,
+  toHaveCssClass,
+  toNotContainRawContent,
+  toHaveProperHtmlStructure,
+  // Platform meta matchers
+  toHavePlatformMeta,
+  toHaveMetaKey,
+  toHaveMetaValue,
+  toNotHaveMetaKey,
+  toHaveOnlyNamespacedMeta,
+  toHavePlatformMimeType,
+  toHavePlatformHtml
+};
+
+// libs/testing/src/matchers/mcp-matchers.ts
+var toContainTool = function(received, toolName) {
+  const tools = received;
+  if (!Array.isArray(tools)) {
+    return {
+      pass: false,
+      message: () => `Expected an array of tools, but received ${typeof received}`
+    };
+  }
+  const pass = tools.some((t) => t.name === toolName);
+  const availableTools = tools.map((t) => t.name).join(", ");
+  return {
+    pass,
+    message: () => pass ? `Expected tools not to contain "${toolName}"` : `Expected tools to contain "${toolName}", but got: [${availableTools}]`
+  };
+};
+var toBeSuccessful = function(received) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("isSuccess" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a result wrapper object with isSuccess property`
+    };
+  }
+  const pass = result.isSuccess;
+  return {
+    pass,
+    message: () => pass ? "Expected result not to be successful" : `Expected result to be successful, but got error: ${result.error?.message ?? "unknown error"}`
+  };
+};
+var toBeError = function(received, expectedCode) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("isError" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a result wrapper object with isError property`
+    };
+  }
+  let pass = result.isError;
+  if (pass && expectedCode !== void 0) {
+    pass = result.error?.code === expectedCode;
+  }
+  return {
+    pass,
+    message: () => {
+      if (!result.isError) {
+        return "Expected result to be an error, but it was successful";
+      }
+      if (expectedCode !== void 0 && result.error?.code !== expectedCode) {
+        return `Expected error code ${expectedCode}, but got ${result.error?.code}`;
+      }
+      return "Expected result not to be an error";
+    }
+  };
+};
+var toHaveTextContent = function(received, expectedText) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("text" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a ToolResultWrapper or ResourceContentWrapper object with text method`
+    };
+  }
+  const text = result.text();
+  const hasText = "hasTextContent" in result ? result.hasTextContent() : text !== void 0;
+  let pass = hasText;
+  if (pass && expectedText !== void 0) {
+    pass = text?.includes(expectedText) ?? false;
+  }
+  return {
+    pass,
+    message: () => {
+      if (!hasText) {
+        return "Expected result to have text content";
+      }
+      if (expectedText !== void 0 && !text?.includes(expectedText)) {
+        return `Expected text to contain "${expectedText}", but got: "${text}"`;
+      }
+      return "Expected result not to have text content";
+    }
+  };
+};
+var toHaveImageContent = function(received) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("hasImageContent" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a ToolResultWrapper object with hasImageContent method`
+    };
+  }
+  const pass = result.hasImageContent();
+  return {
+    pass,
+    message: () => pass ? "Expected result not to have image content" : "Expected result to have image content"
+  };
+};
+var toHaveResourceContent = function(received) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("hasResourceContent" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a ToolResultWrapper object with hasResourceContent method`
+    };
+  }
+  const pass = result.hasResourceContent();
+  return {
+    pass,
+    message: () => pass ? "Expected result not to have resource content" : "Expected result to have resource content"
+  };
+};
+var toContainResource = function(received, uri) {
+  const resources = received;
+  if (!Array.isArray(resources)) {
+    return {
+      pass: false,
+      message: () => `Expected an array of resources, but received ${typeof received}`
+    };
+  }
+  const pass = resources.some((r) => r.uri === uri);
+  const availableUris = resources.map((r) => r.uri).join(", ");
+  return {
+    pass,
+    message: () => pass ? `Expected resources not to contain "${uri}"` : `Expected resources to contain "${uri}", but got: [${availableUris}]`
+  };
+};
+var toContainResourceTemplate = function(received, uriTemplate) {
+  const templates = received;
+  if (!Array.isArray(templates)) {
+    return {
+      pass: false,
+      message: () => `Expected an array of resource templates, but received ${typeof received}`
+    };
+  }
+  const pass = templates.some((t) => t.uriTemplate === uriTemplate);
+  const availableTemplates = templates.map((t) => t.uriTemplate).join(", ");
+  return {
+    pass,
+    message: () => pass ? `Expected templates not to contain "${uriTemplate}"` : `Expected templates to contain "${uriTemplate}", but got: [${availableTemplates}]`
+  };
+};
+var toHaveMimeType = function(received, mimeType) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("hasMimeType" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a ResourceContentWrapper object with hasMimeType method`
+    };
+  }
+  const pass = result.hasMimeType(mimeType);
+  const actualMimeType = result.mimeType();
+  return {
+    pass,
+    message: () => pass ? `Expected content not to have MIME type "${mimeType}"` : `Expected MIME type "${mimeType}", but got "${actualMimeType}"`
+  };
+};
+var toContainPrompt = function(received, name) {
+  const prompts = received;
+  if (!Array.isArray(prompts)) {
+    return {
+      pass: false,
+      message: () => `Expected an array of prompts, but received ${typeof received}`
+    };
+  }
+  const pass = prompts.some((p) => p.name === name);
+  const availablePrompts = prompts.map((p) => p.name).join(", ");
+  return {
+    pass,
+    message: () => pass ? `Expected prompts not to contain "${name}"` : `Expected prompts to contain "${name}", but got: [${availablePrompts}]`
+  };
+};
+var toHaveMessages = function(received, count) {
+  const result = received;
+  if (typeof result !== "object" || result === null || !("messages" in result)) {
+    return {
+      pass: false,
+      message: () => `Expected a PromptResultWrapper object with messages property`
+    };
+  }
+  const actualCount = result.messages?.length ?? 0;
+  const pass = actualCount === count;
+  return {
+    pass,
+    message: () => pass ? `Expected prompt not to have ${count} messages` : `Expected prompt to have ${count} messages, but got ${actualCount}`
+  };
+};
+var toBeValidJsonRpc = function(received) {
+  const response = received;
+  if (typeof response !== "object" || response === null) {
+    return {
+      pass: false,
+      message: () => `Expected an object, but received ${typeof received}`
+    };
+  }
+  const hasJsonRpc = response["jsonrpc"] === "2.0";
+  const hasId = "id" in response;
+  const hasResult = "result" in response;
+  const hasError = "error" in response;
+  const hasExactlyOneResultOrError = (hasResult || hasError) && !(hasResult && hasError);
+  const pass = hasJsonRpc && hasId && hasExactlyOneResultOrError;
+  return {
+    pass,
+    message: () => {
+      if (pass) {
+        return "Expected response not to be valid JSON-RPC";
+      }
+      const issues = [];
+      if (!hasJsonRpc) issues.push('missing or invalid "jsonrpc": "2.0"');
+      if (!hasId) issues.push('missing "id" field');
+      if (!hasExactlyOneResultOrError) {
+        if (!hasResult && !hasError) issues.push('missing "result" or "error"');
+        else issues.push('cannot have both "result" and "error"');
+      }
+      return `Expected valid JSON-RPC 2.0 response: ${issues.join(", ")}`;
+    }
+  };
+};
+var toHaveResult = function(received) {
+  const response = received;
+  if (typeof response !== "object" || response === null) {
+    return {
+      pass: false,
+      message: () => `Expected an object, but received ${typeof received}`
+    };
+  }
+  const pass = "result" in response;
+  return {
+    pass,
+    message: () => pass ? "Expected response not to have result" : "Expected response to have result"
+  };
+};
+var toHaveError = function(received) {
+  const response = received;
+  if (typeof response !== "object" || response === null) {
+    return {
+      pass: false,
+      message: () => `Expected an object, but received ${typeof received}`
+    };
+  }
+  const pass = "error" in response;
+  return {
+    pass,
+    message: () => pass ? "Expected response not to have error" : "Expected response to have error"
+  };
+};
+var toHaveErrorCode = function(received, code) {
+  const response = received;
+  if (typeof response !== "object" || response === null) {
+    return {
+      pass: false,
+      message: () => `Expected an object, but received ${typeof received}`
+    };
+  }
+  const actualCode = response.error?.code;
+  const pass = actualCode === code;
+  return {
+    pass,
+    message: () => pass ? `Expected response not to have error code ${code}` : `Expected error code ${code}, but got ${actualCode ?? "no error"}`
+  };
+};
+var mcpMatchers = {
+  // Tool matchers
+  toContainTool,
+  toBeSuccessful,
+  toBeError,
+  toHaveTextContent,
+  toHaveImageContent,
+  toHaveResourceContent,
+  // Resource matchers
+  toContainResource,
+  toContainResourceTemplate,
+  toHaveMimeType,
+  // Prompt matchers
+  toContainPrompt,
+  toHaveMessages,
+  // Protocol matchers
+  toBeValidJsonRpc,
+  toHaveResult,
+  toHaveError,
+  toHaveErrorCode,
+  // UI matchers (for testing tool UI responses)
+  ...uiMatchers
+};
+
+// libs/testing/src/http-mock/http-mock.ts
+var originalFetch = null;
+var mockingEnabled = false;
+var activeInterceptors = [];
+var HttpInterceptorImpl = class {
+  mocks = [];
+  _allowPassthrough = false;
+  _isActive = true;
+  mock(definition) {
+    const entry = {
+      definition,
+      callCount: 0,
+      calls: [],
+      remainingUses: definition.times ?? Infinity
+    };
+    this.mocks.push(entry);
+    return {
+      remove: () => {
+        const index = this.mocks.indexOf(entry);
+        if (index !== -1) {
+          this.mocks.splice(index, 1);
+        }
+      },
+      callCount: () => entry.callCount,
+      calls: () => [...entry.calls],
+      waitForCalls: async (count, timeoutMs = 5e3) => {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+          if (entry.callCount >= count) {
+            return entry.calls.slice(0, count);
+          }
+          await sleep3(50);
+        }
+        throw new Error(`Timeout waiting for ${count} calls, got ${entry.callCount}`);
+      }
+    };
+  }
+  get(url, response) {
+    return this.mock({
+      match: { url, method: "GET" },
+      response: normalizeResponse(response)
+    });
+  }
+  post(url, response) {
+    return this.mock({
+      match: { url, method: "POST" },
+      response: normalizeResponse(response)
+    });
+  }
+  put(url, response) {
+    return this.mock({
+      match: { url, method: "PUT" },
+      response: normalizeResponse(response)
+    });
+  }
+  delete(url, response) {
+    return this.mock({
+      match: { url, method: "DELETE" },
+      response: normalizeResponse(response)
+    });
+  }
+  any(url, response) {
+    return this.mock({
+      match: { url },
+      response: normalizeResponse(response)
+    });
+  }
+  clear() {
+    this.mocks = [];
+  }
+  pending() {
+    return this.mocks.filter((m) => m.remainingUses > 0).map((m) => m.definition);
+  }
+  isDone() {
+    return this.mocks.every((m) => m.remainingUses <= 0 || m.definition.times === void 0);
+  }
+  assertDone() {
+    const pending = this.pending().filter((m) => m.times !== void 0);
+    if (pending.length > 0) {
+      const descriptions = pending.map((m) => {
+        const url = m.match.url instanceof RegExp ? m.match.url.toString() : m.match.url;
+        return `  - ${m.match.method ?? "ANY"} ${url}`;
+      });
+      throw new Error(`Unused HTTP mocks:
+${descriptions.join("\n")}`);
+    }
+  }
+  allowPassthrough(allow) {
+    this._allowPassthrough = allow;
+  }
+  restore() {
+    this._isActive = false;
+    const index = activeInterceptors.indexOf(this);
+    if (index !== -1) {
+      activeInterceptors.splice(index, 1);
+    }
+  }
+  // Internal methods
+  isActive() {
+    return this._isActive;
+  }
+  canPassthrough() {
+    return this._allowPassthrough;
+  }
+  /**
+   * Try to match a request against mocks in this scope
+   */
+  async matchRequest(info) {
+    if (!this._isActive) return null;
+    for (const entry of this.mocks) {
+      if (entry.remainingUses <= 0) continue;
+      if (this.requestMatches(info, entry.definition.match)) {
+        entry.callCount++;
+        entry.calls.push(info);
+        entry.remainingUses--;
+        let mockResponse2;
+        if (typeof entry.definition.response === "function") {
+          mockResponse2 = await entry.definition.response(info);
+        } else {
+          mockResponse2 = entry.definition.response;
+        }
+        if (mockResponse2.delay && mockResponse2.delay > 0) {
+          await sleep3(mockResponse2.delay);
+        }
+        return createMockResponse(mockResponse2);
+      }
+    }
+    return null;
+  }
+  requestMatches(info, matcher) {
+    if (!this.urlMatches(info.url, matcher.url)) {
+      return false;
+    }
+    if (matcher.method) {
+      const methods = Array.isArray(matcher.method) ? matcher.method : [matcher.method];
+      if (!methods.includes(info.method)) {
+        return false;
+      }
+    }
+    if (matcher.headers) {
+      for (const [key, expected] of Object.entries(matcher.headers)) {
+        const actual = info.headers[key.toLowerCase()];
+        if (!actual) return false;
+        if (expected instanceof RegExp) {
+          if (!expected.test(actual)) return false;
+        } else if (actual !== expected) {
+          return false;
+        }
+      }
+    }
+    if (matcher.body !== void 0) {
+      if (!this.bodyMatches(info.body, matcher.body)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  urlMatches(url, matcher) {
+    if (typeof matcher === "string") {
+      return url === matcher || url.includes(matcher);
+    } else if (matcher instanceof RegExp) {
+      return matcher.test(url);
+    } else {
+      return matcher(url);
+    }
+  }
+  bodyMatches(actual, expected) {
+    if (typeof expected === "function") {
+      return expected(actual);
+    }
+    if (typeof expected === "string") {
+      const actualStr = typeof actual === "string" ? actual : JSON.stringify(actual);
+      return actualStr === expected || actualStr.includes(expected);
+    }
+    if (expected instanceof RegExp) {
+      const actualStr = typeof actual === "string" ? actual : JSON.stringify(actual);
+      return expected.test(actualStr);
+    }
+    if (typeof actual !== "object" || actual === null) {
+      return false;
+    }
+    for (const [key, value] of Object.entries(expected)) {
+      const actualValue = actual[key];
+      if (typeof value === "object" && value !== null) {
+        if (!this.bodyMatches(actualValue, value)) {
+          return false;
+        }
+      } else if (actualValue !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+async function interceptedFetch(input, init) {
+  const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+  const method = (init?.method ?? "GET").toUpperCase();
+  const headers = {};
+  if (init?.headers) {
+    if (init.headers instanceof Headers) {
+      init.headers.forEach((value, key) => {
+        headers[key.toLowerCase()] = value;
+      });
+    } else if (Array.isArray(init.headers)) {
+      for (const [key, value] of init.headers) {
+        headers[key.toLowerCase()] = value;
+      }
+    } else {
+      for (const [key, value] of Object.entries(init.headers)) {
+        headers[key.toLowerCase()] = value;
+      }
+    }
+  }
+  let body;
+  let rawBody;
+  if (init?.body) {
+    if (typeof init.body === "string") {
+      rawBody = init.body;
+      try {
+        body = JSON.parse(init.body);
+      } catch {
+        body = init.body;
+      }
+    } else if (init.body instanceof ArrayBuffer || init.body instanceof Uint8Array) {
+      rawBody = new TextDecoder().decode(init.body);
+      try {
+        body = JSON.parse(rawBody);
+      } catch {
+        body = rawBody;
+      }
+    } else {
+      body = init.body;
+    }
+  }
+  const requestInfo = {
+    url,
+    method,
+    headers,
+    body,
+    rawBody
+  };
+  for (let i = activeInterceptors.length - 1; i >= 0; i--) {
+    const interceptor = activeInterceptors[i];
+    if (!interceptor.isActive()) continue;
+    const mockResponse2 = await interceptor.matchRequest(requestInfo);
+    if (mockResponse2) {
+      return mockResponse2;
+    }
+  }
+  for (const interceptor of activeInterceptors) {
+    if (interceptor.isActive() && interceptor.canPassthrough()) {
+      if (originalFetch) {
+        return originalFetch(input, init);
+      }
+    }
+  }
+  throw new Error(
+    `No HTTP mock found for ${method} ${url}
+Add a mock using httpMock.interceptor().${method.toLowerCase()}('${url}', { body: ... })`
+  );
+}
+function normalizeResponse(response) {
+  if (!("status" in response) && !("body" in response) && !("headers" in response)) {
+    return { body: response };
+  }
+  return response;
+}
+function createMockResponse(mock) {
+  const mockAny = mock;
+  if (mockAny._throwError) {
+    const body2 = mock.body;
+    const message = body2 && typeof body2 === "object" && "message" in body2 ? String(body2["message"]) : "Network error";
+    throw new TypeError(`fetch failed: ${message}`);
+  }
+  const status = mock.status ?? 200;
+  const statusText = mock.statusText ?? "OK";
+  const headers = new Headers(mock.headers ?? {});
+  let body = null;
+  if (mock.body !== void 0) {
+    if (typeof mock.body === "string") {
+      body = mock.body;
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "text/plain");
+      }
+    } else if (mock.body instanceof ArrayBuffer) {
+      body = mock.body;
+    } else if (Buffer.isBuffer(mock.body)) {
+      body = new Uint8Array(mock.body).buffer;
+    } else {
+      body = JSON.stringify(mock.body);
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+      }
+    }
+  }
+  return new Response(body, { status, statusText, headers });
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var HttpMockManagerImpl = class {
+  interceptor() {
+    if (!mockingEnabled) {
+      this.enable();
+    }
+    const interceptor = new HttpInterceptorImpl();
+    activeInterceptors.push(interceptor);
+    return interceptor;
+  }
+  enable() {
+    if (mockingEnabled) return;
+    if (typeof globalThis.fetch === "function") {
+      originalFetch = globalThis.fetch;
+      globalThis.fetch = interceptedFetch;
+    }
+    mockingEnabled = true;
+  }
+  disable() {
+    if (!mockingEnabled) return;
+    if (originalFetch) {
+      globalThis.fetch = originalFetch;
+      originalFetch = null;
+    }
+    activeInterceptors.length = 0;
+    mockingEnabled = false;
+  }
+  isEnabled() {
+    return mockingEnabled;
+  }
+  clearAll() {
+    for (const interceptor of activeInterceptors) {
+      interceptor.clear();
+    }
+    activeInterceptors.length = 0;
+  }
+};
+var httpMock = new HttpMockManagerImpl();
+var httpResponse = {
+  /** Create a JSON response */
+  json(data, status = 200) {
+    return {
+      status,
+      headers: { "content-type": "application/json" },
+      body: data
+    };
+  },
+  /** Create a text response */
+  text(data, status = 200) {
+    return {
+      status,
+      headers: { "content-type": "text/plain" },
+      body: data
+    };
+  },
+  /** Create an HTML response */
+  html(data, status = 200) {
+    return {
+      status,
+      headers: { "content-type": "text/html" },
+      body: data
+    };
+  },
+  /** Create an error response */
+  error(status, message) {
+    return {
+      status,
+      statusText: message ?? getStatusText(status),
+      body: message ? { error: message } : void 0
+    };
+  },
+  /** Create a 404 Not Found response */
+  notFound(message = "Not Found") {
+    return httpResponse.error(404, message);
+  },
+  /** Create a 500 Internal Server Error response */
+  serverError(message = "Internal Server Error") {
+    return httpResponse.error(500, message);
+  },
+  /** Create a 401 Unauthorized response */
+  unauthorized(message = "Unauthorized") {
+    return httpResponse.error(401, message);
+  },
+  /** Create a 403 Forbidden response */
+  forbidden(message = "Forbidden") {
+    return httpResponse.error(403, message);
+  },
+  /**
+   * Create a network error that causes fetch to reject
+   * This simulates real network failures where fetch throws instead of returning a Response
+   */
+  networkError(message = "Network error") {
+    return {
+      status: 0,
+      body: { _networkError: true, message },
+      // Mark this as a network error for the interceptor to throw
+      _throwError: true
+    };
+  },
+  /** Create a delayed response */
+  delayed(data, delayMs, status = 200) {
+    return {
+      status,
+      body: data,
+      delay: delayMs
+    };
+  }
+};
+function getStatusText(status) {
+  const texts = {
+    200: "OK",
+    201: "Created",
+    204: "No Content",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable"
+  };
+  return texts[status] ?? "Unknown";
+}
+
+// libs/testing/src/ui/ui-assertions.ts
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var UIAssertions = {
+  /**
+   * Assert tool result has valid rendered UI HTML.
+   * @param result - The tool result wrapper
+   * @returns The rendered HTML string
+   * @throws Error if no UI HTML found or if mdx-fallback detected
+   */
+  assertRenderedUI(result) {
+    const meta = result.raw._meta;
+    if (!meta) {
+      throw new Error("Expected tool result to have _meta, but _meta is undefined");
+    }
+    const html = meta["ui/html"];
+    if (!html) {
+      throw new Error("Expected tool result to have ui/html in _meta, but it is missing");
+    }
+    if (typeof html !== "string") {
+      throw new Error(`Expected ui/html to be a string, but got ${typeof html}`);
+    }
+    if (html.includes("mdx-fallback")) {
+      throw new Error(
+        "Got mdx-fallback instead of rendered HTML - MDX/React rendering failed. Check that @mdx-js/mdx is installed and the template syntax is valid."
+      );
+    }
+    return html;
+  },
+  /**
+   * Assert HTML contains all expected bound values from tool output.
+   * @param html - The rendered HTML string
+   * @param output - The tool output object
+   * @param keys - Array of keys whose values should appear in the HTML
+   * @throws Error if any expected value is missing from the HTML
+   */
+  assertDataBinding(html, output, keys) {
+    const missingKeys = [];
+    for (const key of keys) {
+      const value = output[key];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      const stringValue = String(value);
+      if (!html.includes(stringValue)) {
+        missingKeys.push(`${key}="${stringValue}"`);
+      }
+    }
+    if (missingKeys.length > 0) {
+      throw new Error(
+        `Expected HTML to contain bound values for: ${missingKeys.join(", ")}. Data binding may have failed.`
+      );
+    }
+  },
+  /**
+   * Assert HTML is XSS-safe (no scripts, event handlers, or javascript: URIs).
+   * @param html - The rendered HTML string
+   * @throws Error if potential XSS vulnerabilities are detected
+   */
+  assertXssSafe(html) {
+    const vulnerabilities = [];
+    if (/<script[\s>]/i.test(html)) {
+      vulnerabilities.push("<script> tag detected");
+    }
+    if (/\son\w+\s*=/i.test(html)) {
+      vulnerabilities.push("inline event handler detected (onclick, onerror, etc.)");
+    }
+    if (/javascript:/i.test(html)) {
+      vulnerabilities.push("javascript: URI detected");
+    }
+    if (vulnerabilities.length > 0) {
+      throw new Error(`Potential XSS vulnerabilities found: ${vulnerabilities.join("; ")}`);
+    }
+  },
+  /**
+   * Assert HTML has proper structure (not escaped raw content).
+   * @param html - The rendered HTML string
+   * @throws Error if HTML appears to be raw/unrendered content
+   */
+  assertProperHtmlStructure(html) {
+    if (html.includes("&lt;") && html.includes("&gt;")) {
+      throw new Error(
+        "HTML contains escaped HTML entities (&lt;, &gt;) - content was likely not rendered. Check that the template is being processed correctly."
+      );
+    }
+    if (!/<[a-z]/i.test(html)) {
+      throw new Error("HTML contains no HTML tags - content may be plain text or rendering failed.");
+    }
+  },
+  /**
+   * Assert HTML contains a specific element.
+   * @param html - The rendered HTML string
+   * @param tag - The HTML tag name to look for
+   * @throws Error if the element is not found
+   */
+  assertContainsElement(html, tag) {
+    const regex = new RegExp(`<${escapeRegex2(tag)}[\\s>]`, "i");
+    if (!regex.test(html)) {
+      throw new Error(`Expected HTML to contain <${tag}> element`);
+    }
+  },
+  /**
+   * Assert HTML contains a specific CSS class.
+   * @param html - The rendered HTML string
+   * @param className - The CSS class name to look for
+   * @throws Error if the class is not found
+   */
+  assertHasCssClass(html, className) {
+    const classRegex = new RegExp(`class(?:Name)?\\s*=\\s*["'][^"']*\\b${escapeRegex2(className)}\\b[^"']*["']`, "i");
+    if (!classRegex.test(html)) {
+      throw new Error(`Expected HTML to have CSS class "${className}"`);
+    }
+  },
+  /**
+   * Assert HTML does NOT contain specific content.
+   * Useful for verifying custom components were rendered, not left as raw tags.
+   * @param html - The rendered HTML string
+   * @param content - The content that should NOT appear
+   * @throws Error if the content is found
+   */
+  assertNotContainsRaw(html, content) {
+    if (html.includes(content)) {
+      throw new Error(
+        `HTML contains raw content "${content}" - this component may not have been rendered. Check that all custom components are properly passed to the renderer.`
+      );
+    }
+  },
+  /**
+   * Assert that widget metadata is present in the result.
+   * Checks for ui/html, openai/outputTemplate, or ui/mimeType.
+   * @param result - The tool result wrapper
+   * @throws Error if widget metadata is missing
+   */
+  assertWidgetMetadata(result) {
+    const meta = result.raw._meta;
+    if (!meta) {
+      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)");
+    }
+  },
+  /**
+   * Comprehensive UI validation that runs all checks.
+   * @param result - The tool result wrapper
+   * @param boundKeys - Optional array of output keys to check for data binding
+   * @returns The rendered HTML string
+   * @throws Error if any validation fails
+   */
+  assertValidUI(result, boundKeys) {
+    const html = UIAssertions.assertRenderedUI(result);
+    UIAssertions.assertProperHtmlStructure(html);
+    UIAssertions.assertXssSafe(html);
+    if (boundKeys && boundKeys.length > 0) {
+      try {
+        const output = JSON.parse(result.text() || "{}");
+        UIAssertions.assertDataBinding(html, output, boundKeys);
+      } catch {
+      }
+    }
+    return html;
+  },
+  // ═══════════════════════════════════════════════════════════════════
+  // PLATFORM META ASSERTIONS
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * Assert tool result has correct meta keys for OpenAI platform.
+   * Verifies openai/* keys are present and ui/*, frontmcp/* keys are absent.
+   * @param result - The tool result wrapper
+   * @throws Error if meta keys don't match OpenAI expectations
+   */
+  assertOpenAIMeta(result) {
+    UIAssertions.assertPlatformMeta(result, "openai");
+  },
+  /**
+   * Assert tool result has correct meta keys for ext-apps platform (SEP-1865).
+   * 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 ext-apps expectations
+   */
+  assertExtAppsMeta(result) {
+    UIAssertions.assertPlatformMeta(result, "ext-apps");
+  },
+  /**
+   * Assert tool result has correct meta keys for FrontMCP platforms (Claude, Cursor, etc.).
+   * Verifies frontmcp/* + ui/* keys are present and openai/* keys are absent.
+   * @param result - The tool result wrapper
+   * @throws Error if meta keys don't match FrontMCP expectations
+   */
+  assertFrontmcpMeta(result) {
+    UIAssertions.assertPlatformMeta(result, "claude");
+  },
+  /**
+   * Assert tool result has correct meta keys for a specific platform.
+   * @param result - The tool result wrapper
+   * @param platform - The platform type to check for
+   * @throws Error if meta keys don't match platform expectations
+   */
+  assertPlatformMeta(result, platform) {
+    const meta = result.raw._meta;
+    if (!meta) {
+      throw new Error(`Expected tool result to have _meta with platform meta for "${platform}"`);
+    }
+    const expectedPrefixes = getToolCallMetaPrefixes(platform);
+    const forbiddenPrefixes = getForbiddenMetaPrefixes(platform);
+    const metaKeys = Object.keys(meta);
+    const hasExpectedPrefix = metaKeys.some((key) => expectedPrefixes.some((prefix) => key.startsWith(prefix)));
+    if (!hasExpectedPrefix) {
+      throw new Error(
+        `Expected _meta to have keys with prefixes [${expectedPrefixes.join(", ")}] for platform "${platform}", but found: [${metaKeys.join(", ")}]`
+      );
+    }
+    const forbiddenKeys = metaKeys.filter((key) => forbiddenPrefixes.some((prefix) => key.startsWith(prefix)));
+    if (forbiddenKeys.length > 0) {
+      throw new Error(
+        `Expected _meta NOT to have keys [${forbiddenKeys.join(", ")}] for platform "${platform}" (forbidden prefixes: [${forbiddenPrefixes.join(", ")}])`
+      );
+    }
+  },
+  /**
+   * Assert that no cross-namespace pollution exists in meta.
+   * @param result - The tool result wrapper
+   * @param expectedNamespace - The namespace that SHOULD be present
+   * @throws Error if other namespaces are found
+   */
+  assertNoMixedNamespaces(result, expectedNamespace) {
+    const meta = result.raw._meta;
+    if (!meta) {
+      throw new Error(`Expected tool result to have _meta with namespace "${expectedNamespace}"`);
+    }
+    const metaKeys = Object.keys(meta);
+    const wrongKeys = metaKeys.filter((key) => !key.startsWith(expectedNamespace));
+    if (wrongKeys.length > 0) {
+      throw new Error(
+        `Expected _meta to ONLY have keys with namespace "${expectedNamespace}", but found: [${wrongKeys.join(", ")}]`
+      );
+    }
+  },
+  /**
+   * Assert that _meta has the correct MIME type for a platform.
+   * @param result - The tool result wrapper
+   * @param platform - The platform type to check for
+   * @throws Error if MIME type doesn't match platform expectations
+   */
+  assertPlatformMimeType(result, platform) {
+    const meta = result.raw._meta;
+    const expectedMimeType = getPlatformMimeType(platform);
+    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;
+      case "ext-apps":
+        mimeTypeKey = "ui/mimeType";
+        break;
+      default:
+        mimeTypeKey = "frontmcp/mimeType";
+    }
+    const actualMimeType = meta[mimeTypeKey];
+    if (actualMimeType !== expectedMimeType) {
+      throw new Error(
+        `Expected _meta["${mimeTypeKey}"] to be "${expectedMimeType}" for platform "${platform}", but got "${actualMimeType}"`
+      );
+    }
+  },
+  /**
+   * Assert that _meta has HTML in the correct platform-specific key.
+   * @param result - The tool result wrapper
+   * @param platform - The platform type to check for
+   * @returns The HTML string
+   * @throws Error if HTML is missing or in wrong key
+   */
+  assertPlatformHtml(result, platform) {
+    const meta = result.raw._meta;
+    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;
+      case "ext-apps":
+        htmlKey = "ui/html";
+        break;
+      default:
+        htmlKey = "frontmcp/html";
+    }
+    const html = meta[htmlKey];
+    if (typeof html !== "string" || html.length === 0) {
+      throw new Error(
+        `Expected _meta["${htmlKey}"] to contain HTML for platform "${platform}", but ${html === void 0 ? "key not found" : `got ${typeof html}`}`
+      );
+    }
+    return html;
+  },
+  /**
+   * Comprehensive platform meta validation.
+   * @param result - The tool result wrapper
+   * @param platform - The platform type to validate for
+   * @returns The platform-specific HTML string
+   * @throws Error if any platform-specific validation fails
+   */
+  assertValidPlatformMeta(result, platform) {
+    UIAssertions.assertPlatformMeta(result, platform);
+    UIAssertions.assertPlatformMimeType(result, platform);
+    return UIAssertions.assertPlatformHtml(result, platform);
+  }
+};
+
+// libs/testing/src/example-tools/tool-configs.ts
+import { z } from "zod";
+var basicUIToolInputSchema = z.object({
+  name: z.string().optional().default("World")
+});
+var basicUIToolOutputSchema = z.object({
+  message: z.string(),
+  timestamp: z.number()
+});
+var BASIC_UI_TOOL_CONFIG = {
+  name: "platform-test-basic",
+  description: "Basic UI tool for platform testing",
+  inputSchema: basicUIToolInputSchema,
+  outputSchema: basicUIToolOutputSchema,
+  ui: {
+    /**
+     * Simple template that displays the output.
+     * Works with all platforms.
+     */
+    template: `
+<div class="platform-test-basic">
+  <h1>Platform Test - Basic</h1>
+  <p>Message: {output.message}</p>
+  <p>Timestamp: {output.timestamp}</p>
+</div>
+    `.trim()
+  }
+};
+var fullUIToolInputSchema = z.object({
+  name: z.string().optional().default("World"),
+  count: z.number().optional().default(1)
+});
+var fullUIToolOutputSchema = z.object({
+  message: z.string(),
+  count: z.number(),
+  items: z.array(z.string()),
+  timestamp: z.number()
+});
+var FULL_UI_TOOL_CONFIG = {
+  name: "platform-test-full",
+  description: "Full UI tool with all options for comprehensive platform testing",
+  inputSchema: fullUIToolInputSchema,
+  outputSchema: fullUIToolOutputSchema,
+  ui: {
+    /**
+     * Template with more complex UI elements.
+     */
+    template: `
+<div class="platform-test-full">
+  <h1>Platform Test - Full</h1>
+  <div class="message-box">
+    <strong>Message:</strong> {output.message}
+  </div>
+  <div class="count-box">
+    <strong>Count:</strong> {output.count}
+  </div>
+  <div class="items-list">
+    <strong>Items:</strong>
+    <ul>
+      {output.items.map(item => <li key={item}>{item}</li>)}
+    </ul>
+  </div>
+  <footer>
+    <small>Generated at: {new Date(output.timestamp).toISOString()}</small>
+  </footer>
+</div>
+    `.trim(),
+    /**
+     * Widget is accessible for callback invocations.
+     */
+    widgetAccessible: true,
+    /**
+     * Invocation status messages for OpenAI.
+     */
+    invocationStatus: {
+      invoking: "Processing request...",
+      invoked: "Request completed"
+    },
+    /**
+     * Content Security Policy configuration.
+     */
+    csp: {
+      connectDomains: ["https://api.example.com"],
+      resourceDomains: ["https://cdn.example.com"]
+    },
+    /**
+     * Display mode for the widget.
+     */
+    displayMode: "inline",
+    /**
+     * Prefers border around the widget.
+     */
+    prefersBorder: true,
+    /**
+     * Custom sandbox domain.
+     */
+    sandboxDomain: "sandbox.example.com"
+  }
+};
+function generateBasicUIToolOutput(input) {
+  return {
+    message: `Hello, ${input.name}!`,
+    timestamp: Date.now()
+  };
+}
+function generateFullUIToolOutput(input) {
+  const items = [];
+  for (let i = 1; i <= input.count; i++) {
+    items.push(`Item ${i}`);
+  }
+  return {
+    message: `Hello, ${input.name}! You requested ${input.count} item(s).`,
+    count: input.count,
+    items,
+    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_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_FRONTMCP_TOOLS_LIST_META_KEYS = [
+  "frontmcp/outputTemplate",
+  "frontmcp/resultCanProduceWidget",
+  "ui/cdn",
+  "ui/type"
+];
+var EXPECTED_FRONTMCP_TOOL_CALL_META_KEYS = [
+  "frontmcp/html",
+  "frontmcp/mimeType",
+  "ui/html",
+  "ui/mimeType"
+];
+export {
+  AssertionError,
+  AuthHeaders,
+  BASIC_UI_TOOL_CONFIG,
+  ConnectionError,
+  DefaultInterceptorChain,
+  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_OPENAI_TOOLS_LIST_META_KEYS,
+  EXPECTED_OPENAI_TOOL_CALL_META_KEYS,
+  FULL_UI_TOOL_CONFIG,
+  McpAssertions,
+  McpProtocolError,
+  McpTestClient,
+  McpTestClientBuilder,
+  MockAPIServer,
+  MockOAuthServer,
+  PLATFORM_DETECTION_PATTERNS,
+  ServerStartError,
+  StreamableHttpTransport,
+  TestClientError,
+  TestServer,
+  TestTokenFactory,
+  TestUsers,
+  TimeoutError,
+  UIAssertions,
+  basicUIToolInputSchema,
+  basicUIToolOutputSchema,
+  buildUserAgent,
+  containsPrompt,
+  containsResource,
+  containsResourceTemplate,
+  containsTool,
+  createTestUser,
+  expect,
+  fullUIToolInputSchema,
+  fullUIToolOutputSchema,
+  generateBasicUIToolOutput,
+  generateFullUIToolOutput,
+  getForbiddenMetaPrefixes,
+  getPlatformClientInfo,
+  getPlatformMetaNamespace,
+  getPlatformMimeType,
+  getPlatformUserAgent,
+  getToolCallMetaPrefixes,
+  getToolsListMetaPrefixes,
+  hasMimeType,
+  hasTextContent,
+  httpMock,
+  httpResponse,
+  interceptors,
+  isError,
+  isExtAppsPlatform,
+  isFrontmcpPlatform,
+  isOpenAIPlatform,
+  isSuccessful,
+  mcpMatchers,
+  mockResponse,
+  test,
+  uiMatchers
+};