@effect-uai/mcp 0.12.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Betalyra Sociedade Unipessoal Lda.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/Client.d.mts

@@ -0,0 +1,55 @@
+import { i as McpError } from "./McpError-DWg9BlW5.mjs";
+import { n as TokenSource, t as Auth } from "./auth-ZDvsxpCo.mjs";
+import { C as ProtocolVersion, D as ToolInfo, T as ServerInfo, o as CallToolResult } from "./schema-D2oUNuo5.mjs";
+import { Context, Effect, Layer, Scope } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { ChildProcessSpawner } from "effect/unstable/process";
+declare namespace Client_d_exports {
+  export { Auth, Mcp, McpClient, McpClientConfig, McpRequirements, McpServerInfo, ProtocolPin, TokenSource, connect, layer };
+}
+/** `auto` runs the probe; a pinned version skips detection. */
+type ProtocolPin = "auto" | ProtocolVersion;
+type McpClientConfig = {
+  readonly transport: "http";
+  readonly url: string;
+  /** Static, non-auth headers sent on every request. */
+  readonly headers?: Record<string, string>;
+  /** Omit for a public server. See `Auth` for the three shapes. */
+  readonly auth?: Auth;
+  readonly protocol?: ProtocolPin;
+} | {
+  readonly transport: "stdio";
+  readonly command: string;
+  readonly args?: ReadonlyArray<string>;
+  readonly env?: Record<string, string>;
+  readonly cwd?: string;
+  readonly protocol?: ProtocolPin;
+};
+/**
+ * Services a client needs, by transport. Both are listed because the config is
+ * a runtime value: an app that only uses one still provides the other's layer,
+ * which is cheap (`FetchHttpClient.layer` / `NodeServices.layer`).
+ */
+type McpRequirements = HttpClient.HttpClient | ChildProcessSpawner.ChildProcessSpawner;
+type McpServerInfo = ServerInfo & {
+  /** The negotiated protocol version: the only era signal callers need. */
+  readonly protocolVersion: ProtocolVersion;
+};
+type McpClient = {
+  readonly listTools: Effect.Effect<ReadonlyArray<ToolInfo>, McpError>;
+  readonly callTool: (name: string, args: unknown) => Effect.Effect<CallToolResult, McpError>;
+  readonly serverInfo: McpServerInfo;
+};
+/**
+ * Open a scoped client. The connection lives exactly as long as the enclosing
+ * scope, so `Effect.scoped`, a `Layer`, or `Stream.scoped` all give correct
+ * teardown with no explicit close.
+ */
+declare const connect: (config: McpClientConfig) => Effect.Effect<McpClient, McpError, Scope.Scope | McpRequirements>;
+declare const Mcp_base: Context.ServiceClass<Mcp, "@betalyra/effect-uai/providers/mcp/Mcp", McpClient>;
+declare class Mcp extends Mcp_base {}
+/** DI convenience for the single-server app: connects when the layer builds. */
+declare const layer: (config: McpClientConfig) => Layer.Layer<Mcp, McpError, McpRequirements>;
+//#endregion
+export { Auth, Mcp, McpClient, McpClientConfig, McpRequirements, McpServerInfo, ProtocolPin, type TokenSource, connect, layer, Client_d_exports as t };
+//# sourceMappingURL=Client.d.mts.map

package/dist/Client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Client.d.mts","names":[],"sources":["../src/Client.ts"],"mappings":";;;;;;;;;;KA8BY,uBAAuB;KAEvB;WAEG;WACA;;WAEA,UAAU;;WAEV,OAAO;WACP,WAAW;;WAGX;WACA;WACA,OAAO;WACP,MAAM;WACN;WACA,WAAW;;;;;;;KAQd,kBAAkB,WAAW,aAAa,oBAAoB;KAE9D,gBAAgB;;WAEjB,iBAAiB;;KAGhB;WACD,WAAW,OAAO,OAAO,cAAc,WAAW;WAClD,WAAW,cAAc,kBAAkB,OAAO,OAAO,gBAAgB;WACzE,YAAY;;;;;;;cA8EV,UAAO,QACV,oBACP,OAAO,OAAO,WAAW,UAAU,MAAM,QAAQ;;cA2BvC,YAAY;;cAKZ,QAAK,QAAY,oBAAkB,MAAM,MAAM,KAAK,UAAU"}

package/dist/Client.mjs

@@ -0,0 +1,85 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { McpConnectFailed, McpProtocolError } from "./McpError.mjs";
+import { Auth } from "./internal/auth.mjs";
+import { decodeCallToolResult, decodeListToolsResult } from "./internal/schema.mjs";
+import { probe } from "./internal/protocols/2025-06-18.mjs";
+import { probe as probe$1 } from "./internal/protocols/2026-07-28.mjs";
+import { open } from "./internal/rpc.mjs";
+import { make } from "./internal/httpTransport.mjs";
+import { make as make$1 } from "./internal/stdioTransport.mjs";
+import { Context, Effect, Layer, Option, Ref } from "effect";
+//#region src/Client.ts
+/**
+* `connect` opens a scoped MCP client: transport -> rpc core -> protocol probe.
+* The protocol era is a property of the server, so it is negotiated once here
+* and fixed for the connection's lifetime. The client surface is era-uniform.
+*/
+var Client_exports = /* @__PURE__ */ __exportAll({
+	Auth: () => Auth,
+	Mcp: () => Mcp,
+	connect: () => connect,
+	layer: () => layer
+});
+const undecodable = (method, detail, raw) => new McpProtocolError({
+	method,
+	reason: `undecodable ${method} result${detail}`,
+	raw
+});
+const makeClient = (connection, protocol) => {
+	const request = (method, params) => connection.request(method, protocol.envelope(method, params), protocol.meta(method, params));
+	return {
+		listTools: request("tools/list", {}).pipe(Effect.flatMap((raw) => decodeListToolsResult(raw).pipe(Effect.mapError(() => undecodable("tools/list", "", raw)), Effect.map((result) => result.tools)))),
+		callTool: (name, args) => request("tools/call", {
+			name,
+			arguments: args ?? {}
+		}).pipe(Effect.flatMap((raw) => decodeCallToolResult(raw).pipe(Effect.mapError(() => undecodable("tools/call", ` for ${name}`, raw))))),
+		serverInfo: {
+			...protocol.serverInfo,
+			protocolVersion: protocol.version
+		}
+	};
+};
+/**
+* Try the stateless protocol first, then the handshake era. The stateless
+* probe yields `None` only when the server proves it is not stateless (an
+* error that is not one of the recognized modern codes), which is exactly the
+* spec's era discriminator. A pinned `protocol` skips detection.
+*
+* The result is cached for the connection's lifetime by the caller: era is a
+* property of the server, not of a request.
+*/
+const negotiate = (connection, pin) => {
+	if (pin === "2026-07-28") return required(probe$1(connection));
+	if (pin !== "auto") return required(probe(connection));
+	return probe$1(connection).pipe(Effect.flatMap(Option.match({
+		onNone: () => required(probe(connection)),
+		onSome: Effect.succeed
+	})));
+};
+const required = (probe) => probe.pipe(Effect.flatMap(Option.match({
+	onNone: () => Effect.fail(new McpConnectFailed({ reason: "the server does not speak a supported MCP protocol" })),
+	onSome: Effect.succeed
+})));
+/**
+* Open a scoped client. The connection lives exactly as long as the enclosing
+* scope, so `Effect.scoped`, a `Layer`, or `Stream.scoped` all give correct
+* teardown with no explicit close.
+*/
+const connect = (config) => Effect.gen(function* () {
+	const transport = yield* config.transport === "http" ? make(config) : make$1(config);
+	const protocolRef = yield* Ref.make(Option.none());
+	const connection = yield* open(transport, (inbound) => Ref.get(protocolRef).pipe(Effect.flatMap(Option.match({
+		onNone: () => Effect.void,
+		onSome: (protocol) => protocol.onInbound(inbound)
+	}))));
+	const protocol = yield* negotiate(connection, config.protocol ?? "auto");
+	yield* Ref.set(protocolRef, Option.some(protocol));
+	return makeClient(connection, protocol);
+});
+var Mcp = class extends Context.Service()("@betalyra/effect-uai/providers/mcp/Mcp") {};
+/** DI convenience for the single-server app: connects when the layer builds. */
+const layer = (config) => Layer.effect(Mcp, connect(config));
+//#endregion
+export { Auth, Mcp, connect, layer, Client_exports as t };
+
+//# sourceMappingURL=Client.mjs.map

package/dist/Client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Client.mjs","names":["Stateless.probe","Handshake.probe","HttpTransport.make","StdioTransport.make"],"sources":["../src/Client.ts"],"sourcesContent":["/**\n * `connect` opens a scoped MCP client: transport -> rpc core -> protocol probe.\n * The protocol era is a property of the server, so it is negotiated once here\n * and fixed for the connection's lifetime. The client surface is era-uniform.\n */\nimport { Context, Effect, Layer, Option, Ref, type Scope } from \"effect\"\nimport type { HttpClient } from \"effect/unstable/http\"\nimport type { ChildProcessSpawner } from \"effect/unstable/process\"\nimport { McpConnectFailed, type McpError, McpProtocolError } from \"./McpError.js\"\nimport { Auth, type TokenSource } from \"./internal/auth.js\"\nimport * as Handshake from \"./internal/protocols/2025-06-18.js\"\nimport * as Stateless from \"./internal/protocols/2026-07-28.js\"\nimport type { Protocol } from \"./internal/protocol.js\"\nimport { type McpConnection, open } from \"./internal/rpc.js\"\nimport {\n  type CallToolResult,\n  decodeCallToolResult,\n  decodeListToolsResult,\n  LATEST_VERSION,\n  type McpMethod,\n  type ProtocolVersion,\n  type ServerInfo,\n  type ToolInfo,\n} from \"./internal/schema.js\"\nimport * as HttpTransport from \"./internal/httpTransport.js\"\nimport * as StdioTransport from \"./internal/stdioTransport.js\"\n\nexport { Auth, type TokenSource }\n\n/** `auto` runs the probe; a pinned version skips detection. */\nexport type ProtocolPin = \"auto\" | ProtocolVersion\n\nexport type McpClientConfig =\n  | {\n      readonly transport: \"http\"\n      readonly url: string\n      /** Static, non-auth headers sent on every request. */\n      readonly headers?: Record<string, string>\n      /** Omit for a public server. See `Auth` for the three shapes. */\n      readonly auth?: Auth\n      readonly protocol?: ProtocolPin\n    }\n  | {\n      readonly transport: \"stdio\"\n      readonly command: string\n      readonly args?: ReadonlyArray<string>\n      readonly env?: Record<string, string>\n      readonly cwd?: string\n      readonly protocol?: ProtocolPin\n    }\n\n/**\n * Services a client needs, by transport. Both are listed because the config is\n * a runtime value: an app that only uses one still provides the other's layer,\n * which is cheap (`FetchHttpClient.layer` / `NodeServices.layer`).\n */\nexport type McpRequirements = HttpClient.HttpClient | ChildProcessSpawner.ChildProcessSpawner\n\nexport type McpServerInfo = ServerInfo & {\n  /** The negotiated protocol version: the only era signal callers need. */\n  readonly protocolVersion: ProtocolVersion\n}\n\nexport type McpClient = {\n  readonly listTools: Effect.Effect<ReadonlyArray<ToolInfo>, McpError>\n  readonly callTool: (name: string, args: unknown) => Effect.Effect<CallToolResult, McpError>\n  readonly serverInfo: McpServerInfo\n}\n\nconst undecodable = (method: McpMethod, detail: string, raw: unknown): McpError =>\n  new McpProtocolError({ method, reason: `undecodable ${method} result${detail}`, raw })\n\nconst makeClient = (connection: McpConnection, protocol: Protocol): McpClient => {\n  const request = (method: McpMethod, params: unknown) =>\n    connection.request(method, protocol.envelope(method, params), protocol.meta(method, params))\n\n  return {\n    listTools: request(\"tools/list\", {}).pipe(\n      Effect.flatMap((raw) =>\n        decodeListToolsResult(raw).pipe(\n          Effect.mapError(() => undecodable(\"tools/list\", \"\", raw)),\n          Effect.map((result) => result.tools),\n        ),\n      ),\n    ),\n\n    callTool: (name, args) =>\n      request(\"tools/call\", { name, arguments: args ?? {} }).pipe(\n        Effect.flatMap((raw) =>\n          decodeCallToolResult(raw).pipe(\n            Effect.mapError(() => undecodable(\"tools/call\", ` for ${name}`, raw)),\n          ),\n        ),\n      ),\n\n    serverInfo: { ...protocol.serverInfo, protocolVersion: protocol.version },\n  }\n}\n\n/**\n * Try the stateless protocol first, then the handshake era. The stateless\n * probe yields `None` only when the server proves it is not stateless (an\n * error that is not one of the recognized modern codes), which is exactly the\n * spec's era discriminator. A pinned `protocol` skips detection.\n *\n * The result is cached for the connection's lifetime by the caller: era is a\n * property of the server, not of a request.\n */\nconst negotiate = (\n  connection: McpConnection,\n  pin: ProtocolPin,\n): Effect.Effect<Protocol, McpError, Scope.Scope> => {\n  if (pin === LATEST_VERSION) return required(Stateless.probe(connection))\n  if (pin !== \"auto\") return required(Handshake.probe(connection))\n  return Stateless.probe(connection).pipe(\n    Effect.flatMap(\n      Option.match({\n        onNone: () => required(Handshake.probe(connection)),\n        onSome: Effect.succeed<Protocol>,\n      }),\n    ),\n  )\n}\n\nconst required = (\n  probe: Effect.Effect<Option.Option<Protocol>, McpError, Scope.Scope>,\n): Effect.Effect<Protocol, McpError, Scope.Scope> =>\n  probe.pipe(\n    Effect.flatMap(\n      Option.match({\n        onNone: () =>\n          Effect.fail(\n            new McpConnectFailed({ reason: \"the server does not speak a supported MCP protocol\" }),\n          ),\n        onSome: Effect.succeed<Protocol>,\n      }),\n    ),\n  )\n\n/**\n * Open a scoped client. The connection lives exactly as long as the enclosing\n * scope, so `Effect.scoped`, a `Layer`, or `Stream.scoped` all give correct\n * teardown with no explicit close.\n */\nexport const connect = (\n  config: McpClientConfig,\n): Effect.Effect<McpClient, McpError, Scope.Scope | McpRequirements> =>\n  Effect.gen(function* () {\n    const transport = yield* config.transport === \"http\"\n      ? HttpTransport.make(config)\n      : StdioTransport.make(config)\n\n    // Inbound handling belongs to the protocol, which is not chosen until the\n    // probe completes, so the reader reads it from a Ref that starts empty.\n    // Frames arriving before then can only be legacy noise; ignore them.\n    const protocolRef = yield* Ref.make(Option.none<Protocol>())\n    const connection = yield* open(transport, (inbound) =>\n      Ref.get(protocolRef).pipe(\n        Effect.flatMap(\n          Option.match({\n            onNone: () => Effect.void,\n            onSome: (protocol) => protocol.onInbound(inbound),\n          }),\n        ),\n      ),\n    )\n\n    const protocol = yield* negotiate(connection, config.protocol ?? \"auto\")\n    yield* Ref.set(protocolRef, Option.some(protocol))\n\n    return makeClient(connection, protocol)\n  })\n\nexport class Mcp extends Context.Service<Mcp, McpClient>()(\n  \"@betalyra/effect-uai/providers/mcp/Mcp\",\n) {}\n\n/** DI convenience for the single-server app: connects when the layer builds. */\nexport const layer = (config: McpClientConfig): Layer.Layer<Mcp, McpError, McpRequirements> =>\n  Layer.effect(Mcp, connect(config))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqEA,MAAM,eAAe,QAAmB,QAAgB,QACtD,IAAI,iBAAiB;CAAE;CAAQ,QAAQ,eAAe,OAAO,SAAS;CAAU;AAAI,CAAC;AAEvF,MAAM,cAAc,YAA2B,aAAkC;CAC/E,MAAM,WAAW,QAAmB,WAClC,WAAW,QAAQ,QAAQ,SAAS,SAAS,QAAQ,MAAM,GAAG,SAAS,KAAK,QAAQ,MAAM,CAAC;CAE7F,OAAO;EACL,WAAW,QAAQ,cAAc,CAAC,CAAC,CAAC,CAAC,KACnC,OAAO,SAAS,QACd,sBAAsB,GAAG,CAAC,CAAC,KACzB,OAAO,eAAe,YAAY,cAAc,IAAI,GAAG,CAAC,GACxD,OAAO,KAAK,WAAW,OAAO,KAAK,CACrC,CACF,CACF;EAEA,WAAW,MAAM,SACf,QAAQ,cAAc;GAAE;GAAM,WAAW,QAAQ,CAAC;EAAE,CAAC,CAAC,CAAC,KACrD,OAAO,SAAS,QACd,qBAAqB,GAAG,CAAC,CAAC,KACxB,OAAO,eAAe,YAAY,cAAc,QAAQ,QAAQ,GAAG,CAAC,CACtE,CACF,CACF;EAEF,YAAY;GAAE,GAAG,SAAS;GAAY,iBAAiB,SAAS;EAAQ;CAC1E;AACF;;;;;;;;;;AAWA,MAAM,aACJ,YACA,QACmD;CACnD,IAAI,QAAA,cAAwB,OAAO,SAASA,QAAgB,UAAU,CAAC;CACvE,IAAI,QAAQ,QAAQ,OAAO,SAASC,MAAgB,UAAU,CAAC;CAC/D,OAAOD,QAAgB,UAAU,CAAC,CAAC,KACjC,OAAO,QACL,OAAO,MAAM;EACX,cAAc,SAASC,MAAgB,UAAU,CAAC;EAClD,QAAQ,OAAO;CACjB,CAAC,CACH,CACF;AACF;AAEA,MAAM,YACJ,UAEA,MAAM,KACJ,OAAO,QACL,OAAO,MAAM;CACX,cACE,OAAO,KACL,IAAI,iBAAiB,EAAE,QAAQ,qDAAqD,CAAC,CACvF;CACF,QAAQ,OAAO;AACjB,CAAC,CACH,CACF;;;;;;AAOF,MAAa,WACX,WAEA,OAAO,IAAI,aAAa;CACtB,MAAM,YAAY,OAAO,OAAO,cAAc,SAC1CC,KAAmB,MAAM,IACzBC,OAAoB,MAAM;CAK9B,MAAM,cAAc,OAAO,IAAI,KAAK,OAAO,KAAe,CAAC;CAC3D,MAAM,aAAa,OAAO,KAAK,YAAY,YACzC,IAAI,IAAI,WAAW,CAAC,CAAC,KACnB,OAAO,QACL,OAAO,MAAM;EACX,cAAc,OAAO;EACrB,SAAS,aAAa,SAAS,UAAU,OAAO;CAClD,CAAC,CACH,CACF,CACF;CAEA,MAAM,WAAW,OAAO,UAAU,YAAY,OAAO,YAAY,MAAM;CACvE,OAAO,IAAI,IAAI,aAAa,OAAO,KAAK,QAAQ,CAAC;CAEjD,OAAO,WAAW,YAAY,QAAQ;AACxC,CAAC;AAEH,IAAa,MAAb,cAAyB,QAAQ,QAAwB,CAAC,CACxD,wCACF,CAAC,CAAC,CAAC;;AAGH,MAAa,SAAS,WACpB,MAAM,OAAO,KAAK,QAAQ,MAAM,CAAC"}

package/dist/McpError-DWg9BlW5.d.mts

@@ -0,0 +1,83 @@
+declare namespace McpError_d_exports {
+  export { McpAuthError, McpAuthRequired, McpConnectFailed, McpError, McpProtocolError, McpTransportClosed, McpUnsupportedProtocol, describe };
+}
+declare const McpConnectFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "McpConnectFailed";
+} & Readonly<A>;
+/**
+ * Transport could not establish: DNS / TLS / non-2xx on the first request,
+ * a failed spawn, or a failed era probe. The raw transport error on `raw`.
+ */
+declare class McpConnectFailed extends McpConnectFailed_base<{
+  reason?: string;
+  raw?: unknown;
+}> {}
+declare const McpUnsupportedProtocol_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "McpUnsupportedProtocol";
+} & Readonly<A>;
+/**
+ * Negotiation ended on a protocol version this client does not support
+ * (e.g. a 2025-03-26-only server, or a modern server whose `supported`
+ * list has no mutual version). `offered` is what the server proposed.
+ */
+declare class McpUnsupportedProtocol extends McpUnsupportedProtocol_base<{
+  offered: ReadonlyArray<string>;
+  reason?: string;
+}> {}
+declare const McpProtocolError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "McpProtocolError";
+} & Readonly<A>;
+/**
+ * A JSON-RPC error reply (carrying its `code`), a reply that failed to
+ * decode, or an unsupported protocol feature (v1 fails `input_required`
+ * results here). `method` names the request that was in flight.
+ */
+declare class McpProtocolError extends McpProtocolError_base<{
+  method?: string;
+  code?: number;
+  reason?: string;
+  raw?: unknown;
+}> {}
+declare const McpTransportClosed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "McpTransportClosed";
+} & Readonly<A>;
+/**
+ * The connection dropped with a request in flight, or a legacy session
+ * expired (HTTP 404 on a known `Mcp-Session-Id`). Not resumable; the
+ * remedy is reconnecting and re-issuing the request.
+ */
+declare class McpTransportClosed extends McpTransportClosed_base<{
+  method?: string;
+  reason?: string;
+  raw?: unknown;
+}> {}
+declare const McpAuthRequired_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "McpAuthRequired";
+} & Readonly<A>;
+/**
+ * The server answered `401`. `resourceMetadataUrl` is the RFC 9728
+ * Protected Resource Metadata pointer parsed from `WWW-Authenticate`,
+ * when present; an OAuth layer starts discovery there.
+ */
+declare class McpAuthRequired extends McpAuthRequired_base<{
+  resourceMetadataUrl?: string;
+  wwwAuthenticate?: string;
+}> {}
+declare const McpAuthError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "McpAuthError";
+} & Readonly<A>;
+/** A `TokenSource` / OAuth grant failed to mint or refresh a token. */
+declare class McpAuthError extends McpAuthError_base<{
+  reason?: string;
+  raw?: unknown;
+}> {}
+type McpError = McpConnectFailed | McpUnsupportedProtocol | McpProtocolError | McpTransportClosed | McpAuthRequired | McpAuthError;
+/**
+ * Short human-readable description of an error, for logs and model-facing
+ * failure messages (`Toolkit.describeFailures(McpError.describe)`). Prose,
+ * not a contract; branch on `_tag` instead.
+ */
+declare const describe: (e: McpError) => string;
+//#endregion
+export { McpError_d_exports as a, McpUnsupportedProtocol as c, McpError as i, describe as l, McpAuthRequired as n, McpProtocolError as o, McpConnectFailed as r, McpTransportClosed as s, McpAuthError as t };
+//# sourceMappingURL=McpError-DWg9BlW5.d.mts.map

package/dist/McpError-DWg9BlW5.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"McpError-DWg9BlW5.d.mts","names":[],"sources":["../src/McpError.ts"],"mappings":";;;;;;;;;;cAMa,yBAAyB;EACpC;EACA;;;;;;;;;;cAQW,+BAA+B;EAC1C,SAAS;EACT;;;;;;;;;;cAQW,yBAAyB;EACpC;EACA;EACA;EACA;;;;;;;;;;cAQW,2BAA2B;EACtC;EACA;EACA;;;;;;;;;;cAQW,wBAAwB;EACnC;EACA;;;;;;cAIW,qBAAqB;EAChC;EACA;;KAGU,WACR,mBACA,yBACA,mBACA,qBACA,kBACA;;;;;;cAUS,WAAW,GAAG"}

package/dist/McpError.d.mts

@@ -0,0 +1,2 @@
+import { c as McpUnsupportedProtocol, i as McpError, l as describe, n as McpAuthRequired, o as McpProtocolError, r as McpConnectFailed, s as McpTransportClosed, t as McpAuthError } from "./McpError-DWg9BlW5.mjs";
+export { McpAuthError, McpAuthRequired, McpConnectFailed, McpError, McpProtocolError, McpTransportClosed, McpUnsupportedProtocol, describe };

package/dist/McpError.mjs

@@ -0,0 +1,61 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Data, Match } from "effect";
+//#region src/McpError.ts
+var McpError_exports = /* @__PURE__ */ __exportAll({
+	McpAuthError: () => McpAuthError,
+	McpAuthRequired: () => McpAuthRequired,
+	McpConnectFailed: () => McpConnectFailed,
+	McpProtocolError: () => McpProtocolError,
+	McpTransportClosed: () => McpTransportClosed,
+	McpUnsupportedProtocol: () => McpUnsupportedProtocol,
+	describe: () => describe
+});
+/**
+* Transport could not establish: DNS / TLS / non-2xx on the first request,
+* a failed spawn, or a failed era probe. The raw transport error on `raw`.
+*/
+var McpConnectFailed = class extends Data.TaggedError("McpConnectFailed") {};
+/**
+* Negotiation ended on a protocol version this client does not support
+* (e.g. a 2025-03-26-only server, or a modern server whose `supported`
+* list has no mutual version). `offered` is what the server proposed.
+*/
+var McpUnsupportedProtocol = class extends Data.TaggedError("McpUnsupportedProtocol") {};
+/**
+* A JSON-RPC error reply (carrying its `code`), a reply that failed to
+* decode, or an unsupported protocol feature (v1 fails `input_required`
+* results here). `method` names the request that was in flight.
+*/
+var McpProtocolError = class extends Data.TaggedError("McpProtocolError") {};
+/**
+* The connection dropped with a request in flight, or a legacy session
+* expired (HTTP 404 on a known `Mcp-Session-Id`). Not resumable; the
+* remedy is reconnecting and re-issuing the request.
+*/
+var McpTransportClosed = class extends Data.TaggedError("McpTransportClosed") {};
+/**
+* The server answered `401`. `resourceMetadataUrl` is the RFC 9728
+* Protected Resource Metadata pointer parsed from `WWW-Authenticate`,
+* when present; an OAuth layer starts discovery there.
+*/
+var McpAuthRequired = class extends Data.TaggedError("McpAuthRequired") {};
+/** A `TokenSource` / OAuth grant failed to mint or refresh a token. */
+var McpAuthError = class extends Data.TaggedError("McpAuthError") {};
+const withReason = (base, reason) => reason === void 0 ? base : `${base}: ${reason}`;
+/**
+* Short human-readable description of an error, for logs and model-facing
+* failure messages (`Toolkit.describeFailures(McpError.describe)`). Prose,
+* not a contract; branch on `_tag` instead.
+*/
+const describe = Match.type().pipe(Match.discriminatorsExhaustive("_tag")({
+	McpConnectFailed: (e) => withReason("could not connect to the MCP server", e.reason),
+	McpUnsupportedProtocol: (e) => `the MCP server only offers unsupported protocol versions (${e.offered.join(", ")})`,
+	McpProtocolError: (e) => withReason(`the MCP server rejected ${e.method ?? "the request"}${e.code === void 0 ? "" : ` (${e.code})`}`, e.reason),
+	McpTransportClosed: (e) => withReason("the MCP connection closed", e.reason),
+	McpAuthRequired: () => "the MCP server requires authentication",
+	McpAuthError: (e) => withReason("MCP authentication failed", e.reason)
+}));
+//#endregion
+export { McpAuthError, McpAuthRequired, McpConnectFailed, McpProtocolError, McpTransportClosed, McpUnsupportedProtocol, describe, McpError_exports as t };
+
+//# sourceMappingURL=McpError.mjs.map

package/dist/McpError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"McpError.mjs","names":[],"sources":["../src/McpError.ts"],"sourcesContent":["import { Data, Match } from \"effect\"\n\n/**\n * Transport could not establish: DNS / TLS / non-2xx on the first request,\n * a failed spawn, or a failed era probe. The raw transport error on `raw`.\n */\nexport class McpConnectFailed extends Data.TaggedError(\"McpConnectFailed\")<{\n  reason?: string\n  raw?: unknown\n}> {}\n\n/**\n * Negotiation ended on a protocol version this client does not support\n * (e.g. a 2025-03-26-only server, or a modern server whose `supported`\n * list has no mutual version). `offered` is what the server proposed.\n */\nexport class McpUnsupportedProtocol extends Data.TaggedError(\"McpUnsupportedProtocol\")<{\n  offered: ReadonlyArray<string>\n  reason?: string\n}> {}\n\n/**\n * A JSON-RPC error reply (carrying its `code`), a reply that failed to\n * decode, or an unsupported protocol feature (v1 fails `input_required`\n * results here). `method` names the request that was in flight.\n */\nexport class McpProtocolError extends Data.TaggedError(\"McpProtocolError\")<{\n  method?: string\n  code?: number\n  reason?: string\n  raw?: unknown\n}> {}\n\n/**\n * The connection dropped with a request in flight, or a legacy session\n * expired (HTTP 404 on a known `Mcp-Session-Id`). Not resumable; the\n * remedy is reconnecting and re-issuing the request.\n */\nexport class McpTransportClosed extends Data.TaggedError(\"McpTransportClosed\")<{\n  method?: string\n  reason?: string\n  raw?: unknown\n}> {}\n\n/**\n * The server answered `401`. `resourceMetadataUrl` is the RFC 9728\n * Protected Resource Metadata pointer parsed from `WWW-Authenticate`,\n * when present; an OAuth layer starts discovery there.\n */\nexport class McpAuthRequired extends Data.TaggedError(\"McpAuthRequired\")<{\n  resourceMetadataUrl?: string\n  wwwAuthenticate?: string\n}> {}\n\n/** A `TokenSource` / OAuth grant failed to mint or refresh a token. */\nexport class McpAuthError extends Data.TaggedError(\"McpAuthError\")<{\n  reason?: string\n  raw?: unknown\n}> {}\n\nexport type McpError =\n  | McpConnectFailed\n  | McpUnsupportedProtocol\n  | McpProtocolError\n  | McpTransportClosed\n  | McpAuthRequired\n  | McpAuthError\n\nconst withReason = (base: string, reason: string | undefined): string =>\n  reason === undefined ? base : `${base}: ${reason}`\n\n/**\n * Short human-readable description of an error, for logs and model-facing\n * failure messages (`Toolkit.describeFailures(McpError.describe)`). Prose,\n * not a contract; branch on `_tag` instead.\n */\nexport const describe: (e: McpError) => string = Match.type<McpError>().pipe(\n  Match.discriminatorsExhaustive(\"_tag\")({\n    McpConnectFailed: (e) => withReason(\"could not connect to the MCP server\", e.reason),\n    McpUnsupportedProtocol: (e) =>\n      `the MCP server only offers unsupported protocol versions (${e.offered.join(\", \")})`,\n    McpProtocolError: (e) =>\n      withReason(\n        `the MCP server rejected ${e.method ?? \"the request\"}${\n          e.code === undefined ? \"\" : ` (${e.code})`\n        }`,\n        e.reason,\n      ),\n    McpTransportClosed: (e) => withReason(\"the MCP connection closed\", e.reason),\n    McpAuthRequired: () => \"the MCP server requires authentication\",\n    McpAuthError: (e) => withReason(\"MCP authentication failed\", e.reason),\n  }),\n)\n"],"mappings":";;;;;;;;;;;;;;;;AAMA,IAAa,mBAAb,cAAsC,KAAK,YAAY,kBAAkB,CAAC,CAGvE,CAAC;;;;;;AAOJ,IAAa,yBAAb,cAA4C,KAAK,YAAY,wBAAwB,CAAC,CAGnF,CAAC;;;;;;AAOJ,IAAa,mBAAb,cAAsC,KAAK,YAAY,kBAAkB,CAAC,CAKvE,CAAC;;;;;;AAOJ,IAAa,qBAAb,cAAwC,KAAK,YAAY,oBAAoB,CAAC,CAI3E,CAAC;;;;;;AAOJ,IAAa,kBAAb,cAAqC,KAAK,YAAY,iBAAiB,CAAC,CAGrE,CAAC;;AAGJ,IAAa,eAAb,cAAkC,KAAK,YAAY,cAAc,CAAC,CAG/D,CAAC;AAUJ,MAAM,cAAc,MAAc,WAChC,WAAW,KAAA,IAAY,OAAO,GAAG,KAAK,IAAI;;;;;;AAO5C,MAAa,WAAoC,MAAM,KAAe,CAAC,CAAC,KACtE,MAAM,yBAAyB,MAAM,CAAC,CAAC;CACrC,mBAAmB,MAAM,WAAW,uCAAuC,EAAE,MAAM;CACnF,yBAAyB,MACvB,6DAA6D,EAAE,QAAQ,KAAK,IAAI,EAAE;CACpF,mBAAmB,MACjB,WACE,2BAA2B,EAAE,UAAU,gBACrC,EAAE,SAAS,KAAA,IAAY,KAAK,KAAK,EAAE,KAAK,MAE1C,EAAE,MACJ;CACF,qBAAqB,MAAM,WAAW,6BAA6B,EAAE,MAAM;CAC3E,uBAAuB;CACvB,eAAe,MAAM,WAAW,6BAA6B,EAAE,MAAM;AACvE,CAAC,CACH"}

package/dist/Toolkit.d.mts

@@ -0,0 +1,20 @@
+import { i as McpError } from "./McpError-DWg9BlW5.mjs";
+import { McpClient } from "./Client.mjs";
+import { Effect } from "effect";
+import * as CoreToolkit from "@effect-uai/core/Toolkit";
+declare namespace Toolkit_d_exports {
+  export { McpToolkitOptions, mcpToolkit };
+}
+type McpToolkitOptions = {
+  /** Namespace every tool as `<prefix>__<name>`; recommended when composing servers. */
+  readonly prefix?: string;
+};
+/**
+ * Build a `Toolkit` from the server's advertised tools. The list is snapshotted
+ * here; a tool that later vanishes surfaces through `Toolkit.run`'s graceful
+ * `unknown_tool` path.
+ */
+declare const mcpToolkit: (client: McpClient, options?: McpToolkitOptions) => Effect.Effect<CoreToolkit.Toolkit, McpError>;
+//#endregion
+export { McpToolkitOptions, mcpToolkit, Toolkit_d_exports as t };
+//# sourceMappingURL=Toolkit.d.mts.map

package/dist/Toolkit.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Toolkit.d.mts","names":[],"sources":["../src/Toolkit.ts"],"mappings":";;;;;;;KAiBY;;WAED;;;;;;;cA2EE,aAAU,QACb,WAAS,UACP,sBACT,OAAO,OAAO,YAAY,SAAS"}

package/dist/Toolkit.mjs

@@ -0,0 +1,70 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { McpProtocolError } from "./McpError.mjs";
+import { isTextContent } from "./internal/schema.mjs";
+import { Effect, Option } from "effect";
+import * as Tool from "@effect-uai/core/Tool";
+import * as CoreToolkit from "@effect-uai/core/Toolkit";
+//#region src/Toolkit.ts
+/**
+* Turn a connected MCP server into a core `Toolkit`, one `LocalTool` per MCP
+* tool. Effectful because the tool list is fetched; composes with
+* `Toolkit.compose` like any other kit.
+*/
+var Toolkit_exports = /* @__PURE__ */ __exportAll({ mcpToolkit: () => mcpToolkit });
+/**
+* The server owns validation, so the input schema is a passthrough: it carries
+* the server's JSON Schema verbatim (the model sees the real thing) and
+* accepts whatever the model produced. `strict: false` because server schemas
+* are not written to OpenAI strict rules.
+*/
+const passthroughSchema = (tool) => ({ "~standard": {
+	version: 1,
+	vendor: "effect-uai-mcp",
+	validate: (value) => ({ value }),
+	jsonSchema: {
+		input: () => tool.inputSchema,
+		output: () => ({ type: "object" })
+	}
+} });
+const textOf = (block) => isTextContent(block) ? block.text : `[${block.type} content omitted]`;
+/**
+* Serialize a successful result for the model: `structuredContent` when the
+* server provides it, otherwise the joined text blocks. Non-text blocks become
+* a short placeholder until the loop grows a multimodal tool-output path.
+*/
+const outputOf = (result) => result.structuredContent ?? (result.content ?? []).map(textOf).join("\n");
+/**
+* Two failure channels, deliberately: `isError` is the server telling the
+* model it went wrong, so it becomes a model-visible `ToolFailed`; an
+* `input_required` result is a protocol capability gap the model cannot fix,
+* so it stays a typed `McpError`.
+*/
+const interpret = (name, result) => {
+	if (result.isError === true) return Tool.fail(String(outputOf(result)), { kind: "tool_failed" });
+	if (result.resultType === "input_required") return Effect.fail(new McpProtocolError({
+		method: "tools/call",
+		reason: `${name} requires interactive input (MRTR), unsupported by this client`
+	}));
+	return Effect.succeed(outputOf(result));
+};
+const runTool = (client, name) => (input) => client.callTool(name, input).pipe(Effect.flatMap((result) => interpret(name, result)));
+const toLocalTool = (client, info) => Tool.make({
+	name: info.name,
+	description: info.description ?? info.name,
+	inputSchema: passthroughSchema(info),
+	run: runTool(client, info.name),
+	strict: false
+});
+/**
+* Build a `Toolkit` from the server's advertised tools. The list is snapshotted
+* here; a tool that later vanishes surfaces through `Toolkit.run`'s graceful
+* `unknown_tool` path.
+*/
+const mcpToolkit = (client, options) => client.listTools.pipe(Effect.map((tools) => CoreToolkit.fromArray(tools.map((info) => toLocalTool(client, info)))), Effect.map((kit) => Option.fromNullishOr(options?.prefix).pipe(Option.match({
+	onNone: () => kit,
+	onSome: (prefix) => CoreToolkit.namespace(prefix, kit)
+}))));
+//#endregion
+export { mcpToolkit, Toolkit_exports as t };
+
+//# sourceMappingURL=Toolkit.mjs.map

package/dist/Toolkit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Toolkit.mjs","names":[],"sources":["../src/Toolkit.ts"],"sourcesContent":["/**\n * Turn a connected MCP server into a core `Toolkit`, one `LocalTool` per MCP\n * tool. Effectful because the tool list is fetched; composes with\n * `Toolkit.compose` like any other kit.\n */\nimport { Effect, Option } from \"effect\"\nimport * as Tool from \"@effect-uai/core/Tool\"\nimport * as CoreToolkit from \"@effect-uai/core/Toolkit\"\nimport type { McpClient } from \"./Client.js\"\nimport { type McpError, McpProtocolError } from \"./McpError.js\"\nimport {\n  type CallToolResult,\n  type ContentBlock,\n  isTextContent,\n  type ToolInfo,\n} from \"./internal/schema.js\"\n\nexport type McpToolkitOptions = {\n  /** Namespace every tool as `<prefix>__<name>`; recommended when composing servers. */\n  readonly prefix?: string\n}\n\n/**\n * The server owns validation, so the input schema is a passthrough: it carries\n * the server's JSON Schema verbatim (the model sees the real thing) and\n * accepts whatever the model produced. `strict: false` because server schemas\n * are not written to OpenAI strict rules.\n */\nconst passthroughSchema = (tool: ToolInfo): Tool.ToolInputSchema<unknown> => ({\n  \"~standard\": {\n    version: 1,\n    vendor: \"effect-uai-mcp\",\n    validate: (value: unknown) => ({ value }),\n    jsonSchema: {\n      input: () => tool.inputSchema,\n      output: () => ({ type: \"object\" }),\n    },\n  },\n})\n\nconst textOf = (block: ContentBlock): string =>\n  isTextContent(block) ? block.text : `[${block.type} content omitted]`\n\n/**\n * Serialize a successful result for the model: `structuredContent` when the\n * server provides it, otherwise the joined text blocks. Non-text blocks become\n * a short placeholder until the loop grows a multimodal tool-output path.\n */\nconst outputOf = (result: CallToolResult): unknown =>\n  result.structuredContent ?? (result.content ?? []).map(textOf).join(\"\\n\")\n\n/**\n * Two failure channels, deliberately: `isError` is the server telling the\n * model it went wrong, so it becomes a model-visible `ToolFailed`; an\n * `input_required` result is a protocol capability gap the model cannot fix,\n * so it stays a typed `McpError`.\n */\nconst interpret = (\n  name: string,\n  result: CallToolResult,\n): Effect.Effect<unknown, McpError | Tool.ToolFailed> => {\n  if (result.isError === true) {\n    return Tool.fail(String(outputOf(result)), { kind: \"tool_failed\" })\n  }\n  if (result.resultType === \"input_required\") {\n    return Effect.fail(\n      new McpProtocolError({\n        method: \"tools/call\",\n        reason: `${name} requires interactive input (MRTR), unsupported by this client`,\n      }),\n    )\n  }\n  return Effect.succeed(outputOf(result))\n}\n\nconst runTool =\n  (client: McpClient, name: string) =>\n  (input: unknown): Effect.Effect<unknown, McpError | Tool.ToolFailed> =>\n    client.callTool(name, input).pipe(Effect.flatMap((result) => interpret(name, result)))\n\nconst toLocalTool = (client: McpClient, info: ToolInfo) =>\n  Tool.make({\n    name: info.name,\n    description: info.description ?? info.name,\n    inputSchema: passthroughSchema(info),\n    run: runTool(client, info.name),\n    strict: false,\n  })\n\n/**\n * Build a `Toolkit` from the server's advertised tools. The list is snapshotted\n * here; a tool that later vanishes surfaces through `Toolkit.run`'s graceful\n * `unknown_tool` path.\n */\nexport const mcpToolkit = (\n  client: McpClient,\n  options?: McpToolkitOptions,\n): Effect.Effect<CoreToolkit.Toolkit, McpError> =>\n  client.listTools.pipe(\n    Effect.map((tools) => CoreToolkit.fromArray(tools.map((info) => toLocalTool(client, info)))),\n    Effect.map((kit) =>\n      Option.fromNullishOr(options?.prefix).pipe(\n        Option.match({\n          onNone: () => kit,\n          onSome: (prefix) => CoreToolkit.namespace(prefix, kit),\n        }),\n      ),\n    ),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA4BA,MAAM,qBAAqB,UAAmD,EAC5E,aAAa;CACX,SAAS;CACT,QAAQ;CACR,WAAW,WAAoB,EAAE,MAAM;CACvC,YAAY;EACV,aAAa,KAAK;EAClB,eAAe,EAAE,MAAM,SAAS;CAClC;AACF,EACF;AAEA,MAAM,UAAU,UACd,cAAc,KAAK,IAAI,MAAM,OAAO,IAAI,MAAM,KAAK;;;;;;AAOrD,MAAM,YAAY,WAChB,OAAO,sBAAsB,OAAO,WAAW,CAAC,EAAA,CAAG,IAAI,MAAM,CAAC,CAAC,KAAK,IAAI;;;;;;;AAQ1E,MAAM,aACJ,MACA,WACuD;CACvD,IAAI,OAAO,YAAY,MACrB,OAAO,KAAK,KAAK,OAAO,SAAS,MAAM,CAAC,GAAG,EAAE,MAAM,cAAc,CAAC;CAEpE,IAAI,OAAO,eAAe,kBACxB,OAAO,OAAO,KACZ,IAAI,iBAAiB;EACnB,QAAQ;EACR,QAAQ,GAAG,KAAK;CAClB,CAAC,CACH;CAEF,OAAO,OAAO,QAAQ,SAAS,MAAM,CAAC;AACxC;AAEA,MAAM,WACH,QAAmB,UACnB,UACC,OAAO,SAAS,MAAM,KAAK,CAAC,CAAC,KAAK,OAAO,SAAS,WAAW,UAAU,MAAM,MAAM,CAAC,CAAC;AAEzF,MAAM,eAAe,QAAmB,SACtC,KAAK,KAAK;CACR,MAAM,KAAK;CACX,aAAa,KAAK,eAAe,KAAK;CACtC,aAAa,kBAAkB,IAAI;CACnC,KAAK,QAAQ,QAAQ,KAAK,IAAI;CAC9B,QAAQ;AACV,CAAC;;;;;;AAOH,MAAa,cACX,QACA,YAEA,OAAO,UAAU,KACf,OAAO,KAAK,UAAU,YAAY,UAAU,MAAM,KAAK,SAAS,YAAY,QAAQ,IAAI,CAAC,CAAC,CAAC,GAC3F,OAAO,KAAK,QACV,OAAO,cAAc,SAAS,MAAM,CAAC,CAAC,KACpC,OAAO,MAAM;CACX,cAAc;CACd,SAAS,WAAW,YAAY,UAAU,QAAQ,GAAG;AACvD,CAAC,CACH,CACF,CACF"}

package/dist/auth-ZDvsxpCo.d.mts

@@ -0,0 +1,126 @@
+import { t as McpAuthError } from "./McpError-DWg9BlW5.mjs";
+import { Data, Effect, Option, Redacted } from "effect";
+//#region src/internal/auth.d.ts
+/**
+ * An Effect yielding a bearer token. Any external OAuth, vault, or secret
+ * manager plugs in here. Read per request, so a producer minting expensive
+ * tokens caches internally (as `OAuth.clientCredentials` does).
+ */
+type TokenSource = Effect.Effect<Redacted.Redacted<string>, McpAuthError>;
+type Auth = Data.TaggedEnum<{
+  /** A fixed token: the turnkey case for a token-gated server. */
+  Static: {
+    readonly token: Redacted.Redacted<string>;
+    readonly scheme?: string;
+  };
+  /** Bring your own, re-read before every request. */
+  TokenSource: {
+    readonly token: TokenSource;
+    readonly scheme?: string;
+  };
+  /** Built-in OAuth 2.1, which produces a `TokenSource` and rides the same seam. */
+  OAuth: {
+    readonly source: TokenSource;
+    readonly scheme?: string;
+  };
+}>;
+declare const Auth: {
+  readonly $is: <Tag extends "OAuth" | "Static" | "TokenSource">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "OAuth";
+    readonly source: TokenSource;
+    readonly scheme?: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Static";
+    readonly token: Redacted.Redacted<string>;
+    readonly scheme?: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "TokenSource";
+    readonly token: TokenSource;
+    readonly scheme?: string;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "OAuth" | "Static" | "TokenSource"]: (args: Extract<{
+      readonly _tag: "OAuth";
+      readonly source: TokenSource;
+      readonly scheme?: string;
+    } | {
+      readonly _tag: "Static";
+      readonly token: Redacted.Redacted<string>;
+      readonly scheme?: string;
+    } | {
+      readonly _tag: "TokenSource";
+      readonly token: TokenSource;
+      readonly scheme?: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "OAuth";
+      readonly source: TokenSource;
+      readonly scheme?: string;
+    } | {
+      readonly _tag: "Static";
+      readonly token: Redacted.Redacted<string>;
+      readonly scheme?: string;
+    } | {
+      readonly _tag: "TokenSource";
+      readonly token: TokenSource;
+      readonly scheme?: string;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["OAuth" | "Static" | "TokenSource"]>>;
+    <Cases extends { readonly [Tag in "OAuth" | "Static" | "TokenSource"]: (args: Extract<{
+      readonly _tag: "OAuth";
+      readonly source: TokenSource;
+      readonly scheme?: string;
+    } | {
+      readonly _tag: "Static";
+      readonly token: Redacted.Redacted<string>;
+      readonly scheme?: string;
+    } | {
+      readonly _tag: "TokenSource";
+      readonly token: TokenSource;
+      readonly scheme?: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "OAuth";
+      readonly source: TokenSource;
+      readonly scheme?: string;
+    } | {
+      readonly _tag: "Static";
+      readonly token: Redacted.Redacted<string>;
+      readonly scheme?: string;
+    } | {
+      readonly _tag: "TokenSource";
+      readonly token: TokenSource;
+      readonly scheme?: string;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["OAuth" | "Static" | "TokenSource"]>>;
+  };
+  readonly OAuth: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "OAuth";
+    readonly source: TokenSource;
+    readonly scheme?: string;
+  }, "_tag">;
+  readonly Static: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Static";
+    readonly token: Redacted.Redacted<string>;
+    readonly scheme?: string;
+  }, "_tag">;
+  readonly TokenSource: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TokenSource";
+    readonly token: TokenSource;
+    readonly scheme?: string;
+  }, "_tag">;
+};
+/**
+ * The `Authorization` header for one request, or none for a public server.
+ * `Redacted.value` is unwrapped only here.
+ */
+declare const authHeaders: (auth: Option.Option<Auth>) => Effect.Effect<Record<string, string>, McpAuthError>;
+//#endregion
+export { TokenSource as n, authHeaders as r, Auth as t };
+//# sourceMappingURL=auth-ZDvsxpCo.d.mts.map

package/dist/auth-ZDvsxpCo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-ZDvsxpCo.d.mts","names":[],"sources":["../src/internal/auth.ts"],"mappings":";;;;;;;;KAaY,cAAc,OAAO,OAAO,SAAS,kBAAkB;KAEvD,OAAO,KAAK;;EAEtB;aAAmB,OAAO,SAAS;aAA2B;;;EAE9D;aAAwB,OAAO;aAAsB;;;EAErD;aAAkB,QAAQ;aAAsB;;;cAGrC;;;aAHe,QAAA;aAA+B;;;;;aAJ/B,OAAA,SAAS;aAAoC;;;;;aAExC,OAAA;aAA+B;;;;;;;eAEpC,QAAA;eAA+B;;;eAJ/B,OAAA,SAAS;eAAoC;;;eAExC,OAAA;eAA+B;;;;;;;;;;;;;;;;;;eAEpC,QAAA;eAA+B;;;eAJ/B,OAAA,SAAS;eAAoC;;;eAExC,OAAA;eAA+B;;;;;;;;;;;;;;;;;;;aAEpC,QAAA;aAA+B;;;;aAJ/B,OAAA,SAAS;aAAoC;;;;aAExC,OAAA;aAA+B;;;;;;;cAiBnD,cAAW,MAChB,OAAO,OAAO,UACnB,OAAO,OAAO,wBAAwB"}

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { a as McpError_d_exports } from "./McpError-DWg9BlW5.mjs";
+import { t as Client_d_exports } from "./Client.mjs";
+import { t as Toolkit_d_exports } from "./Toolkit.mjs";
+export { Client_d_exports as Client, McpError_d_exports as McpError, Toolkit_d_exports as Toolkit };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { t as McpError_exports } from "./McpError.mjs";
+import { t as Client_exports } from "./Client.mjs";
+import { t as Toolkit_exports } from "./Toolkit.mjs";
+export { Client_exports as Client, McpError_exports as McpError, Toolkit_exports as Toolkit };

package/dist/internal/auth.d.mts

@@ -0,0 +1,2 @@
+import { n as TokenSource, r as authHeaders, t as Auth } from "../auth-ZDvsxpCo.mjs";
+export { Auth, TokenSource, authHeaders };

package/dist/internal/auth.mjs

@@ -0,0 +1,25 @@
+import { Data, Effect, Option, Redacted } from "effect";
+//#region src/internal/auth.ts
+/**
+* Auth resolution for the HTTP transport. Era-blind: the stateless and
+* handshake protocols both ride an OAuth 2.1 resource server, and neither
+* knows this file exists. Tokens stay `Redacted` until the wire boundary.
+*/
+const Auth = Data.taggedEnum();
+const tokenOf = Auth.$match({
+	Static: ({ token }) => Effect.succeed(token),
+	TokenSource: ({ token }) => token,
+	OAuth: ({ source }) => source
+});
+/**
+* The `Authorization` header for one request, or none for a public server.
+* `Redacted.value` is unwrapped only here.
+*/
+const authHeaders = (auth) => Option.match(auth, {
+	onNone: () => Effect.succeed({}),
+	onSome: (a) => tokenOf(a).pipe(Effect.map((token) => ({ authorization: `${a.scheme ?? "Bearer"} ${Redacted.value(token)}` })))
+});
+//#endregion
+export { Auth, authHeaders };
+
+//# sourceMappingURL=auth.mjs.map

package/dist/internal/auth.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.mjs","names":[],"sources":["../../src/internal/auth.ts"],"sourcesContent":["/**\n * Auth resolution for the HTTP transport. Era-blind: the stateless and\n * handshake protocols both ride an OAuth 2.1 resource server, and neither\n * knows this file exists. Tokens stay `Redacted` until the wire boundary.\n */\nimport { Data, Effect, Option, Redacted } from \"effect\"\nimport type { McpAuthError } from \"../McpError.js\"\n\n/**\n * An Effect yielding a bearer token. Any external OAuth, vault, or secret\n * manager plugs in here. Read per request, so a producer minting expensive\n * tokens caches internally (as `OAuth.clientCredentials` does).\n */\nexport type TokenSource = Effect.Effect<Redacted.Redacted<string>, McpAuthError>\n\nexport type Auth = Data.TaggedEnum<{\n  /** A fixed token: the turnkey case for a token-gated server. */\n  Static: { readonly token: Redacted.Redacted<string>; readonly scheme?: string }\n  /** Bring your own, re-read before every request. */\n  TokenSource: { readonly token: TokenSource; readonly scheme?: string }\n  /** Built-in OAuth 2.1, which produces a `TokenSource` and rides the same seam. */\n  OAuth: { readonly source: TokenSource; readonly scheme?: string }\n}>\n\nexport const Auth = Data.taggedEnum<Auth>()\n\nconst tokenOf: (auth: Auth) => TokenSource = Auth.$match({\n  Static: ({ token }) => Effect.succeed(token),\n  TokenSource: ({ token }) => token,\n  OAuth: ({ source }) => source,\n})\n\n/**\n * The `Authorization` header for one request, or none for a public server.\n * `Redacted.value` is unwrapped only here.\n */\nexport const authHeaders = (\n  auth: Option.Option<Auth>,\n): Effect.Effect<Record<string, string>, McpAuthError> =>\n  Option.match(auth, {\n    onNone: () => Effect.succeed({}),\n    onSome: (a) =>\n      tokenOf(a).pipe(\n        Effect.map((token) => ({\n          authorization: `${a.scheme ?? \"Bearer\"} ${Redacted.value(token)}`,\n        })),\n      ),\n  })\n"],"mappings":";;;;;;;AAwBA,MAAa,OAAO,KAAK,WAAiB;AAE1C,MAAM,UAAuC,KAAK,OAAO;CACvD,SAAS,EAAE,YAAY,OAAO,QAAQ,KAAK;CAC3C,cAAc,EAAE,YAAY;CAC5B,QAAQ,EAAE,aAAa;AACzB,CAAC;;;;;AAMD,MAAa,eACX,SAEA,OAAO,MAAM,MAAM;CACjB,cAAc,OAAO,QAAQ,CAAC,CAAC;CAC/B,SAAS,MACP,QAAQ,CAAC,CAAC,CAAC,KACT,OAAO,KAAK,WAAW,EACrB,eAAe,GAAG,EAAE,UAAU,SAAS,GAAG,SAAS,MAAM,KAAK,IAChE,EAAE,CACJ;AACJ,CAAC"}