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

package/dist/internal/stdioTransport.d.mts

@@ -1,7 +1,7 @@
 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/unstable/process";
+import { ChildProcessSpawner } from "effect/process";
 //#region src/internal/stdioTransport.d.ts
 type StdioConfig = {
   readonly command: string;

package/dist/internal/stdioTransport.mjs

@@ -1,7 +1,7 @@
 import { McpConnectFailed, McpTransportClosed } from "../McpError.mjs";
 import { Effect, Queue, Stream } from "effect";
 import * as JSONL from "@effect-uai/core/JSONL";
-import { ChildProcess } from "effect/unstable/process";
+import { ChildProcess } from "effect/process";
 //#region src/internal/stdioTransport.ts
 /**
 * stdio `Transport`: spawn the server, frame stdout as JSONL (one JSON message

package/dist/internal/stdioTransport.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"stdioTransport.mjs","names":[],"sources":["../../src/internal/stdioTransport.ts"],"sourcesContent":["/**\n * stdio `Transport`: spawn the server, frame stdout as JSONL (one JSON message\n * per line). Scoped, so the child is killed on scope close. Era-blind; the\n * `meta.headers` a caller passes are HTTP-only and ignored here.\n */\nimport { Cause, Effect, Queue, type Scope, Stream } from \"effect\"\nimport { ChildProcess, ChildProcessSpawner } from \"effect/unstable/process\"\nimport * as JSONL from \"@effect-uai/core/JSONL\"\nimport { McpConnectFailed, type McpError, McpTransportClosed } from \"../McpError.js\"\nimport type { Transport } from \"./rpc.js\"\n\nexport type StdioConfig = {\n  readonly command: string\n  readonly args?: ReadonlyArray<string>\n  readonly env?: Record<string, string>\n  readonly cwd?: string\n}\n\nconst encoder = new TextEncoder()\n\nexport const make = (\n  config: StdioConfig,\n): Effect.Effect<Transport, McpError, Scope.Scope | ChildProcessSpawner.ChildProcessSpawner> =>\n  Effect.gen(function* () {\n    // Outbound frames go through a queue rendered as the child's stdin stream;\n    // `Queue.end` on scope close lets the child see a clean EOF.\n    const outbound = yield* Queue.make<Uint8Array, Cause.Done>()\n    const stdin = Stream.fromQueue(outbound)\n\n    const handle = yield* ChildProcess.make(config.command, [...(config.args ?? [])], {\n      ...(config.cwd !== undefined ? { cwd: config.cwd } : {}),\n      ...(config.env !== undefined ? { env: config.env } : {}),\n      stdin: { stream: stdin, endOnDone: true },\n      stdout: \"pipe\",\n      stderr: \"pipe\",\n      killSignal: \"SIGTERM\",\n      forceKillAfter: \"2 seconds\",\n    }).pipe(\n      Effect.mapError(\n        (cause) =>\n          new McpConnectFailed({ reason: `could not spawn ${config.command}`, raw: cause }),\n      ),\n    )\n    yield* Effect.addFinalizer(() => Queue.end(outbound))\n\n    const send = (frame: string): Effect.Effect<void, McpError> =>\n      Queue.offer(outbound, encoder.encode(`${frame}\\n`)).pipe(\n        Effect.mapError(\n          (cause) =>\n            new McpTransportClosed({ reason: \"server stdin closed\", raw: cause }) as McpError,\n        ),\n        Effect.asVoid,\n      )\n\n    const messages = handle.stdout.pipe(\n      JSONL.fromBytes,\n      Stream.mapError(\n        (cause) => new McpTransportClosed({ reason: \"server stdout closed\", raw: cause }),\n      ),\n    )\n\n    return { send, messages } satisfies Transport\n  })\n"],"mappings":";;;;;;;;;;AAkBA,MAAM,UAAU,IAAI,YAAY;AAEhC,MAAa,QACX,WAEA,OAAO,IAAI,aAAa;CAGtB,MAAM,WAAW,OAAO,MAAM,KAA6B;CAC3D,MAAM,QAAQ,OAAO,UAAU,QAAQ;CAEvC,MAAM,SAAS,OAAO,aAAa,KAAK,OAAO,SAAS,CAAC,GAAI,OAAO,QAAQ,CAAC,CAAE,GAAG;EAChF,GAAI,OAAO,QAAQ,KAAA,IAAY,EAAE,KAAK,OAAO,IAAI,IAAI,CAAC;EACtD,GAAI,OAAO,QAAQ,KAAA,IAAY,EAAE,KAAK,OAAO,IAAI,IAAI,CAAC;EACtD,OAAO;GAAE,QAAQ;GAAO,WAAW;EAAK;EACxC,QAAQ;EACR,QAAQ;EACR,YAAY;EACZ,gBAAgB;CAClB,CAAC,CAAC,CAAC,KACD,OAAO,UACJ,UACC,IAAI,iBAAiB;EAAE,QAAQ,mBAAmB,OAAO;EAAW,KAAK;CAAM,CAAC,CACpF,CACF;CACA,OAAO,OAAO,mBAAmB,MAAM,IAAI,QAAQ,CAAC;CAEpD,MAAM,QAAQ,UACZ,MAAM,MAAM,UAAU,QAAQ,OAAO,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,KAClD,OAAO,UACJ,UACC,IAAI,mBAAmB;EAAE,QAAQ;EAAuB,KAAK;CAAM,CAAC,CACxE,GACA,OAAO,MACT;CASF,OAAO;EAAE;EAAM,UAPE,OAAO,OAAO,KAC7B,MAAM,WACN,OAAO,UACJ,UAAU,IAAI,mBAAmB;GAAE,QAAQ;GAAwB,KAAK;EAAM,CAAC,CAClF,CAGoB;CAAE;AAC1B,CAAC"}
+{"version":3,"file":"stdioTransport.mjs","names":[],"sources":["../../src/internal/stdioTransport.ts"],"sourcesContent":["/**\n * stdio `Transport`: spawn the server, frame stdout as JSONL (one JSON message\n * per line). Scoped, so the child is killed on scope close. Era-blind; the\n * `meta.headers` a caller passes are HTTP-only and ignored here.\n */\nimport { Cause, Effect, Queue, type Scope, Stream } from \"effect\"\nimport { ChildProcess, ChildProcessSpawner } from \"effect/process\"\nimport * as JSONL from \"@effect-uai/core/JSONL\"\nimport { McpConnectFailed, type McpError, McpTransportClosed } from \"../McpError.js\"\nimport type { Transport } from \"./rpc.js\"\n\nexport type StdioConfig = {\n  readonly command: string\n  readonly args?: ReadonlyArray<string>\n  readonly env?: Record<string, string>\n  readonly cwd?: string\n}\n\nconst encoder = new TextEncoder()\n\nexport const make = (\n  config: StdioConfig,\n): Effect.Effect<Transport, McpError, Scope.Scope | ChildProcessSpawner.ChildProcessSpawner> =>\n  Effect.gen(function* () {\n    // Outbound frames go through a queue rendered as the child's stdin stream;\n    // `Queue.end` on scope close lets the child see a clean EOF.\n    const outbound = yield* Queue.make<Uint8Array, Cause.Done>()\n    const stdin = Stream.fromQueue(outbound)\n\n    const handle = yield* ChildProcess.make(config.command, [...(config.args ?? [])], {\n      ...(config.cwd !== undefined ? { cwd: config.cwd } : {}),\n      ...(config.env !== undefined ? { env: config.env } : {}),\n      stdin: { stream: stdin, endOnDone: true },\n      stdout: \"pipe\",\n      stderr: \"pipe\",\n      killSignal: \"SIGTERM\",\n      forceKillAfter: \"2 seconds\",\n    }).pipe(\n      Effect.mapError(\n        (cause) =>\n          new McpConnectFailed({ reason: `could not spawn ${config.command}`, raw: cause }),\n      ),\n    )\n    yield* Effect.addFinalizer(() => Queue.end(outbound))\n\n    const send = (frame: string): Effect.Effect<void, McpError> =>\n      Queue.offer(outbound, encoder.encode(`${frame}\\n`)).pipe(\n        Effect.mapError(\n          (cause) =>\n            new McpTransportClosed({ reason: \"server stdin closed\", raw: cause }) as McpError,\n        ),\n        Effect.asVoid,\n      )\n\n    const messages = handle.stdout.pipe(\n      JSONL.fromBytes,\n      Stream.mapError(\n        (cause) => new McpTransportClosed({ reason: \"server stdout closed\", raw: cause }),\n      ),\n    )\n\n    return { send, messages } satisfies Transport\n  })\n"],"mappings":";;;;;;;;;;AAkBA,MAAM,UAAU,IAAI,YAAY;AAEhC,MAAa,QACX,WAEA,OAAO,IAAI,aAAa;CAGtB,MAAM,WAAW,OAAO,MAAM,KAA6B;CAC3D,MAAM,QAAQ,OAAO,UAAU,QAAQ;CAEvC,MAAM,SAAS,OAAO,aAAa,KAAK,OAAO,SAAS,CAAC,GAAI,OAAO,QAAQ,CAAC,CAAE,GAAG;EAChF,GAAI,OAAO,QAAQ,KAAA,IAAY,EAAE,KAAK,OAAO,IAAI,IAAI,CAAC;EACtD,GAAI,OAAO,QAAQ,KAAA,IAAY,EAAE,KAAK,OAAO,IAAI,IAAI,CAAC;EACtD,OAAO;GAAE,QAAQ;GAAO,WAAW;EAAK;EACxC,QAAQ;EACR,QAAQ;EACR,YAAY;EACZ,gBAAgB;CAClB,CAAC,CAAC,CAAC,KACD,OAAO,UACJ,UACC,IAAI,iBAAiB;EAAE,QAAQ,mBAAmB,OAAO;EAAW,KAAK;CAAM,CAAC,CACpF,CACF;CACA,OAAO,OAAO,mBAAmB,MAAM,IAAI,QAAQ,CAAC;CAEpD,MAAM,QAAQ,UACZ,MAAM,MAAM,UAAU,QAAQ,OAAO,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,KAClD,OAAO,UACJ,UACC,IAAI,mBAAmB;EAAE,QAAQ;EAAuB,KAAK;CAAM,CAAC,CACxE,GACA,OAAO,MACT;CASF,OAAO;EAAE;EAAM,UAPE,OAAO,OAAO,KAC7B,MAAM,WACN,OAAO,UACJ,UAAU,IAAI,mBAAmB;GAAE,QAAQ;GAAwB,KAAK;EAAM,CAAC,CAClF,CAGoB;CAAE;AAC1B,CAAC"}

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.17.0",
+  "version": "0.19.0-dev-20261109183959",
   "description": "Model Context Protocol client provider for @effect-uai/core.",
   "keywords": [
     "agents",
@@ -53,15 +53,15 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-rc.111",
-    "@effect/vitest": "4.0.0-rc.111",
-    "effect": "4.0.0-rc.111",
+    "@effect/platform-node": "4.1.2",
+    "@effect/vitest": "4.1.2",
+    "effect": "4.1.2",
     "typescript": "^7.0.2",
-    "@effect-uai/core": "0.17.0"
+    "@effect-uai/core": "0.19.0-dev-20261109183959"
   },
   "peerDependencies": {
-    "@effect-uai/core": ">=0.5.0 <1",
-    "effect": ">=4.0.0-rc.111 <5.0.0"
+    "@effect-uai/core": "0.19.0-dev-20261109183959",
+    "effect": ">=4.0.1 <5.0.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/Client.ts

@@ -4,8 +4,8 @@
  * and fixed for the connection's lifetime. The client surface is era-uniform.
  */
 import { Context, Effect, Layer, Option, Ref, type Scope } from "effect"
-import type { HttpClient } from "effect/unstable/http"
-import type { ChildProcessSpawner } from "effect/unstable/process"
+import type { HttpClient } from "effect/http"
+import type { ChildProcessSpawner } from "effect/process"
 import { McpConnectFailed, type McpError, McpProtocolError } from "./McpError.js"
 import { Auth, type TokenSource } from "./internal/auth.js"
 import * as Handshake from "./internal/protocols/2025-06-18.js"

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/httpTransport.ts

@@ -9,7 +9,7 @@
  * cancellation signal (closing the response stream).
  */
 import { Cause, Effect, Match, Option, Queue, Ref, type Scope, Stream } from "effect"
-import { HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/http"
 import * as SSE from "@effect-uai/core/SSE"
 import {
   McpAuthRequired,

package/src/internal/protocols/2026-07-28.ts

@@ -7,7 +7,8 @@
  * Files here are named for the revision they implement. A later revision that
  * keeps this wire shape gets its own file re-exporting this one.
  */
-import { Effect, Encoding, Option, Predicate, Record, type Scope } from "effect"
+import { Effect, Option, Predicate, Record, type Scope } from "effect"
+import { Base64 } from "effect/encoding"
 import { type McpError, McpUnsupportedProtocol } from "../../McpError.js"
 import { modernRejection, type Protocol, type ProtocolProbe } from "../protocol.js"
 import type { McpConnection, SendMeta } from "../rpc.js"
@@ -56,7 +57,7 @@ const HEADER_SAFE = /^[\x21-\x7e]([\x20-\x7e]*[\x21-\x7e])?$/
  * for the marker) ride the spec's Base64 sentinel form.
  */
 export const headerValue = (raw: string): string =>
-  HEADER_SAFE.test(raw) && !SENTINEL.test(raw) ? raw : `=?base64?${Encoding.encodeBase64(raw)}?=`
+  HEADER_SAFE.test(raw) && !SENTINEL.test(raw) ? raw : `=?base64?${Base64.encode(raw)}?=`
 
 const makeProtocol = (version: ProtocolVersion, serverInfo: ServerInfo): Protocol => ({
   version,