@prefecthq/fastmcp-ts 0.0.2-alpha.0

package/dist/client.js

@@ -0,0 +1,1758 @@
+import "./chunk-PZ5AY32C.js";
+
+// src/client/handlers.ts
+function defaultLogHandler(message) {
+  const prefix = message.logger ? `[${message.logger}]` : "[server]";
+  const data = typeof message.data === "string" ? message.data : JSON.stringify(message.data);
+  const text = `${prefix} ${data}`;
+  const level = message.level;
+  if (level === "debug") {
+    console.debug(text);
+  } else if (level === "warning") {
+    console.warn(text);
+  } else if (level === "error" || level === "critical" || level === "alert" || level === "emergency") {
+    console.error(text);
+  } else {
+    console.info(text);
+  }
+}
+function defaultProgressHandler(progress, total, message) {
+  const pct = total != null ? ` (${Math.round(progress / total * 100)}%)` : "";
+  const msg = message ? ` \u2014 ${message}` : "";
+  console.debug(
+    `progress: ${progress}${total != null ? `/${total}` : ""}${pct}${msg}`
+  );
+}
+
+// src/client/auth.ts
+import { spawn } from "child_process";
+import * as fs from "fs/promises";
+import * as http from "http";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var InMemoryStore = class {
+  _map = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this._map.get(key) ?? null;
+  }
+  async set(key, value) {
+    this._map.set(key, value);
+  }
+  async delete(key) {
+    this._map.delete(key);
+  }
+};
+var FileTokenStorage = class {
+  _path;
+  constructor(path) {
+    this._path = path ?? join(homedir(), ".fastmcp", "tokens.json");
+  }
+  async _readAll() {
+    try {
+      const raw = await fs.readFile(this._path, "utf8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  async _writeAll(data) {
+    await fs.mkdir(dirname(this._path), { recursive: true });
+    const tmp = `${this._path}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2), "utf8");
+    await fs.rename(tmp, this._path);
+  }
+  async get(key) {
+    const data = await this._readAll();
+    return data[key] ?? null;
+  }
+  async set(key, value) {
+    const data = await this._readAll();
+    data[key] = value;
+    await this._writeAll(data);
+  }
+  async delete(key) {
+    const data = await this._readAll();
+    if (!(key in data)) return;
+    delete data[key];
+    await this._writeAll(data);
+  }
+};
+var OAuth = class {
+  _serverUrl = "";
+  _clientId;
+  _clientSecret;
+  _scopes;
+  _clientName;
+  _store;
+  _callbackPort;
+  _onRedirect;
+  _codeVerifier;
+  _callbackPromise = null;
+  _callbackResolve = null;
+  _callbackReject = null;
+  _callbackServer = null;
+  _actualCallbackPort = null;
+  constructor(options = {}) {
+    this._clientId = options.clientId;
+    this._clientSecret = options.clientSecret;
+    this._scopes = Array.isArray(options.scopes) ? options.scopes.join(" ") : options.scopes;
+    this._clientName = options.clientName ?? "FastMCP Client";
+    this._store = options.store ?? new InMemoryStore();
+    this._callbackPort = options.callbackPort ?? 8765;
+    this._onRedirect = options.onRedirect;
+  }
+  /**
+   * Binds the MCP server URL so that all storage keys are namespaced by it.
+   * Called by Client before connecting.
+   */
+  _bind(serverUrl) {
+    this._serverUrl = serverUrl;
+  }
+  // ---- OAuthClientProvider interface ----
+  get redirectUrl() {
+    const port = this._actualCallbackPort ?? this._callbackPort;
+    return `http://localhost:${port}/callback`;
+  }
+  get clientMetadata() {
+    const port = this._actualCallbackPort ?? this._callbackPort;
+    return {
+      redirect_uris: [`http://localhost:${port}/callback`],
+      token_endpoint_auth_method: this._clientSecret ? "client_secret_post" : "none",
+      grant_types: ["authorization_code"],
+      response_types: ["code"],
+      client_name: this._clientName,
+      ...this._scopes ? { scope: this._scopes } : {}
+    };
+  }
+  async clientInformation() {
+    if (this._clientId) {
+      return {
+        client_id: this._clientId,
+        ...this._clientSecret ? { client_secret: this._clientSecret } : {}
+      };
+    }
+    const raw = await this._store.get(this._key("client_info"));
+    if (!raw) return void 0;
+    return JSON.parse(raw);
+  }
+  async saveClientInformation(info) {
+    if (this._clientId) return;
+    await this._store.set(this._key("client_info"), JSON.stringify(info));
+  }
+  async tokens() {
+    const raw = await this._store.get(this._key("tokens"));
+    if (!raw) return void 0;
+    return JSON.parse(raw);
+  }
+  async saveTokens(tokens) {
+    await this._store.set(this._key("tokens"), JSON.stringify(tokens));
+  }
+  async redirectToAuthorization(authorizationUrl) {
+    this._callbackPromise = new Promise((resolve2, reject) => {
+      this._callbackResolve = resolve2;
+      this._callbackReject = reject;
+    });
+    this._callbackPromise.catch(() => {
+    });
+    await this._startCallbackServer();
+    if (this._onRedirect) {
+      await this._onRedirect(authorizationUrl);
+    } else {
+      openBrowser(authorizationUrl.toString());
+    }
+  }
+  saveCodeVerifier(codeVerifier) {
+    this._codeVerifier = codeVerifier;
+  }
+  codeVerifier() {
+    if (this._codeVerifier === void 0) {
+      throw new Error("No PKCE code verifier has been saved");
+    }
+    return this._codeVerifier;
+  }
+  async invalidateCredentials(scope) {
+    if (scope === "all" || scope === "tokens") {
+      await this._store.delete(this._key("tokens"));
+    }
+    if (scope === "all" || scope === "client") {
+      await this._store.delete(this._key("client_info"));
+    }
+    if (scope === "all" || scope === "verifier") {
+      this._codeVerifier = void 0;
+    }
+    if (scope === "all" || scope === "discovery") {
+      await this._store.delete(this._key("discovery"));
+    }
+  }
+  async saveDiscoveryState(state) {
+    await this._store.set(this._key("discovery"), JSON.stringify(state));
+  }
+  async discoveryState() {
+    const raw = await this._store.get(this._key("discovery"));
+    if (!raw) return void 0;
+    return JSON.parse(raw);
+  }
+  // ---- Internal helpers ----
+  /**
+   * Returns the actual port the callback server bound to.
+   * Only populated after redirectToAuthorization() has been called.
+   */
+  get callbackServerPort() {
+    return this._actualCallbackPort;
+  }
+  /**
+   * Waits for the OAuth authorization code to arrive via the callback server,
+   * then stops the server and resolves with the code.
+   *
+   * Must be called after the UnauthorizedError thrown by connect() is caught.
+   */
+  async waitForCallback(timeoutMs = 5 * 60 * 1e3) {
+    if (!this._callbackPromise) {
+      throw new Error("No pending OAuth callback \u2014 call redirectToAuthorization() first");
+    }
+    const timeout = new Promise(
+      (_, reject) => setTimeout(
+        () => reject(new Error("OAuth callback timed out waiting for authorization")),
+        timeoutMs
+      )
+    );
+    try {
+      return await Promise.race([this._callbackPromise, timeout]);
+    } finally {
+      this._callbackPromise = null;
+      this._callbackResolve = null;
+      this._callbackReject = null;
+      this._stopCallbackServer();
+    }
+  }
+  _key(type) {
+    return `${this._serverUrl}/${type}`;
+  }
+  _startCallbackServer() {
+    if (this._callbackServer) return Promise.resolve();
+    return new Promise((resolve2, reject) => {
+      const server = http.createServer((req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost`);
+        const error = url.searchParams.get("error");
+        if (error && this._callbackReject) {
+          const description = url.searchParams.get("error_description") ?? error;
+          this._callbackReject(new Error(`OAuth authorization denied: ${description}`));
+          res.writeHead(200, { "content-type": "text/html" });
+          res.end(
+            "<html><body><h1>Authorization denied</h1><p>You may close this tab.</p></body></html>"
+          );
+          return;
+        }
+        const code = url.searchParams.get("code");
+        if (code && this._callbackResolve) {
+          this._callbackResolve(code);
+          res.writeHead(200, { "content-type": "text/html" });
+          res.end(
+            "<html><body><h1>Authorization complete</h1><p>You may close this tab.</p></body></html>"
+          );
+        } else {
+          res.writeHead(400);
+          res.end("Missing code parameter");
+        }
+      });
+      server.on("error", reject);
+      server.listen(this._callbackPort, () => {
+        const addr = server.address();
+        if (addr && typeof addr !== "string") {
+          this._actualCallbackPort = addr.port;
+        }
+        this._callbackServer = server;
+        resolve2();
+      });
+    });
+  }
+  _stopCallbackServer() {
+    this._callbackServer?.close();
+    this._callbackServer = null;
+    this._actualCallbackPort = null;
+  }
+};
+var BearerAuth = class {
+  _token;
+  constructor(token) {
+    this._token = token.startsWith("Bearer ") ? token.slice(7) : token;
+  }
+  getHeaders() {
+    return { Authorization: `Bearer ${this._token}` };
+  }
+};
+var DEFAULT_REFRESH_BUFFER_SECONDS = 60;
+function normalizeToken(token) {
+  if (typeof token.expires_at === "number" && token.expires_at > 0) {
+    if (token.expires_at < 1e10) {
+      return { ...token, expires_at: token.expires_at * 1e3 };
+    }
+    return token;
+  }
+  if (typeof token.expires_in === "number" && token.expires_in > 0) {
+    return { ...token, expires_at: Date.now() + token.expires_in * 1e3 };
+  }
+  return token;
+}
+function isExpiring(token, bufferMs) {
+  if (token.expires_at == null) return false;
+  return token.expires_at - Date.now() <= bufferMs;
+}
+var ClientCredentials = class {
+  kind = "client_credentials";
+  _tokenEndpoint;
+  _clientId;
+  _clientSecret;
+  _scope;
+  _store;
+  _bufferMs;
+  _fetchPromise = null;
+  constructor(options) {
+    this._tokenEndpoint = options.tokenEndpoint;
+    this._clientId = options.clientId;
+    this._clientSecret = options.clientSecret;
+    this._scope = options.scope;
+    this._store = options.store ?? new InMemoryStore();
+    this._bufferMs = (options.refreshBufferSeconds ?? DEFAULT_REFRESH_BUFFER_SECONDS) * 1e3;
+  }
+  async getHeaders() {
+    const token = await this._getValidToken();
+    const type = token.token_type?.trim() || "Bearer";
+    return { Authorization: `${type} ${token.access_token}` };
+  }
+  get _tokenKey() {
+    return `${this._tokenEndpoint}/token`;
+  }
+  async _getValidToken() {
+    const raw = await this._store.get(this._tokenKey);
+    if (raw) {
+      const normalized = normalizeToken(JSON.parse(raw));
+      if (!isExpiring(normalized, this._bufferMs)) return normalized;
+    }
+    return await this._doFetch();
+  }
+  async _doFetch() {
+    this._fetchPromise ??= (async () => {
+      const params = new URLSearchParams({
+        grant_type: "client_credentials",
+        client_id: this._clientId,
+        client_secret: this._clientSecret
+      });
+      if (this._scope) params.set("scope", this._scope);
+      const response = await fetch(this._tokenEndpoint, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: params.toString()
+      });
+      if (!response.ok) {
+        const detail = await response.text().catch(() => "");
+        throw new Error(
+          `ClientCredentials token fetch failed (${response.status})${detail ? `: ${detail}` : ""}`
+        );
+      }
+      const data = await response.json();
+      if (!data.access_token) {
+        throw new Error("ClientCredentials token response missing access_token");
+      }
+      const token = normalizeToken(data);
+      await this._store.set(this._tokenKey, JSON.stringify(token));
+      return token;
+    })().finally(() => {
+      this._fetchPromise = null;
+    });
+    return this._fetchPromise;
+  }
+};
+function openBrowser(url) {
+  if (process.platform === "win32") {
+    spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
+  } else if (process.platform === "darwin") {
+    spawn("open", [url], { detached: true, stdio: "ignore" });
+  } else {
+    spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+  }
+}
+
+// src/client/transports.ts
+import { normalizeHeaders } from "@modelcontextprotocol/sdk/shared/transport";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio";
+function isMcpServerLike(value) {
+  return typeof value === "object" && value !== null && "connect" in value && typeof value.connect === "function";
+}
+function isMcpConfig(value) {
+  return typeof value === "object" && value !== null && "mcpServers" in value && typeof value.mcpServers === "object" && value.mcpServers !== null;
+}
+var StdioTransport = class {
+  command;
+  args;
+  env;
+  cwd;
+  constructor(command, args = [], options) {
+    this.command = command;
+    this.args = args;
+    this.env = options?.env;
+    this.cwd = options?.cwd;
+  }
+};
+function isAsyncAuth(auth) {
+  return "kind" in auth;
+}
+function buildHttpOptions(auth, extraHeaders = {}) {
+  const hasExtra = Object.keys(extraHeaders).length > 0;
+  if (!auth && !hasExtra) return {};
+  if (auth instanceof OAuth) {
+    const opts = { authProvider: auth };
+    if (hasExtra) opts.requestInit = { headers: extraHeaders };
+    return opts;
+  }
+  if (auth && isAsyncAuth(auth)) {
+    const customFetch = async (url, init) => {
+      const authHeaders = await auth.getHeaders();
+      return fetch(url, {
+        ...init,
+        headers: {
+          ...authHeaders,
+          ...extraHeaders,
+          ...normalizeHeaders(init?.headers)
+        }
+      });
+    };
+    return { fetch: customFetch };
+  }
+  const staticHeaders = {
+    ...auth ? auth.getHeaders() : {},
+    ...extraHeaders
+  };
+  return {
+    requestInit: { headers: staticHeaders },
+    // Also exposed for SSE's EventSource connection (eventsource npm pkg
+    // accepts headers in EventSourceInit, unlike the browser API).
+    eventSourceInit: { headers: staticHeaders }
+  };
+}
+function urlToTransport(url, auth, extraHeaders = {}) {
+  const { requestInit, fetch: customFetch, eventSourceInit, authProvider } = buildHttpOptions(auth, extraHeaders);
+  const segments = url.pathname.split("/");
+  const isSSE = segments.includes("sse") || url.pathname.endsWith("/sse");
+  if (isSSE) {
+    return new SSEClientTransport(url, {
+      ...authProvider ? { authProvider } : {},
+      ...requestInit ? { requestInit } : {},
+      ...eventSourceInit ? { eventSourceInit } : {},
+      ...customFetch ? { fetch: customFetch } : {}
+    });
+  }
+  return new StreamableHTTPClientTransport(url, {
+    ...authProvider ? { authProvider } : {},
+    ...requestInit ? { requestInit } : {},
+    ...customFetch ? { fetch: customFetch } : {}
+  });
+}
+function resolveEntryTransport(entry, auth) {
+  if (isMcpServerLike(entry)) {
+    const [serverSide, clientSide] = InMemoryTransport.createLinkedPair();
+    return {
+      transport: clientSide,
+      beforeConnect: () => entry.connect(serverSide)
+    };
+  }
+  const entryAuth = resolveEntryAuth(entry.auth) ?? auth;
+  if ("url" in entry) {
+    const url = new URL(entry.url);
+    const extraHeaders = entry.headers ?? {};
+    return { transport: urlToTransport(url, entryAuth, extraHeaders) };
+  }
+  const cmd = entry;
+  return {
+    transport: new StdioClientTransport({
+      command: cmd.command,
+      args: cmd.args,
+      env: cmd.env
+    })
+  };
+}
+function resolveEntryAuth(auth) {
+  if (!auth) return void 0;
+  if (typeof auth === "string") return new BearerAuth(auth);
+  return auth;
+}
+function resolveTransport(input, auth) {
+  if (input instanceof StdioTransport) {
+    return {
+      transport: new StdioClientTransport({
+        command: input.command,
+        args: input.args,
+        env: input.env,
+        cwd: input.cwd
+      })
+    };
+  }
+  if (typeof input === "string") {
+    const url = new URL(input);
+    return { transport: urlToTransport(url, auth) };
+  }
+  if (typeof input === "object" && input !== null && "start" in input && typeof input.start === "function") {
+    return { transport: input };
+  }
+  if (isMcpConfig(input)) {
+    const entries = Object.entries(input.mcpServers);
+    if (entries.length === 0) throw new Error("mcpServers config is empty");
+    const [, entry] = entries[0];
+    return resolveEntryTransport(entry, auth);
+  }
+  if (isMcpServerLike(input)) {
+    const [serverSide, clientSide] = InMemoryTransport.createLinkedPair();
+    return {
+      transport: clientSide,
+      beforeConnect: () => input.connect(serverSide)
+    };
+  }
+  throw new Error(
+    "Unrecognized transport input: expected a URL string, FastMCP server instance, mcpServers config object, StdioTransport, or SDK Transport"
+  );
+}
+
+// src/client/client.ts
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+import { Client as SdkClient2 } from "@modelcontextprotocol/sdk/client";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import {
+  CompatibilityCallToolResultSchema as CompatibilityCallToolResultSchema2,
+  CreateMessageRequestSchema as CreateMessageRequestSchema2,
+  ElicitRequestSchema as ElicitRequestSchema2,
+  ListRootsRequestSchema as ListRootsRequestSchema2,
+  LoggingMessageNotificationSchema as LoggingMessageNotificationSchema2,
+  ResourceUpdatedNotificationSchema as ResourceUpdatedNotificationSchema2
+} from "@modelcontextprotocol/sdk/types";
+
+// src/client/multi-server.ts
+import { Client as SdkClient } from "@modelcontextprotocol/sdk/client";
+import {
+  CompatibilityCallToolResultSchema,
+  LoggingMessageNotificationSchema,
+  ResourceUpdatedNotificationSchema,
+  CreateMessageRequestSchema,
+  ElicitRequestSchema,
+  ListRootsRequestSchema
+} from "@modelcontextprotocol/sdk/types";
+var MultiServerClient = class _MultiServerClient {
+  _clients = /* @__PURE__ */ new Map();
+  _connectPromise = null;
+  _connected = false;
+  /** URI (or namespaced template URI) → server name, populated by list calls */
+  _uriMap = /* @__PURE__ */ new Map();
+  _config;
+  _handlers;
+  _roots;
+  _defaultOptions;
+  _resourceSubscriptions = /* @__PURE__ */ new Map();
+  constructor(config, options) {
+    this._config = config;
+    this._handlers = {
+      log: options?.handlers?.log ?? defaultLogHandler,
+      progress: options?.handlers?.progress ?? defaultProgressHandler,
+      sampling: options?.handlers?.sampling,
+      elicitation: options?.handlers?.elicitation
+    };
+    this._roots = options?.roots;
+    this._defaultOptions = options?.defaultOptions ?? {};
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  async connect() {
+    if (this._connected) return;
+    if (this._connectPromise) {
+      await this._connectPromise;
+      return;
+    }
+    this._connectPromise = this._doConnect().finally(() => {
+      this._connectPromise = null;
+    });
+    await this._connectPromise;
+  }
+  async _doConnect() {
+    const entries = Object.entries(this._config.mcpServers);
+    if (entries.length === 0) throw new Error("mcpServers config is empty");
+    const connected = [];
+    try {
+      await Promise.all(
+        entries.map(async ([name, entry]) => {
+          const sdk = this._buildSdkClient();
+          this._registerHandlers(sdk);
+          const { transport, beforeConnect } = resolveEntryTransport(
+            entry
+          );
+          if (beforeConnect) await beforeConnect();
+          await sdk.connect(transport);
+          connected.push([name, sdk]);
+        })
+      );
+    } catch (err) {
+      await Promise.allSettled(connected.map(([, sdk]) => sdk.close()));
+      throw err;
+    }
+    for (const [name, sdk] of connected) {
+      this._clients.set(name, sdk);
+    }
+    this._connected = true;
+  }
+  async close() {
+    if (!this._connected) return;
+    this._connected = false;
+    this._uriMap.clear();
+    await Promise.allSettled([...this._clients.values()].map((sdk) => sdk.close()));
+    this._clients.clear();
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  isConnected() {
+    return this._connected;
+  }
+  static async connect(config, options) {
+    const client = new _MultiServerClient(config, options);
+    await client.connect();
+    return client;
+  }
+  // -------------------------------------------------------------------------
+  // Core protocol
+  // -------------------------------------------------------------------------
+  async ping(options) {
+    this._assertConnected();
+    await Promise.all(
+      [...this._clients.values()].map(
+        (sdk) => sdk.ping(this._toSdkOptions(options))
+      )
+    );
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // Tools
+  // -------------------------------------------------------------------------
+  async listTools(options) {
+    this._assertConnected();
+    const results = await Promise.all(
+      [...this._clients.entries()].map(async ([name, sdk]) => {
+        const r = await sdk.listTools(
+          void 0,
+          this._toSdkOptions(options, void 0, this._defaultOptions.tool?.timeout)
+        );
+        return r.tools.map((t) => ({ ...t, name: `${name}_${t.name}` }));
+      })
+    );
+    return results.flat();
+  }
+  async callTool(name, args, options) {
+    const raw = await this.callToolRaw(name, args, options);
+    if (raw.isError) {
+      const message = raw.content.filter((c) => c.type === "text").map((c) => c.text ?? "").join("\n") || "Tool returned an error";
+      throw new ToolCallError(message, raw.content);
+    }
+    return raw;
+  }
+  async callToolRaw(name, args, options) {
+    const { serverName, localName } = this._parseNamespacedName(name);
+    const sdk = this._sdkForServer(serverName);
+    const sdkOptions = this._toSdkOptions(
+      options,
+      options?.onProgress,
+      this._defaultOptions.tool?.timeout
+    );
+    const result = await sdk.callTool(
+      { name: localName, arguments: args ?? {} },
+      CompatibilityCallToolResultSchema,
+      sdkOptions
+    );
+    return {
+      content: result.content,
+      structuredContent: result.structuredContent ?? null,
+      isError: result.isError === true
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Resources
+  // -------------------------------------------------------------------------
+  async listResources(options) {
+    this._assertConnected();
+    const results = await Promise.all(
+      [...this._clients.entries()].map(async ([name, sdk]) => {
+        const r = await sdk.listResources(
+          void 0,
+          this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+        );
+        const resources = r.resources;
+        for (const res of resources) {
+          this._uriMap.set(res.uri, name);
+        }
+        return resources.map((res) => ({
+          ...res,
+          name: res.name ? `${name}_${res.name}` : res.name
+        }));
+      })
+    );
+    return results.flat();
+  }
+  async listResourceTemplates(options) {
+    this._assertConnected();
+    const results = await Promise.all(
+      [...this._clients.entries()].map(async ([name, sdk]) => {
+        const r = await sdk.listResourceTemplates(
+          void 0,
+          this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+        );
+        const templates = r.resourceTemplates;
+        for (const tmpl of templates) {
+          this._uriMap.set(tmpl.uriTemplate, name);
+        }
+        return templates.map((tmpl) => ({
+          ...tmpl,
+          name: tmpl.name ? `${name}_${tmpl.name}` : tmpl.name
+        }));
+      })
+    );
+    return results.flat();
+  }
+  async readResource(uri, options) {
+    this._assertConnected();
+    const sdkOptions = this._toSdkOptions(
+      options,
+      void 0,
+      this._defaultOptions.resource?.timeout
+    );
+    const knownServer = this._uriMap.get(uri);
+    if (knownServer) {
+      const sdk = this._clients.get(knownServer);
+      const result = await sdk.readResource({ uri }, sdkOptions);
+      return result.contents;
+    }
+    const errors = [];
+    for (const sdk of this._clients.values()) {
+      try {
+        const result = await sdk.readResource({ uri }, sdkOptions);
+        return result.contents;
+      } catch (err) {
+        errors.push(err);
+      }
+    }
+    throw new Error(
+      `Resource not found on any server: ${uri}
+` + errors.map((e) => String(e)).join("\n")
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Prompts
+  // -------------------------------------------------------------------------
+  async listPrompts(options) {
+    this._assertConnected();
+    const results = await Promise.all(
+      [...this._clients.entries()].map(async ([name, sdk]) => {
+        const r = await sdk.listPrompts(
+          void 0,
+          this._toSdkOptions(options, void 0, this._defaultOptions.prompt?.timeout)
+        );
+        return r.prompts.map((p) => ({ ...p, name: `${name}_${p.name}` }));
+      })
+    );
+    return results.flat();
+  }
+  async getPrompt(name, args, options) {
+    const { serverName, localName } = this._parseNamespacedName(name);
+    const sdk = this._sdkForServer(serverName);
+    const result = await sdk.getPrompt(
+      { name: localName, arguments: args },
+      this._toSdkOptions(options, void 0, this._defaultOptions.prompt?.timeout)
+    );
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // Resource subscriptions
+  // -------------------------------------------------------------------------
+  async subscribeResource(uri, handler, options) {
+    this._assertConnected();
+    this._resourceSubscriptions.set(uri, handler);
+    const serverName = this._uriMap.get(uri);
+    if (serverName) {
+      await this._clients.get(serverName).subscribeResource(
+        { uri },
+        this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+      );
+      return;
+    }
+    const errors = [];
+    for (const sdk of this._clients.values()) {
+      try {
+        await sdk.subscribeResource(
+          { uri },
+          this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+        );
+        return;
+      } catch (err) {
+        errors.push(err);
+      }
+    }
+    throw new Error(`Subscribe failed on all servers:
+${errors.map(String).join("\n")}`);
+  }
+  async unsubscribeResource(uri, options) {
+    this._assertConnected();
+    this._resourceSubscriptions.delete(uri);
+    const serverName = this._uriMap.get(uri);
+    if (serverName) {
+      await this._clients.get(serverName).unsubscribeResource(
+        { uri },
+        this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+      );
+      return;
+    }
+    await Promise.allSettled(
+      [...this._clients.values()].map(
+        (sdk) => sdk.unsubscribeResource(
+          { uri },
+          this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+        )
+      )
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Completion
+  // -------------------------------------------------------------------------
+  async complete(ref, argument, context, options) {
+    this._assertConnected();
+    const sdkOptions = this._toSdkOptions(options);
+    if (ref.type === "ref/prompt") {
+      const { serverName: serverName2, localName } = this._parseNamespacedName(ref.name);
+      const sdk = this._sdkForServer(serverName2);
+      const result = await sdk.complete(
+        { ref: { type: "ref/prompt", name: localName }, argument, ...context ? { context } : {} },
+        sdkOptions
+      );
+      return result.completion;
+    }
+    const serverName = this._uriMap.get(ref.uri);
+    if (serverName) {
+      const result = await this._clients.get(serverName).complete(
+        { ref, argument, ...context ? { context } : {} },
+        sdkOptions
+      );
+      return result.completion;
+    }
+    const errors = [];
+    for (const sdk of this._clients.values()) {
+      try {
+        const result = await sdk.complete(
+          { ref, argument, ...context ? { context } : {} },
+          sdkOptions
+        );
+        return result.completion;
+      } catch (err) {
+        errors.push(err);
+      }
+    }
+    throw new Error(`Completion failed on all servers:
+${errors.map(String).join("\n")}`);
+  }
+  // -------------------------------------------------------------------------
+  // Logging
+  // -------------------------------------------------------------------------
+  async setLogLevel(level, options) {
+    this._assertConnected();
+    await Promise.all(
+      [...this._clients.values()].map(
+        (sdk) => sdk.setLoggingLevel(level, this._toSdkOptions(options))
+      )
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  _assertConnected() {
+    if (!this._connected) {
+      throw new Error("MultiServerClient is not connected. Call connect() first.");
+    }
+  }
+  _parseNamespacedName(name) {
+    const serverNames = [...this._clients.keys()].sort((a, b) => b.length - a.length);
+    for (const serverName of serverNames) {
+      const prefix = `${serverName}_`;
+      if (name.startsWith(prefix)) {
+        return { serverName, localName: name.slice(prefix.length) };
+      }
+    }
+    throw new Error(
+      `Tool/prompt name "${name}" has no server namespace prefix. Expected format: "<serverName>_<name>".`
+    );
+  }
+  _sdkForServer(serverName) {
+    const sdk = this._clients.get(serverName);
+    if (!sdk) {
+      throw new Error(
+        `No server named "${serverName}" in this MultiServerClient. Known servers: ${[...this._clients.keys()].join(", ")}.`
+      );
+    }
+    return sdk;
+  }
+  _buildSdkClient() {
+    return new SdkClient(
+      { name: "fastmcp-ts", version: "1.0.0" },
+      { capabilities: this._buildCapabilities() }
+    );
+  }
+  _buildCapabilities() {
+    return {
+      ...this._handlers.sampling ? { sampling: { tools: {} } } : {},
+      ...this._handlers.elicitation ? { elicitation: {} } : {},
+      ...this._roots ? { roots: { listChanged: false } } : {}
+    };
+  }
+  _registerHandlers(sdk) {
+    sdk.setNotificationHandler(LoggingMessageNotificationSchema, (notification) => {
+      void this._handlers.log({
+        level: notification.params.level,
+        logger: notification.params.logger ?? void 0,
+        data: notification.params.data
+      });
+    });
+    sdk.setNotificationHandler(ResourceUpdatedNotificationSchema, (notification) => {
+      const handler = this._resourceSubscriptions.get(notification.params.uri);
+      if (handler) void handler(notification.params.uri);
+    });
+    if (this._handlers.sampling) {
+      const h = this._handlers.sampling;
+      sdk.setRequestHandler(CreateMessageRequestSchema, async (req) => h(req.params));
+    }
+    if (this._handlers.elicitation) {
+      const h = this._handlers.elicitation;
+      sdk.setRequestHandler(ElicitRequestSchema, async (req) => h(req.params));
+    }
+    if (this._roots) {
+      const roots = this._roots;
+      sdk.setRequestHandler(ListRootsRequestSchema, async () => ({
+        roots: roots.map((uri) => ({ uri }))
+      }));
+    }
+  }
+  _toSdkOptions(options, overrideProgress, scopedTimeoutSeconds) {
+    const timeoutSeconds = options?.timeout ?? scopedTimeoutSeconds ?? this._defaultOptions.timeout;
+    const progressHandler = overrideProgress ?? this._handlers.progress;
+    const sdkOptions = {};
+    if (timeoutSeconds != null) sdkOptions.timeout = timeoutSeconds * 1e3;
+    if (options?.signal) sdkOptions.signal = options.signal;
+    if (progressHandler) {
+      sdkOptions.onprogress = ({ progress, total, message }) => {
+        void progressHandler(progress, total, message);
+      };
+    }
+    return sdkOptions;
+  }
+};
+
+// src/client/client.ts
+var ToolCallError = class extends Error {
+  content;
+  constructor(message, content) {
+    super(message);
+    this.name = "ToolCallError";
+    this.content = content;
+  }
+};
+var Client = class _Client {
+  _sdkClient = null;
+  _refCount = 0;
+  _connectPromise = null;
+  _resourceSubscriptions = /* @__PURE__ */ new Map();
+  _input;
+  _auth;
+  _handlers;
+  _roots;
+  _autoInitialize;
+  _defaultOptions;
+  constructor(input, options) {
+    this._input = input;
+    this._auth = resolveAuth(options?.auth);
+    this._handlers = {
+      log: options?.handlers?.log ?? defaultLogHandler,
+      progress: options?.handlers?.progress ?? defaultProgressHandler,
+      sampling: options?.handlers?.sampling,
+      elicitation: options?.handlers?.elicitation,
+      onToolsListChanged: options?.handlers?.onToolsListChanged,
+      onResourcesListChanged: options?.handlers?.onResourcesListChanged,
+      onPromptsListChanged: options?.handlers?.onPromptsListChanged
+    };
+    this._roots = options?.roots ? normalizeRootsOption(options.roots) : void 0;
+    this._autoInitialize = options?.autoInitialize ?? true;
+    this._defaultOptions = options?.defaultOptions ?? {};
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  async connect() {
+    this._refCount++;
+    if (this._connectPromise) {
+      await this._connectPromise;
+      return;
+    }
+    if (this._sdkClient) return;
+    this._connectPromise = this._doConnect().finally(() => {
+      this._connectPromise = null;
+    });
+    try {
+      await this._connectPromise;
+    } catch (err) {
+      this._refCount = Math.max(0, this._refCount - 1);
+      throw err;
+    }
+  }
+  async _doConnect() {
+    const sdkClient = new SdkClient2(
+      { name: "fastmcp-ts", version: "1.0.0" },
+      {
+        capabilities: this._buildCapabilities(),
+        listChanged: this._buildListChangedConfig()
+      }
+    );
+    this._registerHandlers(sdkClient);
+    const { transport, beforeConnect } = resolveTransport(this._input, this._auth);
+    if (this._auth instanceof OAuth) {
+      const serverUrl = this._extractServerUrl();
+      if (serverUrl) this._auth._bind(serverUrl);
+    }
+    if (beforeConnect) await beforeConnect();
+    try {
+      await sdkClient.connect(transport);
+    } catch (err) {
+      if (err instanceof UnauthorizedError && this._auth instanceof OAuth) {
+        const code = await this._auth.waitForCallback();
+        if ("finishAuth" in transport && typeof transport.finishAuth === "function") {
+          await transport.finishAuth(
+            code
+          );
+        }
+        await sdkClient.connect(transport);
+      } else {
+        throw err;
+      }
+    }
+    this._sdkClient = sdkClient;
+  }
+  _extractServerUrl() {
+    const input = this._input;
+    if (typeof input === "string") return input;
+    if (typeof input === "object" && input !== null && "mcpServers" in input) {
+      const entries = Object.entries(
+        input.mcpServers
+      );
+      if (entries.length > 0) {
+        const [, entry] = entries[0];
+        if (entry && "url" in entry && typeof entry.url === "string") {
+          return entry.url;
+        }
+      }
+    }
+    return void 0;
+  }
+  async close() {
+    this._refCount = Math.max(0, this._refCount - 1);
+    if (this._refCount > 0) return;
+    const sdk = this._sdkClient;
+    this._sdkClient = null;
+    if (sdk) await sdk.close();
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  isConnected() {
+    return this._sdkClient !== null;
+  }
+  static async connect(input, options) {
+    if (typeof input === "object" && input !== null && "mcpServers" in input && Object.keys(input.mcpServers).length > 1) {
+      return MultiServerClient.connect(input, options);
+    }
+    const client = new _Client(input, options);
+    await client.connect();
+    return client;
+  }
+  // -------------------------------------------------------------------------
+  // Core protocol
+  // -------------------------------------------------------------------------
+  async ping(options) {
+    await this._sdk().ping(this._toSdkOptions(options));
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // Tools (IToolsClient)
+  // -------------------------------------------------------------------------
+  async listTools(options) {
+    const result = await this._sdk().listTools(
+      void 0,
+      this._toSdkOptions(options, void 0, this._defaultOptions.tool?.timeout)
+    );
+    return result.tools;
+  }
+  async callTool(name, args, options) {
+    const raw = await this.callToolRaw(name, args, options);
+    if (raw.isError) {
+      const message = raw.content.filter((c) => c.type === "text").map((c) => c.text ?? "").join("\n") || "Tool returned an error";
+      throw new ToolCallError(message, raw.content);
+    }
+    return raw;
+  }
+  /** Returns the full result including isError without throwing. */
+  async callToolRaw(name, args, options) {
+    const sdkOptions = this._toSdkOptions(
+      options,
+      options?.onProgress,
+      this._defaultOptions.tool?.timeout
+    );
+    const result = await this._sdk().callTool(
+      { name, arguments: args ?? {} },
+      CompatibilityCallToolResultSchema2,
+      sdkOptions
+    );
+    return {
+      content: result.content,
+      structuredContent: result.structuredContent ?? null,
+      isError: result.isError === true
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Resources (IResourcesClient)
+  // -------------------------------------------------------------------------
+  async listResources(options) {
+    const result = await this._sdk().listResources(
+      void 0,
+      this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+    );
+    return result.resources;
+  }
+  async listResourceTemplates(options) {
+    const result = await this._sdk().listResourceTemplates(
+      void 0,
+      this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+    );
+    return result.resourceTemplates;
+  }
+  async readResource(uri, options) {
+    const result = await this._sdk().readResource(
+      { uri },
+      this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+    );
+    return result.contents;
+  }
+  /** Returns the raw SDK ReadResourceResult without unwrapping. */
+  async readResourceRaw(uri, options) {
+    return this._sdk().readResource(
+      { uri },
+      this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+    );
+  }
+  async subscribeResource(uri, handler, options) {
+    this._resourceSubscriptions.set(uri, handler);
+    await this._sdk().subscribeResource(
+      { uri },
+      this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+    );
+  }
+  async unsubscribeResource(uri, options) {
+    this._resourceSubscriptions.delete(uri);
+    await this._sdk().unsubscribeResource(
+      { uri },
+      this._toSdkOptions(options, void 0, this._defaultOptions.resource?.timeout)
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Prompts (IPromptsClient)
+  // -------------------------------------------------------------------------
+  async listPrompts(options) {
+    const result = await this._sdk().listPrompts(
+      void 0,
+      this._toSdkOptions(options, void 0, this._defaultOptions.prompt?.timeout)
+    );
+    return result.prompts;
+  }
+  async getPrompt(name, args, options) {
+    const result = await this._sdk().getPrompt(
+      { name, arguments: args },
+      this._toSdkOptions(options, void 0, this._defaultOptions.prompt?.timeout)
+    );
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // Completion
+  // -------------------------------------------------------------------------
+  async complete(ref, argument, context, options) {
+    const result = await this._sdk().complete(
+      { ref, argument, ...context ? { context } : {} },
+      this._toSdkOptions(options)
+    );
+    return result.completion;
+  }
+  // -------------------------------------------------------------------------
+  // Logging
+  // -------------------------------------------------------------------------
+  async setLogLevel(level, options) {
+    await this._sdk().setLoggingLevel(level, this._toSdkOptions(options));
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  _sdk() {
+    if (!this._sdkClient) {
+      throw new Error("Client is not connected. Call connect() first.");
+    }
+    return this._sdkClient;
+  }
+  _toSdkOptions(options, overrideProgress, scopedTimeoutSeconds) {
+    const timeoutSeconds = options?.timeout ?? scopedTimeoutSeconds ?? this._defaultOptions.timeout;
+    const progressHandler = overrideProgress ?? this._handlers.progress;
+    const sdkOptions = {};
+    if (timeoutSeconds != null) sdkOptions.timeout = timeoutSeconds * 1e3;
+    if (options?.signal) sdkOptions.signal = options.signal;
+    if (progressHandler) {
+      sdkOptions.onprogress = ({ progress, total, message }) => {
+        void progressHandler(progress, total, message);
+      };
+    }
+    return sdkOptions;
+  }
+  _buildCapabilities() {
+    return {
+      ...this._handlers.sampling ? { sampling: { tools: {} } } : {},
+      ...this._handlers.elicitation ? { elicitation: {} } : {},
+      ...this._roots ? { roots: { listChanged: true } } : {}
+    };
+  }
+  _buildListChangedConfig() {
+    const { onToolsListChanged, onResourcesListChanged, onPromptsListChanged } = this._handlers;
+    if (!onToolsListChanged && !onResourcesListChanged && !onPromptsListChanged) return void 0;
+    const adapt = (h) => ({
+      onChanged: (err, items) => {
+        void h.onChanged(err, items);
+      },
+      ...h.autoRefresh !== void 0 ? { autoRefresh: h.autoRefresh } : {},
+      ...h.debounceMs !== void 0 ? { debounceMs: h.debounceMs } : {}
+    });
+    return {
+      ...onToolsListChanged ? { tools: adapt(onToolsListChanged) } : {},
+      ...onResourcesListChanged ? { resources: adapt(onResourcesListChanged) } : {},
+      ...onPromptsListChanged ? { prompts: adapt(onPromptsListChanged) } : {}
+    };
+  }
+  _registerHandlers(sdk) {
+    sdk.setNotificationHandler(LoggingMessageNotificationSchema2, (notification) => {
+      void this._handlers.log({
+        level: notification.params.level,
+        logger: notification.params.logger ?? void 0,
+        data: notification.params.data
+      });
+    });
+    sdk.setNotificationHandler(ResourceUpdatedNotificationSchema2, (notification) => {
+      const handler = this._resourceSubscriptions.get(notification.params.uri);
+      if (handler) void handler(notification.params.uri);
+    });
+    if (this._handlers.sampling) {
+      const samplingHandler = this._handlers.sampling;
+      sdk.setRequestHandler(CreateMessageRequestSchema2, async (request) => {
+        return samplingHandler(request.params);
+      });
+    }
+    if (this._handlers.elicitation) {
+      const elicitationHandler = this._handlers.elicitation;
+      sdk.setRequestHandler(ElicitRequestSchema2, async (request) => {
+        return elicitationHandler(request.params);
+      });
+    }
+    if (this._roots) {
+      const getRoots = this._roots;
+      sdk.setRequestHandler(ListRootsRequestSchema2, async () => ({
+        roots: await getRoots()
+      }));
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Roots
+  // -------------------------------------------------------------------------
+  /**
+   * Notify the connected server that the client's roots list has changed.
+   * The server should re-issue a roots/list request to get the updated list.
+   */
+  async notifyRootsChanged() {
+    await this._sdk().sendRootsListChanged();
+  }
+};
+function resolveAuth(auth) {
+  if (!auth) return void 0;
+  if (typeof auth === "string") return new BearerAuth(auth);
+  return auth;
+}
+function normalizeRootsOption(roots) {
+  if (typeof roots === "function") {
+    return async () => (await roots()).map(normalizeRootInput);
+  }
+  const normalized = roots.map(normalizeRootInput);
+  return () => Promise.resolve(normalized);
+}
+function normalizeRootInput(input) {
+  if (typeof input === "string") return { uri: normalizeRootUri(input) };
+  return { ...input, uri: normalizeRootUri(input.uri) };
+}
+function normalizeRootUri(input) {
+  if (input.startsWith("file://")) return input;
+  return pathToFileURL(resolve(input)).href;
+}
+
+// src/client/utils.ts
+async function toResult(fn) {
+  try {
+    const value = await (typeof fn === "function" ? fn() : fn);
+    return { ok: true, value };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}
+
+// src/client/sampling/types.ts
+function resolveModel(prefs, selector, defaultModel) {
+  if (!selector) {
+    return prefs?.hints?.[0]?.name ?? defaultModel;
+  }
+  if (typeof selector === "string") return selector;
+  return selector(prefs);
+}
+
+// src/client/sampling/generic.ts
+var GenericSamplingAdapter = class {
+  _fn;
+  _options;
+  constructor(fn, options) {
+    this._fn = fn;
+    this._options = options ?? {};
+  }
+  asHandler() {
+    return async (params) => {
+      const model = resolveModel(
+        params.modelPreferences,
+        this._options.modelSelector,
+        this._options.defaultModel ?? "unknown"
+      );
+      return this._fn({
+        model,
+        messages: params.messages,
+        system: params.systemPrompt,
+        maxTokens: params.maxTokens ?? 1024,
+        temperature: params.temperature,
+        stopSequences: params.stopSequences,
+        tools: params.tools,
+        toolChoice: params.toolChoice,
+        onToken: this._options.onToken
+      });
+    };
+  }
+};
+
+// src/client/sampling/anthropic.ts
+function toBlocks(content) {
+  const items = Array.isArray(content) ? content : [content];
+  const out = [];
+  for (const block of items) {
+    if (block.type === "text") {
+      out.push({ type: "text", text: block.text });
+    } else if (block.type === "image") {
+      out.push({
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: block.mimeType,
+          data: block.data
+        }
+      });
+    } else if (block.type === "tool_use") {
+      out.push({
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input: block.input
+      });
+    } else if (block.type === "tool_result") {
+      const resultContent = block.content.flatMap(
+        (c) => c.type === "text" ? [{ type: "text", text: c.text }] : []
+      );
+      out.push({
+        type: "tool_result",
+        tool_use_id: block.toolUseId,
+        content: resultContent,
+        is_error: block.isError
+      });
+    }
+  }
+  return out;
+}
+function toAnthropicMessages(messages) {
+  return messages.map((m) => ({
+    role: m.role,
+    content: toBlocks(m.content)
+  }));
+}
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description ?? "",
+    input_schema: t.inputSchema
+  }));
+}
+function toAnthropicToolChoice(choice) {
+  if (!choice) return void 0;
+  if (choice.mode === "required") return { type: "any" };
+  return { type: "auto" };
+}
+function mapStopReason(reason) {
+  if (reason === "end_turn") return "endTurn";
+  if (reason === "stop_sequence") return "stopSequence";
+  if (reason === "max_tokens") return "maxTokens";
+  if (reason === "tool_use") return "toolUse";
+  return reason ?? "endTurn";
+}
+function buildResult(message) {
+  const stopReason = mapStopReason(message.stop_reason);
+  if (stopReason === "toolUse") {
+    const content = message.content.flatMap((block) => {
+      if (block.type === "tool_use") {
+        return [{
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        }];
+      }
+      return [];
+    });
+    return { role: "assistant", model: message.model, stopReason, content };
+  }
+  const textBlock = message.content.find((b) => b.type === "text");
+  const text = textBlock?.type === "text" ? textBlock.text : "";
+  return { role: "assistant", model: message.model, stopReason, content: { type: "text", text } };
+}
+var AnthropicSamplingAdapter = class {
+  _client;
+  _options;
+  constructor(client, options) {
+    this._client = client;
+    this._options = options ?? {};
+  }
+  asHandler() {
+    return async (params) => {
+      const model = resolveModel(
+        params.modelPreferences,
+        this._options.modelSelector,
+        this._options.defaultModel ?? "claude-opus-4-5"
+      );
+      const omitTools = params.toolChoice?.mode === "none";
+      const tools = !omitTools && params.tools?.length ? toAnthropicTools(params.tools) : void 0;
+      const toolChoice = tools ? toAnthropicToolChoice(params.toolChoice) : void 0;
+      const onToken = this._options.onToken;
+      const stream = this._client.messages.stream({
+        model,
+        messages: toAnthropicMessages(params.messages),
+        max_tokens: params.maxTokens ?? 1024,
+        ...params.systemPrompt !== void 0 ? { system: params.systemPrompt } : {},
+        ...params.temperature !== void 0 ? { temperature: params.temperature } : {},
+        ...params.stopSequences?.length ? { stop_sequences: params.stopSequences } : {},
+        ...tools ? { tools } : {},
+        ...toolChoice ? { tool_choice: toolChoice } : {}
+      });
+      if (onToken) {
+        stream.on("text", (text) => {
+          onToken(text);
+        });
+      }
+      const message = await stream.finalMessage();
+      return buildResult(message);
+    };
+  }
+};
+
+// src/client/sampling/openai.ts
+function toContentParts(content) {
+  const items = Array.isArray(content) ? content : [content];
+  if (items.length === 1 && items[0].type === "text") return items[0].text;
+  return items.flatMap((block) => {
+    if (block.type === "text") {
+      return [{ type: "text", text: block.text }];
+    } else if (block.type === "image") {
+      return [{
+        type: "image_url",
+        image_url: { url: `data:${block.mimeType};base64,${block.data}` }
+      }];
+    }
+    return [];
+  });
+}
+function toOpenAIMessages(messages, systemPrompt) {
+  const out = [];
+  if (systemPrompt) {
+    out.push({ role: "system", content: systemPrompt });
+  }
+  for (const m of messages) {
+    const items = Array.isArray(m.content) ? m.content : [m.content];
+    const toolUseItems = items.filter((b) => b.type === "tool_use");
+    if (toolUseItems.length > 0) {
+      out.push({
+        role: "assistant",
+        tool_calls: toolUseItems.map((b) => {
+          if (b.type !== "tool_use") throw new Error("unreachable");
+          return {
+            id: b.id,
+            type: "function",
+            function: { name: b.name, arguments: JSON.stringify(b.input) }
+          };
+        })
+      });
+      continue;
+    }
+    const toolResultItems = items.filter((b) => b.type === "tool_result");
+    if (toolResultItems.length > 0) {
+      for (const b of toolResultItems) {
+        if (b.type !== "tool_result") continue;
+        const text = b.content.filter((c) => c.type === "text").map((c) => c.type === "text" ? c.text : "").join("\n");
+        out.push({ role: "tool", tool_call_id: b.toolUseId, content: text });
+      }
+      continue;
+    }
+    const role = m.role;
+    const content = toContentParts(m.content);
+    if (role === "user") {
+      out.push({ role, content });
+    } else {
+      out.push({ role, content: typeof content === "string" ? content : "" });
+    }
+  }
+  return out;
+}
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      ...t.description ? { description: t.description } : {},
+      parameters: t.inputSchema
+    }
+  }));
+}
+function toOpenAIToolChoice(choice) {
+  if (!choice) return void 0;
+  if (choice.mode === "required") return "required";
+  if (choice.mode === "none") return "none";
+  return "auto";
+}
+function mapFinishReason(reason) {
+  if (reason === "stop") return "endTurn";
+  if (reason === "length") return "maxTokens";
+  if (reason === "tool_calls") return "toolUse";
+  return "endTurn";
+}
+function buildResult2(completion) {
+  const choice = completion.choices[0];
+  const stopReason = mapFinishReason(choice?.finish_reason);
+  const model = completion.model;
+  if (stopReason === "toolUse") {
+    const calls = choice.message.tool_calls ?? [];
+    const content = calls.flatMap((tc) => {
+      if (tc.type !== "function") return [];
+      const fn = tc.function;
+      return [{
+        type: "tool_use",
+        id: tc.id,
+        name: fn.name,
+        input: JSON.parse(fn.arguments)
+      }];
+    });
+    return { role: "assistant", model, stopReason, content };
+  }
+  const text = choice.message.content ?? "";
+  return { role: "assistant", model, stopReason, content: { type: "text", text } };
+}
+var OpenAISamplingAdapter = class {
+  _client;
+  _options;
+  constructor(client, options) {
+    this._client = client;
+    this._options = options ?? {};
+  }
+  asHandler() {
+    return async (params) => {
+      const model = resolveModel(
+        params.modelPreferences,
+        this._options.modelSelector,
+        this._options.defaultModel ?? "gpt-4o"
+      );
+      const omitTools = params.toolChoice?.mode === "none";
+      const tools = !omitTools && params.tools?.length ? toOpenAITools(params.tools) : void 0;
+      const toolChoice = tools ? toOpenAIToolChoice(params.toolChoice) : void 0;
+      const onToken = this._options.onToken;
+      const stream = this._client.chat.completions.stream({
+        model,
+        messages: toOpenAIMessages(params.messages, params.systemPrompt),
+        max_completion_tokens: params.maxTokens ?? 1024,
+        ...params.temperature !== void 0 ? { temperature: params.temperature } : {},
+        ...params.stopSequences?.length ? { stop: params.stopSequences } : {},
+        ...tools ? { tools } : {},
+        ...toolChoice !== void 0 ? { tool_choice: toolChoice } : {}
+      });
+      if (onToken) {
+        stream.on("content", (delta) => {
+          onToken(delta);
+        });
+      }
+      const completion = await stream.finalChatCompletion();
+      return buildResult2(completion);
+    };
+  }
+};
+
+// src/client/sampling/google.ts
+function pruneTitle(schema) {
+  const { title: _dropped, ...rest } = schema;
+  if (rest.properties && typeof rest.properties === "object") {
+    rest.properties = Object.fromEntries(
+      Object.entries(rest.properties).map(([k, v]) => [
+        k,
+        pruneTitle(v)
+      ])
+    );
+  }
+  return rest;
+}
+function toGeminiRole(role) {
+  return role === "assistant" ? "model" : "user";
+}
+function buildToolNameMap(messages) {
+  const map = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    const items = Array.isArray(m.content) ? m.content : [m.content];
+    for (const b of items) {
+      if (b.type === "tool_use") map.set(b.id, b.name);
+    }
+  }
+  return map;
+}
+function toGeminiContents(messages, toolNameById) {
+  return messages.map((m) => {
+    const items = Array.isArray(m.content) ? m.content : [m.content];
+    const parts = items.flatMap((block) => {
+      if (block.type === "text") {
+        return [{ text: block.text }];
+      } else if (block.type === "image") {
+        return [{ inlineData: { data: block.data, mimeType: block.mimeType } }];
+      } else if (block.type === "tool_use") {
+        return [{ functionCall: { name: block.name, args: block.input } }];
+      } else if (block.type === "tool_result") {
+        const name = toolNameById.get(block.toolUseId) ?? block.toolUseId;
+        const text = block.content.filter((c) => c.type === "text").map((c) => c.type === "text" ? c.text : "").join("\n");
+        return [{ functionResponse: { name, response: { content: text } } }];
+      }
+      return [];
+    });
+    return { role: toGeminiRole(m.role), parts };
+  });
+}
+function toGeminiFunctionDeclarations(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    ...t.description ? { description: t.description } : {},
+    parameters: pruneTitle(t.inputSchema)
+  }));
+}
+function toGeminiToolConfig(choice) {
+  if (!choice) return void 0;
+  const mode = choice.mode === "required" ? "ANY" : choice.mode === "none" ? "NONE" : "AUTO";
+  return { functionCallingConfig: { mode } };
+}
+function buildResult3(response, model) {
+  const functionCalls = response.functionCalls;
+  if (functionCalls?.length) {
+    const content = functionCalls.map((fc, i) => ({
+      type: "tool_use",
+      id: fc.id ?? `tool-${i}`,
+      name: fc.name ?? "",
+      input: fc.args ?? {}
+    }));
+    return { role: "assistant", model, stopReason: "toolUse", content };
+  }
+  const candidate = response.candidates?.[0];
+  const finishReason = candidate?.finishReason;
+  const stopReason = finishReason === "MAX_TOKENS" ? "maxTokens" : "endTurn";
+  const text = response.text ?? "";
+  return { role: "assistant", model, stopReason, content: { type: "text", text } };
+}
+var GoogleSamplingAdapter = class {
+  _client;
+  _options;
+  constructor(client, options) {
+    this._client = client;
+    this._options = options ?? {};
+  }
+  asHandler() {
+    return async (params) => {
+      const model = resolveModel(
+        params.modelPreferences,
+        this._options.modelSelector,
+        this._options.defaultModel ?? "gemini-2.0-flash"
+      );
+      const toolNameById = buildToolNameMap(params.messages);
+      const contents = toGeminiContents(params.messages, toolNameById);
+      const onToken = this._options.onToken;
+      const omitTools = params.toolChoice?.mode === "none";
+      const functionDeclarations = !omitTools && params.tools?.length ? toGeminiFunctionDeclarations(params.tools) : void 0;
+      const toolConfig = !omitTools ? toGeminiToolConfig(params.toolChoice) : void 0;
+      const config = {
+        maxOutputTokens: params.maxTokens ?? 1024,
+        ...params.temperature !== void 0 ? { temperature: params.temperature } : {},
+        ...params.stopSequences?.length ? { stopSequences: params.stopSequences } : {},
+        ...params.systemPrompt ? { systemInstruction: { parts: [{ text: params.systemPrompt }] } } : {},
+        ...functionDeclarations ? { tools: [{ functionDeclarations }] } : {},
+        ...toolConfig ? { toolConfig } : {}
+      };
+      const stream = await this._client.models.generateContentStream({
+        model,
+        contents,
+        config
+      });
+      let lastChunk;
+      for await (const chunk of stream) {
+        lastChunk = chunk;
+        if (onToken) {
+          const text = chunk.text;
+          if (text) onToken(text);
+        }
+      }
+      return buildResult3(lastChunk, model);
+    };
+  }
+};
+export {
+  AnthropicSamplingAdapter,
+  BearerAuth,
+  Client,
+  ClientCredentials,
+  FileTokenStorage,
+  GenericSamplingAdapter,
+  GoogleSamplingAdapter,
+  InMemoryStore,
+  MultiServerClient,
+  OAuth,
+  OpenAISamplingAdapter,
+  StdioTransport,
+  ToolCallError,
+  defaultLogHandler,
+  defaultProgressHandler,
+  toResult
+};
+//# sourceMappingURL=client.js.map