@mcpjam/sdk 0.1.4 → 0.8.0

package/dist/index.js

@@ -1,31 +1,537 @@
-// src/mcp-client-manager/index.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import {
-  getDefaultEnvironment,
-  StdioClientTransport
-} from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { DEFAULT_REQUEST_TIMEOUT_MSEC } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import {
-  CallToolResultSchema as CallToolResultSchema2,
-  ElicitRequestSchema,
-  ResourceListChangedNotificationSchema,
-  ResourceUpdatedNotificationSchema,
-  PromptListChangedNotificationSchema
-} from "@modelcontextprotocol/sdk/types.js";
+'use strict';
 
-// src/mcp-client-manager/tool-converters.ts
-import {
-  CallToolResultSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import {
-  dynamicTool,
-  jsonSchema,
-  tool as defineTool
-} from "ai";
-var ensureJsonSchemaObject = (schema) => {
-  var _a;
+var index_js = require('@modelcontextprotocol/sdk/client/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
+var sse_js = require('@modelcontextprotocol/sdk/client/sse.js');
+var streamableHttp_js = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var protocol_js = require('@modelcontextprotocol/sdk/shared/protocol.js');
+var zod = require('zod');
+var ai = require('ai');
+var anthropic = require('@ai-sdk/anthropic');
+var azure = require('@ai-sdk/azure');
+var deepseek = require('@ai-sdk/deepseek');
+var google = require('@ai-sdk/google');
+var mistral = require('@ai-sdk/mistral');
+var openai = require('@ai-sdk/openai');
+var xai = require('@ai-sdk/xai');
+var aiSdkProvider = require('@openrouter/ai-sdk-provider');
+var ollamaAiProviderV2 = require('ollama-ai-provider-v2');
+
+// src/mcp-client-manager/MCPClientManager.ts
+var DEFAULT_CLIENT_VERSION = "1.0.0";
+var DEFAULT_TIMEOUT = protocol_js.DEFAULT_REQUEST_TIMEOUT_MSEC;
+var HTTP_CONNECT_TIMEOUT = 3e3;
+
+// src/mcp-client-manager/error-utils.ts
+function isMethodUnavailableError(error, method) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  const methodTokens = /* @__PURE__ */ new Set();
+  methodTokens.add(method.toLowerCase());
+  for (const part of method.split(/[/:._-]/)) {
+    if (part) {
+      methodTokens.add(part.toLowerCase());
+    }
+  }
+  const indicators = [
+    "method not found",
+    "not implemented",
+    "unsupported",
+    "does not support",
+    "unimplemented"
+  ];
+  const indicatorMatch = indicators.some(
+    (indicator) => message.includes(indicator)
+  );
+  if (!indicatorMatch) {
+    return false;
+  }
+  if (Array.from(methodTokens).some((token) => message.includes(token))) {
+    return true;
+  }
+  return true;
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+// src/mcp-client-manager/errors.ts
+var MCPError = class extends Error {
+  constructor(message, code, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "MCPError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var MCPAuthError = class extends MCPError {
+  constructor(message, statusCode, options) {
+    super(message, "AUTH_ERROR", options);
+    this.statusCode = statusCode;
+    this.name = "MCPAuthError";
+  }
+};
+function isMCPAuthError(error) {
+  return error instanceof MCPAuthError;
+}
+function hasNumericCode(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "number";
+}
+function isAuthError(error) {
+  if (!(error instanceof Error)) {
+    return { isAuth: false };
+  }
+  if (error.name === "UnauthorizedError") {
+    return { isAuth: true, statusCode: 401 };
+  }
+  if (error.name === "MCPAuthError") {
+    const statusCode = "statusCode" in error && typeof error.statusCode === "number" ? error.statusCode : void 0;
+    return { isAuth: true, statusCode };
+  }
+  if (hasNumericCode(error)) {
+    const code = error.code;
+    if (code === 401 || code === 403) {
+      return { isAuth: true, statusCode: code };
+    }
+  }
+  const message = error.message.toLowerCase();
+  const authPatterns = [
+    "unauthorized",
+    "invalid_token",
+    "invalid token",
+    "token expired",
+    "token has expired",
+    "access denied",
+    "authentication failed",
+    "authentication required",
+    "not authenticated",
+    "forbidden"
+  ];
+  if (authPatterns.some((pattern) => message.includes(pattern))) {
+    return { isAuth: true };
+  }
+  const statusMatch = message.match(/\b(status[:\s]*)?401\b|\bhttp\s*401\b/i);
+  if (statusMatch) {
+    return { isAuth: true, statusCode: 401 };
+  }
+  const forbiddenMatch = message.match(
+    /\b(status[:\s]*)?403\b|\bhttp\s*403\b/i
+  );
+  if (forbiddenMatch) {
+    return { isAuth: true, statusCode: 403 };
+  }
+  return { isAuth: false };
+}
+
+// src/mcp-client-manager/transport-utils.ts
+function normalizeHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  if (typeof headers === "object" && !Array.isArray(headers) && !(headers instanceof Headers)) {
+    return headers;
+  }
+  const normalized = {};
+  const headersObj = new Headers(headers);
+  headersObj.forEach((value, key) => {
+    normalized[key] = value;
+  });
+  return normalized;
+}
+function getExistingAuthorization(headers) {
+  return headers["Authorization"] ?? headers["authorization"];
+}
+function buildRequestInit(accessToken, requestInit) {
+  if (!accessToken) {
+    return requestInit;
+  }
+  const existingHeaders = normalizeHeaders(requestInit?.headers);
+  const existingAuth = getExistingAuthorization(existingHeaders);
+  const { authorization: _, ...headersWithoutLowercaseAuth } = existingHeaders;
+  return {
+    ...requestInit,
+    headers: {
+      Authorization: existingAuth ?? `Bearer ${accessToken}`,
+      ...headersWithoutLowercaseAuth
+    }
+  };
+}
+function wrapTransportForLogging(serverId, logger, transport) {
+  class LoggingTransport {
+    constructor(inner) {
+      this.inner = inner;
+      this.inner.onmessage = (message, extra) => {
+        try {
+          logger({ direction: "receive", message, serverId });
+        } catch {
+        }
+        this.onmessage?.(message, extra);
+      };
+      this.inner.onclose = () => {
+        this.onclose?.();
+      };
+      this.inner.onerror = (error) => {
+        this.onerror?.(error);
+      };
+    }
+    onclose;
+    onerror;
+    onmessage;
+    async start() {
+      if (typeof this.inner.start === "function") {
+        await this.inner.start();
+      }
+    }
+    async send(message, options) {
+      try {
+        logger({ direction: "send", message, serverId });
+      } catch {
+      }
+      await this.inner.send(message, options);
+    }
+    async close() {
+      await this.inner.close();
+    }
+    get sessionId() {
+      return this.inner.sessionId;
+    }
+    setProtocolVersion(version) {
+      if (typeof this.inner.setProtocolVersion === "function") {
+        this.inner.setProtocolVersion(version);
+      }
+    }
+  }
+  return new LoggingTransport(transport);
+}
+function createDefaultRpcLogger() {
+  return ({ direction, message, serverId }) => {
+    let printable;
+    try {
+      printable = typeof message === "string" ? message : JSON.stringify(message);
+    } catch {
+      printable = String(message);
+    }
+    console.debug(`[MCP:${serverId}] ${direction.toUpperCase()} ${printable}`);
+  };
+}
+var NotificationManager = class {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Adds a notification handler for a specific server and schema.
+   *
+   * @param serverId - The server ID
+   * @param schema - The notification schema to handle
+   * @param handler - The handler function
+   */
+  addHandler(serverId, schema, handler) {
+    const serverHandlers = this.handlers.get(serverId) ?? /* @__PURE__ */ new Map();
+    const handlersForSchema = serverHandlers.get(schema) ?? /* @__PURE__ */ new Set();
+    handlersForSchema.add(handler);
+    serverHandlers.set(schema, handlersForSchema);
+    this.handlers.set(serverId, serverHandlers);
+  }
+  /**
+   * Creates a dispatcher function that invokes all handlers for a schema.
+   *
+   * @param serverId - The server ID
+   * @param schema - The notification schema
+   * @returns A handler that dispatches to all registered handlers
+   */
+  createDispatcher(serverId, schema) {
+    return (notification) => {
+      const serverHandlers = this.handlers.get(serverId);
+      const handlersForSchema = serverHandlers?.get(schema);
+      if (!handlersForSchema || handlersForSchema.size === 0) {
+        return;
+      }
+      for (const handler of handlersForSchema) {
+        try {
+          handler(notification);
+        } catch {
+        }
+      }
+    };
+  }
+  /**
+   * Applies all registered handlers to a client.
+   *
+   * @param serverId - The server ID
+   * @param client - The MCP client to configure
+   */
+  applyToClient(serverId, client) {
+    const serverHandlers = this.handlers.get(serverId);
+    if (!serverHandlers) {
+      return;
+    }
+    for (const [schema] of serverHandlers) {
+      client.setNotificationHandler(
+        schema,
+        this.createDispatcher(serverId, schema)
+      );
+    }
+  }
+  /**
+   * Clears all handlers for a server.
+   *
+   * @param serverId - The server ID to clear
+   */
+  clearServer(serverId) {
+    this.handlers.delete(serverId);
+  }
+  /**
+   * Gets handler schemas registered for a server.
+   *
+   * @param serverId - The server ID
+   * @returns Array of registered notification schemas
+   */
+  getSchemas(serverId) {
+    const serverHandlers = this.handlers.get(serverId);
+    return serverHandlers ? Array.from(serverHandlers.keys()) : [];
+  }
+};
+function applyProgressHandler(serverId, client, progressHandler) {
+  client.setNotificationHandler(types_js.ProgressNotificationSchema, (notification) => {
+    const params = notification.params;
+    progressHandler({
+      serverId,
+      progressToken: params.progressToken,
+      progress: params.progress,
+      total: params.total,
+      message: params.message
+    });
+  });
+}
+var ElicitationManager = class {
+  handlers = /* @__PURE__ */ new Map();
+  globalCallback;
+  pendingElicitations = /* @__PURE__ */ new Map();
+  /**
+   * Sets a server-specific elicitation handler.
+   *
+   * @param serverId - The server ID
+   * @param handler - The elicitation handler
+   */
+  setHandler(serverId, handler) {
+    this.handlers.set(serverId, handler);
+  }
+  /**
+   * Clears a server-specific handler.
+   *
+   * @param serverId - The server ID
+   */
+  clearHandler(serverId) {
+    this.handlers.delete(serverId);
+  }
+  /**
+   * Gets a server-specific handler.
+   *
+   * @param serverId - The server ID
+   * @returns The handler if set, undefined otherwise
+   */
+  getHandler(serverId) {
+    return this.handlers.get(serverId);
+  }
+  /**
+   * Sets the global elicitation callback.
+   *
+   * @param callback - The callback function
+   */
+  setGlobalCallback(callback) {
+    this.globalCallback = callback;
+  }
+  /**
+   * Clears the global callback.
+   */
+  clearGlobalCallback() {
+    this.globalCallback = void 0;
+  }
+  /**
+   * Gets the global callback.
+   *
+   * @returns The callback if set, undefined otherwise
+   */
+  getGlobalCallback() {
+    return this.globalCallback;
+  }
+  /**
+   * Gets the pending elicitations map.
+   * Useful for external code that needs to add resolvers.
+   *
+   * @returns The pending elicitations map
+   */
+  getPendingElicitations() {
+    return this.pendingElicitations;
+  }
+  /**
+   * Resolves a pending elicitation by requestId.
+   *
+   * @param requestId - The request ID to resolve
+   * @param response - The elicitation response
+   * @returns True if the elicitation was found and resolved
+   */
+  respond(requestId, response) {
+    const pending = this.pendingElicitations.get(requestId);
+    if (!pending) {
+      return false;
+    }
+    try {
+      pending.resolve(response);
+      return true;
+    } finally {
+      this.pendingElicitations.delete(requestId);
+    }
+  }
+  /**
+   * Applies the appropriate elicitation handler to a client.
+   * Server-specific handlers take precedence over the global callback.
+   *
+   * @param serverId - The server ID
+   * @param client - The MCP client
+   */
+  applyToClient(serverId, client) {
+    const serverSpecific = this.handlers.get(serverId);
+    if (serverSpecific) {
+      client.setRequestHandler(
+        types_js.ElicitRequestSchema,
+        async (request) => serverSpecific(request.params)
+      );
+      return;
+    }
+    if (this.globalCallback) {
+      client.setRequestHandler(types_js.ElicitRequestSchema, async (request) => {
+        const reqId = `elicit_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const meta = request.params?._meta;
+        const relatedTask = meta?.["io.modelcontextprotocol/related-task"];
+        const relatedTaskId = relatedTask?.taskId;
+        return await this.globalCallback({
+          requestId: reqId,
+          message: request.params?.message,
+          schema: request.params?.requestedSchema ?? request.params?.schema,
+          relatedTaskId
+        });
+      });
+    }
+  }
+  /**
+   * Removes elicitation handler from a client.
+   *
+   * @param client - The MCP client
+   */
+  removeFromClient(client) {
+    client.removeRequestHandler("elicitation/create");
+  }
+  /**
+   * Clears all data for a server.
+   *
+   * @param serverId - The server ID
+   */
+  clearServer(serverId) {
+    this.handlers.delete(serverId);
+  }
+};
+var TaskSchema = zod.z.object({
+  taskId: zod.z.string(),
+  status: zod.z.enum([
+    "working",
+    "input_required",
+    "completed",
+    "failed",
+    "cancelled"
+  ]),
+  statusMessage: zod.z.string().optional(),
+  createdAt: zod.z.string(),
+  lastUpdatedAt: zod.z.string(),
+  ttl: zod.z.number().nullable(),
+  pollInterval: zod.z.number().optional()
+});
+var ListTasksResultSchema = zod.z.object({
+  tasks: zod.z.array(TaskSchema),
+  nextCursor: zod.z.string().optional()
+});
+var TaskStatusNotificationSchema = zod.z.object({
+  method: zod.z.literal("notifications/tasks/status"),
+  params: zod.z.object({
+    taskId: zod.z.string(),
+    status: zod.z.enum([
+      "working",
+      "input_required",
+      "completed",
+      "failed",
+      "cancelled"
+    ]),
+    statusMessage: zod.z.string().optional(),
+    createdAt: zod.z.string(),
+    lastUpdatedAt: zod.z.string(),
+    ttl: zod.z.number().nullable(),
+    pollInterval: zod.z.number().optional()
+  }).optional()
+});
+var TaskResultSchema = zod.z.unknown();
+async function listTasks(client, cursor, options) {
+  return client.request(
+    {
+      method: "tasks/list",
+      params: cursor ? { cursor } : {}
+    },
+    ListTasksResultSchema,
+    options
+  );
+}
+async function getTask(client, taskId, options) {
+  return client.request(
+    {
+      method: "tasks/get",
+      params: { taskId }
+    },
+    TaskSchema,
+    options
+  );
+}
+async function getTaskResult(client, taskId, options) {
+  return client.request(
+    {
+      method: "tasks/result",
+      params: { taskId }
+    },
+    TaskResultSchema,
+    options
+  );
+}
+async function cancelTask(client, taskId, options) {
+  return client.request(
+    {
+      method: "tasks/cancel",
+      params: { taskId }
+    },
+    TaskSchema,
+    options
+  );
+}
+function supportsTasksForToolCalls(capabilities) {
+  const caps = capabilities;
+  return Boolean(
+    caps?.tasks?.requests?.tools?.call || caps?.experimental?.tasks?.requests?.tools?.call
+  );
+}
+function supportsTasksList(capabilities) {
+  const caps = capabilities;
+  return Boolean(caps?.tasks?.list || caps?.experimental?.tasks?.list);
+}
+function supportsTasksCancel(capabilities) {
+  const caps = capabilities;
+  return Boolean(caps?.tasks?.cancel || caps?.experimental?.tasks?.cancel);
+}
+function ensureJsonSchemaObject(schema) {
   if (schema && typeof schema === "object") {
     const record = schema;
     const base = record.jsonSchema ? ensureJsonSchemaObject(record.jsonSchema) : record;
@@ -33,7 +539,7 @@ var ensureJsonSchemaObject = (schema) => {
       base.type = "object";
     }
     if (base.type === "object") {
-      base.properties = (_a = base.properties) != null ? _a : {};
+      base.properties = base.properties ?? {};
       if (base.additionalProperties === void 0) {
         base.additionalProperties = false;
       }
@@ -45,31 +551,25 @@ var ensureJsonSchemaObject = (schema) => {
     properties: {},
     additionalProperties: false
   };
-};
+}
 async function convertMCPToolsToVercelTools(listToolsResult, {
   schemas = "automatic",
   callTool
 }) {
-  var _a, _b;
   const tools = {};
   for (const toolDescription of listToolsResult.tools) {
     const { name, description, inputSchema } = toolDescription;
     const execute = async (args, options) => {
-      var _a2, _b2;
-      (_b2 = (_a2 = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a2.throwIfAborted) == null ? void 0 : _b2.call(_a2);
+      options?.abortSignal?.throwIfAborted?.();
       const result = await callTool({ name, args, options });
-      return CallToolResultSchema.parse(result);
+      return types_js.CallToolResultSchema.parse(result);
     };
     let vercelTool;
     if (schemas === "automatic") {
       const normalizedInputSchema = ensureJsonSchemaObject(inputSchema);
-      vercelTool = dynamicTool({
+      vercelTool = ai.dynamicTool({
         description,
-        inputSchema: jsonSchema({
-          type: "object",
-          properties: (_a = normalizedInputSchema.properties) != null ? _a : {},
-          additionalProperties: (_b = normalizedInputSchema.additionalProperties) != null ? _b : false
-        }),
+        inputSchema: ai.jsonSchema(normalizedInputSchema),
         execute
       });
     } else {
@@ -77,7 +577,7 @@ async function convertMCPToolsToVercelTools(listToolsResult, {
       if (!(name in overrides)) {
         continue;
       }
-      vercelTool = defineTool({
+      vercelTool = ai.tool({
         description,
         inputSchema: overrides[name].inputSchema,
         execute
@@ -88,236 +588,290 @@ async function convertMCPToolsToVercelTools(listToolsResult, {
   return tools;
 }
 
-// src/mcp-client-manager/index.ts
+// src/mcp-client-manager/MCPClientManager.ts
 var MCPClientManager = class {
+  // State management
+  clientStates = /* @__PURE__ */ new Map();
+  toolsMetadataCache = /* @__PURE__ */ new Map();
+  // Managers for specific features
+  notificationManager = new NotificationManager();
+  elicitationManager = new ElicitationManager();
+  // Default options
+  defaultClientName;
+  defaultClientVersion;
+  defaultCapabilities;
+  defaultTimeout;
+  defaultLogJsonRpc;
+  defaultRpcLogger;
+  defaultProgressHandler;
+  // Progress token counter for uniqueness
+  progressTokenCounter = 0;
+  /**
+   * Creates a new MCPClientManager.
+   *
+   * @param servers - Configuration map of server IDs to server configs
+   * @param options - Global options for the manager
+   */
   constructor(servers = {}, options = {}) {
-    this.clientStates = /* @__PURE__ */ new Map();
-    this.notificationHandlers = /* @__PURE__ */ new Map();
-    this.elicitationHandlers = /* @__PURE__ */ new Map();
-    this.toolsMetadataCache = /* @__PURE__ */ new Map();
-    this.defaultLogJsonRpc = false;
-    this.pendingElicitations = /* @__PURE__ */ new Map();
-    var _a, _b, _c, _d, _e;
-    this.defaultClientVersion = (_a = options.defaultClientVersion) != null ? _a : "1.0.0";
-    this.defaultClientName = (_b = options.defaultClientName) != null ? _b : void 0;
-    this.defaultCapabilities = { ...(_c = options.defaultCapabilities) != null ? _c : {} };
-    this.defaultTimeout = (_d = options.defaultTimeout) != null ? _d : DEFAULT_REQUEST_TIMEOUT_MSEC;
-    this.defaultLogJsonRpc = (_e = options.defaultLogJsonRpc) != null ? _e : false;
+    this.defaultClientVersion = options.defaultClientVersion ?? DEFAULT_CLIENT_VERSION;
+    this.defaultClientName = options.defaultClientName;
+    this.defaultCapabilities = { ...options.defaultCapabilities ?? {} };
+    this.defaultTimeout = options.defaultTimeout ?? DEFAULT_TIMEOUT;
+    this.defaultLogJsonRpc = options.defaultLogJsonRpc ?? false;
     this.defaultRpcLogger = options.rpcLogger;
+    this.defaultProgressHandler = options.progressHandler;
     for (const [id, config] of Object.entries(servers)) {
       void this.connectToServer(id, config);
     }
   }
+  // ===========================================================================
+  // Server Management
+  // ===========================================================================
+  /**
+   * Lists all registered server IDs.
+   */
   listServers() {
     return Array.from(this.clientStates.keys());
   }
+  /**
+   * Checks if a server is registered.
+   */
   hasServer(serverId) {
     return this.clientStates.has(serverId);
   }
+  /**
+   * Gets summaries for all registered servers.
+   */
   getServerSummaries() {
     return Array.from(this.clientStates.entries()).map(([serverId, state]) => ({
       id: serverId,
-      status: this.resolveConnectionStatus(state),
+      status: this.getConnectionStatus(serverId),
       config: state.config
     }));
   }
+  /**
+   * Gets the connection status for a server.
+   */
   getConnectionStatus(serverId) {
-    return this.resolveConnectionStatus(this.clientStates.get(serverId));
+    const state = this.clientStates.get(serverId);
+    if (state?.promise) return "connecting";
+    if (state?.client) return "connected";
+    return "disconnected";
   }
+  /**
+   * Gets the configuration for a server.
+   */
   getServerConfig(serverId) {
-    var _a;
-    return (_a = this.clientStates.get(serverId)) == null ? void 0 : _a.config;
+    return this.clientStates.get(serverId)?.config;
+  }
+  /**
+   * Gets the capabilities reported by a server.
+   */
+  getServerCapabilities(serverId) {
+    return this.clientStates.get(serverId)?.client?.getServerCapabilities();
+  }
+  /**
+   * Gets the underlying MCP Client for a server.
+   */
+  getClient(serverId) {
+    return this.clientStates.get(serverId)?.client;
+  }
+  /**
+   * Gets initialization information for a connected server.
+   */
+  getInitializationInfo(serverId) {
+    const state = this.clientStates.get(serverId);
+    const client = state?.client;
+    if (!client) return void 0;
+    const config = state.config;
+    let transportType;
+    if (this.isStdioConfig(config)) {
+      transportType = "stdio";
+    } else {
+      const url = new URL(config.url);
+      transportType = config.preferSSE || url.pathname.endsWith("/sse") ? "sse" : "streamable-http";
+    }
+    let protocolVersion;
+    if (state.transport) {
+      protocolVersion = state.transport._protocolVersion;
+    }
+    return {
+      protocolVersion,
+      transport: transportType,
+      serverCapabilities: client.getServerCapabilities(),
+      serverVersion: client.getServerVersion(),
+      instructions: client.getInstructions(),
+      clientCapabilities: this.buildCapabilities(config)
+    };
   }
+  // ===========================================================================
+  // Connection Management
+  // ===========================================================================
+  /**
+   * Connects to an MCP server.
+   *
+   * @param serverId - Unique identifier for the server
+   * @param config - Server configuration
+   * @returns The connected MCP Client
+   */
   async connectToServer(serverId, config) {
-    var _a;
-    if (this.clientStates.has(serverId)) {
+    const timeout = config.timeout ?? this.defaultTimeout;
+    const existingState = this.clientStates.get(serverId);
+    if (existingState?.client) {
       throw new Error(`MCP server "${serverId}" is already connected.`);
     }
-    const timeout = this.getTimeout(config);
-    const state = (_a = this.clientStates.get(serverId)) != null ? _a : {
-      config,
-      timeout
-    };
+    const state = existingState ?? { config, timeout };
     state.config = config;
     state.timeout = timeout;
-    if (state.client) {
-      this.clientStates.set(serverId, state);
-      return state.client;
-    }
     if (state.promise) {
       this.clientStates.set(serverId, state);
       return state.promise;
     }
-    const connectionPromise = (async () => {
-      var _a2;
-      const client = new Client(
-        {
-          name: this.defaultClientName ? `${this.defaultClientName}` : serverId,
-          version: (_a2 = config.version) != null ? _a2 : this.defaultClientVersion
-        },
-        {
-          capabilities: this.buildCapabilities(config)
-        }
-      );
-      this.applyNotificationHandlers(serverId, client);
-      this.applyElicitationHandler(serverId, client);
-      if (config.onError) {
-        client.onerror = (error) => {
-          var _a3;
-          (_a3 = config.onError) == null ? void 0 : _a3.call(config, error);
-        };
-      }
-      client.onclose = () => {
-        this.resetState(serverId);
-      };
-      let transport;
-      if (this.isStdioConfig(config)) {
-        transport = await this.connectViaStdio(
-          serverId,
-          client,
-          config,
-          timeout
-        );
-      } else {
-        transport = await this.connectViaHttp(
-          serverId,
-          client,
-          config,
-          timeout
-        );
-      }
-      state.client = client;
-      state.transport = transport;
-      state.promise = void 0;
-      this.clientStates.set(serverId, state);
-      return client;
-    })().catch((error) => {
-      state.promise = void 0;
-      state.client = void 0;
-      state.transport = void 0;
-      this.clientStates.set(serverId, state);
-      throw error;
-    });
+    const connectionPromise = this.performConnection(
+      serverId,
+      config,
+      timeout,
+      state
+    );
     state.promise = connectionPromise;
     this.clientStates.set(serverId, state);
     return connectionPromise;
   }
+  /**
+   * Disconnects from a server.
+   */
   async disconnectServer(serverId) {
-    const client = this.getClientById(serverId);
+    const state = this.clientStates.get(serverId);
+    if (!state?.client) return;
     try {
-      await client.close();
+      await state.client.close();
+    } catch {
     } finally {
-      if (client.transport) {
-        await this.safeCloseTransport(client.transport);
+      if (state.transport) {
+        await this.safeCloseTransport(state.transport);
       }
       this.resetState(serverId);
     }
   }
-  removeServer(serverId) {
-    this.resetState(serverId);
-    this.notificationHandlers.delete(serverId);
-    this.elicitationHandlers.delete(serverId);
+  /**
+   * Removes a server from the manager entirely.
+   */
+  async removeServer(serverId) {
+    await this.disconnectServer(serverId);
+    this.notificationManager.clearServer(serverId);
+    this.elicitationManager.clearServer(serverId);
   }
+  /**
+   * Disconnects from all servers.
+   */
   async disconnectAllServers() {
     const serverIds = this.listServers();
-    await Promise.all(
-      serverIds.map((serverId) => this.disconnectServer(serverId))
-    );
+    await Promise.all(serverIds.map((id) => this.disconnectServer(id)));
     for (const serverId of serverIds) {
-      this.resetState(serverId);
-      this.notificationHandlers.delete(serverId);
-      this.elicitationHandlers.delete(serverId);
+      this.notificationManager.clearServer(serverId);
+      this.elicitationManager.clearServer(serverId);
     }
   }
+  // ===========================================================================
+  // Tools
+  // ===========================================================================
+  /**
+   * Lists tools available from a server.
+   */
   async listTools(serverId, params, options) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
+    const client = this.getClientOrThrow(serverId);
     try {
       const result = await client.listTools(
         params,
         this.withTimeout(serverId, options)
       );
-      const metadataMap = /* @__PURE__ */ new Map();
-      for (const tool of result.tools) {
-        if (tool._meta) {
-          metadataMap.set(tool.name, tool._meta);
-        }
-      }
-      this.toolsMetadataCache.set(serverId, metadataMap);
+      this.cacheToolsMetadata(serverId, result.tools);
       return result;
     } catch (error) {
-      if (this.isMethodUnavailableError(error, "tools/list")) {
+      if (isMethodUnavailableError(error, "tools/list")) {
         this.toolsMetadataCache.set(serverId, /* @__PURE__ */ new Map());
         return { tools: [] };
       }
       throw error;
     }
   }
+  /**
+   * Gets tools from multiple servers (or all servers if none specified).
+   * Returns tools with execute functions pre-wired to call this manager.
+   *
+   * @param serverIds - Server IDs to get tools from (or all if omitted)
+   * @returns Array of executable tools
+   *
+   * @example
+   * ```typescript
+   * const tools = await manager.getTools(["asana"]);
+   * const agent = new TestAgent({ tools, model: "openai/gpt-4o", apiKey });
+   * ```
+   */
   async getTools(serverIds) {
-    const targetServerIds = serverIds && serverIds.length > 0 ? serverIds : this.listServers();
+    const targetIds = serverIds !== void 0 ? serverIds : this.listServers();
     const toolLists = await Promise.all(
-      targetServerIds.map(async (serverId) => {
+      targetIds.map(async (serverId) => {
         await this.ensureConnected(serverId);
-        const client = this.getClientById(serverId);
-        const result = await client.listTools(
-          void 0,
-          this.withTimeout(serverId)
-        );
-        const metadataMap = /* @__PURE__ */ new Map();
-        for (const tool of result.tools) {
-          if (tool._meta) {
-            metadataMap.set(tool.name, tool._meta);
+        const result = await this.listTools(serverId);
+        return result.tools.map((tool) => ({
+          ...tool,
+          _meta: { ...tool._meta, _serverId: serverId },
+          execute: async (args, options) => {
+            const requestOptions = options?.signal ? { signal: options.signal } : void 0;
+            return this.executeTool(
+              serverId,
+              tool.name,
+              args,
+              requestOptions
+            );
           }
-        }
-        this.toolsMetadataCache.set(serverId, metadataMap);
-        return result.tools;
+        }));
       })
     );
-    return { tools: toolLists.flat() };
+    return toolLists.flat();
   }
+  /**
+   * Gets cached tool metadata for a server.
+   */
   getAllToolsMetadata(serverId) {
     const metadataMap = this.toolsMetadataCache.get(serverId);
     return metadataMap ? Object.fromEntries(metadataMap) : {};
   }
-  pingServer(serverId, options) {
-    const client = this.getClientById(serverId);
-    try {
-      client.ping(options);
-    } catch (error) {
-      throw new Error(
-        `Failed to ping MCP server "${serverId}": ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
+  /**
+   * Gets tools formatted for Vercel AI SDK.
+   *
+   * @param serverIds - Server IDs to get tools from (or all if omitted)
+   * @param options - Schema options
+   * @returns AiSdkTool compatible with Vercel AI SDK's generateText()
+   */
   async getToolsForAiSdk(serverIds, options = {}) {
     const ids = Array.isArray(serverIds) ? serverIds : serverIds ? [serverIds] : this.listServers();
-    const loadForServer = async (id) => {
-      await this.ensureConnected(id);
-      const listToolsResult = await this.listTools(id);
-      return convertMCPToolsToVercelTools(listToolsResult, {
-        schemas: options.schemas,
-        callTool: async ({ name, args, options: callOptions }) => {
-          const requestOptions = (callOptions == null ? void 0 : callOptions.abortSignal) ? { signal: callOptions.abortSignal } : void 0;
-          const result = await this.executeTool(
-            id,
-            name,
-            args != null ? args : {},
-            requestOptions
-          );
-          return CallToolResultSchema2.parse(result);
-        }
-      });
-    };
     const perServerTools = await Promise.all(
       ids.map(async (id) => {
         try {
-          const tools = await loadForServer(id);
-          for (const [name, tool] of Object.entries(tools)) {
+          await this.ensureConnected(id);
+          const listToolsResult = await this.listTools(id);
+          const tools = await convertMCPToolsToVercelTools(listToolsResult, {
+            schemas: options.schemas,
+            callTool: async ({ name, args, options: callOptions }) => {
+              const requestOptions = callOptions?.abortSignal ? { signal: callOptions.abortSignal } : void 0;
+              const result = await this.executeTool(
+                id,
+                name,
+                args ?? {},
+                requestOptions
+              );
+              return types_js.CallToolResultSchema.parse(result);
+            }
+          });
+          for (const [_name, tool] of Object.entries(tools)) {
             tool._serverId = id;
           }
           return tools;
         } catch (error) {
-          if (this.isMethodUnavailableError(error, "tools/list")) {
+          if (isMethodUnavailableError(error, "tools/list")) {
             return {};
           }
           throw error;
@@ -326,236 +880,447 @@ var MCPClientManager = class {
     );
     const flattened = {};
     for (const toolset of perServerTools) {
-      for (const [name, tool] of Object.entries(toolset)) {
-        flattened[name] = tool;
-      }
+      Object.assign(flattened, toolset);
     }
     return flattened;
   }
-  async executeTool(serverId, toolName, args = {}, options) {
+  /**
+   * Executes a tool on a server.
+   *
+   * @param serverId - The server ID
+   * @param toolName - The tool name
+   * @param args - Tool arguments
+   * @param options - Request options
+   * @param taskOptions - Task options for async execution
+   */
+  async executeTool(serverId, toolName, args = {}, options, taskOptions) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
-    return client.callTool(
-      {
-        name: toolName,
-        arguments: args
-      },
-      CallToolResultSchema2,
-      this.withTimeout(serverId, options)
-    );
+    const client = this.getClientOrThrow(serverId);
+    const mergedOptions = this.withProgressHandler(serverId, options);
+    const callParams = { name: toolName, arguments: args };
+    if (taskOptions !== void 0) {
+      const taskValue = taskOptions.ttl !== void 0 ? { ttl: taskOptions.ttl } : {};
+      const result = await client.request(
+        { method: "tools/call", params: { ...callParams, task: taskValue } },
+        types_js.CreateTaskResultSchema,
+        mergedOptions
+      );
+      return {
+        task: result.task,
+        _meta: {
+          "io.modelcontextprotocol/model-immediate-response": `Task ${result.task.taskId} created with status: ${result.task.status}`
+        }
+      };
+    }
+    return client.callTool(callParams, types_js.CallToolResultSchema, mergedOptions);
   }
+  // ===========================================================================
+  // Resources
+  // ===========================================================================
+  /**
+   * Lists resources available from a server.
+   */
   async listResources(serverId, params, options) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
+    const client = this.getClientOrThrow(serverId);
     try {
       return await client.listResources(
         params,
         this.withTimeout(serverId, options)
       );
     } catch (error) {
-      if (this.isMethodUnavailableError(error, "resources/list")) {
-        return {
-          resources: []
-        };
+      if (isMethodUnavailableError(error, "resources/list")) {
+        return { resources: [] };
       }
       throw error;
     }
   }
+  /**
+   * Reads a resource from a server.
+   */
   async readResource(serverId, params, options) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
-    return client.readResource(params, this.withTimeout(serverId, options));
+    const client = this.getClientOrThrow(serverId);
+    return client.readResource(
+      params,
+      this.withProgressHandler(serverId, options)
+    );
   }
+  /**
+   * Subscribes to resource updates.
+   */
   async subscribeResource(serverId, params, options) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
+    const client = this.getClientOrThrow(serverId);
     return client.subscribeResource(
       params,
       this.withTimeout(serverId, options)
     );
   }
+  /**
+   * Unsubscribes from resource updates.
+   */
   async unsubscribeResource(serverId, params, options) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
+    const client = this.getClientOrThrow(serverId);
     return client.unsubscribeResource(
       params,
       this.withTimeout(serverId, options)
     );
   }
+  /**
+   * Lists resource templates from a server.
+   */
   async listResourceTemplates(serverId, params, options) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
+    const client = this.getClientOrThrow(serverId);
     return client.listResourceTemplates(
       params,
       this.withTimeout(serverId, options)
     );
   }
+  // ===========================================================================
+  // Prompts
+  // ===========================================================================
+  /**
+   * Lists prompts available from a server.
+   */
   async listPrompts(serverId, params, options) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
+    const client = this.getClientOrThrow(serverId);
     try {
       return await client.listPrompts(
         params,
         this.withTimeout(serverId, options)
       );
     } catch (error) {
-      if (this.isMethodUnavailableError(error, "prompts/list")) {
-        return {
-          prompts: []
-        };
+      if (isMethodUnavailableError(error, "prompts/list")) {
+        return { prompts: [] };
       }
       throw error;
     }
   }
+  /**
+   * Gets a prompt from a server.
+   */
   async getPrompt(serverId, params, options) {
     await this.ensureConnected(serverId);
-    const client = this.getClientById(serverId);
-    return client.getPrompt(params, this.withTimeout(serverId, options));
+    const client = this.getClientOrThrow(serverId);
+    return client.getPrompt(
+      params,
+      this.withProgressHandler(serverId, options)
+    );
+  }
+  // ===========================================================================
+  // Utility Methods
+  // ===========================================================================
+  /**
+   * Pings a server to check connectivity.
+   */
+  pingServer(serverId, options) {
+    const client = this.getClientOrThrow(serverId);
+    try {
+      client.ping(options);
+    } catch (error) {
+      throw new Error(
+        `Failed to ping MCP server "${serverId}": ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Sets the logging level for a server.
+   */
+  async setLoggingLevel(serverId, level = "debug") {
+    await this.ensureConnected(serverId);
+    const client = this.getClientOrThrow(serverId);
+    await client.setLoggingLevel(level);
   }
+  /**
+   * Gets the session ID for a Streamable HTTP server.
+   */
   getSessionIdByServer(serverId) {
     const state = this.clientStates.get(serverId);
-    if (!(state == null ? void 0 : state.transport)) {
+    if (!state?.transport) {
       throw new Error(`Unknown MCP server "${serverId}".`);
     }
-    if (state.transport instanceof StreamableHTTPClientTransport) {
+    if (state.transport instanceof streamableHttp_js.StreamableHTTPClientTransport) {
       return state.transport.sessionId;
     }
     throw new Error(
       `Server "${serverId}" must be Streamable HTTP to get the session ID.`
     );
   }
+  // ===========================================================================
+  // Notification Handlers
+  // ===========================================================================
+  /**
+   * Adds a notification handler for a server.
+   */
   addNotificationHandler(serverId, schema, handler) {
-    var _a, _b, _c;
-    const serverHandlers = (_a = this.notificationHandlers.get(serverId)) != null ? _a : /* @__PURE__ */ new Map();
-    const handlersForSchema = (_b = serverHandlers.get(schema)) != null ? _b : /* @__PURE__ */ new Set();
-    handlersForSchema.add(handler);
-    serverHandlers.set(schema, handlersForSchema);
-    this.notificationHandlers.set(serverId, serverHandlers);
-    const client = (_c = this.clientStates.get(serverId)) == null ? void 0 : _c.client;
+    this.notificationManager.addHandler(serverId, schema, handler);
+    const client = this.clientStates.get(serverId)?.client;
     if (client) {
       client.setNotificationHandler(
         schema,
-        this.createNotificationDispatcher(serverId, schema)
+        this.notificationManager.createDispatcher(serverId, schema)
       );
     }
   }
+  /**
+   * Registers a handler for resource list changes.
+   */
   onResourceListChanged(serverId, handler) {
     this.addNotificationHandler(
       serverId,
-      ResourceListChangedNotificationSchema,
+      types_js.ResourceListChangedNotificationSchema,
       handler
     );
   }
+  /**
+   * Registers a handler for resource updates.
+   */
   onResourceUpdated(serverId, handler) {
     this.addNotificationHandler(
       serverId,
-      ResourceUpdatedNotificationSchema,
+      types_js.ResourceUpdatedNotificationSchema,
       handler
     );
   }
+  /**
+   * Registers a handler for prompt list changes.
+   */
   onPromptListChanged(serverId, handler) {
     this.addNotificationHandler(
       serverId,
-      PromptListChangedNotificationSchema,
+      types_js.PromptListChangedNotificationSchema,
       handler
     );
   }
-  getClient(serverId) {
-    var _a;
-    return (_a = this.clientStates.get(serverId)) == null ? void 0 : _a.client;
+  /**
+   * Registers a handler for task status changes.
+   */
+  onTaskStatusChanged(serverId, handler) {
+    this.addNotificationHandler(
+      serverId,
+      TaskStatusNotificationSchema,
+      handler
+    );
   }
+  // ===========================================================================
+  // Elicitation
+  // ===========================================================================
+  /**
+   * Sets a server-specific elicitation handler.
+   */
   setElicitationHandler(serverId, handler) {
-    var _a;
     if (!this.clientStates.has(serverId)) {
       throw new Error(`Unknown MCP server "${serverId}".`);
     }
-    this.elicitationHandlers.set(serverId, handler);
-    const client = (_a = this.clientStates.get(serverId)) == null ? void 0 : _a.client;
+    this.elicitationManager.setHandler(serverId, handler);
+    const client = this.clientStates.get(serverId)?.client;
     if (client) {
-      this.applyElicitationHandler(serverId, client);
+      this.elicitationManager.applyToClient(serverId, client);
     }
   }
+  /**
+   * Clears a server-specific elicitation handler.
+   */
   clearElicitationHandler(serverId) {
-    var _a;
-    this.elicitationHandlers.delete(serverId);
-    const client = (_a = this.clientStates.get(serverId)) == null ? void 0 : _a.client;
+    this.elicitationManager.clearHandler(serverId);
+    const client = this.clientStates.get(serverId)?.client;
     if (client) {
-      client.removeRequestHandler("elicitation/create");
+      if (this.elicitationManager.getGlobalCallback()) {
+        this.elicitationManager.applyToClient(serverId, client);
+      } else {
+        this.elicitationManager.removeFromClient(client);
+      }
     }
   }
-  // Global elicitation callback API (no serverId required)
+  /**
+   * Sets a global elicitation callback for all servers.
+   */
   setElicitationCallback(callback) {
-    this.elicitationCallback = callback;
+    this.elicitationManager.setGlobalCallback(callback);
     for (const [serverId, state] of this.clientStates.entries()) {
-      const client = state.client;
-      if (!client) continue;
-      if (this.elicitationHandlers.has(serverId)) {
-        this.applyElicitationHandler(serverId, client);
-      } else {
-        this.applyElicitationHandler(serverId, client);
+      if (state.client) {
+        this.elicitationManager.applyToClient(serverId, state.client);
       }
     }
   }
+  /**
+   * Clears the global elicitation callback.
+   */
   clearElicitationCallback() {
-    this.elicitationCallback = void 0;
+    this.elicitationManager.clearGlobalCallback();
     for (const [serverId, state] of this.clientStates.entries()) {
-      const client = state.client;
-      if (!client) continue;
-      if (this.elicitationHandlers.has(serverId)) {
-        this.applyElicitationHandler(serverId, client);
+      if (!state.client) continue;
+      if (this.elicitationManager.getHandler(serverId)) {
+        this.elicitationManager.applyToClient(serverId, state.client);
       } else {
-        client.removeRequestHandler("elicitation/create");
+        this.elicitationManager.removeFromClient(state.client);
       }
     }
   }
-  // Expose the pending elicitation map so callers can add resolvers
+  /**
+   * Gets the pending elicitations map for external resolvers.
+   */
   getPendingElicitations() {
-    return this.pendingElicitations;
+    return this.elicitationManager.getPendingElicitations();
   }
-  // Helper to resolve a pending elicitation from outside
+  /**
+   * Responds to a pending elicitation.
+   */
   respondToElicitation(requestId, response) {
-    const pending = this.pendingElicitations.get(requestId);
-    if (!pending) return false;
+    return this.elicitationManager.respond(requestId, response);
+  }
+  // ===========================================================================
+  // Tasks (MCP Tasks experimental feature)
+  // ===========================================================================
+  /**
+   * Lists tasks from a server.
+   */
+  async listTasks(serverId, cursor, options) {
+    await this.ensureConnected(serverId);
+    const client = this.getClientOrThrow(serverId);
     try {
-      pending.resolve(response);
-      return true;
-    } finally {
-      this.pendingElicitations.delete(requestId);
+      return await listTasks(
+        client,
+        cursor,
+        this.withTimeout(serverId, options)
+      );
+    } catch (error) {
+      if (isMethodUnavailableError(error, "tasks/list")) {
+        return { tasks: [] };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Gets a task by ID.
+   */
+  async getTask(serverId, taskId, options) {
+    await this.ensureConnected(serverId);
+    const client = this.getClientOrThrow(serverId);
+    return getTask(client, taskId, this.withTimeout(serverId, options));
+  }
+  /**
+   * Gets the result of a completed task.
+   */
+  async getTaskResult(serverId, taskId, options) {
+    await this.ensureConnected(serverId);
+    const client = this.getClientOrThrow(serverId);
+    return getTaskResult(
+      client,
+      taskId,
+      this.withTimeout(serverId, options)
+    );
+  }
+  /**
+   * Cancels a task.
+   */
+  async cancelTask(serverId, taskId, options) {
+    await this.ensureConnected(serverId);
+    const client = this.getClientOrThrow(serverId);
+    return cancelTask(client, taskId, this.withTimeout(serverId, options));
+  }
+  /**
+   * Checks if server supports task-augmented tool calls.
+   */
+  supportsTasksForToolCalls(serverId) {
+    return supportsTasksForToolCalls(this.getServerCapabilities(serverId));
+  }
+  /**
+   * Checks if server supports listing tasks.
+   */
+  supportsTasksList(serverId) {
+    return supportsTasksList(this.getServerCapabilities(serverId));
+  }
+  /**
+   * Checks if server supports canceling tasks.
+   */
+  supportsTasksCancel(serverId) {
+    return supportsTasksCancel(this.getServerCapabilities(serverId));
+  }
+  // ===========================================================================
+  // Private Helpers
+  // ===========================================================================
+  async performConnection(serverId, config, timeout, state) {
+    try {
+      const client = new index_js.Client(
+        {
+          name: this.defaultClientName ?? serverId,
+          version: config.version ?? this.defaultClientVersion
+        },
+        { capabilities: this.buildCapabilities(config) }
+      );
+      this.notificationManager.applyToClient(serverId, client);
+      if (this.defaultProgressHandler) {
+        applyProgressHandler(serverId, client, this.defaultProgressHandler);
+      }
+      this.elicitationManager.applyToClient(serverId, client);
+      if (config.onError) {
+        client.onerror = (error) => config.onError?.(error);
+      }
+      client.onclose = () => this.resetState(serverId);
+      let transport;
+      if (this.isStdioConfig(config)) {
+        transport = await this.connectViaStdio(
+          serverId,
+          client,
+          config,
+          timeout
+        );
+      } else {
+        transport = await this.connectViaHttp(
+          serverId,
+          client,
+          config,
+          timeout
+        );
+      }
+      state.client = client;
+      state.transport = transport;
+      state.promise = void 0;
+      this.clientStates.set(serverId, state);
+      this.setLoggingLevel(serverId, "debug").catch(() => {
+      });
+      return client;
+    } catch (error) {
+      this.resetState(serverId);
+      throw error;
     }
   }
   async connectViaStdio(serverId, client, config, timeout) {
-    var _a;
-    const underlying = new StdioClientTransport({
+    const underlying = new stdio_js.StdioClientTransport({
       command: config.command,
       args: config.args,
-      env: { ...getDefaultEnvironment(), ...(_a = config.env) != null ? _a : {} }
+      env: { ...stdio_js.getDefaultEnvironment(), ...config.env ?? {} }
     });
-    const wrapped = this.wrapTransportForLogging(serverId, config, underlying);
-    await client.connect(wrapped, { timeout });
+    const logger = this.resolveRpcLogger(config);
+    const transport = logger ? wrapTransportForLogging(serverId, logger, underlying) : underlying;
+    await client.connect(transport, { timeout });
     return underlying;
   }
   async connectViaHttp(serverId, client, config, timeout) {
-    var _a;
-    const preferSSE = (_a = config.preferSSE) != null ? _a : config.url.pathname.endsWith("/sse");
+    const url = new URL(config.url);
+    const requestInit = buildRequestInit(
+      config.accessToken,
+      config.requestInit
+    );
+    const preferSSE = config.preferSSE ?? url.pathname.endsWith("/sse");
     let streamableError;
     if (!preferSSE) {
-      const streamableTransport = new StreamableHTTPClientTransport(
-        config.url,
-        {
-          requestInit: config.requestInit,
-          reconnectionOptions: config.reconnectionOptions,
-          authProvider: config.authProvider,
-          sessionId: config.sessionId
-        }
-      );
+      const streamableTransport = new streamableHttp_js.StreamableHTTPClientTransport(url, {
+        requestInit,
+        reconnectionOptions: config.reconnectionOptions,
+        authProvider: config.authProvider,
+        sessionId: config.sessionId
+      });
       try {
-        const wrapped = this.wrapTransportForLogging(
-          serverId,
-          config,
-          streamableTransport
-        );
+        const logger = this.resolveRpcLogger(config);
+        const wrapped = logger ? wrapTransportForLogging(serverId, logger, streamableTransport) : streamableTransport;
         await client.connect(wrapped, {
-          timeout: Math.min(timeout, 3e3)
+          timeout: Math.min(timeout, HTTP_CONNECT_TIMEOUT)
         });
         return streamableTransport;
       } catch (error) {
@@ -563,24 +1328,33 @@ var MCPClientManager = class {
         await this.safeCloseTransport(streamableTransport);
       }
     }
-    const sseTransport = new SSEClientTransport(config.url, {
-      requestInit: config.requestInit,
+    const sseTransport = new sse_js.SSEClientTransport(url, {
+      requestInit,
       eventSourceInit: config.eventSourceInit,
       authProvider: config.authProvider
     });
     try {
-      const wrapped = this.wrapTransportForLogging(
-        serverId,
-        config,
-        sseTransport
-      );
+      const logger = this.resolveRpcLogger(config);
+      const wrapped = logger ? wrapTransportForLogging(serverId, logger, sseTransport) : sseTransport;
       await client.connect(wrapped, { timeout });
       return sseTransport;
     } catch (error) {
       await this.safeCloseTransport(sseTransport);
-      const streamableMessage = streamableError ? ` Streamable HTTP error: ${this.formatError(streamableError)}.` : "";
+      const streamableMessage = streamableError ? ` Streamable HTTP error: ${formatError(streamableError)}.` : "";
+      const sseErrorMessage = formatError(error);
+      const combinedErrorMessage = `${streamableMessage} SSE error: ${sseErrorMessage}`.trim();
+      const sseAuthCheck = isAuthError(error);
+      const streamableAuthCheck = streamableError ? isAuthError(streamableError) : { isAuth: false };
+      if (sseAuthCheck.isAuth || streamableAuthCheck.isAuth) {
+        const statusCode = sseAuthCheck.statusCode ?? streamableAuthCheck.statusCode;
+        throw new MCPAuthError(
+          `Authentication failed for MCP server "${serverId}": ${combinedErrorMessage}`,
+          statusCode,
+          { cause: error }
+        );
+      }
       throw new Error(
-        `Failed to connect to MCP server "${serverId}" using HTTP transports.${streamableMessage} SSE error: ${this.formatError(error)}.`
+        `Failed to connect to MCP server "${serverId}" using HTTP transports.${streamableMessage} SSE error: ${sseErrorMessage}.`
       );
     }
   }
@@ -590,60 +1364,9 @@ var MCPClientManager = class {
     } catch {
     }
   }
-  applyNotificationHandlers(serverId, client) {
-    const serverHandlers = this.notificationHandlers.get(serverId);
-    if (!serverHandlers) {
-      return;
-    }
-    for (const [schema] of serverHandlers) {
-      client.setNotificationHandler(
-        schema,
-        this.createNotificationDispatcher(serverId, schema)
-      );
-    }
-  }
-  createNotificationDispatcher(serverId, schema) {
-    return (notification) => {
-      const serverHandlers = this.notificationHandlers.get(serverId);
-      const handlersForSchema = serverHandlers == null ? void 0 : serverHandlers.get(schema);
-      if (!handlersForSchema || handlersForSchema.size === 0) {
-        return;
-      }
-      for (const handler of handlersForSchema) {
-        try {
-          handler(notification);
-        } catch {
-        }
-      }
-    };
-  }
-  applyElicitationHandler(serverId, client) {
-    const serverSpecific = this.elicitationHandlers.get(serverId);
-    if (serverSpecific) {
-      client.setRequestHandler(
-        ElicitRequestSchema,
-        async (request) => serverSpecific(request.params)
-      );
-      return;
-    }
-    if (this.elicitationCallback) {
-      client.setRequestHandler(ElicitRequestSchema, async (request) => {
-        var _a, _b, _c, _d;
-        const reqId = `elicit_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-        return await this.elicitationCallback({
-          requestId: reqId,
-          message: (_a = request.params) == null ? void 0 : _a.message,
-          schema: (_d = (_b = request.params) == null ? void 0 : _b.requestedSchema) != null ? _d : (_c = request.params) == null ? void 0 : _c.schema
-        });
-      });
-      return;
-    }
-  }
   async ensureConnected(serverId) {
     const state = this.clientStates.get(serverId);
-    if (state == null ? void 0 : state.client) {
-      return;
-    }
+    if (state?.client) return;
     if (!state) {
       throw new Error(`Unknown MCP server "${serverId}".`);
     }
@@ -653,172 +1376,1468 @@ var MCPClientManager = class {
     }
     await this.connectToServer(serverId, state.config);
   }
+  getClientOrThrow(serverId) {
+    const state = this.clientStates.get(serverId);
+    if (!state?.client) {
+      throw new Error(`MCP server "${serverId}" is not connected.`);
+    }
+    return state.client;
+  }
   resetState(serverId) {
     this.clientStates.delete(serverId);
     this.toolsMetadataCache.delete(serverId);
   }
-  resolveConnectionStatus(state) {
-    if (!state) {
-      return "disconnected";
-    }
-    if (state.client) {
-      return "connected";
-    }
-    if (state.promise) {
-      return "connecting";
-    }
-    return "disconnected";
-  }
   withTimeout(serverId, options) {
-    var _a;
     const state = this.clientStates.get(serverId);
-    const timeout = (_a = state == null ? void 0 : state.timeout) != null ? _a : state ? this.getTimeout(state.config) : this.defaultTimeout;
-    if (!options) {
-      return { timeout };
-    }
-    if (options.timeout === void 0) {
-      return { ...options, timeout };
-    }
+    const timeout = state?.timeout ?? this.defaultTimeout;
+    if (!options) return { timeout };
+    if (options.timeout === void 0) return { ...options, timeout };
     return options;
   }
+  withProgressHandler(serverId, options) {
+    const mergedOptions = this.withTimeout(serverId, options);
+    if (!mergedOptions.onprogress && this.defaultProgressHandler) {
+      const progressToken = `${serverId}-request-${Date.now()}-${++this.progressTokenCounter}`;
+      mergedOptions.onprogress = (progress) => {
+        this.defaultProgressHandler({
+          serverId,
+          progressToken,
+          progress: progress.progress,
+          total: progress.total,
+          message: progress.message
+        });
+      };
+    }
+    return mergedOptions;
+  }
   buildCapabilities(config) {
-    var _a;
     const capabilities = {
       ...this.defaultCapabilities,
-      ...(_a = config.capabilities) != null ? _a : {}
+      ...config.capabilities ?? {}
     };
     if (!capabilities.elicitation) {
       capabilities.elicitation = {};
     }
     return capabilities;
   }
-  formatError(error) {
-    if (error instanceof Error) {
-      return error.message;
+  resolveRpcLogger(config) {
+    if (config.rpcLogger) return config.rpcLogger;
+    if (config.logJsonRpc || this.defaultLogJsonRpc)
+      return createDefaultRpcLogger();
+    if (this.defaultRpcLogger) return this.defaultRpcLogger;
+    return void 0;
+  }
+  cacheToolsMetadata(serverId, tools) {
+    const metadataMap = /* @__PURE__ */ new Map();
+    for (const tool of tools) {
+      if (tool._meta) {
+        metadataMap.set(tool.name, tool._meta);
+      }
     }
-    try {
-      return JSON.stringify(error);
-    } catch {
-      return String(error);
-    }
-  }
-  // Returns a transport that logs JSON-RPC traffic if enabled for this server
-  wrapTransportForLogging(serverId, config, transport) {
-    const logger = this.resolveRpcLogger(serverId, config);
-    if (!logger) return transport;
-    const log = logger;
-    const self = this;
-    class LoggingTransport {
-      constructor(inner) {
-        this.inner = inner;
-        this.inner.onmessage = (message, extra) => {
-          var _a;
-          try {
-            log({ direction: "receive", message, serverId });
-          } catch {
+    this.toolsMetadataCache.set(serverId, metadataMap);
+  }
+  isStdioConfig(config) {
+    return "command" in config;
+  }
+};
+var BUILT_IN_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "azure",
+  "deepseek",
+  "google",
+  "ollama",
+  "mistral",
+  "openrouter",
+  "xai"
+];
+function parseLLMString(llmString, customProviderNames) {
+  const parts = llmString.split("/");
+  if (parts.length < 2) {
+    throw new Error(
+      `Invalid LLM string format: "${llmString}". Expected format: "provider/model" (e.g., "openai/gpt-4o")`
+    );
+  }
+  const providerName = parts[0];
+  const model = parts.slice(1).join("/");
+  if (BUILT_IN_PROVIDERS.includes(providerName)) {
+    return {
+      type: "builtin",
+      provider: providerName,
+      model
+    };
+  }
+  if (customProviderNames?.has(providerName)) {
+    return {
+      type: "custom",
+      providerName,
+      model
+    };
+  }
+  const allProviders = customProviderNames ? [...BUILT_IN_PROVIDERS, ...customProviderNames] : BUILT_IN_PROVIDERS;
+  throw new Error(
+    `Unknown LLM provider: "${providerName}". Supported providers: ${allProviders.join(", ")}`
+  );
+}
+function createModelFromCustomProvider(customProvider, model, runtimeApiKey) {
+  const apiKey = runtimeApiKey || customProvider.apiKey || (customProvider.apiKeyEnvVar ? process.env[customProvider.apiKeyEnvVar] : void 0) || "";
+  switch (customProvider.protocol) {
+    case "openai-compatible": {
+      const openai$1 = openai.createOpenAI({
+        apiKey,
+        baseURL: customProvider.baseUrl
+      });
+      return customProvider.useChatCompletions ? openai$1.chat(model) : openai$1(model);
+    }
+    case "anthropic-compatible": {
+      const anthropic$1 = anthropic.createAnthropic({
+        apiKey,
+        baseURL: customProvider.baseUrl
+      });
+      return anthropic$1(model);
+    }
+    default: {
+      const _exhaustiveCheck = customProvider.protocol;
+      throw new Error(`Unknown protocol: ${_exhaustiveCheck}`);
+    }
+  }
+}
+function createModelFromString(llmString, options) {
+  const { apiKey, baseUrls, customProviders } = options;
+  const customProvidersMap = customProviders instanceof Map ? customProviders : customProviders ? new Map(Object.entries(customProviders)) : /* @__PURE__ */ new Map();
+  const customProviderNames = new Set(customProvidersMap.keys());
+  const parsed = parseLLMString(llmString, customProviderNames);
+  if (parsed.type === "custom") {
+    const customProvider = customProvidersMap.get(parsed.providerName);
+    if (!customProvider) {
+      throw new Error(
+        `Custom provider "${parsed.providerName}" not found in registry`
+      );
+    }
+    return createModelFromCustomProvider(customProvider, parsed.model, apiKey);
+  }
+  const { provider, model } = parsed;
+  switch (provider) {
+    case "anthropic": {
+      const anthropic$1 = anthropic.createAnthropic({
+        apiKey,
+        ...baseUrls?.anthropic && { baseURL: baseUrls.anthropic }
+      });
+      return anthropic$1(model);
+    }
+    case "openai": {
+      const openai$1 = openai.createOpenAI({
+        apiKey,
+        ...baseUrls?.openai && { baseURL: baseUrls.openai }
+      });
+      return openai$1(model);
+    }
+    case "deepseek": {
+      const deepseek$1 = deepseek.createDeepSeek({ apiKey });
+      return deepseek$1(model);
+    }
+    case "google": {
+      const google$1 = google.createGoogleGenerativeAI({ apiKey });
+      return google$1(model);
+    }
+    case "ollama": {
+      const raw = baseUrls?.ollama || "http://127.0.0.1:11434/api";
+      const normalized = /\/api\/?$/.test(raw) ? raw : `${raw.replace(/\/+$/, "")}/api`;
+      const ollama = ollamaAiProviderV2.createOllama({ baseURL: normalized });
+      return ollama(model);
+    }
+    case "mistral": {
+      const mistral$1 = mistral.createMistral({ apiKey });
+      return mistral$1(model);
+    }
+    case "openrouter": {
+      const openrouter = aiSdkProvider.createOpenRouter({ apiKey });
+      return openrouter(model);
+    }
+    case "xai": {
+      const xai$1 = xai.createXai({ apiKey });
+      return xai$1(model);
+    }
+    case "azure": {
+      const azure$1 = azure.createAzure({
+        apiKey,
+        baseURL: baseUrls?.azure
+      });
+      return azure$1(model);
+    }
+    default: {
+      const _exhaustiveCheck = provider;
+      throw new Error(`Unhandled provider: ${_exhaustiveCheck}`);
+    }
+  }
+}
+function parseModelIds(modelIdsString) {
+  return modelIdsString.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
+}
+function createCustomProvider(config) {
+  const modelIds = Array.isArray(config.modelIds) ? config.modelIds : parseModelIds(config.modelIds);
+  if (modelIds.length === 0) {
+    throw new Error("At least one model ID is required");
+  }
+  if (!config.name || config.name.includes("/")) {
+    throw new Error("Provider name is required and cannot contain '/'");
+  }
+  if (!config.baseUrl) {
+    throw new Error("Base URL is required");
+  }
+  return {
+    name: config.name,
+    protocol: config.protocol,
+    baseUrl: config.baseUrl,
+    modelIds,
+    ...config.apiKey && { apiKey: config.apiKey },
+    ...config.apiKeyEnvVar && { apiKeyEnvVar: config.apiKeyEnvVar },
+    ...config.useChatCompletions && {
+      useChatCompletions: config.useChatCompletions
+    }
+  };
+}
+var PROVIDER_PRESETS = {
+  /** LiteLLM proxy - requires useChatCompletions */
+  litellm: (baseUrl = "http://localhost:4000", modelIds) => ({
+    name: "litellm",
+    protocol: "openai-compatible",
+    baseUrl,
+    modelIds,
+    apiKeyEnvVar: "LITELLM_API_KEY",
+    useChatCompletions: true
+  })
+};
+
+// src/tool-extraction.ts
+function extractToolCalls(result) {
+  const toolCalls = [];
+  if (result.steps && Array.isArray(result.steps)) {
+    for (const step of result.steps) {
+      if (step.toolCalls && Array.isArray(step.toolCalls)) {
+        for (const tc of step.toolCalls) {
+          toolCalls.push({
+            toolName: tc.toolName,
+            arguments: tc.input ?? {}
+          });
+        }
+      }
+    }
+  }
+  if (toolCalls.length === 0 && result.toolCalls && Array.isArray(result.toolCalls)) {
+    for (const tc of result.toolCalls) {
+      toolCalls.push({
+        toolName: tc.toolName,
+        arguments: tc.input ?? {}
+      });
+    }
+  }
+  return toolCalls;
+}
+function extractToolNames(result) {
+  return extractToolCalls(result).map((tc) => tc.toolName);
+}
+
+// src/PromptResult.ts
+var PromptResult = class _PromptResult {
+  /** The original prompt/query that was sent */
+  prompt;
+  /** The text response from the LLM */
+  text;
+  /** The full conversation history */
+  _messages;
+  /** Latency breakdown (e2e, llm, mcp) */
+  _latency;
+  /** Tool calls made during the prompt */
+  _toolCalls;
+  /** Token usage statistics */
+  _usage;
+  /** Error message if the prompt failed */
+  _error;
+  /**
+   * Create a new PromptResult
+   * @param data - The raw prompt result data
+   */
+  constructor(data) {
+    this.prompt = data.prompt;
+    this._messages = data.messages;
+    this.text = data.text;
+    this._latency = data.latency;
+    this._toolCalls = data.toolCalls;
+    this._usage = data.usage;
+    this._error = data.error;
+  }
+  /**
+   * Get the original query/prompt that was sent.
+   *
+   * @returns The original prompt string
+   */
+  getPrompt() {
+    return this.prompt;
+  }
+  /**
+   * Get the full conversation history (user, assistant, tool messages).
+   * Returns a copy to prevent external modification.
+   *
+   * @returns Array of CoreMessage objects
+   */
+  getMessages() {
+    return [...this._messages];
+  }
+  /**
+   * Get only user messages from the conversation.
+   *
+   * @returns Array of CoreUserMessage objects
+   */
+  getUserMessages() {
+    return this._messages.filter(
+      (m) => m.role === "user"
+    );
+  }
+  /**
+   * Get only assistant messages from the conversation.
+   *
+   * @returns Array of CoreAssistantMessage objects
+   */
+  getAssistantMessages() {
+    return this._messages.filter(
+      (m) => m.role === "assistant"
+    );
+  }
+  /**
+   * Get only tool result messages from the conversation.
+   *
+   * @returns Array of CoreToolMessage objects
+   */
+  getToolMessages() {
+    return this._messages.filter(
+      (m) => m.role === "tool"
+    );
+  }
+  /**
+   * Get the end-to-end latency in milliseconds.
+   * This is the total wall-clock time for the prompt.
+   *
+   * @returns End-to-end latency in milliseconds
+   */
+  e2eLatencyMs() {
+    return this._latency.e2eMs;
+  }
+  /**
+   * Get the LLM API latency in milliseconds.
+   * This is the time spent waiting for LLM responses (excluding tool execution).
+   *
+   * @returns LLM latency in milliseconds
+   */
+  llmLatencyMs() {
+    return this._latency.llmMs;
+  }
+  /**
+   * Get the MCP tool execution latency in milliseconds.
+   * This is the time spent executing MCP tools.
+   *
+   * @returns MCP tool latency in milliseconds
+   */
+  mcpLatencyMs() {
+    return this._latency.mcpMs;
+  }
+  /**
+   * Get the full latency breakdown.
+   *
+   * @returns LatencyBreakdown object with e2eMs, llmMs, and mcpMs
+   */
+  getLatency() {
+    return { ...this._latency };
+  }
+  /**
+   * Get the names of all tools that were called during this prompt.
+   * Returns a standard string[] that can be used with .includes().
+   *
+   * @returns Array of tool names
+   */
+  toolsCalled() {
+    return this._toolCalls.map((tc) => tc.toolName);
+  }
+  /**
+   * Check if a specific tool was called during this prompt.
+   * Case-sensitive exact match.
+   *
+   * @param toolName - The name of the tool to check for
+   * @returns true if the tool was called
+   */
+  hasToolCall(toolName) {
+    return this._toolCalls.some((tc) => tc.toolName === toolName);
+  }
+  /**
+   * Get all tool calls with their arguments.
+   *
+   * @returns Array of ToolCall objects
+   */
+  getToolCalls() {
+    return [...this._toolCalls];
+  }
+  /**
+   * Get the arguments passed to a specific tool call.
+   * Returns undefined if the tool was not called.
+   * If the tool was called multiple times, returns the first call's arguments.
+   *
+   * @param toolName - The name of the tool
+   * @returns The arguments object or undefined
+   */
+  getToolArguments(toolName) {
+    const call = this._toolCalls.find((tc) => tc.toolName === toolName);
+    return call?.arguments;
+  }
+  /**
+   * Get the total number of tokens used.
+   *
+   * @returns Total tokens (input + output)
+   */
+  totalTokens() {
+    return this._usage.totalTokens;
+  }
+  /**
+   * Get the number of input tokens used.
+   *
+   * @returns Input token count
+   */
+  inputTokens() {
+    return this._usage.inputTokens;
+  }
+  /**
+   * Get the number of output tokens used.
+   *
+   * @returns Output token count
+   */
+  outputTokens() {
+    return this._usage.outputTokens;
+  }
+  /**
+   * Get the full token usage statistics.
+   *
+   * @returns TokenUsage object
+   */
+  getUsage() {
+    return { ...this._usage };
+  }
+  /**
+   * Check if this prompt resulted in an error.
+   *
+   * @returns true if there was an error
+   */
+  hasError() {
+    return this._error !== void 0;
+  }
+  /**
+   * Get the error message if the prompt failed.
+   *
+   * @returns The error message or undefined
+   */
+  getError() {
+    return this._error;
+  }
+  /**
+   * Create a PromptResult from raw data.
+   * Factory method for convenience.
+   *
+   * @param data - The raw prompt result data
+   * @returns A new PromptResult instance
+   */
+  static from(data) {
+    return new _PromptResult(data);
+  }
+  /**
+   * Create an error PromptResult.
+   * Factory method for error cases.
+   *
+   * @param error - The error message
+   * @param latency - The latency breakdown or e2e time in milliseconds
+   * @returns A new PromptResult instance with error state
+   */
+  static error(error, latency = 0, prompt = "") {
+    const latencyBreakdown = typeof latency === "number" ? { e2eMs: latency, llmMs: 0, mcpMs: 0 } : latency;
+    return new _PromptResult({
+      prompt,
+      messages: [],
+      text: "",
+      toolCalls: [],
+      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+      latency: latencyBreakdown,
+      error
+    });
+  }
+  /**
+   * Format the conversation trace as a JSON string.
+   * Useful for debugging failed evaluations.
+   *
+   * @returns A JSON string of the conversation messages
+   */
+  formatTrace() {
+    return JSON.stringify(this._messages, null, 2);
+  }
+};
+
+// src/TestAgent.ts
+function isToolArray(tools) {
+  return Array.isArray(tools);
+}
+function convertToToolSet(tools) {
+  const toolSet = {};
+  for (const tool of tools) {
+    const visibility = tool._meta?.ui?.visibility;
+    if (visibility && visibility.length === 1 && visibility[0] === "app") {
+      continue;
+    }
+    const converted = ai.dynamicTool({
+      description: tool.description,
+      inputSchema: ai.jsonSchema(ensureJsonSchemaObject(tool.inputSchema)),
+      execute: async (args, options) => {
+        options?.abortSignal?.throwIfAborted?.();
+        const result = await tool.execute(args);
+        return types_js.CallToolResultSchema.parse(result);
+      }
+    });
+    if (tool._meta?._serverId) {
+      converted._serverId = tool._meta._serverId;
+    }
+    toolSet[tool.name] = converted;
+  }
+  return toolSet;
+}
+var TestAgent = class _TestAgent {
+  tools;
+  model;
+  apiKey;
+  systemPrompt;
+  temperature;
+  maxSteps;
+  customProviders;
+  /** The result of the last prompt (for toolsCalled() convenience method) */
+  lastResult;
+  /** History of all prompt results during a test execution */
+  promptHistory = [];
+  /**
+   * Create a new TestAgent
+   * @param config - Agent configuration
+   */
+  constructor(config) {
+    this.tools = isToolArray(config.tools) ? convertToToolSet(config.tools) : config.tools;
+    this.model = config.model;
+    this.apiKey = config.apiKey;
+    this.systemPrompt = config.systemPrompt ?? "You are a helpful assistant.";
+    this.temperature = config.temperature;
+    this.maxSteps = config.maxSteps ?? 10;
+    this.customProviders = config.customProviders;
+  }
+  /**
+   * Create instrumented tools that track execution latency.
+   * @param onLatency - Callback to report latency for each tool execution
+   * @returns ToolSet with instrumented execute functions
+   */
+  createInstrumentedTools(onLatency) {
+    const instrumented = {};
+    for (const [name, tool] of Object.entries(this.tools)) {
+      if (tool.execute) {
+        const originalExecute = tool.execute;
+        instrumented[name] = {
+          ...tool,
+          execute: async (args, options) => {
+            const start = Date.now();
+            try {
+              return await originalExecute(args, options);
+            } finally {
+              onLatency(Date.now() - start);
+            }
           }
-          (_a = this.onmessage) == null ? void 0 : _a.call(this, message, extra);
-        };
-        this.inner.onclose = () => {
-          var _a;
-          (_a = this.onclose) == null ? void 0 : _a.call(this);
-        };
-        this.inner.onerror = (error) => {
-          var _a;
-          (_a = this.onerror) == null ? void 0 : _a.call(this, error);
         };
+      } else {
+        instrumented[name] = tool;
       }
-      async start() {
-        if (typeof this.inner.start === "function") {
-          await this.inner.start();
+    }
+    return instrumented;
+  }
+  /**
+   * Build an array of CoreMessages from previous PromptResult(s) for multi-turn context.
+   * @param context - Single PromptResult or array of PromptResults to include as context
+   * @returns Array of CoreMessages representing the conversation history
+   */
+  buildContextMessages(context) {
+    if (!context) {
+      return [];
+    }
+    const results = Array.isArray(context) ? context : [context];
+    const messages = [];
+    for (const result of results) {
+      messages.push(...result.getMessages());
+    }
+    return messages;
+  }
+  /**
+   * Run a prompt with the LLM, allowing tool calls.
+   * Never throws - errors are returned in the PromptResult.
+   *
+   * @param message - The user message to send to the LLM
+   * @param options - Optional settings including context for multi-turn conversations
+   * @returns PromptResult with text response, tool calls, token usage, and latency breakdown
+   *
+   * @example
+   * // Single-turn (default)
+   * const result = await agent.prompt("Show me workspaces");
+   *
+   * @example
+   * // Multi-turn with context
+   * const r1 = await agent.prompt("Show me workspaces");
+   * const r2 = await agent.prompt("Now show tasks", { context: r1 });
+   *
+   * @example
+   * // Multi-turn with multiple context results
+   * const r1 = await agent.prompt("Show workspaces");
+   * const r2 = await agent.prompt("Pick the first", { context: r1 });
+   * const r3 = await agent.prompt("Show tasks", { context: [r1, r2] });
+   */
+  async prompt(message, options) {
+    const startTime = Date.now();
+    let totalMcpMs = 0;
+    let lastStepEndTime = startTime;
+    let totalLlmMs = 0;
+    let stepMcpMs = 0;
+    try {
+      const modelOptions = {
+        apiKey: this.apiKey,
+        customProviders: this.customProviders
+      };
+      const model = createModelFromString(this.model, modelOptions);
+      const instrumentedTools = this.createInstrumentedTools((ms) => {
+        totalMcpMs += ms;
+        stepMcpMs += ms;
+      });
+      const contextMessages = this.buildContextMessages(options?.context);
+      const userMessage = { role: "user", content: message };
+      const result = await ai.generateText({
+        model,
+        tools: instrumentedTools,
+        system: this.systemPrompt,
+        // Use messages array for multi-turn, simple prompt for single-turn
+        ...contextMessages.length > 0 ? { messages: [...contextMessages, userMessage] } : { prompt: message },
+        // Only include temperature if explicitly set (some models like reasoning models don't support it)
+        ...this.temperature !== void 0 && { temperature: this.temperature },
+        // Use stopWhen with stepCountIs for controlling max agentic steps
+        // AI SDK v6+ uses this instead of maxSteps
+        stopWhen: ai.stepCountIs(this.maxSteps),
+        onStepFinish: () => {
+          const now = Date.now();
+          const stepDuration = now - lastStepEndTime;
+          totalLlmMs += Math.max(0, stepDuration - stepMcpMs);
+          lastStepEndTime = now;
+          stepMcpMs = 0;
         }
+      });
+      const e2eMs = Date.now() - startTime;
+      const toolCalls = extractToolCalls(result);
+      const usage = result.totalUsage ?? result.usage;
+      const inputTokens = usage?.inputTokens ?? 0;
+      const outputTokens = usage?.outputTokens ?? 0;
+      const messages = [];
+      messages.push(userMessage);
+      if (result.response?.messages) {
+        messages.push(...result.response.messages);
       }
-      async send(message, options) {
-        try {
-          log({ direction: "send", message, serverId });
-        } catch {
-        }
-        await this.inner.send(message, options);
+      this.lastResult = PromptResult.from({
+        prompt: message,
+        messages,
+        text: result.text,
+        toolCalls,
+        usage: {
+          inputTokens,
+          outputTokens,
+          totalTokens: inputTokens + outputTokens
+        },
+        latency: { e2eMs, llmMs: totalLlmMs, mcpMs: totalMcpMs }
+      });
+      this.promptHistory.push(this.lastResult);
+      return this.lastResult;
+    } catch (error) {
+      const e2eMs = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.lastResult = PromptResult.error(
+        errorMessage,
+        {
+          e2eMs,
+          llmMs: totalLlmMs,
+          mcpMs: totalMcpMs
+        },
+        message
+      );
+      this.promptHistory.push(this.lastResult);
+      return this.lastResult;
+    }
+  }
+  /**
+   * Get the names of tools called in the last prompt.
+   * Convenience method for quick checks in eval functions.
+   *
+   * @returns Array of tool names from the last prompt, or empty array if no prompt has been run
+   */
+  toolsCalled() {
+    if (!this.lastResult) {
+      return [];
+    }
+    return this.lastResult.toolsCalled();
+  }
+  /**
+   * Create a new TestAgent with modified options.
+   * Useful for creating variants for different test scenarios.
+   *
+   * @param options - Partial config to override
+   * @returns A new TestAgent instance with the merged configuration
+   */
+  withOptions(options) {
+    return new _TestAgent({
+      tools: options.tools ?? this.tools,
+      model: options.model ?? this.model,
+      apiKey: options.apiKey ?? this.apiKey,
+      systemPrompt: options.systemPrompt ?? this.systemPrompt,
+      temperature: options.temperature ?? this.temperature,
+      maxSteps: options.maxSteps ?? this.maxSteps,
+      customProviders: options.customProviders ?? this.customProviders
+    });
+  }
+  /**
+   * Get the configured tools
+   */
+  getTools() {
+    return this.tools;
+  }
+  /**
+   * Get the LLM provider/model string
+   */
+  getModel() {
+    return this.model;
+  }
+  /**
+   * Get the API key
+   */
+  getApiKey() {
+    return this.apiKey;
+  }
+  /**
+   * Get the current system prompt
+   */
+  getSystemPrompt() {
+    return this.systemPrompt;
+  }
+  /**
+   * Set a new system prompt
+   */
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  /**
+   * Get the current temperature (undefined means model default)
+   */
+  getTemperature() {
+    return this.temperature;
+  }
+  /**
+   * Set the temperature (must be between 0 and 2)
+   */
+  setTemperature(temperature) {
+    if (temperature < 0 || temperature > 2) {
+      throw new Error("Temperature must be between 0 and 2");
+    }
+    this.temperature = temperature;
+  }
+  /**
+   * Get the max steps configuration
+   */
+  getMaxSteps() {
+    return this.maxSteps;
+  }
+  /**
+   * Get the result of the last prompt
+   */
+  getLastResult() {
+    return this.lastResult;
+  }
+  /**
+   * Reset the prompt history.
+   * Call this before each test iteration to clear previous results.
+   */
+  resetPromptHistory() {
+    this.promptHistory = [];
+  }
+  /**
+   * Get the history of all prompt results since the last reset.
+   * Returns a copy of the array to prevent external modification.
+   */
+  getPromptHistory() {
+    return [...this.promptHistory];
+  }
+};
+
+// src/validators.ts
+function matchToolCalls(expected, actual) {
+  if (expected.length !== actual.length) {
+    return false;
+  }
+  for (let i = 0; i < expected.length; i++) {
+    if (expected[i] !== actual[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchToolCallsSubset(expected, actual) {
+  for (const tool of expected) {
+    if (!actual.includes(tool)) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchAnyToolCall(expected, actual) {
+  if (expected.length === 0) {
+    return false;
+  }
+  for (const tool of expected) {
+    if (actual.includes(tool)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchToolCallCount(toolName, actual, count) {
+  const actualCount = actual.filter((t) => t === toolName).length;
+  return actualCount === count;
+}
+function matchNoToolCalls(actual) {
+  return actual.length === 0;
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a === null || b === null || a === void 0 || b === void 0) {
+    return false;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) {
+        return false;
       }
-      async close() {
-        await this.inner.close();
+    }
+    return true;
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return false;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (const key of aKeys) {
+      if (!Object.prototype.hasOwnProperty.call(b, key) || !deepEqual(
+        a[key],
+        b[key]
+      )) {
+        return false;
       }
-      get sessionId() {
-        return this.inner.sessionId;
+    }
+    return true;
+  }
+  return false;
+}
+function matchToolCallWithArgs(toolName, expectedArgs, toolCalls) {
+  for (const call of toolCalls) {
+    if (call.toolName === toolName && deepEqual(call.arguments, expectedArgs)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchToolCallWithPartialArgs(toolName, expectedArgs, toolCalls) {
+  for (const call of toolCalls) {
+    if (call.toolName !== toolName) {
+      continue;
+    }
+    let allMatch = true;
+    for (const [key, expectedValue] of Object.entries(expectedArgs)) {
+      if (!(key in call.arguments) || !deepEqual(call.arguments[key], expectedValue)) {
+        allMatch = false;
+        break;
       }
-      setProtocolVersion(version) {
-        if (typeof this.inner.setProtocolVersion === "function") {
-          this.inner.setProtocolVersion(version);
-        }
+    }
+    if (allMatch) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchToolArgument(toolName, argKey, expectedValue, toolCalls) {
+  for (const call of toolCalls) {
+    if (call.toolName === toolName && argKey in call.arguments && deepEqual(call.arguments[argKey], expectedValue)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchToolArgumentWith(toolName, argKey, predicate, toolCalls) {
+  for (const call of toolCalls) {
+    if (call.toolName === toolName && argKey in call.arguments) {
+      if (predicate(call.arguments[argKey])) {
+        return true;
       }
     }
-    return new LoggingTransport(transport);
   }
-  resolveRpcLogger(serverId, config) {
-    if (config.rpcLogger) return config.rpcLogger;
-    if (config.logJsonRpc || this.defaultLogJsonRpc) {
-      return ({ direction, message, serverId: id }) => {
-        let printable;
-        try {
-          printable = typeof message === "string" ? message : JSON.stringify(message);
-        } catch {
-          printable = String(message);
-        }
-        console.debug(`[MCP:${id}] ${direction.toUpperCase()} ${printable}`);
-      };
+  return false;
+}
+
+// src/percentiles.ts
+function calculatePercentile(sortedValues, percentile) {
+  if (sortedValues.length === 0) {
+    throw new Error("Cannot calculate percentile of empty array");
+  }
+  if (percentile < 0 || percentile > 100) {
+    throw new Error("Percentile must be between 0 and 100");
+  }
+  const index = percentile / 100 * (sortedValues.length - 1);
+  const lowerIndex = Math.floor(index);
+  const upperIndex = Math.ceil(index);
+  if (lowerIndex === upperIndex) {
+    return sortedValues[lowerIndex];
+  }
+  const weight = index - lowerIndex;
+  return sortedValues[lowerIndex] * (1 - weight) + sortedValues[upperIndex] * weight;
+}
+function calculateLatencyStats(values) {
+  if (values.length === 0) {
+    throw new Error("Cannot calculate stats of empty array");
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const sum = values.reduce((acc, val) => acc + val, 0);
+  return {
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+    mean: sum / values.length,
+    p50: calculatePercentile(sorted, 50),
+    p95: calculatePercentile(sorted, 95),
+    count: values.length
+  };
+}
+
+// src/EvalTest.ts
+var Semaphore = class {
+  permits;
+  waiting = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  async acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
     }
-    if (this.defaultRpcLogger) return this.defaultRpcLogger;
-    return void 0;
+    await new Promise((resolve) => this.waiting.push(resolve));
   }
-  isMethodUnavailableError(error, method) {
-    if (!(error instanceof Error)) {
-      return false;
+  release() {
+    const next = this.waiting.shift();
+    if (next) {
+      next();
+    } else {
+      this.permits++;
+    }
+  }
+};
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`Operation timed out after ${ms}ms`));
+    }, ms);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var EvalTest = class {
+  config;
+  lastRunResult = null;
+  constructor(config) {
+    if (!config.test) {
+      throw new Error("Invalid config: must provide 'test' function");
     }
-    const message = error.message.toLowerCase();
-    const methodTokens = /* @__PURE__ */ new Set();
-    const pushToken = (token) => {
-      if (token) {
-        methodTokens.add(token.toLowerCase());
+    this.config = config;
+  }
+  /**
+   * Run this test with the given agent and options
+   */
+  async run(agent, options) {
+    const concurrency = options.concurrency ?? 5;
+    const retries = options.retries ?? 0;
+    const timeoutMs = options.timeoutMs ?? 3e4;
+    const onProgress = options.onProgress;
+    const semaphore = new Semaphore(concurrency);
+    let completedCount = 0;
+    const testFn = this.config.test;
+    const iterationResults = [];
+    const total = options.iterations;
+    const runSingleIteration = async () => {
+      await semaphore.acquire();
+      try {
+        let lastError;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+          try {
+            const iterationAgent = agent.withOptions({});
+            const passed = await withTimeout(
+              Promise.resolve(testFn(iterationAgent)),
+              timeoutMs
+            );
+            const promptResults = iterationAgent.getPromptHistory();
+            const latencies = promptResults.map((r) => r.getLatency());
+            const tokens = {
+              total: promptResults.reduce((sum, r) => sum + r.totalTokens(), 0),
+              input: promptResults.reduce((sum, r) => sum + r.inputTokens(), 0),
+              output: promptResults.reduce(
+                (sum, r) => sum + r.outputTokens(),
+                0
+              )
+            };
+            return {
+              passed,
+              latencies: latencies.length > 0 ? latencies : [{ e2eMs: 0, llmMs: 0, mcpMs: 0 }],
+              tokens,
+              retryCount: attempt,
+              prompts: promptResults
+            };
+          } catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+            if (attempt < retries) {
+              await sleep(100 * Math.pow(2, attempt));
+            }
+          }
+        }
+        return {
+          passed: false,
+          latencies: [{ e2eMs: 0, llmMs: 0, mcpMs: 0 }],
+          tokens: { total: 0, input: 0, output: 0 },
+          error: lastError,
+          retryCount: retries
+        };
+      } finally {
+        semaphore.release();
+        const completed = ++completedCount;
+        if (onProgress) {
+          onProgress(completed, total);
+        }
       }
     };
-    pushToken(method);
-    for (const part of method.split(/[\/:._-]/)) {
-      pushToken(part);
-    }
-    const indicators = [
-      "method not found",
-      "not implemented",
-      "unsupported",
-      "does not support",
-      "unimplemented"
-    ];
-    const indicatorMatch = indicators.some(
-      (indicator) => message.includes(indicator)
+    const promises = Array.from(
+      { length: options.iterations },
+      () => runSingleIteration()
     );
-    if (!indicatorMatch) {
-      return false;
+    const results = await Promise.all(promises);
+    iterationResults.push(...results);
+    const runResult = this.aggregateResults(iterationResults);
+    if (options.onFailure && runResult.failures > 0) {
+      options.onFailure(this.getFailureReport());
     }
-    if (Array.from(methodTokens).some((token) => message.includes(token))) {
-      return true;
+    return runResult;
+  }
+  aggregateResults(iterations) {
+    const allLatencies = iterations.flatMap((r) => r.latencies);
+    const defaultStats = {
+      min: 0,
+      max: 0,
+      mean: 0,
+      p50: 0,
+      p95: 0,
+      count: 0
+    };
+    const e2eValues = allLatencies.map((l) => l.e2eMs);
+    const llmValues = allLatencies.map((l) => l.llmMs);
+    const mcpValues = allLatencies.map((l) => l.mcpMs);
+    const successes = iterations.filter((r) => r.passed).length;
+    const failures = iterations.filter((r) => !r.passed).length;
+    this.lastRunResult = {
+      iterations: iterations.length,
+      successes,
+      failures,
+      results: iterations.map((r) => r.passed),
+      iterationDetails: iterations,
+      tokenUsage: {
+        total: iterations.reduce((sum, r) => sum + r.tokens.total, 0),
+        input: iterations.reduce((sum, r) => sum + r.tokens.input, 0),
+        output: iterations.reduce((sum, r) => sum + r.tokens.output, 0),
+        perIteration: iterations.map((r) => r.tokens)
+      },
+      latency: {
+        e2e: e2eValues.length > 0 ? calculateLatencyStats(e2eValues) : defaultStats,
+        llm: llmValues.length > 0 ? calculateLatencyStats(llmValues) : defaultStats,
+        mcp: mcpValues.length > 0 ? calculateLatencyStats(mcpValues) : defaultStats,
+        perIteration: allLatencies
+      }
+    };
+    return this.lastRunResult;
+  }
+  /**
+   * Get the accuracy of the last run (success rate)
+   */
+  accuracy() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
     }
-    return true;
+    return this.lastRunResult.successes / this.lastRunResult.iterations;
   }
-  getTimeout(config) {
-    var _a;
-    return (_a = config.timeout) != null ? _a : this.defaultTimeout;
+  /**
+   * Get the recall (true positive rate) of the last run
+   */
+  recall() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.accuracy();
   }
-  isStdioConfig(config) {
-    return "command" in config;
+  /**
+   * Get the precision of the last run
+   */
+  precision() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.accuracy();
   }
-  getClientById(serverId) {
-    const state = this.clientStates.get(serverId);
-    if (!(state == null ? void 0 : state.client)) {
-      throw new Error(`MCP server "${serverId}" is not connected.`);
+  /**
+   * Get the true positive rate (same as recall)
+   */
+  truePositiveRate() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
     }
-    return state.client;
+    return this.recall();
+  }
+  /**
+   * Get the false positive rate
+   */
+  falsePositiveRate() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.lastRunResult.failures / this.lastRunResult.iterations;
+  }
+  /**
+   * Get the average token use per iteration
+   */
+  averageTokenUse() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    if (this.lastRunResult.iterations === 0) {
+      return 0;
+    }
+    return this.lastRunResult.tokenUsage.total / this.lastRunResult.iterations;
+  }
+  /**
+   * Get the full results of the last run
+   */
+  getResults() {
+    return this.lastRunResult;
+  }
+  /**
+   * Get the name of this test
+   */
+  getName() {
+    return this.config.name;
+  }
+  /**
+   * Get the configuration of this test
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Get all iteration details from the last run
+   */
+  getAllIterations() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return [...this.lastRunResult.iterationDetails];
+  }
+  /**
+   * Get only the failed iterations from the last run
+   */
+  getFailedIterations() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.lastRunResult.iterationDetails.filter((r) => !r.passed);
+  }
+  /**
+   * Get only the successful iterations from the last run
+   */
+  getSuccessfulIterations() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.lastRunResult.iterationDetails.filter((r) => r.passed);
+  }
+  /**
+   * Get a failure report with traces from all failed iterations.
+   * Useful for debugging why evaluations failed.
+   *
+   * @returns A formatted string with failure details
+   */
+  getFailureReport() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    const failedIterations = this.getFailedIterations();
+    if (failedIterations.length === 0) {
+      return "No failures.";
+    }
+    const reports = failedIterations.map((iteration, index) => {
+      const header = `=== Failed Iteration ${index + 1}/${failedIterations.length} ===`;
+      const error = iteration.error ? `Error: ${iteration.error}` : "";
+      const traces = (iteration.prompts ?? []).map((p, i) => `--- Prompt ${i + 1} ---
+${p.formatTrace()}`).join("\n\n");
+      return [header, error, traces].filter(Boolean).join("\n");
+    });
+    return reports.join("\n\n");
   }
 };
-export {
-  MCPClientManager
+
+// src/EvalSuite.ts
+var EvalSuite = class {
+  name;
+  tests = /* @__PURE__ */ new Map();
+  lastRunResult = null;
+  constructor(config) {
+    this.name = config?.name ?? "EvalSuite";
+  }
+  /**
+   * Add a test to the suite
+   */
+  add(test) {
+    const name = test.getName();
+    if (this.tests.has(name)) {
+      throw new Error(`Test with name "${name}" already exists in suite`);
+    }
+    this.tests.set(name, test);
+  }
+  /**
+   * Get a test by name
+   */
+  get(name) {
+    return this.tests.get(name);
+  }
+  /**
+   * Get all tests in the suite
+   */
+  getAll() {
+    return Array.from(this.tests.values());
+  }
+  /**
+   * Run all tests in the suite with the given agent and options
+   */
+  async run(agent, options) {
+    const testResults = /* @__PURE__ */ new Map();
+    const totalIterations = this.tests.size * options.iterations;
+    let completedIterations = 0;
+    for (const [name, test] of this.tests) {
+      const testOptions = {
+        ...options,
+        onProgress: options.onProgress ? (completed, _total) => {
+          const overallCompleted = completedIterations + completed;
+          options.onProgress(overallCompleted, totalIterations);
+        } : void 0
+      };
+      const result = await test.run(agent, testOptions);
+      testResults.set(name, result);
+      completedIterations += options.iterations;
+    }
+    this.lastRunResult = this.aggregateResults(testResults);
+    return this.lastRunResult;
+  }
+  aggregateResults(testResults) {
+    const results = Array.from(testResults.values());
+    const allIterations = results.flatMap(
+      (r) => r.iterationDetails
+    );
+    const totalIterations = allIterations.length;
+    const totalSuccesses = allIterations.filter((r) => r.passed).length;
+    const totalFailures = totalIterations - totalSuccesses;
+    const allLatencies = results.flatMap(
+      (r) => r.latency.perIteration
+    );
+    const defaultStats = {
+      min: 0,
+      max: 0,
+      mean: 0,
+      p50: 0,
+      p95: 0,
+      count: 0
+    };
+    const e2eValues = allLatencies.map((l) => l.e2eMs);
+    const llmValues = allLatencies.map((l) => l.llmMs);
+    const mcpValues = allLatencies.map((l) => l.mcpMs);
+    const totalTokens = results.reduce((sum, r) => sum + r.tokenUsage.total, 0);
+    const perTestTokens = results.map((r) => r.tokenUsage.total);
+    return {
+      tests: testResults,
+      aggregate: {
+        iterations: totalIterations,
+        successes: totalSuccesses,
+        failures: totalFailures,
+        accuracy: totalIterations > 0 ? totalSuccesses / totalIterations : 0,
+        tokenUsage: {
+          total: totalTokens,
+          perTest: perTestTokens
+        },
+        latency: {
+          e2e: e2eValues.length > 0 ? calculateLatencyStats(e2eValues) : defaultStats,
+          llm: llmValues.length > 0 ? calculateLatencyStats(llmValues) : defaultStats,
+          mcp: mcpValues.length > 0 ? calculateLatencyStats(mcpValues) : defaultStats
+        }
+      }
+    };
+  }
+  /**
+   * Get the aggregate accuracy across all tests
+   */
+  accuracy() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.lastRunResult.aggregate.accuracy;
+  }
+  /**
+   * Get the aggregate recall (same as accuracy in basic context)
+   */
+  recall() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.accuracy();
+  }
+  /**
+   * Get the aggregate precision (same as accuracy in basic context)
+   */
+  precision() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.accuracy();
+  }
+  /**
+   * Get the aggregate true positive rate (same as recall)
+   */
+  truePositiveRate() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    return this.recall();
+  }
+  /**
+   * Get the aggregate false positive rate
+   */
+  falsePositiveRate() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    const { failures, iterations } = this.lastRunResult.aggregate;
+    return iterations > 0 ? failures / iterations : 0;
+  }
+  /**
+   * Get the average token use per iteration across all tests
+   */
+  averageTokenUse() {
+    if (!this.lastRunResult) {
+      throw new Error("No run results available. Call run() first.");
+    }
+    const { total } = this.lastRunResult.aggregate.tokenUsage;
+    const { iterations } = this.lastRunResult.aggregate;
+    return iterations > 0 ? total / iterations : 0;
+  }
+  /**
+   * Get the full suite results
+   */
+  getResults() {
+    return this.lastRunResult;
+  }
+  /**
+   * Get the name of the suite
+   */
+  getName() {
+    return this.name;
+  }
+  /**
+   * Get the number of tests in the suite
+   */
+  size() {
+    return this.tests.size;
+  }
 };
+
+Object.defineProperty(exports, "PromptListChangedNotificationSchema", {
+  enumerable: true,
+  get: function () { return types_js.PromptListChangedNotificationSchema; }
+});
+Object.defineProperty(exports, "ResourceListChangedNotificationSchema", {
+  enumerable: true,
+  get: function () { return types_js.ResourceListChangedNotificationSchema; }
+});
+Object.defineProperty(exports, "ResourceUpdatedNotificationSchema", {
+  enumerable: true,
+  get: function () { return types_js.ResourceUpdatedNotificationSchema; }
+});
+exports.EvalSuite = EvalSuite;
+exports.EvalTest = EvalTest;
+exports.MCPAuthError = MCPAuthError;
+exports.MCPClientManager = MCPClientManager;
+exports.MCPError = MCPError;
+exports.PROVIDER_PRESETS = PROVIDER_PRESETS;
+exports.PromptResult = PromptResult;
+exports.TestAgent = TestAgent;
+exports.buildRequestInit = buildRequestInit;
+exports.calculateLatencyStats = calculateLatencyStats;
+exports.calculatePercentile = calculatePercentile;
+exports.convertMCPToolsToVercelTools = convertMCPToolsToVercelTools;
+exports.createCustomProvider = createCustomProvider;
+exports.createModelFromString = createModelFromString;
+exports.ensureJsonSchemaObject = ensureJsonSchemaObject;
+exports.extractToolCalls = extractToolCalls;
+exports.extractToolNames = extractToolNames;
+exports.formatError = formatError;
+exports.isAuthError = isAuthError;
+exports.isMCPAuthError = isMCPAuthError;
+exports.isMethodUnavailableError = isMethodUnavailableError;
+exports.matchAnyToolCall = matchAnyToolCall;
+exports.matchNoToolCalls = matchNoToolCalls;
+exports.matchToolArgument = matchToolArgument;
+exports.matchToolArgumentWith = matchToolArgumentWith;
+exports.matchToolCallCount = matchToolCallCount;
+exports.matchToolCallWithArgs = matchToolCallWithArgs;
+exports.matchToolCallWithPartialArgs = matchToolCallWithPartialArgs;
+exports.matchToolCalls = matchToolCalls;
+exports.matchToolCallsSubset = matchToolCallsSubset;
+exports.parseLLMString = parseLLMString;
+exports.parseModelIds = parseModelIds;
+exports.supportsTasksCancel = supportsTasksCancel;
+exports.supportsTasksForToolCalls = supportsTasksForToolCalls;
+exports.supportsTasksList = supportsTasksList;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map