@frontmcp/testing 1.8.7 → 1.9.0

package/index.js

@@ -60,6 +60,7 @@ __export(index_exports, {
   RegressionDetector: () => RegressionDetector,
   ReportGenerator: () => ReportGenerator,
   ServerStartError: () => ServerStartError,
+  SseTransport: () => SseTransport,
   StreamableHttpTransport: () => StreamableHttpTransport,
   TestClientError: () => TestClientError,
   TestServer: () => TestServer,
@@ -486,8 +487,453 @@ function isInterceptedError(err) {
   return typeof err === "object" && err !== null && interceptedErrors.has(err);
 }
 
-// libs/testing/src/transport/streamable-http.transport.ts
+// libs/testing/src/transport/sse.transport.ts
 var DEFAULT_TIMEOUT = 3e4;
+var SseTransport = class {
+  baseUrl;
+  entryPath;
+  timeout;
+  authHeaders;
+  publicMode;
+  debug;
+  clientInfo;
+  notificationHandler;
+  interceptors;
+  elicitationHandler;
+  state = "disconnected";
+  authToken;
+  sessionId;
+  messageEndpoint;
+  stream;
+  pending = /* @__PURE__ */ new Map();
+  connectionCount = 0;
+  reconnectCount = 0;
+  lastRequestHeaders = {};
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.entryPath = config.entryPath;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.authHeaders = config.auth?.headers ?? {};
+    this.authToken = config.auth?.token;
+    this.publicMode = config.publicMode ?? false;
+    this.debug = config.debug ?? false;
+    this.clientInfo = config.clientInfo;
+    this.notificationHandler = config.notificationHandler;
+    this.interceptors = config.interceptors;
+    this.elicitationHandler = config.elicitationHandler;
+  }
+  async connect() {
+    this.state = "connecting";
+    this.connectionCount++;
+    try {
+      if (!this.publicMode && !this.authToken) {
+        await this.requestAnonymousToken();
+      }
+      await this.openStream();
+      this.state = "connected";
+      this.log(`Connected; messages go to ${this.messageEndpoint}`);
+    } catch (error) {
+      this.state = "error";
+      this.stream?.abort();
+      this.stream = void 0;
+      throw error;
+    }
+  }
+  async request(message) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    if (this.interceptors) {
+      const intercepted = await this.interceptors.processRequest(message, {
+        timestamp: /* @__PURE__ */ new Date(),
+        transport: "sse",
+        sessionId: this.sessionId
+      });
+      switch (intercepted.type) {
+        case "mock":
+          return await this.interceptors.processResponse(
+            message,
+            intercepted.response,
+            Date.now() - startTime
+          );
+        case "error":
+          throw markInterceptedError(intercepted.error);
+        case "continue":
+          message = intercepted.request;
+          break;
+      }
+    }
+    let response;
+    if (message.id === void 0) {
+      await this.post(JSON.stringify(message));
+      response = { jsonrpc: "2.0", id: null, result: void 0 };
+    } else {
+      response = await this.postAndAwait(message.id, JSON.stringify(message));
+    }
+    if (this.interceptors) {
+      response = await this.interceptors.processResponse(message, response, Date.now() - startTime);
+    }
+    return response;
+  }
+  async notify(message) {
+    this.ensureConnected();
+    const result = await this.post(JSON.stringify(message));
+    if (!result.ok) this.log(`HTTP ${result.status} on notification: ${result.body}`);
+  }
+  async sendRaw(data) {
+    this.ensureConnected();
+    let id;
+    try {
+      const parsed = JSON.parse(data);
+      if (typeof parsed.id === "string" || typeof parsed.id === "number") id = parsed.id;
+    } catch {
+    }
+    if (id !== void 0) return this.postAndAwait(id, data);
+    const result = await this.post(data);
+    if (!result.ok) {
+      return { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error", data: result.body } };
+    }
+    return { jsonrpc: "2.0", id: null, result: void 0 };
+  }
+  async close() {
+    this.closeStream("Transport closed");
+    this.state = "disconnected";
+    this.sessionId = void 0;
+    this.messageEndpoint = void 0;
+    this.log("SSE transport closed");
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  getState() {
+    return this.state;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  setTimeout(ms) {
+    this.timeout = ms;
+  }
+  getMessageEndpoint() {
+    return this.messageEndpoint;
+  }
+  getConnectionCount() {
+    return this.connectionCount;
+  }
+  getReconnectCount() {
+    return this.reconnectCount;
+  }
+  getLastRequestHeaders() {
+    return { ...this.lastRequestHeaders };
+  }
+  setInterceptors(interceptors2) {
+    this.interceptors = interceptors2;
+  }
+  getInterceptors() {
+    return this.interceptors;
+  }
+  setElicitationHandler(handler) {
+    this.elicitationHandler = handler;
+  }
+  async simulateDisconnect() {
+    this.closeStream("Simulated disconnect");
+    this.state = "disconnected";
+    this.sessionId = void 0;
+    this.messageEndpoint = void 0;
+  }
+  async waitForReconnect(timeoutMs) {
+    this.reconnectCount++;
+    let timer;
+    try {
+      await Promise.race([
+        this.connect(),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Timeout waiting for reconnection")), timeoutMs);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // STREAM
+  // ═══════════════════════════════════════════════════════════════════
+  /** Open `GET <entry>/sse` and wait for the `endpoint` event. */
+  async openStream() {
+    const controller = new AbortController();
+    this.stream = controller;
+    const url = this.sseUrl();
+    const { "Content-Type": _contentType, ...headers } = this.buildHeaders();
+    this.log(`GET ${url}`);
+    const connectTimer = setTimeout(() => controller.abort(), this.timeout);
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "GET",
+        headers: { ...headers, Accept: "text/event-stream" },
+        signal: controller.signal
+      });
+    } catch (error) {
+      clearTimeout(connectTimer);
+      throw new Error(
+        isAbortError(error) ? `SSE connection to ${url} timed out after ${this.timeout}ms` : `SSE connection to ${url} failed: ${errorMessage(error)}`,
+        { cause: error }
+      );
+    }
+    const isEventStream = response.headers.get("content-type")?.includes("text/event-stream") ?? false;
+    if (!response.ok || !response.body || !isEventStream) {
+      clearTimeout(connectTimer);
+      const body = await response.text().catch(() => "");
+      throw new Error(
+        `SSE connection to ${url} failed: HTTP ${response.status} ${response.statusText}${body ? ` \u2014 ${body}` : ""}. The legacy HTTP+SSE transport needs a server that serves it (@FrontMcp({ transport: { protocol: { legacy: true } } })).`
+      );
+    }
+    const endpoint = new Promise((resolve, reject) => {
+      const reader = response.body?.getReader();
+      if (!reader) {
+        reject(new Error(`SSE connection to ${url} has no body`));
+        return;
+      }
+      void this.readStream(controller, reader, resolve, reject);
+    });
+    try {
+      const data = await endpoint;
+      const messageUrl = new URL(data, url);
+      this.messageEndpoint = messageUrl.toString();
+      this.sessionId = messageUrl.searchParams.get("sessionId") ?? void 0;
+    } finally {
+      clearTimeout(connectTimer);
+    }
+  }
+  async readStream(controller, reader, onEndpoint, onEndpointError) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let endpointSeen = false;
+    try {
+      for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
+        const { completeEvents, remainder } = splitSSEEvents(buffer + decoder.decode(chunk.value, { stream: true }));
+        buffer = remainder;
+        for (const text of completeEvents) {
+          const event = parseSSEEvent(text);
+          if (!event) continue;
+          if (event.type === "endpoint") {
+            if (!endpointSeen) {
+              endpointSeen = true;
+              onEndpoint(event.data);
+            }
+            continue;
+          }
+          await this.handleMessage(event.data);
+        }
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) this.log("SSE stream failed:", error);
+    } finally {
+      reader.releaseLock();
+    }
+    if (!endpointSeen) {
+      onEndpointError(
+        new Error(
+          controller.signal.aborted ? `SSE stream at ${this.sseUrl()} sent no endpoint event within ${this.timeout}ms` : `SSE stream at ${this.sseUrl()} ended before the server sent its endpoint`
+        )
+      );
+    }
+    if (this.stream === controller) {
+      this.stream = void 0;
+      this.rejectPending("SSE stream closed by the server");
+      if (this.state === "connected") this.state = "disconnected";
+    }
+  }
+  async handleMessage(data) {
+    let message;
+    try {
+      message = JSON.parse(data);
+    } catch {
+      this.log("Ignoring SSE event that is not JSON:", data);
+      return;
+    }
+    if (!message || typeof message !== "object") return;
+    if (typeof message.method === "string") {
+      const request = message;
+      if (request.id === void 0 || request.id === null) {
+        this.notificationHandler?.(request);
+        return;
+      }
+      await this.answerServerRequest(request);
+      return;
+    }
+    if (message.id !== void 0 && message.id !== null) {
+      const pending = this.pending.get(message.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(message.id);
+        pending.resolve(message);
+      }
+    }
+  }
+  /** Server→client requests: elicitation goes to the handler, `ping` is answered, the rest refused. */
+  async answerServerRequest(request) {
+    const id = request.id;
+    let reply;
+    if (request.method === "elicitation/create") {
+      reply = { jsonrpc: "2.0", id, result: await this.elicit(request.params) };
+    } else if (request.method === "ping") {
+      reply = { jsonrpc: "2.0", id, result: {} };
+    } else {
+      reply = { jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${request.method}` } };
+    }
+    const result = await this.post(JSON.stringify(reply));
+    if (!result.ok) this.log(`HTTP ${result.status} answering ${request.method}: ${result.body}`);
+  }
+  async elicit(params) {
+    if (!this.elicitationHandler) return { action: "decline" };
+    try {
+      return await this.elicitationHandler(params);
+    } catch (error) {
+      this.log("Elicitation handler error:", error);
+      return { action: "cancel" };
+    }
+  }
+  closeStream(reason) {
+    const controller = this.stream;
+    this.stream = void 0;
+    controller?.abort();
+    this.rejectPending(reason);
+  }
+  rejectPending(reason) {
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.resolve({ jsonrpc: "2.0", id, error: { code: -32e3, message: reason } });
+    }
+    this.pending.clear();
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // POSTING
+  // ═══════════════════════════════════════════════════════════════════
+  /** POST a message and resolve with the response the stream carries for `id`. */
+  async postAndAwait(id, body) {
+    const answer = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        resolve({ jsonrpc: "2.0", id, error: { code: -32e3, message: `Request timeout after ${this.timeout}ms` } });
+      }, this.timeout);
+      this.pending.set(id, { resolve, timer });
+    });
+    const result = await this.post(body);
+    if (!result.ok) {
+      const pending = this.pending.get(id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(id);
+      }
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32e3, message: `HTTP ${result.status}: ${result.statusText}`, data: result.body }
+      };
+    }
+    return answer;
+  }
+  async post(body) {
+    const endpoint = this.messageEndpoint;
+    if (!endpoint) throw new Error("SSE transport has no message endpoint. Call connect() first.");
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    this.log(`POST ${endpoint}`, body);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(endpoint, { method: "POST", headers, body, signal: controller.signal });
+      const text = await response.text();
+      return { ok: response.ok, status: response.status, statusText: response.statusText, body: text };
+    } catch (error) {
+      if (isAbortError(error)) {
+        return { ok: false, status: 0, statusText: `timeout after ${this.timeout}ms`, body: "" };
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // HELPERS
+  // ═══════════════════════════════════════════════════════════════════
+  async requestAnonymousToken() {
+    const url = new URL(this.baseUrl);
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}/oauth/token`;
+    url.search = "";
+    const tokenUrl = url.toString();
+    try {
+      const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ grant_type: "anonymous", client_id: crypto.randomUUID(), resource: this.baseUrl })
+      });
+      if (!response.ok) {
+        this.log(`No anonymous token (HTTP ${response.status})`);
+        return;
+      }
+      const token = await response.json();
+      if (token.access_token) this.authToken = token.access_token;
+    } catch (error) {
+      this.log("Error requesting anonymous token:", error);
+    }
+  }
+  /** `<baseUrl><entryPath>/sse`, built from URL parts so query params on `baseUrl` survive. */
+  sseUrl() {
+    const url = new URL(this.baseUrl);
+    const entry = (this.entryPath ?? "").replace(/^\/+|\/+$/g, "");
+    const basePath = url.pathname.replace(/\/+$/, "");
+    url.pathname = entry ? `${basePath}/${entry}/sse` : `${basePath}/sse`;
+    return url.toString();
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream"
+    };
+    if (this.clientInfo) headers["User-Agent"] = `${this.clientInfo.name}/${this.clientInfo.version}`;
+    if (this.authToken) headers["Authorization"] = `Bearer ${this.authToken}`;
+    if (this.sessionId) headers["mcp-session-id"] = this.sessionId;
+    Object.assign(headers, this.authHeaders);
+    return headers;
+  }
+  ensureConnected() {
+    if (this.state !== "connected") {
+      throw new Error("Transport not connected. Call connect() first.");
+    }
+  }
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[SSE] ${message}`, data ?? "");
+    }
+  }
+};
+function splitSSEEvents(buffer) {
+  const endsWithCarriageReturn = buffer.endsWith("\r");
+  const normalized = (endsWithCarriageReturn ? buffer.slice(0, -1) : buffer).replace(/\r\n?/g, "\n");
+  const completeEvents = normalized.split("\n\n");
+  const remainder = completeEvents.pop() ?? "";
+  return { completeEvents, remainder: endsWithCarriageReturn ? `${remainder}\r` : remainder };
+}
+function parseSSEEvent(text) {
+  let type = "message";
+  const data = [];
+  for (const line of text.split("\n")) {
+    if (line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+    if (field === "event") type = value;
+    else if (field === "data") data.push(value);
+  }
+  return data.length > 0 ? { type, data: data.join("\n") } : void 0;
+}
+
+// libs/testing/src/transport/streamable-http.transport.ts
+var DEFAULT_TIMEOUT2 = 3e4;
 var NOTIFICATION_STREAM_REOPEN_DELAY_MS = 250;
 var StreamableHttpTransport = class {
   config;
@@ -509,7 +955,7 @@ var StreamableHttpTransport = class {
       baseUrl: config.baseUrl.replace(/\/$/, ""),
       // Remove trailing slash
       entryPath: config.entryPath,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT2,
       auth: config.auth ?? {},
       publicMode: config.publicMode ?? false,
       debug: config.debug ?? false,
@@ -849,7 +1295,7 @@ var StreamableHttpTransport = class {
     let buffer = "";
     try {
       for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
-        const { completeEvents, remainder } = splitSSEEvents(buffer + decoder.decode(chunk.value, { stream: true }));
+        const { completeEvents, remainder } = splitSSEEvents2(buffer + decoder.decode(chunk.value, { stream: true }));
         buffer = remainder;
         for (const eventText of completeEvents) {
           for (const event of this.parseSSEEvents(eventText, void 0).events) {
@@ -1183,7 +1629,7 @@ var StreamableHttpTransport = class {
     };
   }
 };
-function splitSSEEvents(buffer) {
+function splitSSEEvents2(buffer) {
   const endsWithCarriageReturn = buffer.endsWith("\r");
   const normalized = (endsWithCarriageReturn ? buffer.slice(0, -1) : buffer).replace(/\r\n?/g, "\n");
   const completeEvents = normalized.split("\n\n");
@@ -1440,7 +1886,7 @@ var McpTestClientBuilder = class {
 };
 
 // libs/testing/src/client/mcp-test-client.ts
-var DEFAULT_TIMEOUT2 = 3e4;
+var DEFAULT_TIMEOUT3 = 3e4;
 var DEFAULT_PROTOCOL_VERSION = "2025-06-18";
 var UNSUPPORTED_PROTOCOL_VERSIONS = ["2026-07-28"];
 var DEFAULT_CLIENT_INFO = {
@@ -1510,7 +1956,7 @@ var McpTestClient = class {
       transport: config.transport ?? "streamable-http",
       auth: config.auth ?? {},
       publicMode: config.publicMode ?? false,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT2,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT3,
       debug: config.debug ?? false,
       protocolVersion: config.protocolVersion ?? DEFAULT_PROTOCOL_VERSION,
       clientInfo: config.clientInfo ?? DEFAULT_CLIENT_INFO,
@@ -2276,7 +2722,18 @@ var McpTestClient = class {
           notificationHandler: this.recordNotification
         });
       case "sse":
-        throw new Error("SSE transport not yet implemented");
+        return new SseTransport({
+          baseUrl,
+          entryPath: this.config.entryPath,
+          timeout: this.config.timeout,
+          auth: this.config.auth,
+          publicMode: this.config.publicMode,
+          debug: this.config.debug,
+          interceptors: this._interceptors,
+          clientInfo: this.config.clientInfo,
+          elicitationHandler: this._elicitationHandler,
+          notificationHandler: this.recordNotification
+        });
       default:
         throw new Error(`Unknown transport type: ${this.config.transport}`);
     }
@@ -5223,7 +5680,19 @@ function jestGlobals() {
     );
   }
 }
-var scopes = [{ skipped: false, config: {}, configured: false, cleanupRegistered: false }];
+function newScope(parent) {
+  return {
+    skipped: parent?.skipped ?? false,
+    reason: parent?.reason,
+    config: {},
+    envs: [],
+    configured: false,
+    cleanupRegistered: false,
+    beforeEachHooks: [],
+    afterEachHooks: []
+  };
+}
+var scopes = [newScope()];
 function currentScope() {
   return scopes[scopes.length - 1];
 }
@@ -5231,9 +5700,8 @@ var serverEntries = /* @__PURE__ */ new Map();
 function resolveConfig(chain) {
   const merged = {};
   for (const scope of chain) {
-    const { env, ...rest } = scope.config;
-    Object.assign(merged, rest);
-    if (env) merged.env = { ...merged.env, ...env };
+    Object.assign(merged, scope.config);
+    for (const env of scope.envs) merged.env = { ...merged.env, ...env };
   }
   return merged;
 }
@@ -5486,17 +5954,39 @@ function resolveServerCommand(server) {
 function runWithFixtures(fn, chain) {
   return async (...extra) => {
     const fixtures = await buildFixtures(chain);
-    let testFailed = false;
+    let failure;
     try {
+      for (const scope of chain) {
+        for (const hook of scope.beforeEachHooks) await hook(fixtures);
+      }
       await fn(fixtures, ...extra);
     } catch (error) {
-      testFailed = true;
-      throw error;
-    } finally {
-      await cleanupTestFixtures(fixtures, testFailed);
+      failure = { error };
     }
+    try {
+      await runAfterEachHooks(chain, fixtures);
+    } catch (error) {
+      failure ??= { error };
+    }
+    await cleanupTestFixtures(fixtures, failure !== void 0);
+    if (failure) throw failure.error;
   };
 }
+async function runAfterEachHooks(chain, fixtures) {
+  let firstError;
+  let failed = false;
+  for (let i = chain.length - 1; i >= 0; i--) {
+    for (const hook of chain[i].afterEachHooks) {
+      try {
+        await hook(fixtures);
+      } catch (error) {
+        if (!failed) firstError = error;
+        failed = true;
+      }
+    }
+  }
+  if (failed) throw firstError;
+}
 function skipTitle(name, scope) {
   return scope.reason ? `${name} (skipped: ${scope.reason})` : name;
 }
@@ -5511,11 +6001,9 @@ function testWithFixtures(name, fn) {
 }
 function use(config) {
   const scope = currentScope();
-  scope.config = {
-    ...scope.config,
-    ...config,
-    env: config.env ? { ...scope.config.env, ...config.env } : scope.config.env
-  };
+  const { env, ...rest } = config;
+  scope.config = { ...scope.config, ...rest };
+  if (env) scope.envs.push(env);
   scope.configured = true;
   if (!scope.cleanupRegistered) {
     scope.cleanupRegistered = true;
@@ -5566,14 +6054,7 @@ function each(table, ...tagged) {
 }
 function withScope(fn) {
   return (...args) => {
-    const parent = currentScope();
-    scopes.push({
-      skipped: parent.skipped,
-      reason: parent.reason,
-      config: {},
-      configured: false,
-      cleanupRegistered: false
-    });
+    scopes.push(newScope(currentScope()));
     try {
       fn(...args);
     } finally {
@@ -5611,12 +6092,22 @@ var describeWithScope = Object.assign(
     each: scopedEach(() => jestGlobals().describe.each)
   }
 );
+function eachHook(kind) {
+  return (fn, timeout) => {
+    if (typeof fn === "function" && fn.length > 0) {
+      const scope = currentScope();
+      (kind === "beforeEach" ? scope.beforeEachHooks : scope.afterEachHooks).push(fn);
+      return;
+    }
+    jestGlobals()[kind](fn, timeout);
+  };
+}
 var test = testWithFixtures;
 test.use = use;
 test.describe = describeWithScope;
 test.beforeAll = ((...args) => jestGlobals().beforeAll(...args));
-test.beforeEach = ((...args) => jestGlobals().beforeEach(...args));
-test.afterEach = ((...args) => jestGlobals().afterEach(...args));
+test.beforeEach = eachHook("beforeEach");
+test.afterEach = eachHook("afterEach");
 test.afterAll = ((...args) => jestGlobals().afterAll(...args));
 test.skip = skip;
 test.only = only;
@@ -8746,6 +9237,7 @@ function isTcpPortListening(port, host = "127.0.0.1", timeoutMs = 1500) {
   RegressionDetector,
   ReportGenerator,
   ServerStartError,
+  SseTransport,
   StreamableHttpTransport,
   TestClientError,
   TestServer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/testing",
-  "version": "1.8.7",
+  "version": "1.9.0",
   "description": "E2E testing framework for FrontMCP servers - MCP client, auth mocks, Playwright integration",
   "author": "AgentFront <info@agentfront.dev>",
   "homepage": "https://docs.agentfront.dev",
@@ -87,9 +87,9 @@
     "./esm": null
   },
   "peerDependencies": {
-    "@frontmcp/lazy-zod": "1.8.7",
-    "@frontmcp/sdk": "1.8.7",
-    "@frontmcp/ui": "1.8.7",
+    "@frontmcp/lazy-zod": "1.9.0",
+    "@frontmcp/sdk": "1.9.0",
+    "@frontmcp/ui": "1.9.0",
     "@jest/globals": "^29.0.0 || ^30.0.0",
     "@playwright/test": "^1.40.0",
     "jest": "^29.0.0 || ^30.0.0"
@@ -112,8 +112,10 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@frontmcp/protocol": "1.8.7",
-    "@frontmcp/utils": "1.8.7",
+    "@frontmcp/protocol": "1.9.0",
+    "@frontmcp/utils": "1.9.0",
+    "@swc/core": "~1.15.41",
+    "@swc/jest": "~0.2.38",
     "jose": "^6.0.11",
     "tslib": "^2.3.0"
   },