@smthrs/mcp 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/McpClient.js

@@ -0,0 +1,622 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var McpClient_exports = {};
+__export(McpClient_exports, {
+  ConnectOptionsSchema: () => ConnectOptionsSchema,
+  HttpConnectOptionsSchema: () => HttpConnectOptionsSchema,
+  clientInfo: () => clientInfo,
+  connect: () => connect,
+  defaultHandshakeTimeoutMs: () => defaultHandshakeTimeoutMs,
+  defaultMaxCatalogPages: () => defaultMaxCatalogPages,
+  defaultMaxFrameBytes: () => defaultMaxFrameBytes,
+  defaultMaxOutboundFrameBytes: () => defaultMaxOutboundFrameBytes,
+  defaultMaxStderrBytes: () => defaultMaxStderrBytes,
+  defaultMaxToolDocumentBytes: () => defaultMaxToolDocumentBytes,
+  defaultMaxToolNameBytes: () => defaultMaxToolNameBytes,
+  defaultMaxTools: () => defaultMaxTools,
+  defaultQueueCapacity: () => defaultQueueCapacity,
+  defaultRequestTimeoutMs: () => defaultRequestTimeoutMs,
+  maxJsonDepth: () => maxJsonDepth,
+  supportedProtocolVersions: () => supportedProtocolVersions
+});
+module.exports = __toCommonJS(McpClient_exports);
+var import_Record = require("@smthrs/canonical/Record");
+var import_effect = require("effect");
+var DiagnosticReporter = __toESM(require("./internal/DiagnosticReporter.js"), 1);
+var HttpTransport = __toESM(require("./internal/HttpTransport.js"), 1);
+var JsonLimits = __toESM(require("./internal/JsonLimits.js"), 1);
+var Limits = __toESM(require("./internal/Limits.js"), 1);
+var StdioTransport = __toESM(require("./internal/StdioTransport.js"), 1);
+var Transport = __toESM(require("./internal/Transport.js"), 1);
+var import_McpError = require("./McpError.js");
+const isHttp = (options) => options.url !== void 0;
+const PositiveInteger = import_effect.Schema.Int.check(import_effect.Schema.isGreaterThan(0));
+const ConnectOptionsSchema = import_effect.Schema.Struct({
+  server: import_effect.Schema.NonEmptyString,
+  command: import_effect.Schema.NonEmptyString,
+  args: import_effect.Schema.Array(import_effect.Schema.String),
+  cwd: import_effect.Schema.optional(import_effect.Schema.NonEmptyString),
+  env: import_effect.Schema.optional(import_effect.Schema.Record(import_effect.Schema.String, import_effect.Schema.String)),
+  handshakeTimeoutMs: import_effect.Schema.optional(PositiveInteger),
+  requestTimeoutMs: import_effect.Schema.optional(PositiveInteger),
+  queueCapacity: import_effect.Schema.optional(PositiveInteger),
+  maxFrameBytes: import_effect.Schema.optional(PositiveInteger),
+  maxOutboundFrameBytes: import_effect.Schema.optional(PositiveInteger),
+  maxStderrBytes: import_effect.Schema.optional(PositiveInteger),
+  maxTools: import_effect.Schema.optional(PositiveInteger),
+  maxToolNameBytes: import_effect.Schema.optional(PositiveInteger),
+  maxToolDocumentBytes: import_effect.Schema.optional(PositiveInteger),
+  maxCatalogPages: import_effect.Schema.optional(PositiveInteger)
+});
+const isEndpoint = (url) => {
+  if (!URL.canParse(url)) return false;
+  const parsed = new URL(url);
+  return (parsed.protocol === "http:" || parsed.protocol === "https:") && parsed.username === "" && parsed.password === "";
+};
+const HttpConnectOptionsSchema = import_effect.Schema.Struct({
+  server: import_effect.Schema.NonEmptyString,
+  url: import_effect.Schema.String.check(import_effect.Schema.makeFilter(isEndpoint, { expected: "an http: or https: URL without credentials" })),
+  bearerTokenEnv: import_effect.Schema.optionalKey(import_effect.Schema.String.check(import_effect.Schema.isPattern(/^[A-Za-z_][A-Za-z0-9_]*$/))),
+  handshakeTimeoutMs: import_effect.Schema.optional(PositiveInteger),
+  requestTimeoutMs: import_effect.Schema.optional(PositiveInteger),
+  maxFrameBytes: import_effect.Schema.optional(PositiveInteger),
+  maxOutboundFrameBytes: import_effect.Schema.optional(PositiveInteger),
+  maxTools: import_effect.Schema.optional(PositiveInteger),
+  maxToolNameBytes: import_effect.Schema.optional(PositiveInteger),
+  maxToolDocumentBytes: import_effect.Schema.optional(PositiveInteger),
+  maxCatalogPages: import_effect.Schema.optional(PositiveInteger)
+});
+const clientInfo = Object.freeze({
+  name: "smithers",
+  version: "1.0.0-rc.3"
+});
+const supportedProtocolVersions = Object.freeze([
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05"
+]);
+const defaultHandshakeTimeoutMs = 1e4;
+const defaultRequestTimeoutMs = Transport.defaultRequestTimeoutMs;
+const defaultQueueCapacity = StdioTransport.defaultQueueCapacity;
+const defaultMaxFrameBytes = Transport.defaultMaxFrameBytes;
+const defaultMaxOutboundFrameBytes = Transport.defaultMaxOutboundFrameBytes;
+const defaultMaxStderrBytes = StdioTransport.defaultMaxStderrBytes;
+const defaultMaxTools = 256;
+const defaultMaxToolNameBytes = 128;
+const defaultMaxToolDocumentBytes = 65536;
+const defaultMaxCatalogPages = 32;
+const maxJsonDepth = JsonLimits.maxDepth;
+const invalidResponse = (server, message) => new import_McpError.McpError({ code: "invalid_response", message, server });
+const asInitialize = (server, result) => {
+  if (!(0, import_Record.isRecord)(result)) {
+    return import_effect.Result.fail(Limits.protocolError(
+      server,
+      `MCP server "${server}" returned a malformed initialize result: result is not an object`
+    ));
+  }
+  if (typeof result.protocolVersion !== "string") {
+    return import_effect.Result.fail(Limits.protocolError(
+      server,
+      `MCP server "${server}" returned a malformed initialize result: protocolVersion is not a string`
+    ));
+  }
+  if (!supportedProtocolVersions.includes(result.protocolVersion)) {
+    return import_effect.Result.fail(Limits.protocolError(
+      server,
+      `MCP server "${server}" speaks an unsupported protocol version; this client speaks ${supportedProtocolVersions.join(", ")}`
+    ));
+  }
+  if (!(0, import_Record.isRecord)(result.capabilities)) {
+    return import_effect.Result.fail(Limits.protocolError(
+      server,
+      `MCP server "${server}" returned a malformed initialize result: capabilities is not an object`
+    ));
+  }
+  if (!Object.hasOwn(result.capabilities, "tools") || !(0, import_Record.isRecord)(result.capabilities.tools)) {
+    return import_effect.Result.fail(Limits.protocolError(
+      server,
+      `MCP server "${server}" does not serve tools: its initialize result declares no tools capability`
+    ));
+  }
+  return import_effect.Result.succeed(void 0);
+};
+const nameEncoder = new TextEncoder();
+const forbiddenToolNameCharacter = /[/\p{Cc}\p{Cf}\p{Cs}\u2028\u2029]/u;
+const isForbiddenToolName = (name) => name === "." || name === ".." || forbiddenToolNameCharacter.test(name);
+const asToolPage = (server, result, limits, seen, described) => {
+  const tools = (0, import_Record.isRecord)(result) ? result.tools : void 0;
+  if (!Array.isArray(tools)) {
+    return import_effect.Result.fail(invalidResponse(
+      server,
+      `MCP server "${server}" returned a tools/list result with no tools array`
+    ));
+  }
+  for (const [index, tool] of tools.entries()) {
+    if (described.length >= limits.maxTools) {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned more than ${limits.maxTools} tools`
+      ));
+    }
+    if (!(0, import_Record.isRecord)(tool)) {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned tools[${index}], which is not an object`
+      ));
+    }
+    const record = tool;
+    if (typeof record.name !== "string" || record.name === "") {
+      return import_effect.Result.fail(invalidResponse(server, `MCP server "${server}" returned tools[${index}] with no name`));
+    }
+    if (nameEncoder.encode(record.name).byteLength > limits.maxToolNameBytes) {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned a tool name longer than ${limits.maxToolNameBytes} bytes`
+      ));
+    }
+    if (isForbiddenToolName(record.name)) {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned a tool name that is "." or "..", or contains "/" or an invisible or control character`
+      ));
+    }
+    if (seen.has(record.name)) {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned a duplicate tool name at catalog index ${index}`
+      ));
+    }
+    if (!(0, import_Record.isRecord)(record.inputSchema) || record.inputSchema.type !== "object") {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned a tool whose inputSchema is not a JSON Schema object of type "object"`
+      ));
+    }
+    const description = typeof record.description === "string" ? record.description : void 0;
+    const documentBytes = nameEncoder.encode(description ?? "").byteLength + nameEncoder.encode(JSON.stringify(record.inputSchema)).byteLength;
+    if (documentBytes > limits.maxToolDocumentBytes) {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned a tool description and inputSchema longer than ${limits.maxToolDocumentBytes} bytes`
+      ));
+    }
+    let outputSchema;
+    if (Object.hasOwn(record, "outputSchema")) {
+      if (!(0, import_Record.isRecord)(record.outputSchema)) {
+        return import_effect.Result.fail(invalidResponse(
+          server,
+          `MCP server "${server}" returned a tool whose outputSchema is not a JSON object`
+        ));
+      }
+      outputSchema = record.outputSchema;
+    }
+    seen.add(record.name);
+    described.push({
+      name: record.name,
+      description,
+      inputSchema: record.inputSchema,
+      outputSchema
+    });
+  }
+  const nextCursor = (0, import_Record.isRecord)(result) && Object.hasOwn(result, "nextCursor") ? result.nextCursor : void 0;
+  if (nextCursor === void 0) return import_effect.Result.succeed({ nextCursor: void 0 });
+  if (typeof nextCursor !== "string" || nextCursor === "") {
+    return import_effect.Result.fail(invalidResponse(
+      server,
+      `MCP server "${server}" returned a tools/list cursor that is not a non-empty string`
+    ));
+  }
+  return import_effect.Result.succeed({ nextCursor });
+};
+const outputTypes = {
+  null: import_effect.Schema.Null,
+  boolean: import_effect.Schema.Boolean,
+  object: import_effect.Schema.declare(import_Record.isRecord),
+  array: import_effect.Schema.declare(Array.isArray),
+  number: import_effect.Schema.Number,
+  string: import_effect.Schema.String,
+  integer: import_effect.Schema.Number.check(import_effect.Schema.makeFilter(Number.isInteger))
+};
+const runJsonWork = (work) => import_effect.Effect.gen(function* () {
+  while (true) {
+    for (let steps = 0; steps < 1024; steps += 1) {
+      const next = work.next();
+      if (next.done) return next.value;
+    }
+    yield* import_effect.Effect.yieldNow;
+  }
+});
+const enumKey = function* (value) {
+  yield;
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const item of value) items.push(yield* enumKey(item));
+    return `[${items.join(",")}]`;
+  }
+  if ((0, import_Record.isRecord)(value)) {
+    const members = [];
+    for (const key of Object.keys(value).sort()) {
+      members.push(`${JSON.stringify(key)}:${yield* enumKey(value[key])}`);
+    }
+    return `{${members.join(",")}}`;
+  }
+  return JSON.stringify(value);
+};
+const compileOutputSchema = function* (schema) {
+  yield;
+  const types = /* @__PURE__ */ new Set();
+  for (const candidate of Array.isArray(schema.type) ? schema.type : [schema.type]) {
+    yield;
+    if (typeof candidate === "string" && Object.hasOwn(outputTypes, candidate)) {
+      types.add(candidate);
+    }
+  }
+  const accepts = import_effect.Schema.is(
+    types.size === 0 ? import_effect.Schema.Unknown : import_effect.Schema.Union([...types].map((type) => outputTypes[type]))
+  );
+  const typeReason = `expected ${[...types].join(" or ")}`;
+  let enumIndex;
+  if (Array.isArray(schema.enum)) {
+    enumIndex = /* @__PURE__ */ new Set();
+    for (const member of schema.enum) enumIndex.add(yield* enumKey(member));
+  }
+  const required = [];
+  if (Array.isArray(schema.required)) {
+    for (const key of schema.required) {
+      yield;
+      if (typeof key === "string") required.push(key);
+    }
+  }
+  const properties = [];
+  if ((0, import_Record.isRecord)(schema.properties)) {
+    for (const [key, property] of Object.entries(schema.properties)) {
+      yield;
+      if ((0, import_Record.isRecord)(property)) properties.push([key, yield* compileOutputSchema(property)]);
+    }
+  }
+  const items = (0, import_Record.isRecord)(schema.items) ? yield* compileOutputSchema(schema.items) : void 0;
+  return function* (value, path) {
+    yield;
+    if (enumIndex !== void 0 && !enumIndex.has(yield* enumKey(value))) {
+      return { path, reason: "expected a declared enum value" };
+    }
+    if (!accepts(value)) return { path, reason: typeReason };
+    if ((0, import_Record.isRecord)(value)) {
+      for (const key of required) {
+        yield;
+        if (!Object.hasOwn(value, key)) return { path: `${path}.${key}`, reason: "required property is missing" };
+      }
+      for (const [key, validate] of properties) {
+        yield;
+        if (!Object.hasOwn(value, key)) continue;
+        const issue = yield* validate(value[key], `${path}.${key}`);
+        if (issue !== void 0) return issue;
+      }
+    }
+    if (Array.isArray(value) && items !== void 0) {
+      for (const [index, item] of value.entries()) {
+        const issue = yield* items(item, `${path}[${index}]`);
+        if (issue !== void 0) return issue;
+      }
+    }
+    return void 0;
+  };
+};
+const asToolResult = function* (server, result, outputSchema, diagnostic, validate) {
+  if (!(0, import_Record.isRecord)(result)) {
+    return import_effect.Result.fail(invalidResponse(
+      server,
+      `MCP server "${server}" returned a tools/call result that is not an object`
+    ));
+  }
+  const hasContent = Object.hasOwn(result, "content");
+  const hasStructuredContent = Object.hasOwn(result, "structuredContent");
+  if (!hasContent && !hasStructuredContent) {
+    return import_effect.Result.fail(invalidResponse(
+      server,
+      `MCP server "${server}" returned a tools/call result with no content array`
+    ));
+  }
+  if (hasContent && !Array.isArray(result.content)) {
+    return import_effect.Result.fail(invalidResponse(
+      server,
+      `MCP server "${server}" returned a tools/call result with no content array`
+    ));
+  }
+  const content = [];
+  const blocks = hasContent ? result.content : [];
+  for (const [index, block] of blocks.entries()) {
+    yield;
+    if (!(0, import_Record.isRecord)(block)) {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned a tools/call result whose content[${index}] is not an object`
+      ));
+    }
+    content.push(block);
+  }
+  if (Object.hasOwn(result, "isError") && typeof result.isError !== "boolean") {
+    return import_effect.Result.fail(invalidResponse(
+      server,
+      `MCP server "${server}" returned a tools/call result whose isError is not a boolean`
+    ));
+  }
+  let structuredContent;
+  if (hasStructuredContent) {
+    if (!(0, import_Record.isRecord)(result.structuredContent)) {
+      return import_effect.Result.fail(invalidResponse(
+        server,
+        `MCP server "${server}" returned a tools/call result whose structuredContent is not a JSON object`
+      ));
+    }
+    structuredContent = result.structuredContent;
+    if (validate !== void 0) {
+      const issue = yield* validate(structuredContent, "structuredContent");
+      if (issue !== void 0) {
+        diagnostic("invalid-response", { issue, outputSchema });
+        return import_effect.Result.fail(invalidResponse(
+          server,
+          `MCP server "${server}" returned structuredContent that its own outputSchema rejects: ${issue.reason}; property path withheld`
+        ));
+      }
+    }
+  }
+  return import_effect.Result.succeed({
+    content,
+    isError: result.isError === true,
+    structuredContent
+  });
+};
+const renderJsonPath = (path) => typeof path === "string" ? path : `${renderJsonPath(path.parent)}${typeof path.key === "number" ? `[${path.key}]` : `.${path.key}`}`;
+const jsonFailure = (path, reason) => import_effect.Result.fail({ path: renderJsonPath(path), reason });
+const reflect = (thunk) => {
+  try {
+    return import_effect.Result.succeed(thunk());
+  } catch {
+    return import_effect.Result.fail("a property that threw when read");
+  }
+};
+const ownDescriptors = (object) => reflect(() => Object.getOwnPropertyDescriptors(object));
+const isAccessor = (descriptor) => Object.hasOwn(descriptor, "get") || Object.hasOwn(descriptor, "set");
+const spendJson = (budget, bytes) => {
+  budget.remaining -= bytes;
+  return budget.remaining >= 0;
+};
+const snapshotJson = (value, path, ancestors, budget) => {
+  const bytes = typeof value === "string" ? value.length + 2 : typeof value === "number" || typeof value === "boolean" ? String(value).length : value === null ? 4 : 2;
+  if (!spendJson(budget, bytes)) return jsonFailure(path, "JSON expansion exceeds the outbound frame budget");
+  if (value === null) return import_effect.Result.succeed(null);
+  if (typeof value === "boolean" || typeof value === "string") return import_effect.Result.succeed(value);
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? import_effect.Result.succeed(value) : jsonFailure(path, "a non-finite number");
+  }
+  if (typeof value === "undefined") return jsonFailure(path, "undefined");
+  if (typeof value === "bigint") return jsonFailure(path, "a bigint");
+  if (typeof value === "function") return jsonFailure(path, "a function");
+  if (typeof value === "symbol") return jsonFailure(path, "a symbol");
+  if (ancestors.has(value)) return jsonFailure(path, "a cyclic reference");
+  if (ancestors.size + 3 > maxJsonDepth) return jsonFailure(path, `JSON nesting exceeds ${maxJsonDepth} containers`);
+  const array = reflect(() => Array.isArray(value));
+  if (import_effect.Result.isFailure(array)) return jsonFailure(path, array.failure);
+  if (array.success) {
+    const length = reflect(() => value.length);
+    if (import_effect.Result.isFailure(length)) return jsonFailure(path, length.failure);
+    if (!Number.isSafeInteger(length.success) || length.success < 0) {
+      return jsonFailure(path, "a property that threw when read");
+    }
+    if (!spendJson(budget, Math.max(0, length.success - 1))) {
+      return jsonFailure(path, "JSON expansion exceeds the outbound frame budget");
+    }
+    const descriptors2 = ownDescriptors(value);
+    if (import_effect.Result.isFailure(descriptors2)) return jsonFailure(path, descriptors2.failure);
+    ancestors.add(value);
+    const copied2 = [];
+    const memberPath2 = { parent: path, key: 0 };
+    for (let index = 0; index < length.success; index += 1) {
+      memberPath2.key = index;
+      const descriptor = Object.hasOwn(descriptors2.success, index) ? descriptors2.success[index] : void 0;
+      if (descriptor !== void 0 && isAccessor(descriptor)) {
+        ancestors.delete(value);
+        return jsonFailure(memberPath2, "an accessor property");
+      }
+      const member = descriptor === void 0 ? void 0 : descriptor.value;
+      const snapshot = snapshotJson(member, memberPath2, ancestors, budget);
+      if (import_effect.Result.isFailure(snapshot)) {
+        ancestors.delete(value);
+        return snapshot;
+      }
+      copied2.push(snapshot.success);
+    }
+    ancestors.delete(value);
+    return import_effect.Result.succeed(copied2);
+  }
+  const object = value;
+  const prototype = reflect(() => Object.getPrototypeOf(object));
+  if (import_effect.Result.isFailure(prototype)) return jsonFailure(path, prototype.failure);
+  if (prototype.success !== Object.prototype && prototype.success !== null) {
+    return jsonFailure(path, "an object with a non-plain prototype");
+  }
+  const symbols = reflect(() => Object.getOwnPropertySymbols(object));
+  if (import_effect.Result.isFailure(symbols)) return jsonFailure(path, symbols.failure);
+  const descriptors = ownDescriptors(object);
+  if (import_effect.Result.isFailure(descriptors)) return jsonFailure(path, descriptors.failure);
+  for (const key of symbols.success) {
+    if (Object.hasOwn(descriptors.success, key) && descriptors.success[key].enumerable) {
+      return jsonFailure(path, "a symbol-keyed property");
+    }
+  }
+  ancestors.add(object);
+  const copied = {};
+  let members = 0;
+  const memberPath = { parent: path, key: "" };
+  for (const key of Object.keys(descriptors.success)) {
+    memberPath.key = key;
+    const descriptor = descriptors.success[key];
+    if (descriptor.enumerable !== true) continue;
+    if (!spendJson(budget, key.length + 3 + Math.min(1, members++))) {
+      ancestors.delete(object);
+      return jsonFailure(path, "JSON expansion exceeds the outbound frame budget");
+    }
+    if (isAccessor(descriptor)) {
+      ancestors.delete(object);
+      return jsonFailure(memberPath, "an accessor property");
+    }
+    const snapshot = snapshotJson(descriptor.value, memberPath, ancestors, budget);
+    if (import_effect.Result.isFailure(snapshot)) {
+      ancestors.delete(object);
+      return snapshot;
+    }
+    Object.defineProperty(copied, key, {
+      configurable: true,
+      enumerable: true,
+      value: snapshot.success,
+      writable: true
+    });
+  }
+  ancestors.delete(object);
+  return import_effect.Result.succeed(copied);
+};
+const snapshotArguments = (server, args, diagnostic, maxBytes) => {
+  const snapshot = snapshotJson(args, "arguments", /* @__PURE__ */ new Set(), { remaining: maxBytes });
+  if (import_effect.Result.isFailure(snapshot)) {
+    diagnostic("invalid-arguments", snapshot.failure);
+    return import_effect.Result.fail(Limits.protocolError(
+      server,
+      `MCP server "${server}" was sent a tool argument that is not JSON: ${snapshot.failure.reason}; property path withheld`
+    ));
+  }
+  if (!(0, import_Record.isRecord)(snapshot.success)) {
+    return import_effect.Result.fail(Limits.protocolError(server, `MCP server "${server}" tool arguments must be a JSON object`));
+  }
+  return import_effect.Result.succeed(snapshot.success);
+};
+const connect = (options) => import_effect.Effect.acquireUseRelease(
+  import_effect.Effect.flatMap(import_effect.Effect.scope, import_effect.Scope.fork),
+  (scope) => import_effect.Effect.gen(function* () {
+    const diagnostic = yield* DiagnosticReporter.make(options.server);
+    const decodeResponse = (response, decoded) => import_effect.Effect.fromResult(decoded).pipe(
+      import_effect.Effect.tapError(() => import_effect.Effect.sync(() => diagnostic("invalid-response", response)))
+    );
+    const handshakeTimeoutMs = options.handshakeTimeoutMs ?? defaultHandshakeTimeoutMs;
+    const maxArgumentBytes = options.maxOutboundFrameBytes ?? defaultMaxOutboundFrameBytes;
+    const maxTools = options.maxTools ?? defaultMaxTools;
+    const maxToolNameBytes = options.maxToolNameBytes ?? defaultMaxToolNameBytes;
+    const maxToolDocumentBytes = options.maxToolDocumentBytes ?? defaultMaxToolDocumentBytes;
+    const maxCatalogPages = options.maxCatalogPages ?? defaultMaxCatalogPages;
+    yield* Limits.checkPositiveIntegers(options.server, [
+      ["handshakeTimeoutMs", handshakeTimeoutMs],
+      ["maxTools", maxTools],
+      ["maxToolNameBytes", maxToolNameBytes],
+      ["maxToolDocumentBytes", maxToolDocumentBytes],
+      ["maxCatalogPages", maxCatalogPages]
+    ]);
+    const transport = yield* isHttp(options) ? HttpTransport.connect(options) : StdioTransport.connect(options);
+    const initialized = yield* transport.request(
+      "initialize",
+      {
+        protocolVersion: supportedProtocolVersions[0],
+        capabilities: {},
+        clientInfo
+      },
+      handshakeTimeoutMs
+    );
+    yield* decodeResponse(initialized, asInitialize(options.server, initialized));
+    yield* transport.notify("notifications/initialized", void 0, handshakeTimeoutMs);
+    const tools = [];
+    const toolNames = /* @__PURE__ */ new Set();
+    const cursors = /* @__PURE__ */ new Set();
+    let params = {};
+    let pageCount = 0;
+    while (true) {
+      const listed = yield* transport.request("tools/list", params, handshakeTimeoutMs);
+      pageCount += 1;
+      const page = yield* decodeResponse(
+        listed,
+        asToolPage(
+          options.server,
+          listed,
+          { maxTools, maxToolNameBytes, maxToolDocumentBytes },
+          toolNames,
+          tools
+        )
+      );
+      if (page.nextCursor === void 0) break;
+      if (cursors.has(page.nextCursor)) {
+        diagnostic("invalid-response", listed);
+        return yield* import_effect.Effect.fail(invalidResponse(
+          options.server,
+          `MCP server "${options.server}" repeated a tools/list cursor`
+        ));
+      }
+      if (pageCount >= maxCatalogPages) {
+        return yield* import_effect.Effect.fail(invalidResponse(
+          options.server,
+          `MCP server "${options.server}" returned more than ${maxCatalogPages} tools/list pages`
+        ));
+      }
+      cursors.add(page.nextCursor);
+      params = { cursor: page.nextCursor };
+    }
+    JsonLimits.freezeParsed(tools);
+    const validators = /* @__PURE__ */ new Map();
+    for (const tool of tools) {
+      if (tool.outputSchema !== void 0) {
+        validators.set(tool.name, yield* runJsonWork(compileOutputSchema(tool.outputSchema)));
+      }
+    }
+    const callTool = (name, args) => {
+      const tool = tools.find((candidate) => candidate.name === name);
+      if (tool === void 0) {
+        return import_effect.Effect.fail(
+          new import_McpError.McpError({
+            code: "tool_not_found",
+            message: `MCP server "${options.server}" has no requested tool`,
+            server: options.server
+          })
+        );
+      }
+      const snapshot = snapshotArguments(options.server, args, diagnostic, maxArgumentBytes);
+      if (import_effect.Result.isFailure(snapshot)) {
+        return import_effect.Effect.fail(snapshot.failure);
+      }
+      return import_effect.Effect.flatMap(
+        transport.request("tools/call", { name, arguments: snapshot.success }),
+        (result) => import_effect.Effect.flatMap(
+          runJsonWork(asToolResult(options.server, result, tool.outputSchema, diagnostic, validators.get(name))),
+          (decoded) => decodeResponse(result, decoded)
+        )
+      );
+    };
+    return { server: options.server, tools, callTool };
+  }).pipe(import_effect.Scope.provide(scope)),
+  // Closing a failed attempt also detaches it from the caller's scope.
+  // Successful sessions remain owned by that scope until it closes.
+  (scope, exit) => import_effect.Exit.isFailure(exit) ? import_effect.Scope.close(scope, exit) : import_effect.Effect.void
+);
+//# sourceMappingURL=McpClient.js.map