effect-cf 0.34.0 → 0.36.0

package/dist/Mcp.d.mts

@@ -0,0 +1,122 @@
+import { n as NativeRequest } from "./Worker-Dl6_Pijl.mjs";
+import { Effect, Option } from "effect";
+import { CreateMcpHandlerOptions, ServerOptions } from "@modelcontextprotocol/server";
+import { Tool, Toolkit } from "effect/unstable/ai";
+//#region src/Mcp.d.ts
+/**
+ * CORS headers applied to MCP responses.
+ */
+interface CorsOptions {
+  readonly origin?: string;
+  readonly methods?: string;
+  readonly headers?: string;
+  readonly maxAge?: number;
+  readonly exposeHeaders?: string;
+}
+/**
+ * Options for {@link fromToolkit}.
+ *
+ * Extends the MCP SDK `createMcpHandler` options (`legacy`, `responseMode`,
+ * `onerror`, ...) with the server identity advertised to MCP clients and the
+ * Worker edge options (`route`, `corsOptions`, `allowedHostnames`,
+ * `allowedOriginHostnames`).
+ */
+interface FromToolkitOptions extends CreateMcpHandlerOptions {
+  /** Server name advertised in the MCP implementation info. */
+  readonly name: string;
+  /** Server version advertised in the MCP implementation info. */
+  readonly version: string;
+  /** Optional human-readable server title advertised to MCP clients. */
+  readonly title?: string;
+  /**
+   * Options passed to the underlying MCP SDK `McpServer` (capabilities,
+   * instructions, ...).
+   */
+  readonly serverOptions?: ServerOptions;
+  /** Pathname served by the MCP handler. @default "/mcp" */
+  readonly route?: string;
+  /** CORS headers applied to every MCP response. Pass `false` to disable. */
+  readonly corsOptions?: CorsOptions | false;
+  /**
+   * Restrict `Host` headers to these hostnames. Localhost and `workers.dev`
+   * endpoints receive matching defaults; custom domains rely on Cloudflare
+   * routing unless this option is set.
+   */
+  readonly allowedHostnames?: ReadonlyArray<string>;
+  /**
+   * Restrict present browser `Origin` headers to these hostnames. Requests
+   * without an Origin (including non-browser MCP clients) remain valid. The
+   * default includes localhost-class Origins, the endpoint's `workers.dev`
+   * hostname, and a concrete `corsOptions.origin` hostname. Pass `"*"` only
+   * when equivalent Origin validation runs in trusted middleware upstream.
+   */
+  readonly allowedOriginHostnames?: ReadonlyArray<string> | "*";
+}
+/**
+ * Services required to execute the tools of a toolkit: the tool handlers plus
+ * every service those handlers and their parameter/result codecs need.
+ */
+type ToolkitServices<Tools extends Record<string, Tool.Any>> = Tool.HandlersFor<Tools> | Tool.HandlerServices<Tools[keyof Tools]>;
+/**
+ * Context required by the Effect returned from {@link fromToolkit}: the native
+ * request provided by `Worker.make` plus the toolkit services.
+ */
+type FromToolkitContext<Tools extends Record<string, Tool.Any>> = NativeRequest | ToolkitServices<Tools>;
+/**
+ * Creates an Effect that serves a toolkit over MCP with the MCP SDK's
+ * stateless Streamable HTTP handler (`createMcpHandler` from
+ * `@modelcontextprotocol/server`), plus the Worker edge concerns Cloudflare's
+ * remote MCP deployments expect: CORS, `Host` header validation, and browser
+ * `Origin` validation.
+ *
+ * **Details**
+ *
+ * Yield the returned Effect inside a `Worker.make` fetch handler before other
+ * routing. When the request pathname matches `route` (default `"/mcp"`), the
+ * request is served by a fresh MCP server exposing every tool in the toolkit
+ * and the Effect succeeds with `Option.some(response)`. Any other pathname
+ * succeeds with `Option.none()` so the request can fall through to the rest of
+ * the fetch handler.
+ *
+ * Tool calls run through the caller's Effect context: provide the toolkit
+ * handlers (`toolkit.toLayer(...)`) and their services in the Worker layer or
+ * event layer. Tool parameters are decoded and results encoded with each
+ * tool's Effect `Schema`; parameter validation failures become MCP
+ * invalid-params errors, declared tool failures become tool results with
+ * `isError: true`, and unexpected errors are logged and reported to the client
+ * as an internal tool error.
+ *
+ * In-flight tool calls are awaited before the HTTP response is returned, so
+ * tool handlers always run to completion inside the fetch event, including on
+ * transport lanes that stream results into the response body.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Layer, Option } from "effect"
+ * import { HttpRouter } from "effect/unstable/http"
+ * import { Worker } from "effect-cf"
+ * import * as Mcp from "effect-cf/mcp"
+ *
+ * const mcp = Mcp.fromToolkit(ActivityToolkit, {
+ *   name: "strava-ingestor",
+ *   version: "1.0.0",
+ *   route: "/mcp",
+ * })
+ *
+ * const fetch = Effect.gen(function* () {
+ *   const response = yield* mcp
+ *   if (Option.isSome(response)) return response.value
+ *   const router = yield* HttpRouter.HttpRouter
+ *   return yield* router.asHttpEffect()
+ * })
+ *
+ * export default Worker.make(
+ *   Layer.mergeAll(ApplicationLive, ActivityToolkitLive),
+ *   { fetch },
+ * )
+ * ```
+ */
+declare const fromToolkit: <Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options: FromToolkitOptions) => Effect.Effect<Option.Option<Response>, unknown, FromToolkitContext<Tools>>;
+//#endregion
+export { CorsOptions, FromToolkitContext, FromToolkitOptions, ToolkitServices, fromToolkit };

package/dist/Mcp.mjs

@@ -0,0 +1,270 @@
+import { r as runNativeCallback } from "./WorkerContext-Yobnfw-K.mjs";
+import { n as NativeRequest } from "./Worker-XsGJsCJX.mjs";
+import { Cause, Context, Effect, Exit, Option, Predicate, Schema, Sink, Stream } from "effect";
+import { McpServer, createMcpHandler, hostHeaderValidationResponse, localhostAllowedHostnames, localhostAllowedOrigins, originValidationResponse } from "@modelcontextprotocol/server";
+import { AiError, Tool } from "effect/unstable/ai";
+//#region src/Mcp.ts
+const DEFAULT_CORS_OPTIONS = {
+	origin: "*",
+	headers: "Content-Type, Accept, Authorization, mcp-session-id, MCP-Protocol-Version, Mcp-Method, Mcp-Name",
+	methods: "GET, POST, DELETE, OPTIONS",
+	exposeHeaders: "mcp-session-id",
+	maxAge: 86400
+};
+const corsHeaders = (options) => {
+	const merged = {
+		...DEFAULT_CORS_OPTIONS,
+		...options
+	};
+	return new Headers({
+		"Access-Control-Allow-Headers": merged.headers,
+		"Access-Control-Allow-Methods": merged.methods,
+		"Access-Control-Allow-Origin": merged.origin,
+		"Access-Control-Expose-Headers": merged.exposeHeaders,
+		"Access-Control-Max-Age": String(merged.maxAge)
+	});
+};
+const withCors = (response, options) => {
+	if (options === false) return response;
+	const headers = new Headers(response.headers);
+	for (const [headerName, value] of corsHeaders(options ?? {})) headers.set(headerName, value);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+};
+const corsOriginHostname = (corsOptions) => {
+	const origin = corsOptions === false ? void 0 : corsOptions?.origin;
+	if (origin === void 0 || !URL.canParse(origin)) return;
+	const url = new URL(origin);
+	return (url.protocol === "http:" || url.protocol === "https:") && url.hostname !== "" ? url.hostname : void 0;
+};
+/**
+* `Host` and `Origin` validation for the MCP route, using the MCP SDK's
+* validation primitives with the same defaults Cloudflare applies: localhost
+* and `workers.dev` endpoints validate the `Host` header against themselves,
+* and present browser `Origin` headers must match localhost-class Origins, the
+* endpoint's `workers.dev` hostname, or a concrete configured CORS origin.
+*/
+const edgeGuardResponse = (request, requestUrl, options) => {
+	const localEndpoint = localhostAllowedHostnames().includes(requestUrl.hostname);
+	const workersDevEndpoint = requestUrl.hostname.endsWith(".workers.dev");
+	const acceptedHostnames = options.allowedHostnames ?? (localEndpoint ? localhostAllowedHostnames() : workersDevEndpoint ? [requestUrl.hostname] : void 0);
+	if (acceptedHostnames !== void 0) {
+		const hostRejection = hostHeaderValidationResponse(request, [...acceptedHostnames]);
+		if (hostRejection !== void 0) return hostRejection;
+	}
+	if (options.allowedOriginHostnames === "*") return;
+	let acceptedOriginHostnames = options.allowedOriginHostnames;
+	if (acceptedOriginHostnames === void 0) {
+		const defaults = new Set(localhostAllowedOrigins());
+		if (workersDevEndpoint) defaults.add(requestUrl.hostname);
+		const configuredOriginHostname = corsOriginHostname(options.corsOptions);
+		if (configuredOriginHostname !== void 0) defaults.add(configuredOriginHostname);
+		acceptedOriginHostnames = [...defaults];
+	}
+	return originValidationResponse(request, [...acceptedOriginHostnames]);
+};
+const INTERNAL_TOOL_ERROR_MESSAGE = "Tool execution failed due to an internal server error.";
+const toolErrorResult = (message) => ({
+	isError: true,
+	content: [{
+		type: "text",
+		text: message
+	}]
+});
+/**
+* Wraps a JSON Schema produced by Effect `Schema` as the Standard Schema shape
+* accepted by MCP SDK v2 `registerTool`, with a passthrough `validate`.
+*
+* Used for output schemas and for dynamic tools whose parameters are already a
+* JSON Schema: the toolkit performs its own decoding, so there is nothing
+* additional to validate here.
+*/
+const standardSchemaFromJsonSchema = (jsonSchema) => ({ "~standard": {
+	version: 1,
+	vendor: "effect-cf",
+	validate: (value) => ({ value }),
+	jsonSchema: {
+		input: () => jsonSchema,
+		output: () => jsonSchema
+	}
+} });
+/**
+* Builds the tool input schema registered with the MCP SDK.
+*
+* The SDK validates incoming `tools/call` arguments with `~standard.validate`
+* and answers validation failures with an MCP invalid-params error, so the
+* tool's Effect parameters `Schema` backs `validate`. On success the original
+* encoded arguments are kept: the toolkit decodes them itself when the tool
+* handler executes.
+*/
+const standardInputSchema = (tool) => {
+	const jsonSchema = Tool.getJsonSchema(tool);
+	if (!Schema.isSchema(tool.parametersSchema)) return standardSchemaFromJsonSchema(jsonSchema);
+	const parametersSchema = tool.parametersSchema;
+	const validate = Schema.toStandardSchemaV1(parametersSchema)["~standard"].validate;
+	return { "~standard": {
+		version: 1,
+		vendor: "effect-cf",
+		validate: (value) => {
+			const result = validate(value);
+			if (result instanceof Promise) return result.then((awaited) => awaited.issues === void 0 ? { value } : awaited);
+			return result.issues === void 0 ? { value } : result;
+		},
+		jsonSchema: {
+			input: () => jsonSchema,
+			output: () => jsonSchema
+		}
+	} };
+};
+const handleToolCall = (built, tool, params) => {
+	const isDeclaredFailure = Schema.is(tool.failureSchema);
+	return built.handle(tool.name, params).pipe(Stream.unwrap, Stream.run(Sink.last()), Effect.flatMap(Effect.fromOption), Effect.map((result) => {
+		if (result.isFailure) return toolErrorResult(JSON.stringify(result.encodedResult));
+		const structuredContent = Predicate.isObject(result.encodedResult) ? result.encodedResult : void 0;
+		const content = result.encodedResult === void 0 ? [] : [{
+			type: "text",
+			text: JSON.stringify(result.encodedResult)
+		}];
+		if (structuredContent === void 0) return {
+			isError: false,
+			content
+		};
+		return {
+			isError: false,
+			structuredContent,
+			content
+		};
+	}), Effect.tapCause(Effect.logError), Effect.catch((error) => {
+		if (AiError.isAiError(error)) {
+			const reason = error.reason;
+			return Effect.succeed(toolErrorResult(reason._tag === "ToolParameterValidationError" ? reason.message : INTERNAL_TOOL_ERROR_MESSAGE));
+		}
+		if (isDeclaredFailure(error)) {
+			const message = error instanceof Error ? error.message : INTERNAL_TOOL_ERROR_MESSAGE;
+			return Effect.succeed(toolErrorResult(message));
+		}
+		return Effect.succeed(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE));
+	}), Effect.catchDefect(() => Effect.succeed(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE))));
+};
+const registerToolkitTool = (server, built, tool, run) => {
+	const outputJsonSchema = Tool.getJsonSchemaFromSchema(tool.successSchema);
+	const outputSchema = outputJsonSchema.type === "object" ? standardSchemaFromJsonSchema(outputJsonSchema) : void 0;
+	const title = Context.getOrUndefined(tool.annotations, Tool.Title);
+	const toolMeta = Context.getOrUndefined(tool.annotations, Tool.Meta);
+	server.registerTool(tool.name, {
+		title,
+		description: Tool.getDescription(tool),
+		inputSchema: standardInputSchema(tool),
+		outputSchema,
+		annotations: {
+			title,
+			readOnlyHint: Context.get(tool.annotations, Tool.Readonly),
+			destructiveHint: Context.get(tool.annotations, Tool.Destructive),
+			idempotentHint: Context.get(tool.annotations, Tool.Idempotent),
+			openWorldHint: Context.get(tool.annotations, Tool.OpenWorld)
+		},
+		_meta: toolMeta
+	}, async (args) => {
+		const exit = await run(handleToolCall(built, tool, args ?? {}));
+		if (Exit.isSuccess(exit)) return exit.value;
+		throw Cause.squash(exit.cause);
+	});
+};
+/**
+* Creates an Effect that serves a toolkit over MCP with the MCP SDK's
+* stateless Streamable HTTP handler (`createMcpHandler` from
+* `@modelcontextprotocol/server`), plus the Worker edge concerns Cloudflare's
+* remote MCP deployments expect: CORS, `Host` header validation, and browser
+* `Origin` validation.
+*
+* **Details**
+*
+* Yield the returned Effect inside a `Worker.make` fetch handler before other
+* routing. When the request pathname matches `route` (default `"/mcp"`), the
+* request is served by a fresh MCP server exposing every tool in the toolkit
+* and the Effect succeeds with `Option.some(response)`. Any other pathname
+* succeeds with `Option.none()` so the request can fall through to the rest of
+* the fetch handler.
+*
+* Tool calls run through the caller's Effect context: provide the toolkit
+* handlers (`toolkit.toLayer(...)`) and their services in the Worker layer or
+* event layer. Tool parameters are decoded and results encoded with each
+* tool's Effect `Schema`; parameter validation failures become MCP
+* invalid-params errors, declared tool failures become tool results with
+* `isError: true`, and unexpected errors are logged and reported to the client
+* as an internal tool error.
+*
+* In-flight tool calls are awaited before the HTTP response is returned, so
+* tool handlers always run to completion inside the fetch event, including on
+* transport lanes that stream results into the response body.
+*
+* **Example**
+*
+* ```ts
+* import { Effect, Layer, Option } from "effect"
+* import { HttpRouter } from "effect/unstable/http"
+* import { Worker } from "effect-cf"
+* import * as Mcp from "effect-cf/mcp"
+*
+* const mcp = Mcp.fromToolkit(ActivityToolkit, {
+*   name: "strava-ingestor",
+*   version: "1.0.0",
+*   route: "/mcp",
+* })
+*
+* const fetch = Effect.gen(function* () {
+*   const response = yield* mcp
+*   if (Option.isSome(response)) return response.value
+*   const router = yield* HttpRouter.HttpRouter
+*   return yield* router.asHttpEffect()
+* })
+*
+* export default Worker.make(
+*   Layer.mergeAll(ApplicationLive, ActivityToolkitLive),
+*   { fetch },
+* )
+* ```
+*/
+const fromToolkit = (toolkit, options) => {
+	const { name, version, title, serverOptions, route = "/mcp", corsOptions, allowedHostnames, allowedOriginHostnames, ...handlerOptions } = options;
+	const serverInfo = {
+		name,
+		version,
+		title
+	};
+	return Effect.gen(function* () {
+		const request = yield* NativeRequest;
+		const requestUrl = new URL(request.url);
+		if (requestUrl.pathname !== route) return Option.none();
+		const rejection = edgeGuardResponse(request, requestUrl, {
+			corsOptions,
+			allowedHostnames,
+			allowedOriginHostnames
+		});
+		if (rejection !== void 0) return Option.some(withCors(rejection, corsOptions));
+		if (request.method === "OPTIONS" && corsOptions !== false) return Option.some(new Response(null, { headers: corsHeaders(corsOptions ?? {}) }));
+		const built = yield* toolkit;
+		const response = yield* runNativeCallback(async (run) => {
+			const pending = /* @__PURE__ */ new Set();
+			const trackedRun = (effect) => {
+				const promise = run(effect);
+				pending.add(promise);
+				promise.finally(() => pending.delete(promise));
+				return promise;
+			};
+			const response = await createMcpHandler(() => {
+				const server = new McpServer(serverInfo, serverOptions);
+				for (const tool of Object.values(built.tools)) registerToolkitTool(server, built, tool, trackedRun);
+				return server;
+			}, handlerOptions).fetch(request);
+			while (pending.size > 0) await Promise.allSettled([...pending]);
+			return response;
+		});
+		return Option.some(withCors(response, corsOptions));
+	});
+};
+//#endregion
+export { fromToolkit };

package/dist/Vitest.d.mts

@@ -1,6 +1,6 @@
 import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-DKcLrQCM.mjs";
-import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-CrEunfQ-.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-BumVQTuW.mjs";
+import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-CpgAmFqo.mjs";
+import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-CvJT9hB5.mjs";
 import { Effect, Layer, Schema } from "effect";
 import { DurableObject } from "cloudflare:workers";
 import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";

package/dist/Vitest.mjs

@@ -1,5 +1,6 @@
 import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-Byx2OgNd.mjs";
-import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-De4ZojhY.mjs";
+import { r as runNativeCallback } from "./WorkerContext-Yobnfw-K.mjs";
+import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-DCh4PZMN.mjs";
 import { ConfigProvider, Effect, Exit, Layer } from "effect";
 import { env } from "cloudflare:workers";
 import { abortAllDurableObjects as abortAllDurableObjects$1, adminSecretsStore as adminSecretsStore$1, applyD1Migrations as applyD1Migrations$1, createExecutionContext, createMessageBatch, createPagesEventContext, createScheduledController, evictAllDurableObjects as evictAllDurableObjects$1, evictDurableObject as evictDurableObject$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1, listDurableObjectIds as listDurableObjectIds$1, reset as reset$1, runDurableObjectAlarm as runDurableObjectAlarm$1, runInDurableObject as runInDurableObject$1, waitOnExecutionContext } from "cloudflare:test";
@@ -63,12 +64,10 @@ const queue = Effect.fn("effect-cf/vitest/queue")(function* (Worker, queueName,
 * passed to `use` for direct access.
 */
 const runInDurableObject = Effect.fn("effect-cf/vitest/runInDurableObject")(function* (stub, use) {
-	const context = yield* Effect.context();
-	return yield* yield* Effect.promise(() => runInDurableObject$1(stub, (instance, nativeState) => {
+	return yield* yield* runNativeCallback((run) => runInDurableObject$1(stub, (instance, nativeState) => {
 		const state = fromDurableObjectState(nativeState);
-		const effect = Effect.provideService(use(instance, state), DurableObjectState, state);
-		return Effect.runPromiseExitWith(context)(effect);
-	}));
+		return run(Effect.provideService(Effect.suspend(() => use(instance, state)), DurableObjectState, state));
+	})).pipe(Effect.orDie);
 });
 const runDurableObjectAlarm = Effect.fn("effect-cf/vitest/runDurableObjectAlarm")(function* (stub) {
 	return yield* Effect.promise(() => runDurableObjectAlarm$1(stub));
@@ -119,12 +118,11 @@ const wrapWorkflowModifier = (modifier) => ({
 	forceEventTimeout: (step) => Effect.promise(() => modifier.forceEventTimeout(step))
 });
 const runWorkflowModifier = Effect.fnUntraced(function* (register, use) {
-	const context = yield* Effect.context();
-	return yield* yield* Effect.promise(async () => {
+	return yield* yield* runNativeCallback(async (run) => {
 		let callbackExit;
 		try {
 			await register(async (modifier) => {
-				callbackExit = await Effect.runPromiseExitWith(context)(use(wrapWorkflowModifier(modifier)));
+				callbackExit = await run(Effect.suspend(() => use(wrapWorkflowModifier(modifier))));
 				if (Exit.isFailure(callbackExit)) throw callbackExit;
 			});
 		} catch (cause) {
@@ -133,7 +131,7 @@ const runWorkflowModifier = Effect.fnUntraced(function* (register, use) {
 		}
 		if (callbackExit === void 0) throw new Error("The Workers Vitest plugin did not invoke the Workflow modifier callback");
 		return callbackExit;
-	});
+	}).pipe(Effect.orDie);
 });
 const wrapWorkflowInstanceIntrospector = (introspector) => ({
 	raw: introspector,