@effect-uai/mcp 0.18.0 → 0.19.0-dev-20261109183959

package/dist/Client.d.mts

@@ -1,6 +1,6 @@
 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 { n as TokenSource, t as Auth } from "./auth-CRIPfiPB.mjs";
+import { A as ServerInfo, D as ProtocolVersion, M as ToolInfo, s as CallToolResult } from "./schema-tDws3q4j.mjs";
 import { Context, Effect, Layer, Scope } from "effect";
 import { HttpClient } from "effect/http";
 import { ChildProcessSpawner } from "effect/process";

package/dist/Toolkit.d.mts

@@ -1,20 +1,24 @@
 import { i as McpError } from "./McpError-DWg9BlW5.mjs";
 import { McpClient } from "./Client.mjs";
-import { Effect } from "effect";
+import { Effect, Schema } from "effect";
 import * as CoreToolkit from "@effect-uai/core/Toolkit";
 declare namespace Toolkit_d_exports {
-  export { McpToolkitOptions, mcpToolkit };
+  export { McpToolFailed, McpToolkitOptions, mcpToolkit };
 }
 type McpToolkitOptions = {
   /** Namespace every tool as `<prefix>__<name>`; recommended when composing servers. */
   readonly prefix?: string;
 };
+declare const McpToolFailed_base: Schema.Class<McpToolFailed, Schema.TaggedStruct<"McpToolFailed", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The server reported an error (`isError`); the model sees its content as `message`. */
+declare class McpToolFailed extends McpToolFailed_base {}
 /**
  * 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.
+ * here; a tool that later vanishes surfaces as `Toolkit.run`'s `UnknownTool`.
  */
 declare const mcpToolkit: (client: McpClient, options?: McpToolkitOptions) => Effect.Effect<CoreToolkit.Toolkit, McpError>;
 //#endregion
-export { McpToolkitOptions, mcpToolkit, Toolkit_d_exports as t };
+export { McpToolFailed, McpToolkitOptions, mcpToolkit, Toolkit_d_exports as t };
 //# sourceMappingURL=Toolkit.d.mts.map

package/dist/Toolkit.d.mts.map

@@ -1 +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"}
+{"version":3,"file":"Toolkit.d.mts","names":[],"sources":["../src/Toolkit.ts"],"mappings":";;;;;;;KAsBY;;WAED;;;;;;cAIE,sBAAsB;;;;;cAiGtB,aAAU,QACb,WAAS,UACP,sBACT,OAAO,OAAO,YAAY,SAAS"}

package/dist/Toolkit.mjs

@@ -1,16 +1,25 @@
 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 { isKnownContent } from "./internal/schema.mjs";
+import { Effect, Match, Option, Schema } from "effect";
+import * as Content from "@effect-uai/core/Content";
+import { fileBase64, fileUrl } from "@effect-uai/core/File";
+import { imageBase64 } from "@effect-uai/core/Image";
 import * as Tool from "@effect-uai/core/Tool";
 import * as CoreToolkit from "@effect-uai/core/Toolkit";
+import * as ToolOutput from "@effect-uai/core/ToolOutput";
 //#region src/Toolkit.ts
 /**
-* Turn a connected MCP server into a core `Toolkit`, one `LocalTool` per MCP
+* Turn a connected MCP server into a core `Toolkit`, one local tool 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 });
+var Toolkit_exports = /* @__PURE__ */ __exportAll({
+	McpToolFailed: () => McpToolFailed,
+	mcpToolkit: () => mcpToolkit
+});
+/** The server reported an error (`isError`); the model sees its content as `message`. */
+var McpToolFailed = class extends Schema.TaggedError("@betalyra/effect-uai/mcp/McpToolFailed")("McpToolFailed", { message: Schema.String }) {};
 /**
 * 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
@@ -26,45 +35,54 @@ const passthroughSchema = (tool) => ({ "~standard": {
 		output: () => ({ type: "object" })
 	}
 } });
-const textOf = (block) => isTextContent(block) ? block.text : `[${block.type} content omitted]`;
+const knownValue = Match.type().pipe(Match.discriminatorsExhaustive("type")({
+	text: (b) => b.text,
+	image: (b) => Content.image(imageBase64(b.data, b.mimeType)),
+	audio: (b) => Content.file(fileBase64(b.data, b.mimeType)),
+	resource_link: (b) => Content.file(fileUrl(b.uri, b.mimeType), b.name),
+	resource: ({ resource }) => "text" in resource ? resource.text : Content.file(fileBase64(resource.blob, resource.mimeType ?? "application/octet-stream"))
+}));
+const valueOf = (block) => isKnownContent(block) ? knownValue(block) : `[${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.
+* A result as the tool's value: `structuredContent` when the server provides it
+* (its text blocks usually repeat it), plus any media; otherwise every block.
 */
-const outputOf = (result) => result.structuredContent ?? (result.content ?? []).map(textOf).join("\n");
+const outputOf = (result) => {
+	const values = (result.content ?? []).map(valueOf);
+	return Option.match(Option.fromNullishOr(result.structuredContent), {
+		onNone: () => ToolOutput.single(values),
+		onSome: (structured) => ToolOutput.single([structured, ...values.filter(Content.isMedia)])
+	});
+};
+const messageOf = (result) => (result.content ?? []).map(valueOf).filter((v) => typeof v === "string").join("\n");
 /**
 * Two failure channels, deliberately: `isError` is the server telling the
-* model it went wrong, so it becomes a model-visible `ToolFailed`; an
+* model it went wrong, so it becomes the declared `McpToolFailed`; an
 * `input_required` result is a protocol capability gap the model cannot fix,
-* so it stays a typed `McpError`.
+* so it stays a typed `McpError` and fails the run.
 */
-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 interpret = (name, result) => Match.value(result).pipe(Match.when({ isError: true }, (r) => Effect.fail(new McpToolFailed({ message: messageOf(r) }))), Match.when({ resultType: "input_required" }, () => Effect.fail(new McpProtocolError({
+	method: "tools/call",
+	reason: `${name} requires interactive input (MRTR), unsupported by this client`
+}))), Match.orElse((r) => Effect.succeed(outputOf(r))));
 const toLocalTool = (client, info) => Tool.make({
 	name: info.name,
 	description: info.description ?? info.name,
 	inputSchema: passthroughSchema(info),
-	run: runTool(client, info.name),
+	outputSchema: Content.Value,
+	failureSchema: McpToolFailed,
+	run: (input) => client.callTool(info.name, input).pipe(Effect.flatMap((r) => interpret(info.name, r))),
 	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.
+* here; a tool that later vanishes surfaces as `Toolkit.run`'s `UnknownTool`.
 */
 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 };
+export { McpToolFailed, mcpToolkit, Toolkit_exports as t };
 
 //# sourceMappingURL=Toolkit.mjs.map

package/dist/Toolkit.mjs.map

@@ -1 +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"}
+{"version":3,"file":"Toolkit.mjs","names":[],"sources":["../src/Toolkit.ts"],"sourcesContent":["/**\n * Turn a connected MCP server into a core `Toolkit`, one local tool per MCP\n * tool. Effectful because the tool list is fetched; composes with\n * `Toolkit.compose` like any other kit.\n */\nimport { Effect, Match, Option, Schema } from \"effect\"\nimport * as Content from \"@effect-uai/core/Content\"\nimport { fileBase64, fileUrl } from \"@effect-uai/core/File\"\nimport { imageBase64 } from \"@effect-uai/core/Image\"\nimport * as Tool from \"@effect-uai/core/Tool\"\nimport * as CoreToolkit from \"@effect-uai/core/Toolkit\"\nimport * as ToolOutput from \"@effect-uai/core/ToolOutput\"\nimport type { McpClient } from \"./Client.js\"\nimport { type McpError, McpProtocolError } from \"./McpError.js\"\nimport {\n  type CallToolResult,\n  type ContentBlock,\n  isKnownContent,\n  type KnownContent,\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/** The server reported an error (`isError`); the model sees its content as `message`. */\nexport class McpToolFailed extends Schema.TaggedError<McpToolFailed>(\n  \"@betalyra/effect-uai/mcp/McpToolFailed\",\n)(\"McpToolFailed\", { message: Schema.String }) {}\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\n// A blob without a MIME type is opaque bytes.\nconst knownValue = Match.type<KnownContent>().pipe(\n  Match.discriminatorsExhaustive(\"type\")({\n    text: (b): string | Content.Media => b.text,\n    image: (b) => Content.image(imageBase64(b.data, b.mimeType)),\n    audio: (b) => Content.file(fileBase64(b.data, b.mimeType)),\n    resource_link: (b) => Content.file(fileUrl(b.uri, b.mimeType), b.name),\n    resource: ({ resource }) =>\n      \"text\" in resource\n        ? resource.text\n        : Content.file(fileBase64(resource.blob, resource.mimeType ?? \"application/octet-stream\")),\n  }),\n)\n\nconst valueOf = (block: ContentBlock): string | Content.Media =>\n  isKnownContent(block) ? knownValue(block) : `[${block.type} content omitted]`\n\n/**\n * A result as the tool's value: `structuredContent` when the server provides it\n * (its text blocks usually repeat it), plus any media; otherwise every block.\n */\nconst outputOf = (result: CallToolResult): Content.Value => {\n  const values: ReadonlyArray<Schema.Json | Content.Media> = (result.content ?? []).map(valueOf)\n  return Option.match(Option.fromNullishOr(result.structuredContent), {\n    onNone: () => ToolOutput.single(values),\n    onSome: (structured) => ToolOutput.single([structured, ...values.filter(Content.isMedia)]),\n  })\n}\n\nconst messageOf = (result: CallToolResult): string =>\n  (result.content ?? [])\n    .map(valueOf)\n    .filter((v): v is string => typeof v === \"string\")\n    .join(\"\\n\")\n\n/**\n * Two failure channels, deliberately: `isError` is the server telling the\n * model it went wrong, so it becomes the declared `McpToolFailed`; an\n * `input_required` result is a protocol capability gap the model cannot fix,\n * so it stays a typed `McpError` and fails the run.\n */\nconst interpret = (\n  name: string,\n  result: CallToolResult,\n): Effect.Effect<Content.Value, McpError | McpToolFailed> =>\n  Match.value(result).pipe(\n    Match.when({ isError: true }, (r) => Effect.fail(new McpToolFailed({ message: messageOf(r) }))),\n    Match.when({ resultType: \"input_required\" }, () =>\n      Effect.fail(\n        new McpProtocolError({\n          method: \"tools/call\",\n          reason: `${name} requires interactive input (MRTR), unsupported by this client`,\n        }),\n      ),\n    ),\n    Match.orElse((r) => Effect.succeed(outputOf(r))),\n  )\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    // Known only at runtime: any mix of text, JSON and media.\n    outputSchema: Content.Value,\n    failureSchema: McpToolFailed,\n    run: (input) =>\n      client.callTool(info.name, input).pipe(Effect.flatMap((r) => interpret(info.name, r))),\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 as `Toolkit.run`'s `UnknownTool`.\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,IAAa,gBAAb,cAAmC,OAAO,YACxC,wCACF,CAAC,CAAC,iBAAiB,EAAE,SAAS,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;;;;;;;AAQhD,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;AAGA,MAAM,aAAa,MAAM,KAAmB,CAAC,CAAC,KAC5C,MAAM,yBAAyB,MAAM,CAAC,CAAC;CACrC,OAAO,MAA8B,EAAE;CACvC,QAAQ,MAAM,QAAQ,MAAM,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC;CAC3D,QAAQ,MAAM,QAAQ,KAAK,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC;CACzD,gBAAgB,MAAM,QAAQ,KAAK,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,EAAE,IAAI;CACrE,WAAW,EAAE,eACX,UAAU,WACN,SAAS,OACT,QAAQ,KAAK,WAAW,SAAS,MAAM,SAAS,YAAY,0BAA0B,CAAC;AAC/F,CAAC,CACH;AAEA,MAAM,WAAW,UACf,eAAe,KAAK,IAAI,WAAW,KAAK,IAAI,IAAI,MAAM,KAAK;;;;;AAM7D,MAAM,YAAY,WAA0C;CAC1D,MAAM,UAAsD,OAAO,WAAW,CAAC,EAAA,CAAG,IAAI,OAAO;CAC7F,OAAO,OAAO,MAAM,OAAO,cAAc,OAAO,iBAAiB,GAAG;EAClE,cAAc,WAAW,OAAO,MAAM;EACtC,SAAS,eAAe,WAAW,OAAO,CAAC,YAAY,GAAG,OAAO,OAAO,QAAQ,OAAO,CAAC,CAAC;CAC3F,CAAC;AACH;AAEA,MAAM,aAAa,YAChB,OAAO,WAAW,CAAC,EAAA,CACjB,IAAI,OAAO,CAAC,CACZ,QAAQ,MAAmB,OAAO,MAAM,QAAQ,CAAC,CACjD,KAAK,IAAI;;;;;;;AAQd,MAAM,aACJ,MACA,WAEA,MAAM,MAAM,MAAM,CAAC,CAAC,KAClB,MAAM,KAAK,EAAE,SAAS,KAAK,IAAI,MAAM,OAAO,KAAK,IAAI,cAAc,EAAE,SAAS,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,GAC9F,MAAM,KAAK,EAAE,YAAY,iBAAiB,SACxC,OAAO,KACL,IAAI,iBAAiB;CACnB,QAAQ;CACR,QAAQ,GAAG,KAAK;AAClB,CAAC,CACH,CACF,GACA,MAAM,QAAQ,MAAM,OAAO,QAAQ,SAAS,CAAC,CAAC,CAAC,CACjD;AAEF,MAAM,eAAe,QAAmB,SACtC,KAAK,KAAK;CACR,MAAM,KAAK;CACX,aAAa,KAAK,eAAe,KAAK;CACtC,aAAa,kBAAkB,IAAI;CAEnC,cAAc,QAAQ;CACtB,eAAe;CACf,MAAM,UACJ,OAAO,SAAS,KAAK,MAAM,KAAK,CAAC,CAAC,KAAK,OAAO,SAAS,MAAM,UAAU,KAAK,MAAM,CAAC,CAAC,CAAC;CACvF,QAAQ;AACV,CAAC;;;;;AAMH,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-CRIPfiPB.d.mts

@@ -0,0 +1,47 @@
+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: Data.TaggedEnum.Constructor<{
+  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;
+}>;
+/**
+ * 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-CRIPfiPB.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth-CRIPfiPB.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,MAAI,KAAA,WAAA;;WAHW,QAAA;WAA+B;;;WAJ/B,OAAA,SAAS;WAAoC;;;WAExC,OAAA;WAA+B;;;;;;cAiBnD,cAAW,MAChB,OAAO,OAAO,UACnB,OAAO,OAAO,wBAAwB"}

package/dist/internal/auth.d.mts

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

package/dist/internal/httpTransport.d.mts

@@ -1,6 +1,6 @@
 import { i as McpError } from "../McpError-DWg9BlW5.mjs";
-import { t as Auth } from "../auth-ZDvsxpCo.mjs";
-import { i as Transport } from "../rpc-Bq95Lio9.mjs";
+import { t as Auth } from "../auth-CRIPfiPB.mjs";
+import { i as Transport } from "../rpc-Bs2BCLha.mjs";
 import { Effect, Scope } from "effect";
 import { HttpClient } from "effect/http";
 //#region src/internal/httpTransport.d.ts

package/dist/internal/protocol.d.mts

@@ -1,2 +1,2 @@
-import { i as modernRejection, n as Protocol, r as ProtocolProbe, t as ModernRejection } from "../protocol-kjC3iAMb.mjs";
+import { i as modernRejection, n as Protocol, r as ProtocolProbe, t as ModernRejection } from "../protocol-C3L9kaRW.mjs";
 export { ModernRejection, Protocol, ProtocolProbe, modernRejection };

package/dist/internal/protocols/2025-06-18.d.mts

@@ -1,4 +1,4 @@
-import { r as ProtocolProbe } from "../../protocol-kjC3iAMb.mjs";
+import { r as ProtocolProbe } from "../../protocol-C3L9kaRW.mjs";
 //#region src/internal/protocols/2025-06-18.d.ts
 /**
  * Run the `initialize` handshake. Unlike the stateless probe there is nothing

package/dist/internal/protocols/2026-07-28.d.mts

@@ -1,4 +1,4 @@
-import { r as ProtocolProbe } from "../../protocol-kjC3iAMb.mjs";
+import { r as ProtocolProbe } from "../../protocol-C3L9kaRW.mjs";
 //#region src/internal/protocols/2026-07-28.d.ts
 /**
  * Header values outside the safe set (and any literal that would be mistaken

package/dist/internal/rpc.d.mts

@@ -1,2 +1,2 @@
-import { a as open, i as Transport, n as McpConnection, r as SendMeta, t as Inbound } from "../rpc-Bq95Lio9.mjs";
+import { a as open, i as Transport, n as McpConnection, r as SendMeta, t as Inbound } from "../rpc-Bs2BCLha.mjs";
 export { Inbound, McpConnection, SendMeta, Transport, open };

package/dist/internal/schema.d.mts

@@ -1,2 +1,2 @@
-import { A as decodeCallToolResult, B as resultFrame, C as ProtocolVersion, D as ToolInfo, E as TextContent, F as decodeUnsupportedVersionData, I as errorFrame, L as isTextContent, M as decodeInboundMessage, N as decodeInitializeResult, O as UnsupportedVersionData, P as decodeListToolsResult, R as notificationFrame, S as OtherContent, T as ServerInfo, _ as META_CLIENT_INFO, a as CODE_UNSUPPORTED_PROTOCOL_VERSION, b as MODERN_ERROR_CODES, c as DiscoverResult, d as JsonRpcErrorObject, f as JsonRpcId, g as META_CLIENT_CAPABILITIES, h as ListToolsResult, i as CODE_MISSING_CLIENT_CAPABILITY, j as decodeDiscoverResult, k as asProtocolVersion, l as InboundMessage, m as LEGACY_VERSION, n as CODE_HEADER_MISMATCH, o as CallToolResult, p as LATEST_VERSION, r as CODE_METHOD_NOT_FOUND, s as ContentBlock, t as CLIENT_INFO, u as InitializeResult, v as META_PROTOCOL_VERSION, w as ResultMeta, x as McpMethod, y as META_SERVER_INFO, z as requestFrame } from "../schema-D2oUNuo5.mjs";
-export { CLIENT_INFO, CODE_HEADER_MISMATCH, CODE_METHOD_NOT_FOUND, CODE_MISSING_CLIENT_CAPABILITY, CODE_UNSUPPORTED_PROTOCOL_VERSION, CallToolResult, ContentBlock, DiscoverResult, InboundMessage, InitializeResult, JsonRpcErrorObject, JsonRpcId, LATEST_VERSION, LEGACY_VERSION, ListToolsResult, META_CLIENT_CAPABILITIES, META_CLIENT_INFO, META_PROTOCOL_VERSION, META_SERVER_INFO, MODERN_ERROR_CODES, McpMethod, OtherContent, ProtocolVersion, ResultMeta, ServerInfo, TextContent, ToolInfo, UnsupportedVersionData, asProtocolVersion, decodeCallToolResult, decodeDiscoverResult, decodeInboundMessage, decodeInitializeResult, decodeListToolsResult, decodeUnsupportedVersionData, errorFrame, isTextContent, notificationFrame, requestFrame, resultFrame };
+import { A as ServerInfo, B as decodeUnsupportedVersionData, C as META_SERVER_INFO, D as ProtocolVersion, E as OtherContent, F as decodeCallToolResult, G as resultFrame, H as isKnownContent, I as decodeDiscoverResult, L as decodeInboundMessage, M as ToolInfo, N as UnsupportedVersionData, O as ResourceLink, P as asProtocolVersion, R as decodeInitializeResult, S as META_PROTOCOL_VERSION, T as McpMethod, U as notificationFrame, V as errorFrame, W as requestFrame, _ as LATEST_VERSION, a as CODE_MISSING_CLIENT_CAPABILITY, b as META_CLIENT_CAPABILITIES, c as ContentBlock, d as ImageContent, f as InboundMessage, g as KnownContent, h as JsonRpcId, i as CODE_METHOD_NOT_FOUND, j as TextContent, k as ResultMeta, l as DiscoverResult, m as JsonRpcErrorObject, n as CLIENT_INFO, o as CODE_UNSUPPORTED_PROTOCOL_VERSION, p as InitializeResult, r as CODE_HEADER_MISMATCH, s as CallToolResult, t as AudioContent, u as EmbeddedResource, v as LEGACY_VERSION, w as MODERN_ERROR_CODES, x as META_CLIENT_INFO, y as ListToolsResult, z as decodeListToolsResult } from "../schema-tDws3q4j.mjs";
+export { AudioContent, CLIENT_INFO, CODE_HEADER_MISMATCH, CODE_METHOD_NOT_FOUND, CODE_MISSING_CLIENT_CAPABILITY, CODE_UNSUPPORTED_PROTOCOL_VERSION, CallToolResult, ContentBlock, DiscoverResult, EmbeddedResource, ImageContent, InboundMessage, InitializeResult, JsonRpcErrorObject, JsonRpcId, KnownContent, LATEST_VERSION, LEGACY_VERSION, ListToolsResult, META_CLIENT_CAPABILITIES, META_CLIENT_INFO, META_PROTOCOL_VERSION, META_SERVER_INFO, MODERN_ERROR_CODES, McpMethod, OtherContent, ProtocolVersion, ResourceLink, ResultMeta, ServerInfo, TextContent, ToolInfo, UnsupportedVersionData, asProtocolVersion, decodeCallToolResult, decodeDiscoverResult, decodeInboundMessage, decodeInitializeResult, decodeListToolsResult, decodeUnsupportedVersionData, errorFrame, isKnownContent, notificationFrame, requestFrame, resultFrame };

package/dist/internal/schema.mjs

@@ -120,14 +120,48 @@ const TextContent = Schema.Struct({
 	type: Schema.Literal("text"),
 	text: Schema.String
 });
-/** Non-text blocks (image / audio / resource) are placeholder-summarized in v1. */
+const ImageContent = Schema.Struct({
+	type: Schema.Literal("image"),
+	data: Schema.String,
+	mimeType: Schema.String
+});
+const AudioContent = Schema.Struct({
+	type: Schema.Literal("audio"),
+	data: Schema.String,
+	mimeType: Schema.String
+});
+const ResourceLink = Schema.Struct({
+	type: Schema.Literal("resource_link"),
+	uri: Schema.String,
+	name: Schema.optional(Schema.String),
+	mimeType: Schema.optional(Schema.String)
+});
+const EmbeddedResource = Schema.Struct({
+	type: Schema.Literal("resource"),
+	resource: Schema.Union([Schema.Struct({
+		uri: Schema.String,
+		text: Schema.String
+	}), Schema.Struct({
+		uri: Schema.String,
+		blob: Schema.String,
+		mimeType: Schema.optional(Schema.String)
+	})])
+});
+/** A block type this client does not know; summarized for the model. */
 const OtherContent = Schema.Struct({ type: Schema.String });
-const ContentBlock = Schema.Union([TextContent, OtherContent]);
-const isTextContent = Schema.is(TextContent);
+const KnownContent = Schema.Union([
+	TextContent,
+	ImageContent,
+	AudioContent,
+	ResourceLink,
+	EmbeddedResource
+]);
+const isKnownContent = Schema.is(KnownContent);
+const ContentBlock = Schema.Union([KnownContent, OtherContent]);
 const CallToolResult = Schema.Struct({
 	content: Schema.optionalKey(Schema.Array(ContentBlock)),
 	isError: Schema.optional(Schema.Boolean),
-	structuredContent: Schema.optional(Schema.Unknown),
+	structuredContent: Schema.optional(Schema.Json),
 	resultType: Schema.optional(Schema.String)
 });
 const decodeCallToolResult = Schema.decodeUnknownEffect(CallToolResult);
@@ -163,6 +197,6 @@ const InitializeResult = Schema.Struct({
 });
 const decodeInitializeResult = Schema.decodeUnknownEffect(InitializeResult);
 //#endregion
-export { CLIENT_INFO, CODE_HEADER_MISMATCH, CODE_METHOD_NOT_FOUND, CODE_MISSING_CLIENT_CAPABILITY, CODE_UNSUPPORTED_PROTOCOL_VERSION, CallToolResult, ContentBlock, DiscoverResult, InboundMessage, InitializeResult, JsonRpcErrorObject, JsonRpcId, LATEST_VERSION, LEGACY_VERSION, ListToolsResult, META_CLIENT_CAPABILITIES, META_CLIENT_INFO, META_PROTOCOL_VERSION, META_SERVER_INFO, MODERN_ERROR_CODES, McpMethod, OtherContent, ProtocolVersion, ResultMeta, ServerInfo, TextContent, ToolInfo, UnsupportedVersionData, asProtocolVersion, decodeCallToolResult, decodeDiscoverResult, decodeInboundMessage, decodeInitializeResult, decodeListToolsResult, decodeUnsupportedVersionData, errorFrame, isTextContent, notificationFrame, requestFrame, resultFrame };
+export { AudioContent, CLIENT_INFO, CODE_HEADER_MISMATCH, CODE_METHOD_NOT_FOUND, CODE_MISSING_CLIENT_CAPABILITY, CODE_UNSUPPORTED_PROTOCOL_VERSION, CallToolResult, ContentBlock, DiscoverResult, EmbeddedResource, ImageContent, InboundMessage, InitializeResult, JsonRpcErrorObject, JsonRpcId, KnownContent, LATEST_VERSION, LEGACY_VERSION, ListToolsResult, META_CLIENT_CAPABILITIES, META_CLIENT_INFO, META_PROTOCOL_VERSION, META_SERVER_INFO, MODERN_ERROR_CODES, McpMethod, OtherContent, ProtocolVersion, ResourceLink, ResultMeta, ServerInfo, TextContent, ToolInfo, UnsupportedVersionData, asProtocolVersion, decodeCallToolResult, decodeDiscoverResult, decodeInboundMessage, decodeInitializeResult, decodeListToolsResult, decodeUnsupportedVersionData, errorFrame, isKnownContent, notificationFrame, requestFrame, resultFrame };
 
 //# sourceMappingURL=schema.mjs.map

package/dist/internal/schema.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"schema.mjs","names":[],"sources":["../../src/internal/schema.ts"],"sourcesContent":["/**\n * Self-contained MCP wire schemas, both protocol eras. The single source of\n * truth for the wire format; nothing MCP-shaped is imported from effect.\n * Decodes are deliberately loose (unknown extra fields pass through) so\n * spec-compliant servers with richer payloads never fail the client.\n */\nimport { Option, Schema } from \"effect\"\n\n// ---------------------------------------------------------------------------\n// Protocol versions\n// ---------------------------------------------------------------------------\n\n/** Every protocol version this client can speak. */\nexport const ProtocolVersion = Schema.Literals([\"2026-07-28\", \"2025-11-25\", \"2025-06-18\"])\nexport type ProtocolVersion = typeof ProtocolVersion.Type\n\n/** Newest version we speak: the stateless protocol, and what the probe tries first. */\nexport const LATEST_VERSION = \"2026-07-28\" satisfies ProtocolVersion\n\n/** The legacy handshake era we negotiate; 2025-11-25 is wire-compatible. */\nexport const LEGACY_VERSION = \"2025-06-18\" satisfies ProtocolVersion\n\nconst isProtocolVersion = Schema.is(ProtocolVersion)\n\n/** Narrow a server-offered version string to one we support. */\nexport const asProtocolVersion = (raw: string): Option.Option<ProtocolVersion> =>\n  isProtocolVersion(raw) ? Option.some(raw) : Option.none()\n\n/**\n * The JSON-RPC methods this client issues. Not to be confused with an HTTP\n * method: on Streamable HTTP every one of these travels as a POST, and the\n * name is mirrored into the `Mcp-Method` header.\n */\nexport const McpMethod = Schema.Literals([\n  \"server/discover\",\n  \"initialize\",\n  \"tools/list\",\n  \"tools/call\",\n])\nexport type McpMethod = typeof McpMethod.Type\n\n/** Modern `_meta` keys (SEP-2575): every request self-describes its protocol. */\nexport const META_PROTOCOL_VERSION = \"io.modelcontextprotocol/protocolVersion\"\nexport const META_CLIENT_INFO = \"io.modelcontextprotocol/clientInfo\"\nexport const META_CLIENT_CAPABILITIES = \"io.modelcontextprotocol/clientCapabilities\"\n/** Servers identify themselves in each *result's* `_meta`, not at the top level. */\nexport const META_SERVER_INFO = \"io.modelcontextprotocol/serverInfo\"\n\nexport const CLIENT_INFO = { name: \"@effect-uai/mcp\", version: \"0.12.1\" }\n\n/** Modern JSON-RPC error codes. */\nexport const CODE_HEADER_MISMATCH = -32020\nexport const CODE_MISSING_CLIENT_CAPABILITY = -32021\nexport const CODE_UNSUPPORTED_PROTOCOL_VERSION = -32022\nexport const CODE_METHOD_NOT_FOUND = -32601\n\n/**\n * A reply carrying one of these proves the server speaks a modern version, so\n * era detection corrects and retries instead of falling back to `initialize`.\n */\nexport const MODERN_ERROR_CODES: ReadonlySet<number> = new Set([\n  CODE_HEADER_MISMATCH,\n  CODE_MISSING_CLIENT_CAPABILITY,\n  CODE_UNSUPPORTED_PROTOCOL_VERSION,\n])\n\n// ---------------------------------------------------------------------------\n// JSON-RPC envelope\n// ---------------------------------------------------------------------------\n\nexport const JsonRpcId = Schema.Union([Schema.Number, Schema.String])\nexport type JsonRpcId = typeof JsonRpcId.Type\n\nexport const JsonRpcErrorObject = Schema.Struct({\n  code: Schema.Number,\n  message: Schema.optional(Schema.String),\n  data: Schema.optional(Schema.Unknown),\n})\nexport type JsonRpcErrorObject = typeof JsonRpcErrorObject.Type\n\n/**\n * Any inbound frame: a reply (`id` + `result`/`error`), a server-initiated\n * request (`method` + `id`), or a notification (`method`, no `id`). One\n * loose struct so the reader can classify without a union decode.\n */\nexport const InboundMessage = Schema.Struct({\n  // Null is legal and meaningful: JSON-RPC uses it for errors raised before a\n  // request could be attributed. Rejecting it would drop the frame entirely.\n  id: Schema.optional(Schema.NullOr(JsonRpcId)),\n  result: Schema.optional(Schema.Unknown),\n  error: Schema.optional(JsonRpcErrorObject),\n  method: Schema.optional(Schema.String),\n  params: Schema.optional(Schema.Unknown),\n})\nexport type InboundMessage = typeof InboundMessage.Type\n\nexport const decodeInboundMessage = Schema.decodeUnknownEffect(InboundMessage)\n\n// --- outbound frame builders -----------------------------------------------\n\nexport const requestFrame = (id: JsonRpcId, method: string, params: unknown): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, method, params: params ?? {} })\n\nexport const notificationFrame = (method: string, params?: unknown): string =>\n  JSON.stringify(\n    params === undefined ? { jsonrpc: \"2.0\", method } : { jsonrpc: \"2.0\", method, params },\n  )\n\nexport const resultFrame = (id: JsonRpcId, result: unknown): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, result })\n\nexport const errorFrame = (id: JsonRpcId, code: number, message: string): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, error: { code, message } })\n\n// ---------------------------------------------------------------------------\n// Shared: tools\n// ---------------------------------------------------------------------------\n\nexport const ToolInfo = Schema.Struct({\n  name: Schema.String,\n  description: Schema.optional(Schema.String),\n  inputSchema: Schema.Record(Schema.String, Schema.Unknown),\n})\nexport type ToolInfo = typeof ToolInfo.Type\n\n/**\n * Modern list results may carry cache metadata (`ttlMs` / `cacheScope`);\n * v1 reads but does not act on them (input for a later refresh feature).\n */\nexport const ListToolsResult = Schema.Struct({\n  tools: Schema.Array(ToolInfo),\n  nextCursor: Schema.optional(Schema.String),\n  ttlMs: Schema.optional(Schema.Number),\n  cacheScope: Schema.optional(Schema.String),\n})\nexport type ListToolsResult = typeof ListToolsResult.Type\n\nexport const decodeListToolsResult = Schema.decodeUnknownEffect(ListToolsResult)\n\n// --- content blocks ---------------------------------------------------------\n\nexport const TextContent = Schema.Struct({\n  type: Schema.Literal(\"text\"),\n  text: Schema.String,\n})\nexport type TextContent = typeof TextContent.Type\n\n/** Non-text blocks (image / audio / resource) are placeholder-summarized in v1. */\nexport const OtherContent = Schema.Struct({\n  type: Schema.String,\n})\n\nexport const ContentBlock = Schema.Union([TextContent, OtherContent])\nexport type ContentBlock = typeof ContentBlock.Type\n\nexport const isTextContent = Schema.is(TextContent)\n\nexport const CallToolResult = Schema.Struct({\n  content: Schema.optionalKey(Schema.Array(ContentBlock)),\n  isError: Schema.optional(Schema.Boolean),\n  structuredContent: Schema.optional(Schema.Unknown),\n  // Required on modern results; absent on legacy ones.\n  resultType: Schema.optional(Schema.String),\n})\nexport type CallToolResult = typeof CallToolResult.Type\n\nexport const decodeCallToolResult = Schema.decodeUnknownEffect(CallToolResult)\n\n// ---------------------------------------------------------------------------\n// Modern era (2026-07-28)\n// ---------------------------------------------------------------------------\n\nexport const ServerInfo = Schema.Struct({\n  name: Schema.String,\n  version: Schema.optional(Schema.String),\n  title: Schema.optional(Schema.String),\n})\nexport type ServerInfo = typeof ServerInfo.Type\n\n/** The subset of a result's `_meta` we read. */\nexport const ResultMeta = Schema.Struct({\n  [META_SERVER_INFO]: Schema.optional(ServerInfo),\n})\nexport type ResultMeta = typeof ResultMeta.Type\n\nexport const DiscoverResult = Schema.Struct({\n  supportedVersions: Schema.Array(Schema.String),\n  capabilities: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n  // Spec-conformant servers put identity in `_meta`; a top-level `serverInfo`\n  // is accepted too, since that is where the legacy handshake carries it.\n  _meta: Schema.optional(ResultMeta),\n  serverInfo: Schema.optional(ServerInfo),\n  instructions: Schema.optional(Schema.String),\n})\nexport type DiscoverResult = typeof DiscoverResult.Type\n\nexport const decodeDiscoverResult = Schema.decodeUnknownEffect(DiscoverResult)\n\n/**\n * `data` of a `-32022` UnsupportedProtocolVersionError reply. Decoded, not\n * hand-parsed: the shape is server-controlled and may carry extra fields.\n */\nexport const UnsupportedVersionData = Schema.Struct({\n  supported: Schema.optional(Schema.Array(Schema.String)),\n  requested: Schema.optional(Schema.NullOr(Schema.String)),\n})\nexport type UnsupportedVersionData = typeof UnsupportedVersionData.Type\n\nexport const decodeUnsupportedVersionData = Schema.decodeUnknownOption(UnsupportedVersionData)\n\n// ---------------------------------------------------------------------------\n// Legacy era (2025-06-18 / 2025-11-25)\n// ---------------------------------------------------------------------------\n\nexport const InitializeResult = Schema.Struct({\n  protocolVersion: Schema.String,\n  capabilities: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n  serverInfo: Schema.optional(ServerInfo),\n  instructions: Schema.optional(Schema.String),\n})\nexport type InitializeResult = typeof InitializeResult.Type\n\nexport const decodeInitializeResult = Schema.decodeUnknownEffect(InitializeResult)\n"],"mappings":"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"}
+{"version":3,"file":"schema.mjs","names":[],"sources":["../../src/internal/schema.ts"],"sourcesContent":["/**\n * Self-contained MCP wire schemas, both protocol eras. The single source of\n * truth for the wire format; nothing MCP-shaped is imported from effect.\n * Decodes are deliberately loose (unknown extra fields pass through) so\n * spec-compliant servers with richer payloads never fail the client.\n */\nimport { Option, Schema } from \"effect\"\n\n// ---------------------------------------------------------------------------\n// Protocol versions\n// ---------------------------------------------------------------------------\n\n/** Every protocol version this client can speak. */\nexport const ProtocolVersion = Schema.Literals([\"2026-07-28\", \"2025-11-25\", \"2025-06-18\"])\nexport type ProtocolVersion = typeof ProtocolVersion.Type\n\n/** Newest version we speak: the stateless protocol, and what the probe tries first. */\nexport const LATEST_VERSION = \"2026-07-28\" satisfies ProtocolVersion\n\n/** The legacy handshake era we negotiate; 2025-11-25 is wire-compatible. */\nexport const LEGACY_VERSION = \"2025-06-18\" satisfies ProtocolVersion\n\nconst isProtocolVersion = Schema.is(ProtocolVersion)\n\n/** Narrow a server-offered version string to one we support. */\nexport const asProtocolVersion = (raw: string): Option.Option<ProtocolVersion> =>\n  isProtocolVersion(raw) ? Option.some(raw) : Option.none()\n\n/**\n * The JSON-RPC methods this client issues. Not to be confused with an HTTP\n * method: on Streamable HTTP every one of these travels as a POST, and the\n * name is mirrored into the `Mcp-Method` header.\n */\nexport const McpMethod = Schema.Literals([\n  \"server/discover\",\n  \"initialize\",\n  \"tools/list\",\n  \"tools/call\",\n])\nexport type McpMethod = typeof McpMethod.Type\n\n/** Modern `_meta` keys (SEP-2575): every request self-describes its protocol. */\nexport const META_PROTOCOL_VERSION = \"io.modelcontextprotocol/protocolVersion\"\nexport const META_CLIENT_INFO = \"io.modelcontextprotocol/clientInfo\"\nexport const META_CLIENT_CAPABILITIES = \"io.modelcontextprotocol/clientCapabilities\"\n/** Servers identify themselves in each *result's* `_meta`, not at the top level. */\nexport const META_SERVER_INFO = \"io.modelcontextprotocol/serverInfo\"\n\nexport const CLIENT_INFO = { name: \"@effect-uai/mcp\", version: \"0.12.1\" }\n\n/** Modern JSON-RPC error codes. */\nexport const CODE_HEADER_MISMATCH = -32020\nexport const CODE_MISSING_CLIENT_CAPABILITY = -32021\nexport const CODE_UNSUPPORTED_PROTOCOL_VERSION = -32022\nexport const CODE_METHOD_NOT_FOUND = -32601\n\n/**\n * A reply carrying one of these proves the server speaks a modern version, so\n * era detection corrects and retries instead of falling back to `initialize`.\n */\nexport const MODERN_ERROR_CODES: ReadonlySet<number> = new Set([\n  CODE_HEADER_MISMATCH,\n  CODE_MISSING_CLIENT_CAPABILITY,\n  CODE_UNSUPPORTED_PROTOCOL_VERSION,\n])\n\n// ---------------------------------------------------------------------------\n// JSON-RPC envelope\n// ---------------------------------------------------------------------------\n\nexport const JsonRpcId = Schema.Union([Schema.Number, Schema.String])\nexport type JsonRpcId = typeof JsonRpcId.Type\n\nexport const JsonRpcErrorObject = Schema.Struct({\n  code: Schema.Number,\n  message: Schema.optional(Schema.String),\n  data: Schema.optional(Schema.Unknown),\n})\nexport type JsonRpcErrorObject = typeof JsonRpcErrorObject.Type\n\n/**\n * Any inbound frame: a reply (`id` + `result`/`error`), a server-initiated\n * request (`method` + `id`), or a notification (`method`, no `id`). One\n * loose struct so the reader can classify without a union decode.\n */\nexport const InboundMessage = Schema.Struct({\n  // Null is legal and meaningful: JSON-RPC uses it for errors raised before a\n  // request could be attributed. Rejecting it would drop the frame entirely.\n  id: Schema.optional(Schema.NullOr(JsonRpcId)),\n  result: Schema.optional(Schema.Unknown),\n  error: Schema.optional(JsonRpcErrorObject),\n  method: Schema.optional(Schema.String),\n  params: Schema.optional(Schema.Unknown),\n})\nexport type InboundMessage = typeof InboundMessage.Type\n\nexport const decodeInboundMessage = Schema.decodeUnknownEffect(InboundMessage)\n\n// --- outbound frame builders -----------------------------------------------\n\nexport const requestFrame = (id: JsonRpcId, method: string, params: unknown): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, method, params: params ?? {} })\n\nexport const notificationFrame = (method: string, params?: unknown): string =>\n  JSON.stringify(\n    params === undefined ? { jsonrpc: \"2.0\", method } : { jsonrpc: \"2.0\", method, params },\n  )\n\nexport const resultFrame = (id: JsonRpcId, result: unknown): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, result })\n\nexport const errorFrame = (id: JsonRpcId, code: number, message: string): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, error: { code, message } })\n\n// ---------------------------------------------------------------------------\n// Shared: tools\n// ---------------------------------------------------------------------------\n\nexport const ToolInfo = Schema.Struct({\n  name: Schema.String,\n  description: Schema.optional(Schema.String),\n  inputSchema: Schema.Record(Schema.String, Schema.Unknown),\n})\nexport type ToolInfo = typeof ToolInfo.Type\n\n/**\n * Modern list results may carry cache metadata (`ttlMs` / `cacheScope`);\n * v1 reads but does not act on them (input for a later refresh feature).\n */\nexport const ListToolsResult = Schema.Struct({\n  tools: Schema.Array(ToolInfo),\n  nextCursor: Schema.optional(Schema.String),\n  ttlMs: Schema.optional(Schema.Number),\n  cacheScope: Schema.optional(Schema.String),\n})\nexport type ListToolsResult = typeof ListToolsResult.Type\n\nexport const decodeListToolsResult = Schema.decodeUnknownEffect(ListToolsResult)\n\n// --- content blocks ---------------------------------------------------------\n\nexport const TextContent = Schema.Struct({\n  type: Schema.Literal(\"text\"),\n  text: Schema.String,\n})\nexport type TextContent = typeof TextContent.Type\n\nexport const ImageContent = Schema.Struct({\n  type: Schema.Literal(\"image\"),\n  data: Schema.String,\n  mimeType: Schema.String,\n})\n\nexport const AudioContent = Schema.Struct({\n  type: Schema.Literal(\"audio\"),\n  data: Schema.String,\n  mimeType: Schema.String,\n})\n\nexport const ResourceLink = Schema.Struct({\n  type: Schema.Literal(\"resource_link\"),\n  uri: Schema.String,\n  name: Schema.optional(Schema.String),\n  mimeType: Schema.optional(Schema.String),\n})\n\nexport const EmbeddedResource = Schema.Struct({\n  type: Schema.Literal(\"resource\"),\n  resource: Schema.Union([\n    Schema.Struct({ uri: Schema.String, text: Schema.String }),\n    Schema.Struct({\n      uri: Schema.String,\n      blob: Schema.String,\n      mimeType: Schema.optional(Schema.String),\n    }),\n  ]),\n})\n\n/** A block type this client does not know; summarized for the model. */\nexport const OtherContent = Schema.Struct({\n  type: Schema.String,\n})\n\nexport const KnownContent = Schema.Union([\n  TextContent,\n  ImageContent,\n  AudioContent,\n  ResourceLink,\n  EmbeddedResource,\n])\nexport type KnownContent = typeof KnownContent.Type\nexport const isKnownContent = Schema.is(KnownContent)\n\nexport const ContentBlock = Schema.Union([KnownContent, OtherContent])\nexport type ContentBlock = typeof ContentBlock.Type\n\nexport const CallToolResult = Schema.Struct({\n  content: Schema.optionalKey(Schema.Array(ContentBlock)),\n  isError: Schema.optional(Schema.Boolean),\n  structuredContent: Schema.optional(Schema.Json),\n  // Required on modern results; absent on legacy ones.\n  resultType: Schema.optional(Schema.String),\n})\nexport type CallToolResult = typeof CallToolResult.Type\n\nexport const decodeCallToolResult = Schema.decodeUnknownEffect(CallToolResult)\n\n// ---------------------------------------------------------------------------\n// Modern era (2026-07-28)\n// ---------------------------------------------------------------------------\n\nexport const ServerInfo = Schema.Struct({\n  name: Schema.String,\n  version: Schema.optional(Schema.String),\n  title: Schema.optional(Schema.String),\n})\nexport type ServerInfo = typeof ServerInfo.Type\n\n/** The subset of a result's `_meta` we read. */\nexport const ResultMeta = Schema.Struct({\n  [META_SERVER_INFO]: Schema.optional(ServerInfo),\n})\nexport type ResultMeta = typeof ResultMeta.Type\n\nexport const DiscoverResult = Schema.Struct({\n  supportedVersions: Schema.Array(Schema.String),\n  capabilities: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n  // Spec-conformant servers put identity in `_meta`; a top-level `serverInfo`\n  // is accepted too, since that is where the legacy handshake carries it.\n  _meta: Schema.optional(ResultMeta),\n  serverInfo: Schema.optional(ServerInfo),\n  instructions: Schema.optional(Schema.String),\n})\nexport type DiscoverResult = typeof DiscoverResult.Type\n\nexport const decodeDiscoverResult = Schema.decodeUnknownEffect(DiscoverResult)\n\n/**\n * `data` of a `-32022` UnsupportedProtocolVersionError reply. Decoded, not\n * hand-parsed: the shape is server-controlled and may carry extra fields.\n */\nexport const UnsupportedVersionData = Schema.Struct({\n  supported: Schema.optional(Schema.Array(Schema.String)),\n  requested: Schema.optional(Schema.NullOr(Schema.String)),\n})\nexport type UnsupportedVersionData = typeof UnsupportedVersionData.Type\n\nexport const decodeUnsupportedVersionData = Schema.decodeUnknownOption(UnsupportedVersionData)\n\n// ---------------------------------------------------------------------------\n// Legacy era (2025-06-18 / 2025-11-25)\n// ---------------------------------------------------------------------------\n\nexport const InitializeResult = Schema.Struct({\n  protocolVersion: Schema.String,\n  capabilities: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n  serverInfo: Schema.optional(ServerInfo),\n  instructions: Schema.optional(Schema.String),\n})\nexport type InitializeResult = typeof InitializeResult.Type\n\nexport const decodeInitializeResult = Schema.decodeUnknownEffect(InitializeResult)\n"],"mappings":"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"}

package/dist/internal/stdioTransport.d.mts

@@ -1,5 +1,5 @@
 import { i as McpError } from "../McpError-DWg9BlW5.mjs";
-import { i as Transport } from "../rpc-Bq95Lio9.mjs";
+import { i as Transport } from "../rpc-Bs2BCLha.mjs";
 import { Effect, Scope } from "effect";
 import { ChildProcessSpawner } from "effect/process";
 //#region src/internal/stdioTransport.d.ts

package/dist/{protocol-kjC3iAMb.d.mts → protocol-C3L9kaRW.d.mts}

@@ -1,6 +1,6 @@
 import { i as McpError } from "./McpError-DWg9BlW5.mjs";
-import { C as ProtocolVersion, T as ServerInfo, x as McpMethod } from "./schema-D2oUNuo5.mjs";
-import { n as McpConnection, r as SendMeta, t as Inbound } from "./rpc-Bq95Lio9.mjs";
+import { A as ServerInfo, D as ProtocolVersion, T as McpMethod } from "./schema-tDws3q4j.mjs";
+import { n as McpConnection, r as SendMeta, t as Inbound } from "./rpc-Bs2BCLha.mjs";
 import { Effect, Option, Scope } from "effect";
 //#region src/internal/protocol.d.ts
 type Protocol = {
@@ -32,4 +32,4 @@ type ModernRejection = {
 declare const modernRejection: (error: McpError) => Option.Option<ModernRejection>;
 //#endregion
 export { modernRejection as i, Protocol as n, ProtocolProbe as r, ModernRejection as t };
-//# sourceMappingURL=protocol-kjC3iAMb.d.mts.map
+//# sourceMappingURL=protocol-C3L9kaRW.d.mts.map

package/dist/{protocol-kjC3iAMb.d.mts.map → protocol-C3L9kaRW.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"protocol-kjC3iAMb.d.mts","names":[],"sources":["../src/internal/protocol.ts"],"mappings":";;;;;KAqBY;WACD,SAAS;WACT,YAAY;;WAEZ,WAAW,QAAQ,WAAW;;WAE9B,OAAO,QAAQ,WAAW,oBAAoB;;WAE9C,YAAY,SAAS,YAAY,OAAO;;;;;;KAOvC,iBACV,YAAY,kBACT,OAAO,OAAO,OAAO,OAAO,WAAW,UAAU,MAAM;;;;;;;;KAWhD;WACD;WACA,WAAW;;cAGT,kBAAe,OAAW,aAAW,OAAO,OAAO"}
+{"version":3,"file":"protocol-C3L9kaRW.d.mts","names":[],"sources":["../src/internal/protocol.ts"],"mappings":";;;;;KAqBY;WACD,SAAS;WACT,YAAY;;WAEZ,WAAW,QAAQ,WAAW;;WAE9B,OAAO,QAAQ,WAAW,oBAAoB;;WAE9C,YAAY,SAAS,YAAY,OAAO;;;;;;KAOvC,iBACV,YAAY,kBACT,OAAO,OAAO,OAAO,OAAO,WAAW,UAAU,MAAM;;;;;;;;KAWhD;WACD;WACA,WAAW;;cAGT,kBAAe,OAAW,aAAW,OAAO,OAAO"}

package/dist/{rpc-Bq95Lio9.d.mts → rpc-Bs2BCLha.d.mts}

@@ -1,5 +1,5 @@
 import { i as McpError } from "./McpError-DWg9BlW5.mjs";
-import { f as JsonRpcId } from "./schema-D2oUNuo5.mjs";
+import { h as JsonRpcId } from "./schema-tDws3q4j.mjs";
 import { Effect, Option, Scope, Stream } from "effect";
 //#region src/internal/rpc.d.ts
 /** Per-request transport hints (era headers on HTTP; stdio ignores them). */
@@ -31,4 +31,4 @@ type McpConnection = {
 declare const open: (transport: Transport, onInbound: (inbound: Inbound) => Effect.Effect<void>) => Effect.Effect<McpConnection, never, Scope.Scope>;
 //#endregion
 export { open as a, Transport as i, McpConnection as n, SendMeta as r, Inbound as t };
-//# sourceMappingURL=rpc-Bq95Lio9.d.mts.map
+//# sourceMappingURL=rpc-Bs2BCLha.d.mts.map

package/dist/{rpc-Bq95Lio9.d.mts.map → rpc-Bs2BCLha.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"rpc-Bq95Lio9.d.mts","names":[],"sources":["../src/internal/rpc.ts"],"mappings":";;;;;KAmBY;WACD,UAAU;;;KAIT;WACD,OAAO,eAAe,OAAO,aAAa,OAAO,aAAa;WAC9D,UAAU,OAAO,eAAe;;;KAI/B;WACD,IAAI,OAAO,OAAO;WAClB;WACA;;KAGC;WACD,UACP,gBACA,kBACA,OAAO,aACJ,OAAO,gBAAgB;WACnB,SACP,gBACA,kBACA,OAAO,aACJ,OAAO,aAAa;;WAEhB,UAAU,IAAI,WAAW,oBAAoB,OAAO,aAAa;WACjE,eACP,IAAI,WACJ,cACA,oBACG,OAAO,aAAa;;;;;;cAoBd,OAAI,WACJ,WAAS,YACR,SAAS,YAAY,OAAO,iBACvC,OAAO,OAAO,sBAAsB,MAAM"}
+{"version":3,"file":"rpc-Bs2BCLha.d.mts","names":[],"sources":["../src/internal/rpc.ts"],"mappings":";;;;;KAmBY;WACD,UAAU;;;KAIT;WACD,OAAO,eAAe,OAAO,aAAa,OAAO,aAAa;WAC9D,UAAU,OAAO,eAAe;;;KAI/B;WACD,IAAI,OAAO,OAAO;WAClB;WACA;;KAGC;WACD,UACP,gBACA,kBACA,OAAO,aACJ,OAAO,gBAAgB;WACnB,SACP,gBACA,kBACA,OAAO,aACJ,OAAO,aAAa;;WAEhB,UAAU,IAAI,WAAW,oBAAoB,OAAO,aAAa;WACjE,eACP,IAAI,WACJ,cACA,oBACG,OAAO,aAAa;;;;;;cAoBd,OAAI,WACJ,WAAS,YACR,SAAS,YAAY,OAAO,iBACvC,OAAO,OAAO,sBAAsB,MAAM"}

package/dist/{schema-D2oUNuo5.d.mts → schema-tDws3q4j.d.mts}

@@ -114,30 +114,154 @@ declare const TextContent: Schema.Struct<{
   readonly text: Schema.String;
 }>;
 type TextContent = typeof TextContent.Type;
-/** Non-text blocks (image / audio / resource) are placeholder-summarized in v1. */
+declare const ImageContent: Schema.Struct<{
+  readonly type: Schema.Literal<"image">;
+  readonly data: Schema.String;
+  readonly mimeType: Schema.String;
+}>;
+declare const AudioContent: Schema.Struct<{
+  readonly type: Schema.Literal<"audio">;
+  readonly data: Schema.String;
+  readonly mimeType: Schema.String;
+}>;
+declare const ResourceLink: Schema.Struct<{
+  readonly type: Schema.Literal<"resource_link">;
+  readonly uri: Schema.String;
+  readonly name: Schema.optional<Schema.String>;
+  readonly mimeType: Schema.optional<Schema.String>;
+}>;
+declare const EmbeddedResource: Schema.Struct<{
+  readonly type: Schema.Literal<"resource">;
+  readonly resource: Schema.Union<readonly [Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly blob: Schema.String;
+    readonly mimeType: Schema.optional<Schema.String>;
+  }>]>;
+}>;
+/** A block type this client does not know; summarized for the model. */
 declare const OtherContent: Schema.Struct<{
   readonly type: Schema.String;
 }>;
-declare const ContentBlock: Schema.Union<readonly [Schema.Struct<{
+declare const KnownContent: Schema.Union<readonly [Schema.Struct<{
   readonly type: Schema.Literal<"text">;
   readonly text: Schema.String;
 }>, Schema.Struct<{
-  readonly type: Schema.String;
+  readonly type: Schema.Literal<"image">;
+  readonly data: Schema.String;
+  readonly mimeType: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"audio">;
+  readonly data: Schema.String;
+  readonly mimeType: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"resource_link">;
+  readonly uri: Schema.String;
+  readonly name: Schema.optional<Schema.String>;
+  readonly mimeType: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"resource">;
+  readonly resource: Schema.Union<readonly [Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly blob: Schema.String;
+    readonly mimeType: Schema.optional<Schema.String>;
+  }>]>;
 }>]>;
-type ContentBlock = typeof ContentBlock.Type;
-declare const isTextContent: <I>(input: I) => input is I & {
+type KnownContent = typeof KnownContent.Type;
+declare const isKnownContent: <I>(input: I) => input is I & ({
   readonly type: "text";
   readonly text: string;
-};
+} | {
+  readonly type: "image";
+  readonly data: string;
+  readonly mimeType: string;
+} | {
+  readonly type: "audio";
+  readonly data: string;
+  readonly mimeType: string;
+} | {
+  readonly type: "resource_link";
+  readonly uri: string;
+  readonly name?: string | undefined;
+  readonly mimeType?: string | undefined;
+} | {
+  readonly type: "resource";
+  readonly resource: {
+    readonly uri: string;
+    readonly text: string;
+  } | {
+    readonly uri: string;
+    readonly blob: string;
+    readonly mimeType?: string | undefined;
+  };
+});
+declare const ContentBlock: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"text">;
+  readonly text: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"image">;
+  readonly data: Schema.String;
+  readonly mimeType: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"audio">;
+  readonly data: Schema.String;
+  readonly mimeType: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"resource_link">;
+  readonly uri: Schema.String;
+  readonly name: Schema.optional<Schema.String>;
+  readonly mimeType: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"resource">;
+  readonly resource: Schema.Union<readonly [Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly blob: Schema.String;
+    readonly mimeType: Schema.optional<Schema.String>;
+  }>]>;
+}>]>, Schema.Struct<{
+  readonly type: Schema.String;
+}>]>;
+type ContentBlock = typeof ContentBlock.Type;
 declare const CallToolResult: Schema.Struct<{
-  readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+  readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"text">;
     readonly text: Schema.String;
   }>, Schema.Struct<{
+    readonly type: Schema.Literal<"image">;
+    readonly data: Schema.String;
+    readonly mimeType: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"audio">;
+    readonly data: Schema.String;
+    readonly mimeType: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"resource_link">;
+    readonly uri: Schema.String;
+    readonly name: Schema.optional<Schema.String>;
+    readonly mimeType: Schema.optional<Schema.String>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"resource">;
+    readonly resource: Schema.Union<readonly [Schema.Struct<{
+      readonly uri: Schema.String;
+      readonly text: Schema.String;
+    }>, Schema.Struct<{
+      readonly uri: Schema.String;
+      readonly blob: Schema.String;
+      readonly mimeType: Schema.optional<Schema.String>;
+    }>]>;
+  }>]>, Schema.Struct<{
     readonly type: Schema.String;
   }>]>>>;
   readonly isError: Schema.optional<Schema.Boolean>;
-  readonly structuredContent: Schema.optional<Schema.Unknown>;
+  readonly structuredContent: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
   readonly resultType: Schema.optional<Schema.String>;
 }>;
 type CallToolResult = typeof CallToolResult.Type;
@@ -145,11 +269,34 @@ declare const decodeCallToolResult: (input: unknown, options?: import("effect/Sc
   readonly content?: readonly ({
     readonly type: "text";
     readonly text: string;
+  } | {
+    readonly type: "image";
+    readonly data: string;
+    readonly mimeType: string;
+  } | {
+    readonly type: "audio";
+    readonly data: string;
+    readonly mimeType: string;
+  } | {
+    readonly type: "resource_link";
+    readonly uri: string;
+    readonly name?: string | undefined;
+    readonly mimeType?: string | undefined;
+  } | {
+    readonly type: "resource";
+    readonly resource: {
+      readonly uri: string;
+      readonly text: string;
+    } | {
+      readonly uri: string;
+      readonly blob: string;
+      readonly mimeType?: string | undefined;
+    };
   } | {
     readonly type: string;
   })[];
   readonly isError?: boolean | undefined;
-  readonly structuredContent?: unknown;
+  readonly structuredContent?: Schema.Json | undefined;
   readonly resultType?: string | undefined;
 }, Schema.SchemaError, never>;
 declare const ServerInfo: Schema.Struct<{
@@ -241,5 +388,5 @@ declare const decodeInitializeResult: (input: unknown, options?: import("effect/
   readonly instructions?: string | undefined;
 }, Schema.SchemaError, never>;
 //#endregion
-export { decodeCallToolResult as A, resultFrame as B, ProtocolVersion as C, ToolInfo as D, TextContent as E, decodeUnsupportedVersionData as F, errorFrame as I, isTextContent as L, decodeInboundMessage as M, decodeInitializeResult as N, UnsupportedVersionData as O, decodeListToolsResult as P, notificationFrame as R, OtherContent as S, ServerInfo as T, META_CLIENT_INFO as _, CODE_UNSUPPORTED_PROTOCOL_VERSION as a, MODERN_ERROR_CODES as b, DiscoverResult as c, JsonRpcErrorObject as d, JsonRpcId as f, META_CLIENT_CAPABILITIES as g, ListToolsResult as h, CODE_MISSING_CLIENT_CAPABILITY as i, decodeDiscoverResult as j, asProtocolVersion as k, InboundMessage as l, LEGACY_VERSION as m, CODE_HEADER_MISMATCH as n, CallToolResult as o, LATEST_VERSION as p, CODE_METHOD_NOT_FOUND as r, ContentBlock as s, CLIENT_INFO as t, InitializeResult as u, META_PROTOCOL_VERSION as v, ResultMeta as w, McpMethod as x, META_SERVER_INFO as y, requestFrame as z };
-//# sourceMappingURL=schema-D2oUNuo5.d.mts.map
+export { ServerInfo as A, decodeUnsupportedVersionData as B, META_SERVER_INFO as C, ProtocolVersion as D, OtherContent as E, decodeCallToolResult as F, resultFrame as G, isKnownContent as H, decodeDiscoverResult as I, decodeInboundMessage as L, ToolInfo as M, UnsupportedVersionData as N, ResourceLink as O, asProtocolVersion as P, decodeInitializeResult as R, META_PROTOCOL_VERSION as S, McpMethod as T, notificationFrame as U, errorFrame as V, requestFrame as W, LATEST_VERSION as _, CODE_MISSING_CLIENT_CAPABILITY as a, META_CLIENT_CAPABILITIES as b, ContentBlock as c, ImageContent as d, InboundMessage as f, KnownContent as g, JsonRpcId as h, CODE_METHOD_NOT_FOUND as i, TextContent as j, ResultMeta as k, DiscoverResult as l, JsonRpcErrorObject as m, CLIENT_INFO as n, CODE_UNSUPPORTED_PROTOCOL_VERSION as o, InitializeResult as p, CODE_HEADER_MISMATCH as r, CallToolResult as s, AudioContent as t, EmbeddedResource as u, LEGACY_VERSION as v, MODERN_ERROR_CODES as w, META_CLIENT_INFO as x, ListToolsResult as y, decodeListToolsResult as z };
+//# sourceMappingURL=schema-tDws3q4j.d.mts.map

package/dist/schema-tDws3q4j.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-tDws3q4j.d.mts","names":[],"sources":["../src/internal/schema.ts"],"mappings":";;;cAaa,iBAAe,OAAA;KAChB,yBAAyB,gBAAgB;;cAGxC;;cAGA;;cAKA,oBAAiB,gBAAkB,OAAO,OAAO;;;;;;cAQjD,WAAS,OAAA;KAMV,mBAAmB,UAAU;;cAG5B;cACA;cACA;;cAEA;cAEA;EAAgB;EAAyB;;;cAGzC;cACA;cACA;cACA;;;;;cAMA,oBAAoB;cAUpB,WAAS,OAAA,gBAAA,OAAA,QAAA,OAAA;KACV,mBAAmB,UAAU;cAE5B,oBAAkB,OAAA;;;;;KAKnB,4BAA4B,mBAAmB;;;;;;cAO9C,gBAAc,OAAA;;;;;;;;;;;KASf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;GAA6C,OAAA;cAIjE,eAAY,IAAQ,WAAS,gBAAgB;cAG7C,oBAAiB,gBAAkB;cAKnC,cAAW,IAAQ,WAAS;cAG5B,aAAU,IAAQ,WAAS,cAAc;cAOzC,UAAQ,OAAA;;;;;KAKT,kBAAkB,SAAS;;;;;cAM1B,iBAAe,OAAA;;;;;;;;;;KAMhB,yBAAyB,gBAAgB;cAExC,wBAAqB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;GAA8C,OAAA;cAInE,aAAW,OAAA;;;;KAIZ,qBAAqB,YAAY;cAEhC,cAAY,OAAA;;;;;cAMZ,cAAY,OAAA;;;;;cAMZ,cAAY,OAAA;;;;;;cAOZ,kBAAgB,OAAA;;;;;;;;;;;;cAahB,cAAY,OAAA;iBAAZ,OAAA;;cAIA,cAAY,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOb,sBAAsB,aAAa;cAClC,iBAAc,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEd,cAAY,OAAA,gBAAA,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACb,sBAAsB,aAAa;cAElC,gBAAc,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAApB,OAAA;;GAAiE,OAAA;cAMjE,YAAU,OAAA;;;;;KAKX,oBAAoB,WAAW;;cAG9B,YAAU,OAAA;;;;;;;KAGX,oBAAoB,WAAW;cAE9B,gBAAc,OAAA;;;;;;;;;;;;;;;;;KASf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;;;;;;;;GAA6C,OAAA;;;;;cAMjE,wBAAsB,OAAA;;;;KAIvB,gCAAgC,uBAAuB;cAEtD,+BAA4B,gBAAA,qCAAA,iBAAA,OAAA;;;;cAM5B,kBAAgB,OAAA;;;;;;;;;;KAMjB,0BAA0B,iBAAiB;cAE1C,yBAAsB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;GAA+C,OAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/mcp",
-  "version": "0.18.0",
+  "version": "0.19.0-dev-20261109183959",
   "description": "Model Context Protocol client provider for @effect-uai/core.",
   "keywords": [
     "agents",
@@ -53,14 +53,14 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@effect/platform-node": "4.0.1",
-    "@effect/vitest": "4.0.1",
-    "effect": "4.0.1",
+    "@effect/platform-node": "4.1.2",
+    "@effect/vitest": "4.1.2",
+    "effect": "4.1.2",
     "typescript": "^7.0.2",
-    "@effect-uai/core": "0.18.0"
+    "@effect-uai/core": "0.19.0-dev-20261109183959"
   },
   "peerDependencies": {
-    "@effect-uai/core": ">=0.5.0 <1",
+    "@effect-uai/core": "0.19.0-dev-20261109183959",
     "effect": ">=4.0.1 <5.0.0"
   },
   "scripts": {

package/src/Toolkit.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "@effect/vitest"
+import type { ToolCall } from "@effect-uai/core/Items"
+import * as CoreToolkit from "@effect-uai/core/Toolkit"
+import { Effect, Stream } from "effect"
+import type { McpClient } from "./Client.js"
+import { decodeCallToolResult } from "./internal/schema.js"
+import { mcpToolkit } from "./Toolkit.js"
+
+// A client whose `tools/call` results are raw wire JSON, decoded like the real one.
+const clientReturning = (raw: unknown): McpClient => ({
+  serverInfo: { name: "fake", protocolVersion: "2026-07-28" },
+  listTools: Effect.succeed([{ name: "shot", inputSchema: { type: "object" } }]),
+  callTool: () => Effect.orDie(decodeCallToolResult(raw)),
+})
+
+const call: ToolCall = { type: "function_call", call_id: "c1", name: "shot", arguments: "{}" }
+
+const historyOf = (raw: unknown) =>
+  Effect.gen(function* () {
+    const kit = yield* mcpToolkit(clientReturning(raw))
+    return yield* CoreToolkit.run(kit, [call]).pipe(
+      Stream.filter(CoreToolkit.isOutcome),
+      Stream.mapEffect(CoreToolkit.output(kit)),
+      Stream.runCollect,
+    )
+  })
+
+describe("mcpToolkit", () => {
+  it.effect("keeps images, audio and resources as media parts instead of dropping them", () =>
+    Effect.gen(function* () {
+      const [item] = yield* historyOf({
+        content: [
+          { type: "text", text: "Home page" },
+          { type: "image", data: "AQID", mimeType: "image/png" },
+          { type: "audio", data: "AAAA", mimeType: "audio/wav" },
+          { type: "resource_link", uri: "https://x/a.pdf", name: "a.pdf" },
+          { type: "resource", resource: { uri: "mem://n", text: "a note" } },
+          { type: "hologram" },
+        ],
+      })
+      expect(item?.output).toEqual([
+        { type: "input_text", text: "Home page" },
+        {
+          type: "input_image",
+          source: { _tag: "base64", base64: "AQID", mimeType: "image/png" },
+        },
+        { type: "input_file", source: { _tag: "base64", base64: "AAAA", mimeType: "audio/wav" } },
+        { type: "input_file", source: { _tag: "url", url: "https://x/a.pdf" }, filename: "a.pdf" },
+        { type: "input_text", text: "a note" },
+        { type: "input_text", text: "[hologram content omitted]" },
+      ])
+    }),
+  )
+
+  it.effect("prefers structuredContent over its repeated text, keeping media", () =>
+    Effect.gen(function* () {
+      const [item] = yield* historyOf({
+        content: [
+          { type: "text", text: '{"hits":2}' },
+          { type: "image", data: "AQID", mimeType: "image/png" },
+        ],
+        structuredContent: { hits: 2 },
+      })
+      expect(item?.output.map((p) => (p.type === "input_json" ? p.value : p.type))).toEqual([
+        { hits: 2 },
+        "input_image",
+      ])
+    }),
+  )
+
+  it.effect("turns isError into the declared McpToolFailed the model reads", () =>
+    Effect.gen(function* () {
+      const [item] = yield* historyOf({
+        content: [{ type: "text", text: "rate limited" }],
+        isError: true,
+      })
+      expect(item).toMatchObject({
+        isError: true,
+        output: [{ type: "input_json", value: { _tag: "McpToolFailed", message: "rate limited" } }],
+      })
+    }),
+  )
+})

package/src/Toolkit.ts

@@ -1,17 +1,22 @@
 /**
- * Turn a connected MCP server into a core `Toolkit`, one `LocalTool` per MCP
+ * Turn a connected MCP server into a core `Toolkit`, one local tool per MCP
  * tool. Effectful because the tool list is fetched; composes with
  * `Toolkit.compose` like any other kit.
  */
-import { Effect, Option } from "effect"
+import { Effect, Match, Option, Schema } from "effect"
+import * as Content from "@effect-uai/core/Content"
+import { fileBase64, fileUrl } from "@effect-uai/core/File"
+import { imageBase64 } from "@effect-uai/core/Image"
 import * as Tool from "@effect-uai/core/Tool"
 import * as CoreToolkit from "@effect-uai/core/Toolkit"
+import * as ToolOutput from "@effect-uai/core/ToolOutput"
 import type { McpClient } from "./Client.js"
 import { type McpError, McpProtocolError } from "./McpError.js"
 import {
   type CallToolResult,
   type ContentBlock,
-  isTextContent,
+  isKnownContent,
+  type KnownContent,
   type ToolInfo,
 } from "./internal/schema.js"
 
@@ -20,6 +25,11 @@ export type McpToolkitOptions = {
   readonly prefix?: string
 }
 
+/** The server reported an error (`isError`); the model sees its content as `message`. */
+export class McpToolFailed extends Schema.TaggedError<McpToolFailed>(
+  "@betalyra/effect-uai/mcp/McpToolFailed",
+)("McpToolFailed", { message: Schema.String }) {}
+
 /**
  * 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
@@ -38,59 +48,80 @@ const passthroughSchema = (tool: ToolInfo): Tool.ToolInputSchema<unknown> => ({
   },
 })
 
-const textOf = (block: ContentBlock): string =>
-  isTextContent(block) ? block.text : `[${block.type} content omitted]`
+// A blob without a MIME type is opaque bytes.
+const knownValue = Match.type<KnownContent>().pipe(
+  Match.discriminatorsExhaustive("type")({
+    text: (b): string | Content.Media => b.text,
+    image: (b) => Content.image(imageBase64(b.data, b.mimeType)),
+    audio: (b) => Content.file(fileBase64(b.data, b.mimeType)),
+    resource_link: (b) => Content.file(fileUrl(b.uri, b.mimeType), b.name),
+    resource: ({ resource }) =>
+      "text" in resource
+        ? resource.text
+        : Content.file(fileBase64(resource.blob, resource.mimeType ?? "application/octet-stream")),
+  }),
+)
+
+const valueOf = (block: ContentBlock): string | Content.Media =>
+  isKnownContent(block) ? knownValue(block) : `[${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.
+ * A result as the tool's value: `structuredContent` when the server provides it
+ * (its text blocks usually repeat it), plus any media; otherwise every block.
  */
-const outputOf = (result: CallToolResult): unknown =>
-  result.structuredContent ?? (result.content ?? []).map(textOf).join("\n")
+const outputOf = (result: CallToolResult): Content.Value => {
+  const values: ReadonlyArray<Schema.Json | Content.Media> = (result.content ?? []).map(valueOf)
+  return Option.match(Option.fromNullishOr(result.structuredContent), {
+    onNone: () => ToolOutput.single(values),
+    onSome: (structured) => ToolOutput.single([structured, ...values.filter(Content.isMedia)]),
+  })
+}
+
+const messageOf = (result: CallToolResult): string =>
+  (result.content ?? [])
+    .map(valueOf)
+    .filter((v): v is string => typeof v === "string")
+    .join("\n")
 
 /**
  * Two failure channels, deliberately: `isError` is the server telling the
- * model it went wrong, so it becomes a model-visible `ToolFailed`; an
+ * model it went wrong, so it becomes the declared `McpToolFailed`; an
  * `input_required` result is a protocol capability gap the model cannot fix,
- * so it stays a typed `McpError`.
+ * so it stays a typed `McpError` and fails the run.
  */
 const interpret = (
   name: string,
   result: CallToolResult,
-): Effect.Effect<unknown, McpError | Tool.ToolFailed> => {
-  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: McpClient, name: string) =>
-  (input: unknown): Effect.Effect<unknown, McpError | Tool.ToolFailed> =>
-    client.callTool(name, input).pipe(Effect.flatMap((result) => interpret(name, result)))
+): Effect.Effect<Content.Value, McpError | McpToolFailed> =>
+  Match.value(result).pipe(
+    Match.when({ isError: true }, (r) => Effect.fail(new McpToolFailed({ message: messageOf(r) }))),
+    Match.when({ resultType: "input_required" }, () =>
+      Effect.fail(
+        new McpProtocolError({
+          method: "tools/call",
+          reason: `${name} requires interactive input (MRTR), unsupported by this client`,
+        }),
+      ),
+    ),
+    Match.orElse((r) => Effect.succeed(outputOf(r))),
+  )
 
 const toLocalTool = (client: McpClient, info: ToolInfo) =>
   Tool.make({
     name: info.name,
     description: info.description ?? info.name,
     inputSchema: passthroughSchema(info),
-    run: runTool(client, info.name),
+    // Known only at runtime: any mix of text, JSON and media.
+    outputSchema: Content.Value,
+    failureSchema: McpToolFailed,
+    run: (input) =>
+      client.callTool(info.name, input).pipe(Effect.flatMap((r) => interpret(info.name, r))),
     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.
+ * here; a tool that later vanishes surfaces as `Toolkit.run`'s `UnknownTool`.
  */
 export const mcpToolkit = (
   client: McpClient,

package/src/internal/schema.ts

@@ -145,20 +145,59 @@ export const TextContent = Schema.Struct({
 })
 export type TextContent = typeof TextContent.Type
 
-/** Non-text blocks (image / audio / resource) are placeholder-summarized in v1. */
+export const ImageContent = Schema.Struct({
+  type: Schema.Literal("image"),
+  data: Schema.String,
+  mimeType: Schema.String,
+})
+
+export const AudioContent = Schema.Struct({
+  type: Schema.Literal("audio"),
+  data: Schema.String,
+  mimeType: Schema.String,
+})
+
+export const ResourceLink = Schema.Struct({
+  type: Schema.Literal("resource_link"),
+  uri: Schema.String,
+  name: Schema.optional(Schema.String),
+  mimeType: Schema.optional(Schema.String),
+})
+
+export const EmbeddedResource = Schema.Struct({
+  type: Schema.Literal("resource"),
+  resource: Schema.Union([
+    Schema.Struct({ uri: Schema.String, text: Schema.String }),
+    Schema.Struct({
+      uri: Schema.String,
+      blob: Schema.String,
+      mimeType: Schema.optional(Schema.String),
+    }),
+  ]),
+})
+
+/** A block type this client does not know; summarized for the model. */
 export const OtherContent = Schema.Struct({
   type: Schema.String,
 })
 
-export const ContentBlock = Schema.Union([TextContent, OtherContent])
-export type ContentBlock = typeof ContentBlock.Type
+export const KnownContent = Schema.Union([
+  TextContent,
+  ImageContent,
+  AudioContent,
+  ResourceLink,
+  EmbeddedResource,
+])
+export type KnownContent = typeof KnownContent.Type
+export const isKnownContent = Schema.is(KnownContent)
 
-export const isTextContent = Schema.is(TextContent)
+export const ContentBlock = Schema.Union([KnownContent, OtherContent])
+export type ContentBlock = typeof ContentBlock.Type
 
 export const CallToolResult = Schema.Struct({
   content: Schema.optionalKey(Schema.Array(ContentBlock)),
   isError: Schema.optional(Schema.Boolean),
-  structuredContent: Schema.optional(Schema.Unknown),
+  structuredContent: Schema.optional(Schema.Json),
   // Required on modern results; absent on legacy ones.
   resultType: Schema.optional(Schema.String),
 })

package/dist/auth-ZDvsxpCo.d.mts

@@ -1,126 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/schema-D2oUNuo5.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-D2oUNuo5.d.mts","names":[],"sources":["../src/internal/schema.ts"],"mappings":";;;cAaa,iBAAe,OAAA;KAChB,yBAAyB,gBAAgB;;cAGxC;;cAGA;;cAKA,oBAAiB,gBAAkB,OAAO,OAAO;;;;;;cAQjD,WAAS,OAAA;KAMV,mBAAmB,UAAU;;cAG5B;cACA;cACA;;cAEA;cAEA;EAAgB;EAAyB;;;cAGzC;cACA;cACA;cACA;;;;;cAMA,oBAAoB;cAUpB,WAAS,OAAA,gBAAA,OAAA,QAAA,OAAA;KACV,mBAAmB,UAAU;cAE5B,oBAAkB,OAAA;;;;;KAKnB,4BAA4B,mBAAmB;;;;;;cAO9C,gBAAc,OAAA;;;;;;;;;;;KASf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;GAA6C,OAAA;cAIjE,eAAY,IAAQ,WAAS,gBAAgB;cAG7C,oBAAiB,gBAAkB;cAKnC,cAAW,IAAQ,WAAS;cAG5B,aAAU,IAAQ,WAAS,cAAc;cAOzC,UAAQ,OAAA;;;;;KAKT,kBAAkB,SAAS;;;;;cAM1B,iBAAe,OAAA;;;;;;;;;;KAMhB,yBAAyB,gBAAgB;cAExC,wBAAqB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;GAA8C,OAAA;cAInE,aAAW,OAAA;;;;KAIZ,qBAAqB,YAAY;;cAGhC,cAAY,OAAA;iBAAZ,OAAA;;cAIA,cAAY,OAAA,gBAAA,OAAA;;;;;;KACb,sBAAsB,aAAa;cAElC,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;cAEb,gBAAc,OAAA;;;;;;;;;;;KAOf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;GAA6C,OAAA;cAMjE,YAAU,OAAA;;;;;KAKX,oBAAoB,WAAW;;cAG9B,YAAU,OAAA;;;;;;;KAGX,oBAAoB,WAAW;cAE9B,gBAAc,OAAA;;;;;;;;;;;;;;;;;KASf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;;;;;;;;GAA6C,OAAA;;;;;cAMjE,wBAAsB,OAAA;;;;KAIvB,gCAAgC,uBAAuB;cAEtD,+BAA4B,gBAAA,qCAAA,iBAAA,OAAA;;;;cAM5B,kBAAgB,OAAA;;;;;;;;;;KAMjB,0BAA0B,iBAAiB;cAE1C,yBAAsB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;GAA+C,OAAA"}