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

package/dist/cjs/internal/Limits.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Limits_exports = {};
+__export(Limits_exports, {
+  checkPositiveIntegers: () => checkPositiveIntegers,
+  isPositiveInteger: () => isPositiveInteger,
+  protocolError: () => protocolError
+});
+module.exports = __toCommonJS(Limits_exports);
+var import_effect = require("effect");
+var import_McpError = require("../McpError.js");
+const protocolError = (server, message) => new import_McpError.McpError({ code: "protocol_error", message, server });
+const isPositiveInteger = (value) => Number.isSafeInteger(value) && value > 0;
+const checkPositiveIntegers = (server, entries) => {
+  const invalid = entries.find(([, value]) => !isPositiveInteger(value));
+  return invalid === void 0 ? import_effect.Effect.void : import_effect.Effect.fail(protocolError(server, `MCP option "${invalid[0]}" must be a positive integer`));
+};
+//# sourceMappingURL=Limits.js.map

package/dist/cjs/internal/Limits.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Limits.ts"],
+  "sourcesContent": ["/**\n * Positive-integer option bounds shared by the transport and the client.\n *\n * Both `connect` functions resolve their defaults and then reject the first\n * option that is not a positive safe integer, before any process is spawned.\n * The check and its error prose live here so the two option lists cannot\n * drift in wording or in semantics.\n *\n * @since 1.0.0-rc.0\n */\n\nimport { Effect } from \"effect\"\nimport { McpError } from \"../McpError.ts\"\n\n/**\n * Builds the `protocol_error` failure both modules report for malformed\n * options and frames.\n *\n * @category errors\n * @since 1.0.0-rc.0\n */\nexport const protocolError = (server: string, message: string): McpError =>\n  new McpError({ code: \"protocol_error\", message, server })\n\n/**\n * Whether a value is a positive safe integer.\n *\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const isPositiveInteger = (value: number): boolean => Number.isSafeInteger(value) && value > 0\n\n/**\n * Fails with `protocol_error` naming the first option whose resolved value is\n * not a positive safe integer. Entries are checked in the order given.\n *\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const checkPositiveIntegers = (\n  server: string,\n  entries: ReadonlyArray<readonly [name: string, value: number]>\n): Effect.Effect<void, McpError> => {\n  const invalid = entries.find(([, value]) => !isPositiveInteger(value))\n  return invalid === undefined\n    ? Effect.void\n    : Effect.fail(protocolError(server, `MCP option \"${invalid[0]}\" must be a positive integer`))\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,oBAAuB;AACvB,sBAAyB;AASlB,MAAM,gBAAgB,CAAC,QAAgB,YAC5C,IAAI,yBAAS,EAAE,MAAM,kBAAkB,SAAS,OAAO,CAAC;AAQnD,MAAM,oBAAoB,CAAC,UAA2B,OAAO,cAAc,KAAK,KAAK,QAAQ;AAS7F,MAAM,wBAAwB,CACnC,QACA,YACkC;AAClC,QAAM,UAAU,QAAQ,KAAK,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,kBAAkB,KAAK,CAAC;AACrE,SAAO,YAAY,SACf,qBAAO,OACP,qBAAO,KAAK,cAAc,QAAQ,eAAe,QAAQ,CAAC,CAAC,8BAA8B,CAAC;AAChG;",
+  "names": []
+}

package/dist/cjs/internal/Rpc.d.ts

@@ -0,0 +1,141 @@
+/**
+ * JSON-RPC 2.0 envelope encoding for the MCP stdio transport.
+ *
+ * MCP's stdio transport frames every message as exactly one line of JSON on
+ * standard input or output, so this module is pure line-shaped codec: no
+ * process, no scheduling, no retry policy. {@link StdioTransport} owns those.
+ *
+ * @since 1.0.0-rc.0
+ */
+/**
+ * A JSON-RPC call this client sends. Omitting `id` sends a notification, for
+ * which the server never replies.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Outbound {
+    readonly jsonrpc: "2.0";
+    readonly id?: number | undefined;
+    readonly method: string;
+    readonly params?: unknown;
+}
+/**
+ * Any outbound wire message, including replies to server requests. A reply
+ * preserves the server's exact id type rather than normalizing it as a
+ * correlation id in the client's pending-request map.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type OutboundMessage = Outbound | {
+    readonly jsonrpc: "2.0";
+    readonly id: string | number;
+    readonly result: unknown;
+} | {
+    readonly jsonrpc: "2.0";
+    readonly id: string | number;
+    readonly error: {
+        readonly code: number;
+        readonly message: string;
+    };
+};
+/**
+ * A JSON object from server stdout that claims JSON-RPC by carrying its own
+ * `jsonrpc` property. Validation happens after parsing so an incorrect version
+ * cannot be mistaken for ordinary stdout noise.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Inbound {
+    readonly jsonrpc: unknown;
+    readonly id?: unknown;
+    readonly method?: unknown;
+    readonly params?: unknown;
+    readonly result?: unknown;
+    readonly error?: unknown;
+}
+/**
+ * A validated JSON-RPC reply, normalized to the numeric request id this
+ * client uses for correlation, or an error whose null id cannot be correlated.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Reply = {
+    readonly _tag: "Result";
+    readonly id: number;
+    readonly result: unknown;
+} | {
+    readonly _tag: "Error";
+    readonly id: number;
+    readonly code: number;
+    readonly message: string;
+    readonly data: unknown;
+} | {
+    readonly _tag: "UncorrelatedError";
+    readonly code: number;
+    readonly message: string;
+    readonly data: unknown;
+} | {
+    readonly _tag: "Malformed";
+    readonly reason: string;
+};
+/**
+ * The transport-relevant classification of one parsed JSON-RPC object.
+ * Server request ids belong to the opposite direction and must never be
+ * looked up in the client's pending-request map.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Classification = {
+    readonly _tag: "Notification";
+} | {
+    readonly _tag: "Request";
+    readonly id: string | number;
+    readonly method: string;
+    readonly params: unknown;
+} | Reply;
+/**
+ * Encodes one outbound message as a newline-terminated UTF-8 frame.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const encode: (message: OutboundMessage) => Uint8Array;
+/**
+ * Parses one line of server output. A blank line, invalid JSON, a non-object,
+ * or an object with no own `jsonrpc` property returns `undefined`. MCP servers
+ * commonly log to stdout, so output that does not claim to be JSON-RPC is
+ * noise rather than a protocol violation. Tagged objects are preserved for
+ * {@link classify}, including objects that claim the wrong version.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const parse: (line: string) => Inbound | undefined;
+/**
+ * Validates and normalizes a parsed inbound object as a reply.
+ *
+ * Digit-string ids are accepted only in their canonical ASCII decimal form,
+ * then converted back to the safe integer id used by the pending-request map.
+ * A reply must carry an own id and exactly one own `result` or `error`
+ * property. A null id is accepted only for a valid error, which cannot settle
+ * any particular request.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const replyOf: (message: Inbound) => Reply;
+/**
+ * Classifies a parsed JSON-RPC object for the stdio reader. A wrong version is
+ * malformed; a valid own `method` with an own id is a server request, without
+ * an id a notification. Every remaining object must satisfy {@link replyOf}.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const classify: (message: Inbound) => Classification;
+//# sourceMappingURL=Rpc.d.ts.map

package/dist/cjs/internal/Rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rpc.d.ts","sourceRoot":"","sources":["../../../src/internal/Rpc.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG;IACvC,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB,GAAG;IACF,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CACpE,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB,GAAG;IACF,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB,GAAG;IACF,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB,GAAG;IACF,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GAAG;IAC/D,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB,GAAG,KAAK,CAAA;AAIT;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,eAAe,KAAG,UAA4D,CAAA;AAE9G;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,OAAO,GAAG,SAY9C,CAAA;AAID;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAAI,SAAS,OAAO,KAAG,KAsC1C,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,OAAO,KAAG,cAqB3C,CAAA"}

package/dist/cjs/internal/Rpc.js

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Rpc_exports = {};
+__export(Rpc_exports, {
+  classify: () => classify,
+  encode: () => encode,
+  parse: () => parse,
+  replyOf: () => replyOf
+});
+module.exports = __toCommonJS(Rpc_exports);
+const encoder = new TextEncoder();
+const encode = (message) => encoder.encode(`${JSON.stringify(message)}
+`);
+const parse = (line) => {
+  const trimmed = line.trim();
+  if (trimmed === "") return void 0;
+  let value;
+  try {
+    value = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  if (!Object.hasOwn(value, "jsonrpc")) return void 0;
+  return value;
+};
+const malformed = (reason) => ({ _tag: "Malformed", reason });
+const replyOf = (message) => {
+  if (!Object.hasOwn(message, "id")) return malformed("a reply carried no id");
+  const rawId = message.id;
+  const id = typeof rawId === "number" ? rawId : typeof rawId === "string" && /^(0|[1-9][0-9]*)$/.test(rawId) ? Number(rawId) : Number.NaN;
+  if (rawId !== null && !Number.isSafeInteger(id)) return malformed("a reply id must be a JSON-RPC integer");
+  const hasResult = Object.hasOwn(message, "result");
+  const hasError = Object.hasOwn(message, "error");
+  if (!hasResult && !hasError) return malformed("a reply carried neither result nor error");
+  if (hasResult && hasError) return malformed("a reply carried both result and error");
+  if (hasResult) {
+    if (rawId === null) return malformed("a reply id must be a JSON-RPC integer");
+    return { _tag: "Result", id, result: message.result };
+  }
+  const error = message.error;
+  if (typeof error !== "object" || error === null || Array.isArray(error) || !Number.isInteger(error.code) || typeof error.message !== "string") {
+    return malformed("a reply carried a malformed error object");
+  }
+  const record = error;
+  if (rawId === null) {
+    return { _tag: "UncorrelatedError", code: record.code, message: record.message, data: record.data };
+  }
+  return {
+    _tag: "Error",
+    id,
+    code: record.code,
+    message: record.message,
+    data: record.data
+  };
+};
+const classify = (message) => {
+  if (message.jsonrpc !== "2.0") {
+    return malformed('a JSON-RPC message must carry jsonrpc "2.0"');
+  }
+  if (Object.hasOwn(message, "method")) {
+    if (typeof message.method !== "string") return malformed("a method must be a string");
+    if (Object.hasOwn(message, "result") || Object.hasOwn(message, "error")) {
+      return malformed("a method-bearing message cannot also carry result or error");
+    }
+    if (Object.hasOwn(message, "params") && (typeof message.params !== "object" || message.params === null || Array.isArray(message.params))) return malformed("MCP method params must be an object");
+    if (!Object.hasOwn(message, "id")) return { _tag: "Notification" };
+    const id = message.id;
+    if (typeof id !== "string" && (typeof id !== "number" || !Number.isSafeInteger(id))) {
+      return malformed("a server request id must be a string or safe integer");
+    }
+    return { _tag: "Request", id, method: message.method, params: message.params };
+  }
+  return replyOf(message);
+};
+//# sourceMappingURL=Rpc.js.map

package/dist/cjs/internal/Rpc.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Rpc.ts"],
+  "sourcesContent": ["/**\n * JSON-RPC 2.0 envelope encoding for the MCP stdio transport.\n *\n * MCP's stdio transport frames every message as exactly one line of JSON on\n * standard input or output, so this module is pure line-shaped codec: no\n * process, no scheduling, no retry policy. {@link StdioTransport} owns those.\n *\n * @since 1.0.0-rc.0\n */\n\n/**\n * A JSON-RPC call this client sends. Omitting `id` sends a notification, for\n * which the server never replies.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Outbound {\n  readonly jsonrpc: \"2.0\"\n  readonly id?: number | undefined\n  readonly method: string\n  readonly params?: unknown\n}\n\n/**\n * Any outbound wire message, including replies to server requests. A reply\n * preserves the server's exact id type rather than normalizing it as a\n * correlation id in the client's pending-request map.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type OutboundMessage = Outbound | {\n  readonly jsonrpc: \"2.0\"\n  readonly id: string | number\n  readonly result: unknown\n} | {\n  readonly jsonrpc: \"2.0\"\n  readonly id: string | number\n  readonly error: { readonly code: number; readonly message: string }\n}\n\n/**\n * A JSON object from server stdout that claims JSON-RPC by carrying its own\n * `jsonrpc` property. Validation happens after parsing so an incorrect version\n * cannot be mistaken for ordinary stdout noise.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Inbound {\n  readonly jsonrpc: unknown\n  readonly id?: unknown\n  readonly method?: unknown\n  readonly params?: unknown\n  readonly result?: unknown\n  readonly error?: unknown\n}\n\n/**\n * A validated JSON-RPC reply, normalized to the numeric request id this\n * client uses for correlation, or an error whose null id cannot be correlated.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Reply = {\n  readonly _tag: \"Result\"\n  readonly id: number\n  readonly result: unknown\n} | {\n  readonly _tag: \"Error\"\n  readonly id: number\n  readonly code: number\n  readonly message: string\n  readonly data: unknown\n} | {\n  readonly _tag: \"UncorrelatedError\"\n  readonly code: number\n  readonly message: string\n  readonly data: unknown\n} | {\n  readonly _tag: \"Malformed\"\n  readonly reason: string\n}\n\n/**\n * The transport-relevant classification of one parsed JSON-RPC object.\n * Server request ids belong to the opposite direction and must never be\n * looked up in the client's pending-request map.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Classification = { readonly _tag: \"Notification\" } | {\n  readonly _tag: \"Request\"\n  readonly id: string | number\n  readonly method: string\n  readonly params: unknown\n} | Reply\n\nconst encoder = new TextEncoder()\n\n/**\n * Encodes one outbound message as a newline-terminated UTF-8 frame.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const encode = (message: OutboundMessage): Uint8Array => encoder.encode(`${JSON.stringify(message)}\\n`)\n\n/**\n * Parses one line of server output. A blank line, invalid JSON, a non-object,\n * or an object with no own `jsonrpc` property returns `undefined`. MCP servers\n * commonly log to stdout, so output that does not claim to be JSON-RPC is\n * noise rather than a protocol violation. Tagged objects are preserved for\n * {@link classify}, including objects that claim the wrong version.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const parse = (line: string): Inbound | undefined => {\n  const trimmed = line.trim()\n  if (trimmed === \"\") return undefined\n  let value: unknown\n  try {\n    value = JSON.parse(trimmed)\n  } catch {\n    return undefined\n  }\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) return undefined\n  if (!Object.hasOwn(value, \"jsonrpc\")) return undefined\n  return value as Inbound\n}\n\nconst malformed = (reason: string): Reply => ({ _tag: \"Malformed\", reason })\n\n/**\n * Validates and normalizes a parsed inbound object as a reply.\n *\n * Digit-string ids are accepted only in their canonical ASCII decimal form,\n * then converted back to the safe integer id used by the pending-request map.\n * A reply must carry an own id and exactly one own `result` or `error`\n * property. A null id is accepted only for a valid error, which cannot settle\n * any particular request.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const replyOf = (message: Inbound): Reply => {\n  if (!Object.hasOwn(message, \"id\")) return malformed(\"a reply carried no id\")\n  const rawId = message.id\n  const id = typeof rawId === \"number\"\n    ? rawId\n    : typeof rawId === \"string\" && /^(0|[1-9][0-9]*)$/.test(rawId)\n    ? Number(rawId)\n    : Number.NaN\n  if (rawId !== null && !Number.isSafeInteger(id)) return malformed(\"a reply id must be a JSON-RPC integer\")\n\n  const hasResult = Object.hasOwn(message, \"result\")\n  const hasError = Object.hasOwn(message, \"error\")\n  if (!hasResult && !hasError) return malformed(\"a reply carried neither result nor error\")\n  if (hasResult && hasError) return malformed(\"a reply carried both result and error\")\n  if (hasResult) {\n    if (rawId === null) return malformed(\"a reply id must be a JSON-RPC integer\")\n    return { _tag: \"Result\", id, result: message.result }\n  }\n\n  const error = message.error\n  if (\n    typeof error !== \"object\" || error === null || Array.isArray(error) ||\n    !Number.isInteger((error as { readonly code?: unknown }).code) ||\n    typeof (error as { readonly message?: unknown }).message !== \"string\"\n  ) {\n    return malformed(\"a reply carried a malformed error object\")\n  }\n  const record = error as { readonly code: number; readonly message: string; readonly data?: unknown }\n  if (rawId === null) {\n    return { _tag: \"UncorrelatedError\", code: record.code, message: record.message, data: record.data }\n  }\n  return {\n    _tag: \"Error\",\n    id,\n    code: record.code,\n    message: record.message,\n    data: record.data\n  }\n}\n\n/**\n * Classifies a parsed JSON-RPC object for the stdio reader. A wrong version is\n * malformed; a valid own `method` with an own id is a server request, without\n * an id a notification. Every remaining object must satisfy {@link replyOf}.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const classify = (message: Inbound): Classification => {\n  if (message.jsonrpc !== \"2.0\") {\n    return malformed(\"a JSON-RPC message must carry jsonrpc \\\"2.0\\\"\")\n  }\n  if (Object.hasOwn(message, \"method\")) {\n    if (typeof message.method !== \"string\") return malformed(\"a method must be a string\")\n    if (Object.hasOwn(message, \"result\") || Object.hasOwn(message, \"error\")) {\n      return malformed(\"a method-bearing message cannot also carry result or error\")\n    }\n    if (\n      Object.hasOwn(message, \"params\") &&\n      (typeof message.params !== \"object\" || message.params === null || Array.isArray(message.params))\n    ) return malformed(\"MCP method params must be an object\")\n    if (!Object.hasOwn(message, \"id\")) return { _tag: \"Notification\" }\n    const id = message.id\n    if (typeof id !== \"string\" && (typeof id !== \"number\" || !Number.isSafeInteger(id))) {\n      return malformed(\"a server request id must be a string or safe integer\")\n    }\n    return { _tag: \"Request\", id, method: message.method, params: message.params }\n  }\n  return replyOf(message)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/StdioTransport.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Newline-delimited JSON-RPC transport over a spawned MCP server's stdio.
+ *
+ * This module owns exactly the connection lifecycle and request/reply
+ * correlation an MCP session needs: spawn once, write frames in, read frames
+ * out, match replies to the request that asked for them. It knows nothing
+ * about `initialize`, `tools/list`, or `tools/call`. It answers the protocol's
+ * liveness `ping` with an empty result, and unsupported server requests with
+ * method-not-found. {@link McpClient} owns feature negotiation and tool calls.
+ *
+ * Server-initiated notifications are received and dropped. A future caller
+ * that needs `notifications/*` (for example a progress stream) is the reason
+ * to add a subscription surface here rather than threading one more parameter
+ * through every constructor now.
+ *
+ * @since 1.0.0-rc.0
+ */
+import { Effect } from "effect";
+import type { Scope } from "effect";
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { McpError } from "../McpError.ts";
+import * as Transport from "./Transport.ts";
+/**
+ * Options accepted by {@link connect}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface ConnectOptions {
+    /** The name this server is known by, for error messages only. */
+    readonly server: string;
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+    readonly cwd?: string | undefined;
+    /** Values merged into the bootstrap allowlist rather than the full host environment. */
+    readonly env?: Record<string, string | undefined> | undefined;
+    /** Default deadline for a request/reply exchange. See {@link Transport.defaultRequestTimeoutMs}. */
+    readonly requestTimeoutMs?: number | undefined;
+    /** Maximum number of frames waiting to be written. See {@link defaultQueueCapacity}. */
+    readonly queueCapacity?: number | undefined;
+    /** Maximum UTF-8 bytes accepted in one inbound JSON-RPC frame. See {@link Transport.defaultMaxFrameBytes}. */
+    readonly maxFrameBytes?: number | undefined;
+    /** Maximum UTF-8 bytes emitted in one JSON-RPC frame. See {@link Transport.defaultMaxOutboundFrameBytes}. */
+    readonly maxOutboundFrameBytes?: number | undefined;
+    /** Maximum diagnostic stderr bytes retained in memory. See {@link defaultMaxStderrBytes}. */
+    readonly maxStderrBytes?: number | undefined;
+}
+/**
+ * Default number of outbound frames allowed to wait in memory.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultQueueCapacity = 64;
+/**
+ * Default maximum child-stderr tail retained for connection diagnostics.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultMaxStderrBytes = 2048;
+/**
+ * Spawns an MCP server over stdio and returns a live {@link Transport}.
+ *
+ * The connection is scoped: the writer and reader loops are daemon fibers
+ * forked into the calling scope, and closing that scope tears the process
+ * down with it. Every request pending when the connection closes fails with
+ * `connection_closed` instead of hanging forever.
+ *
+ * Stdout that does not claim JSON-RPC is ignored because servers commonly log
+ * there. Once an object carries its own `jsonrpc` property, a malformed version
+ * or reply closes the connection with `protocol_error`.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const connect: (options: ConnectOptions) => Effect.Effect<Transport.Transport, McpError, ChildProcessSpawner | Scope.Scope>;
+//# sourceMappingURL=StdioTransport.d.ts.map

package/dist/cjs/internal/StdioTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StdioTransport.d.ts","sourceRoot":"","sources":["../../../src/internal/StdioTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EAAY,MAAM,EAAoD,MAAM,QAAQ,CAAA;AAC3F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAEnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAA;AACtF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAKzC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAuD3C;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACpC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,wFAAwF;IACxF,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAA;IAC7D,oGAAoG;IACpG,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9C,wFAAwF;IACxF,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3C,8GAA8G;IAC9G,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3C,6GAA6G;IAC7G,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnD,6FAA6F;IAC7F,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC7C;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAsCzC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO,GAClB,SAAS,cAAc,KACtB,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,mBAAmB,GAAG,KAAK,CAAC,KAAK,CAuT7E,CAAA"}