@yolk-sdk/mcp 0.0.1-canary.0

package/dist/server/server.mjs

@@ -0,0 +1,180 @@
+import { McpServerError } from "./errors.mjs";
+import { Array, Effect, Option } from "effect";
+import * as Schema from "effect/Schema";
+import { ToolCall, contentParts } from "@yolk-sdk/agent/protocol";
+import { latestMcpProtocolVersion } from "@yolk-sdk/mcp/client";
+//#region src/server/server.ts
+const JsonRpcRequestSchema = Schema.Struct({
+	jsonrpc: Schema.Literal("2.0"),
+	id: Schema.Union([Schema.String, Schema.Number]),
+	method: Schema.String,
+	params: Schema.optional(Schema.Unknown)
+});
+const JsonRpcNotificationSchema = Schema.Struct({
+	jsonrpc: Schema.Literal("2.0"),
+	method: Schema.String,
+	params: Schema.optional(Schema.Unknown)
+});
+const CallToolParamsSchema = Schema.Struct({
+	name: Schema.String,
+	arguments: Schema.optional(Schema.Unknown)
+});
+const JsonRpcMessageSchema = Schema.Union([JsonRpcRequestSchema, JsonRpcNotificationSchema]);
+const decodedMessage = (message) => ({
+	_tag: "Message",
+	message
+});
+const decodedResponse = (response) => ({
+	_tag: "Response",
+	response
+});
+const decodeJson = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString);
+const decodeJsonRpcMessage = Schema.decodeUnknownEffect(JsonRpcMessageSchema);
+const decodeCallToolParams = Schema.decodeUnknownEffect(CallToolParamsSchema);
+const encodeJson = (value) => Schema.encodeUnknownEffect(Schema.UnknownFromJsonString)(value).pipe(Effect.mapError((error) => new McpServerError({
+	message: `Could not encode MCP response: ${String(error)}`,
+	cause: "encoding"
+})));
+const decodeMessage = (line) => decodeJson(line).pipe(Effect.mapError((error) => new McpServerError({
+	message: `Malformed MCP JSON: ${String(error)}`,
+	cause: "parse"
+})), Effect.flatMap((value) => decodeJsonRpcMessage(value).pipe(Effect.mapError((error) => new McpServerError({
+	message: `Invalid MCP JSON-RPC message: ${String(error)}`,
+	cause: "validation"
+})))));
+const successResponse = (id, result) => ({
+	jsonrpc: "2.0",
+	id,
+	result
+});
+const errorResponse = (id, code, message) => ({
+	jsonrpc: "2.0",
+	id,
+	error: {
+		code,
+		message
+	}
+});
+const unknownToMessage = (error) => error instanceof Error ? error.message : String(error);
+const isRequest = (message) => "id" in message;
+const protocolErrorCode = (error) => {
+	switch (error.cause) {
+		case "parse": return -32700;
+		case "validation": return -32600;
+		case "protocol": return -32603;
+		case "tool_error":
+		case "encoding": return -32e3;
+	}
+};
+const protocolErrorResponse = (id, error) => errorResponse(id, protocolErrorCode(error), error.message);
+const mcpContentBlockFromPart = (part) => {
+	switch (part._tag) {
+		case "Text": return {
+			type: "text",
+			text: part.text
+		};
+		case "Image": return {
+			type: "image",
+			data: part.data,
+			mimeType: part.mimeType
+		};
+		case "Audio": return {
+			type: "audio",
+			data: part.data,
+			mimeType: `audio/${part.format}`
+		};
+	}
+};
+const mcpResultFromToolResult = (result) => {
+	const content = Array.map(contentParts(result.content), mcpContentBlockFromPart);
+	const base = result.isError === void 0 ? { content } : {
+		content,
+		isError: result.isError
+	};
+	return result.structuredContent === void 0 ? base : {
+		...base,
+		structuredContent: result.structuredContent
+	};
+};
+const mcpErrorResult = (message) => ({
+	content: [{
+		type: "text",
+		text: message
+	}],
+	isError: true
+});
+const mcpResultFromExecutionResult = (result) => "toolCallId" in result ? mcpResultFromToolResult(result) : result;
+const toolListItem = (tool) => ({
+	name: tool.name,
+	description: tool.description,
+	inputSchema: tool.parameters
+});
+const jsonResponse = (body, init) => new Response(body, {
+	...init,
+	headers: {
+		"content-type": "application/json",
+		...init?.headers ?? {}
+	}
+});
+const methodNotAllowedBody = () => encodeJson(errorResponse(null, -32600, "Method not allowed")).pipe(Effect.orElseSucceed(() => "{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{\"code\":-32600,\"message\":\"Method not allowed\"}}"));
+const badRequestBody = (message) => encodeJson(errorResponse(null, -32600, message)).pipe(Effect.orElseSucceed(() => "{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{\"code\":-32600,\"message\":\"Bad request\"}}"));
+const makeMcpToolServer = (input) => {
+	const findTool = (name) => Array.findFirst(input.tools, (tool) => tool.def.name === name);
+	const handleRequest = (request) => Effect.gen(function* () {
+		switch (request.method) {
+			case "initialize": return successResponse(request.id, {
+				protocolVersion: latestMcpProtocolVersion,
+				capabilities: { tools: {} },
+				serverInfo: {
+					name: input.name,
+					version: input.version
+				}
+			});
+			case "tools/list": return successResponse(request.id, { tools: input.tools.map((tool) => toolListItem(tool.def)) });
+			case "tools/call": {
+				const params = yield* decodeCallToolParams(request.params).pipe(Effect.mapError((error) => new McpServerError({
+					message: `Invalid tools/call params: ${String(error)}`,
+					cause: "validation"
+				})));
+				const tool = findTool(params.name);
+				if (Option.isNone(tool)) return errorResponse(request.id, -32602, `Unknown tool: ${params.name}`);
+				const result = yield* tool.value.execute(ToolCall.make({
+					id: String(request.id),
+					name: params.name,
+					params: params.arguments ?? {}
+				})).pipe(Effect.catch((error) => Effect.succeed(mcpErrorResult(`MCP tool failed: ${error.message}`))));
+				return successResponse(request.id, mcpResultFromExecutionResult(result));
+			}
+			default: return errorResponse(request.id, -32601, `Method not found: ${request.method}`);
+		}
+	}).pipe(Effect.catch((error) => error instanceof McpServerError ? Effect.succeed(protocolErrorResponse(request.id, error)) : Effect.succeed(errorResponse(request.id, -32e3, unknownToMessage(error)))));
+	const handleLine = (line) => Effect.gen(function* () {
+		const decoded = yield* decodeMessage(line).pipe(Effect.map(decodedMessage), Effect.catch((error) => encodeJson(protocolErrorResponse(null, error)).pipe(Effect.map((response) => decodedResponse(Option.some(response))))));
+		if (decoded._tag === "Response") return decoded.response;
+		const { message } = decoded;
+		if (!isRequest(message)) return Option.none();
+		const encoded = yield* encodeJson(yield* handleRequest(message));
+		return Option.some(encoded);
+	});
+	const handleJson = (body) => Effect.gen(function* () {
+		const response = yield* handleLine(body);
+		if (Option.isNone(response)) return yield* encodeJson(errorResponse(null, -32600, "Notifications have no response"));
+		return response.value;
+	});
+	const handleHttpRequest = (request) => Effect.gen(function* () {
+		if (request.method !== "POST") return jsonResponse(yield* methodNotAllowedBody(), {
+			status: 405,
+			headers: { allow: "POST" }
+		});
+		return jsonResponse(yield* handleJson(yield* Effect.promise(() => request.text()).pipe(Effect.mapError((error) => unknownToMessage(error)), Effect.catch((error) => badRequestBody(`Could not read request body: ${error}`)))).pipe(Effect.catch((error) => badRequestBody(unknownToMessage(error)))));
+	});
+	return {
+		handleLine,
+		handleJson,
+		handleHttpRequest
+	};
+};
+//#endregion
+export { makeMcpToolServer };
+
+//# sourceMappingURL=server.mjs.map

package/dist/server/server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.mjs","names":["Arr"],"sources":["../../src/server/server.ts"],"sourcesContent":["import { Array as Arr, Effect, Option } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport {\n  ToolCall,\n  contentParts,\n  type ContentPart,\n  type ToolDef,\n  type ToolResult\n} from '@yolk-sdk/agent/protocol'\nimport { latestMcpProtocolVersion } from '@yolk-sdk/mcp/client'\nimport { McpServerError } from './errors.ts'\n\ntype JsonRpcRequest = {\n  readonly jsonrpc: '2.0'\n  readonly id: string | number\n  readonly method: string\n  readonly params?: unknown\n}\n\ntype JsonRpcNotification = {\n  readonly jsonrpc: '2.0'\n  readonly method: string\n  readonly params?: unknown\n}\n\ntype JsonRpcResponse = {\n  readonly jsonrpc: '2.0'\n  readonly id: string | number | null\n  readonly result?: unknown\n  readonly error?: {\n    readonly code: number\n    readonly message: string\n  }\n}\n\nconst JsonRpcRequestSchema = Schema.Struct({\n  jsonrpc: Schema.Literal('2.0'),\n  id: Schema.Union([Schema.String, Schema.Number]),\n  method: Schema.String,\n  params: Schema.optional(Schema.Unknown)\n})\n\nconst JsonRpcNotificationSchema = Schema.Struct({\n  jsonrpc: Schema.Literal('2.0'),\n  method: Schema.String,\n  params: Schema.optional(Schema.Unknown)\n})\n\nconst CallToolParamsSchema = Schema.Struct({\n  name: Schema.String,\n  arguments: Schema.optional(Schema.Unknown)\n})\n\nconst JsonRpcMessageSchema = Schema.Union([JsonRpcRequestSchema, JsonRpcNotificationSchema])\n\ntype JsonRpcMessage = typeof JsonRpcMessageSchema.Type\n\ntype DecodedLine =\n  | { readonly _tag: 'Message'; readonly message: JsonRpcMessage }\n  | { readonly _tag: 'Response'; readonly response: Option.Option<string> }\n\nconst decodedMessage = (message: JsonRpcMessage): DecodedLine => ({ _tag: 'Message', message })\n\nconst decodedResponse = (response: Option.Option<string>): DecodedLine => ({\n  _tag: 'Response',\n  response\n})\n\nconst decodeJson = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString)\nconst decodeJsonRpcMessage = Schema.decodeUnknownEffect(JsonRpcMessageSchema)\nconst decodeCallToolParams = Schema.decodeUnknownEffect(CallToolParamsSchema)\n\nconst encodeJson = (value: unknown) =>\n  Schema.encodeUnknownEffect(Schema.UnknownFromJsonString)(value).pipe(\n    Effect.mapError(\n      error =>\n        new McpServerError({\n          message: `Could not encode MCP response: ${String(error)}`,\n          cause: 'encoding'\n        })\n    )\n  )\n\nconst decodeMessage = (line: string) =>\n  decodeJson(line).pipe(\n    Effect.mapError(\n      error =>\n        new McpServerError({\n          message: `Malformed MCP JSON: ${String(error)}`,\n          cause: 'parse'\n        })\n    ),\n    Effect.flatMap(value =>\n      decodeJsonRpcMessage(value).pipe(\n        Effect.mapError(\n          error =>\n            new McpServerError({\n              message: `Invalid MCP JSON-RPC message: ${String(error)}`,\n              cause: 'validation'\n            })\n        )\n      )\n    )\n  )\n\nconst successResponse = (id: string | number, result: unknown): JsonRpcResponse => ({\n  jsonrpc: '2.0',\n  id,\n  result\n})\n\nconst errorResponse = (\n  id: string | number | null,\n  code: number,\n  message: string\n): JsonRpcResponse => ({\n  jsonrpc: '2.0',\n  id,\n  error: { code, message }\n})\n\nconst unknownToMessage = (error: unknown) =>\n  error instanceof Error ? error.message : String(error)\n\nconst isRequest = (message: JsonRpcRequest | JsonRpcNotification): message is JsonRpcRequest =>\n  'id' in message\n\nconst protocolErrorCode = (error: McpServerError) => {\n  switch (error.cause) {\n    case 'parse':\n      return -32_700\n    case 'validation':\n      return -32_600\n    case 'protocol':\n      return -32_603\n    case 'tool_error':\n    case 'encoding':\n      return -32_000\n  }\n}\n\nconst protocolErrorResponse = (id: string | number | null, error: McpServerError) =>\n  errorResponse(id, protocolErrorCode(error), error.message)\n\nconst mcpContentBlockFromPart = (part: ContentPart) => {\n  switch (part._tag) {\n    case 'Text':\n      return { type: 'text', text: part.text }\n    case 'Image':\n      return { type: 'image', data: part.data, mimeType: part.mimeType }\n    case 'Audio':\n      return { type: 'audio', data: part.data, mimeType: `audio/${part.format}` }\n  }\n}\n\nconst mcpResultFromToolResult = (result: ToolResult) => {\n  const content = Arr.map(contentParts(result.content), mcpContentBlockFromPart)\n  const base = result.isError === undefined ? { content } : { content, isError: result.isError }\n\n  return result.structuredContent === undefined\n    ? base\n    : { ...base, structuredContent: result.structuredContent }\n}\n\nconst mcpErrorResult = (message: string) => ({\n  content: [{ type: 'text', text: message }],\n  isError: true\n})\n\nconst mcpResultFromExecutionResult = (result: ToolResult | ReturnType<typeof mcpErrorResult>) =>\n  'toolCallId' in result ? mcpResultFromToolResult(result) : result\n\nconst toolListItem = (tool: ToolDef) => ({\n  name: tool.name,\n  description: tool.description,\n  inputSchema: tool.parameters\n})\n\nexport type McpServerTool<R = never> = {\n  readonly def: ToolDef\n  readonly execute: (call: ToolCall) => Effect.Effect<ToolResult, McpServerError, R>\n}\n\nexport type McpToolServer<R = never> = {\n  readonly handleLine: (line: string) => Effect.Effect<Option.Option<string>, McpServerError, R>\n  readonly handleJson: (body: string) => Effect.Effect<string, McpServerError, R>\n  readonly handleHttpRequest: (request: Request) => Effect.Effect<Response, never, R>\n}\n\nconst jsonResponse = (body: string, init?: ResponseInit) =>\n  new Response(body, {\n    ...init,\n    headers: {\n      'content-type': 'application/json',\n      ...(init?.headers ?? {})\n    }\n  })\n\nconst methodNotAllowedBody = () =>\n  encodeJson(errorResponse(null, -32_600, 'Method not allowed')).pipe(\n    Effect.orElseSucceed(\n      () => '{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{\"code\":-32600,\"message\":\"Method not allowed\"}}'\n    )\n  )\n\nconst badRequestBody = (message: string) =>\n  encodeJson(errorResponse(null, -32_600, message)).pipe(\n    Effect.orElseSucceed(\n      () => '{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{\"code\":-32600,\"message\":\"Bad request\"}}'\n    )\n  )\n\nexport const makeMcpToolServer = <R>(input: {\n  readonly name: string\n  readonly version: string\n  readonly tools: ReadonlyArray<McpServerTool<R>>\n}): McpToolServer<R> => {\n  const findTool = (name: string) => Arr.findFirst(input.tools, tool => tool.def.name === name)\n\n  const handleRequest = (request: JsonRpcRequest) =>\n    Effect.gen(function* () {\n      switch (request.method) {\n        case 'initialize':\n          return successResponse(request.id, {\n            protocolVersion: latestMcpProtocolVersion,\n            capabilities: { tools: {} },\n            serverInfo: { name: input.name, version: input.version }\n          })\n        case 'tools/list':\n          return successResponse(request.id, {\n            tools: input.tools.map(tool => toolListItem(tool.def))\n          })\n        case 'tools/call': {\n          const params = yield* decodeCallToolParams(request.params).pipe(\n            Effect.mapError(\n              error =>\n                new McpServerError({\n                  message: `Invalid tools/call params: ${String(error)}`,\n                  cause: 'validation'\n                })\n            )\n          )\n          const tool = findTool(params.name)\n          if (Option.isNone(tool)) {\n            return errorResponse(request.id, -32_602, `Unknown tool: ${params.name}`)\n          }\n\n          const result = yield* tool.value\n            .execute(\n              ToolCall.make({\n                id: String(request.id),\n                name: params.name,\n                params: params.arguments ?? {}\n              })\n            )\n            .pipe(\n              Effect.catch(error =>\n                Effect.succeed(mcpErrorResult(`MCP tool failed: ${error.message}`))\n              )\n            )\n\n          return successResponse(request.id, mcpResultFromExecutionResult(result))\n        }\n        default:\n          return errorResponse(request.id, -32_601, `Method not found: ${request.method}`)\n      }\n    }).pipe(\n      Effect.catch(error =>\n        error instanceof McpServerError\n          ? Effect.succeed(protocolErrorResponse(request.id, error))\n          : Effect.succeed(errorResponse(request.id, -32_000, unknownToMessage(error)))\n      )\n    )\n\n  const handleLine = (line: string) =>\n    Effect.gen(function* () {\n      const decoded: DecodedLine = yield* decodeMessage(line).pipe(\n        Effect.map(decodedMessage),\n        Effect.catch(error =>\n          encodeJson(protocolErrorResponse(null, error)).pipe(\n            Effect.map(response => decodedResponse(Option.some(response)))\n          )\n        )\n      )\n\n      if (decoded._tag === 'Response') {\n        return decoded.response\n      }\n\n      const { message } = decoded\n\n      if (!isRequest(message)) {\n        return Option.none<string>()\n      }\n\n      const response = yield* handleRequest(message)\n      const encoded = yield* encodeJson(response)\n      return Option.some(encoded)\n    })\n\n  const handleJson = (body: string) =>\n    Effect.gen(function* () {\n      const response = yield* handleLine(body)\n      if (Option.isNone(response)) {\n        return yield* encodeJson(errorResponse(null, -32_600, 'Notifications have no response'))\n      }\n\n      return response.value\n    })\n\n  const handleHttpRequest = (request: Request) =>\n    Effect.gen(function* () {\n      if (request.method !== 'POST') {\n        const body = yield* methodNotAllowedBody()\n        return jsonResponse(body, { status: 405, headers: { allow: 'POST' } })\n      }\n\n      const body = yield* Effect.promise(() => request.text()).pipe(\n        Effect.mapError(error => unknownToMessage(error)),\n        Effect.catch(error => badRequestBody(`Could not read request body: ${error}`))\n      )\n\n      const responseBody = yield* handleJson(body).pipe(\n        Effect.catch(error => badRequestBody(unknownToMessage(error)))\n      )\n\n      return jsonResponse(responseBody)\n    })\n\n  return { handleLine, handleJson, handleHttpRequest }\n}\n"],"mappings":"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"}

package/dist/server/stdio.d.mts

@@ -0,0 +1,8 @@
+import { McpToolServer } from "./server.mjs";
+import { Effect, Stdio } from "effect";
+
+//#region src/server/stdio.d.ts
+declare const runStdioMcpServer: <R>(server: McpToolServer<R>) => Effect.Effect<never, never, R | Stdio.Stdio>;
+//#endregion
+export { runStdioMcpServer };
+//# sourceMappingURL=stdio.d.mts.map

package/dist/server/stdio.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.mts","names":[],"sources":["../../src/server/stdio.ts"],"mappings":";;;;cAsBa,iBAAA,MACX,MAAA,EAAQ,aAAA,CAAc,CAAA,MACrB,MAAA,CAAO,MAAA,eAAqB,CAAA,GAAI,KAAA,CAAM,KAAA"}

package/dist/server/stdio.mjs

@@ -0,0 +1,18 @@
+import { Effect, Option, Stdio, Stream } from "effect";
+//#region src/server/stdio.ts
+const writeStdout = (stdio, value) => Stream.make(`${value}\n`).pipe(Stream.run(stdio.stdout()));
+const writeResponse = (stdio, response) => Option.match(response, {
+	onNone: () => Effect.void,
+	onSome: (value) => writeStdout(stdio, value)
+});
+const ignoreStdioError = (effect) => effect.pipe(Effect.catch(() => Effect.void));
+const handleStdioLine = (server, stdio, line) => server.handleLine(line).pipe(Effect.flatMap((response) => writeResponse(stdio, response)), ignoreStdioError);
+const runStdioMcpServer = (server) => Effect.gen(function* () {
+	const stdio = yield* Stdio.Stdio;
+	yield* stdio.stdin.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => handleStdioLine(server, stdio, line)), Effect.catch((_error) => Effect.void));
+	return yield* Effect.never;
+});
+//#endregion
+export { runStdioMcpServer };
+
+//# sourceMappingURL=stdio.mjs.map

package/dist/server/stdio.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.mjs","names":[],"sources":["../../src/server/stdio.ts"],"sourcesContent":["import { Effect, Option, Stdio, Stream } from 'effect'\nimport type { PlatformError } from 'effect/PlatformError'\nimport type { McpToolServer } from './server.ts'\n\nconst writeStdout = (stdio: Stdio.Stdio, value: string) =>\n  Stream.make(`${value}\\n`).pipe(Stream.run(stdio.stdout()))\n\nconst writeResponse = (stdio: Stdio.Stdio, response: Option.Option<string>) =>\n  Option.match(response, {\n    onNone: () => Effect.void,\n    onSome: value => writeStdout(stdio, value)\n  })\n\nconst ignoreStdioError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n  effect.pipe(Effect.catch(() => Effect.void))\n\nconst handleStdioLine = <R>(server: McpToolServer<R>, stdio: Stdio.Stdio, line: string) =>\n  server.handleLine(line).pipe(\n    Effect.flatMap(response => writeResponse(stdio, response)),\n    ignoreStdioError\n  )\n\nexport const runStdioMcpServer = <R>(\n  server: McpToolServer<R>\n): Effect.Effect<never, never, R | Stdio.Stdio> =>\n  Effect.gen(function* () {\n    const stdio = yield* Stdio.Stdio\n\n    yield* stdio.stdin.pipe(\n      Stream.decodeText(),\n      Stream.splitLines,\n      Stream.runForEach(line => handleStdioLine(server, stdio, line)),\n      Effect.catch((_error: PlatformError) => Effect.void)\n    )\n\n    return yield* Effect.never\n  })\n"],"mappings":";;AAIA,MAAM,eAAe,OAAoB,UACvC,OAAO,KAAK,GAAG,MAAM,GAAG,EAAE,KAAK,OAAO,IAAI,MAAM,OAAO,CAAC,CAAC;AAE3D,MAAM,iBAAiB,OAAoB,aACzC,OAAO,MAAM,UAAU;CACrB,cAAc,OAAO;CACrB,SAAQ,UAAS,YAAY,OAAO,KAAK;AAC3C,CAAC;AAEH,MAAM,oBAA6B,WACjC,OAAO,KAAK,OAAO,YAAY,OAAO,IAAI,CAAC;AAE7C,MAAM,mBAAsB,QAA0B,OAAoB,SACxE,OAAO,WAAW,IAAI,EAAE,KACtB,OAAO,SAAQ,aAAY,cAAc,OAAO,QAAQ,CAAC,GACzD,gBACF;AAEF,MAAa,qBACX,WAEA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO,MAAM;CAE3B,OAAO,MAAM,MAAM,KACjB,OAAO,WAAW,GAClB,OAAO,YACP,OAAO,YAAW,SAAQ,gBAAgB,QAAQ,OAAO,IAAI,CAAC,GAC9D,OAAO,OAAO,WAA0B,OAAO,IAAI,CACrD;CAEA,OAAO,OAAO,OAAO;AACvB,CAAC"}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@yolk-sdk/mcp",
+  "version": "0.0.1-canary.0",
+  "description": "MCP client, server, and protocol utilities for Yolk agent runtimes.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magoz/yolk-sdk.git",
+    "directory": "packages/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/magoz/yolk-sdk/issues"
+  },
+  "homepage": "https://github.com/magoz/yolk-sdk#readme",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "agent",
+    "tools",
+    "effect"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.mts",
+      "import": "./dist/client/index.mjs",
+      "default": "./dist/client/index.mjs"
+    },
+    "./client/node": {
+      "types": "./dist/client/node.d.mts",
+      "import": "./dist/client/node.mjs",
+      "default": "./dist/client/node.mjs"
+    },
+    "./protocol": {
+      "types": "./dist/client/protocol.d.mts",
+      "import": "./dist/client/protocol.mjs",
+      "default": "./dist/client/protocol.mjs"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.mts",
+      "import": "./dist/server/index.mjs",
+      "default": "./dist/server/index.mjs"
+    }
+  },
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "dist/**/*",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-beta.65",
+    "effect": "4.0.0-beta.65",
+    "@yolk-sdk/agent": "^0.0.1-canary.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:run": "vitest run --passWithNoTests"
+  }
+}

package/src/client/README.md

@@ -0,0 +1,24 @@
+# @yolk-sdk/mcp/client
+
+Domain-free MCP client and tool adapter.
+
+## What it provides
+
+- Remote MCP JSON-RPC over HTTP POST and SSE responses.
+- Local MCP stdio process transport through Effect platform APIs.
+- Node stdio convenience wrappers via `@yolk-sdk/mcp/client/node`.
+- Tool listing and call helpers.
+- MCP tool to Yolk `ToolDef`/`ToolResult` adapters.
+- Security policy gates for local and remote transports.
+
+## Use it when
+
+- A host app wants to expose configured MCP server tools to a Yolk agent.
+- You need local or remote MCP client behavior without app-specific config storage.
+
+## Boundaries
+
+- No persisted config store.
+- No app auth or product permissions.
+- No agent loop/provider imports.
+- Core local APIs require platform services; Node wrappers provide them at host boundary.