@gjermundgaraba/effect-actions 0.1.0-rc.1 → 0.1.0

package/dist/ActionGroup.d.mts

@@ -1,29 +1,30 @@
-import { a as Handler, c as SchemaErrorPolicy, i as Codec, n as Action_d_exports, r as Any$1, t as Action } from "./Action-CXsfTEhx.mjs";
-import { i as Implementation, o as Actions } from "./implementation-DTqp_0DW.mjs";
+import { Action, Action_d_exports, Any as Any$1, Codec, Handler } from "./Action.mjs";
+import { Actions, SchemaErrorPolicy } from "./internal/actions.mjs";
+import { Implementation } from "./internal/implementation.mjs";
 import { Effect, Scope } from "effect";
-//#region src/ActionGroup.d.ts
+declare namespace ActionGroup_d_exports {
+  export { Any, Group, Implementation, Options, SchemaErrorPolicy, make };
+}
 type HandlersFrom<Actions extends ReadonlyArray<Any$1>> = { readonly [A in Actions[number] as A["name"]]: Handler<A, any>; };
-type HandlersContext<H> = { [K in keyof H]: H[K] extends ((input: never) => Effect.Effect<infer _A, infer _E, infer R>) ? R : never; }[keyof H];
 /** Group-level errors join each action's own, so a shared set is declared once. */
-type WithErrors<Actions extends ReadonlyArray<Any$1>, Errors extends ReadonlyArray<Codec>> = { readonly [K in keyof Actions]: Actions[K] extends Action<infer Name, infer Input, infer Output, infer Own, infer Http> ? Action<Name, Input, Output, readonly [...Own, ...Errors], Http> : never; };
+type WithErrors<Actions extends ReadonlyArray<Any$1>, Errors extends ReadonlyArray<Codec>> = { readonly [K in keyof Actions]: Actions[K] extends Action<infer Name, infer Input, infer Output, infer Own, infer Http, infer Mcp> ? Action<Name, Input, Output, readonly [...Own, ...Errors], Http, Mcp> : never; };
+/** What `make` needs to define a group. */
 export interface Options<Name extends string, Errors extends ReadonlyArray<Codec>, PolicyErrors extends ReadonlyArray<Codec>> {
   /** The `HttpApiGroup` identifier, and so the OpenAPI tag and operation-ID prefix. */
   readonly name: Name;
   /** Failures every action of the group may have, added to each action's own. */
   readonly errors?: Errors;
-  /** How both transports answer failed decoding or encoding of these actions. */
+  /** How HTTP answers failed decoding or encoding of these actions; MCP keeps its native answers. */
   readonly schemaError?: SchemaErrorPolicy<PolicyErrors>;
 }
+/** A named set of action contracts: what adapters serve and what `implement` binds. */
 export interface Group<Name extends string, Actions$1 extends ReadonlyArray<Any$1>, PolicyErrors extends ReadonlyArray<Codec> = ReadonlyArray<Codec>> extends Actions<Name, Actions$1, PolicyErrors> {
-  /**
-   * Bind every handler at once. Pass an Effect to resolve build-time services
-   * once (`const users = yield* Users`); services yielded inside a handler are
-   * request-scoped instead. Scoped acquisition lasts for the adapter runtime.
-   */
-  readonly implement: <H extends HandlersFrom<Actions$1>, EX = never, RX = never>(build: H | Effect.Effect<H, EX, RX>) => Implementation<Group<Name, Actions$1, PolicyErrors>, HandlersContext<H>, NoInfer<EX>, NoInfer<Exclude<RX, Scope.Scope>>>;
+  /** Bind every handler at once, resolving build-time services once per adapter layer. */
+  readonly implement: <H extends HandlersFrom<Actions$1>, EX = never, RX = never>(build: H | Effect.Effect<H, EX, RX>) => Implementation<Group<Name, Actions$1, PolicyErrors>, H, NoInfer<EX>, NoInfer<Exclude<RX, Scope.Scope>>>;
 }
+/** Any group, with its actions erased. */
 export type Any = Group<string, ReadonlyArray<Any$1>>;
-/** Duplicate action and MCP names fail at definition time. */
+/** Define a group. Invalid or duplicate action and MCP names fail here, at definition time. */
 export declare function make<const Name extends string, const Actions extends ReadonlyArray<Any$1>, const Errors extends ReadonlyArray<Codec> = [], const PolicyErrors extends ReadonlyArray<Codec> = []>(options: Options<Name, Errors, PolicyErrors>, ...actions: Actions): Group<Name, WithErrors<Actions, Errors>, PolicyErrors>;
 //#endregion
-export type { Implementation };
+export { ActionGroup_d_exports, type Implementation, type SchemaErrorPolicy };

package/dist/ActionGroup.mjs

@@ -1,9 +1,10 @@
-import { n as assertDistinct, t as Implementation } from "./implementation-4Q2BESw5.mjs";
+import { assertDistinct, assertName } from "./internal/actions.mjs";
+import { Implementation } from "./internal/implementation.mjs";
 import { Effect } from "effect";
 //#region src/ActionGroup.ts
 function make(options, ...declared) {
 	const { name } = options;
-	if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(name)) throw new Error(`Invalid action group name: ${name}`);
+	assertName("action group name", name);
 	const actions = declared.map((action) => ({
 		...action,
 		errors: [...action.errors, ...options.errors ?? []]

package/dist/ActionHttp.d.mts

@@ -1,52 +1,39 @@
-import { d as __exportAll, i as Codec, n as Action_d_exports, r as Any } from "./Action-CXsfTEhx.mjs";
-import { a as RequestContext, n as BuildContext, o as Actions, r as BuildError, s as PolicyError, t as AnyImplementation } from "./implementation-DTqp_0DW.mjs";
-import { Effect, Layer, Schema } from "effect";
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-import { Etag, HttpClient, HttpPlatform, HttpRouter } from "effect/unstable/http";
+import { Action_d_exports, Any, Codec } from "./Action.mjs";
+import { Actions, PolicyError } from "./internal/actions.mjs";
+import { AnyImplementation, BuildContext, BuildError, RequestContext } from "./internal/implementation.mjs";
+import { Layer, Schema } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Etag, HttpPlatform, HttpRouter } from "effect/unstable/http";
 import { FileSystem } from "effect/FileSystem";
 import { Path } from "effect/Path";
 declare namespace ActionHttp_d_exports {
-  export { Api, Client, ClientOptions, Http, Options, make };
+  export { Api, Http, Options, make };
 }
 /** Contract-level configuration: servers and clients must agree on it. */
 export interface Options {
   readonly apiPath: `/${string}`;
 }
-/** Distribute over the tuple so each name retains its own codecs. */
 type Endpoint<A extends Any, E extends Codec> = A extends {
   readonly http: false;
-} ? never : A extends Any ? HttpApiEndpoint.HttpApiEndpoint<A["name"], "POST", `/${string}`, never, never, Schema.toCodecJson<A["input"]>, never, Schema.toCodecJson<A["success"]>, Schema.toCodecJson<A["errors"][number] | E>> : never;
-/** One native group per action group; groups without HTTP actions are omitted. */
+} ? never : A extends Any ? HttpApiEndpoint.HttpApiEndpoint<A["name"], "POST", `/${string}`, never, never, Schema.toCodecJson<A["input"]>, never, Schema.toCodecJson<A["success"]>, Schema.toCodecJson<A["errors"][number] | E>, never> : never;
 type ApiGroup<G extends Actions> = G extends Actions ? [Endpoint<G["actions"][number], never>] extends [never] ? never : HttpApiGroup.HttpApiGroup<G["name"], Endpoint<G["actions"][number], PolicyError<G>>> : never;
+/** The native `HttpApi` of every HTTP-enabled action of `G`, one group per action group. */
 export type Api<G extends Actions> = HttpApi.HttpApi<"actions", ApiGroup<G>>;
-type Served<G extends Actions> = G extends Actions ? G["actions"][number] extends (infer Item) ? Item extends Any ? {
-  readonly action: Item;
-  readonly policyError: PolicyError<G>;
-} : never : never : never;
-/** Direct decoded-input methods of every group, excluding MCP-only actions. */
-export type Client<G extends Actions> = { readonly [Pair in Served<G> as Pair["action"]["http"] extends false ? never : Pair["action"]["name"]]: (...args: {} extends Pair["action"]["input"]["Type"] ? [input?: Pair["action"]["input"]["Type"]] : [input: Pair["action"]["input"]["Type"]]) => HttpApiClient.Client.MethodReturn<Endpoint<Pair["action"], Pair["policyError"]>, never, never, "decoded-only">; };
-/** Native connection options: `baseUrl`, `transformClient`, `transformResponse`. */
-export type ClientOptions = NonNullable<Parameters<typeof HttpApiClient.make>[1]>;
-export interface Http<G extends Actions> {
+/** A namespaced HTTP binding. */
+export interface Http<Groups extends ReadonlyArray<Actions>> {
+  /** The exact contracts bound to this HTTP adapter, in declaration order. */
+  readonly groups: Groups;
+  readonly api: Api<Groups[number]>;
   /**
-   * The native `HttpApi` for every HTTP-enabled action: `POST <apiPath>/<name>`.
-   * Documents, documentation UIs and native clients are Effect's own, from this value.
+   * Serve any number of implementations in one layer. Build failures, build
+   * services and request services are unions over precisely those apps.
    */
-  readonly api: Api<G>;
-  /**
-   * The routes of one group. Merge one per group; router middleware provided
-   * to a layer applies to that group only. Handler requirements are
-   * request-level requirements, exactly as native `HttpApiBuilder` handlers'
-   * are. A group without HTTP actions registers nothing and is not acquired.
-   */
-  readonly layer: <App extends AnyImplementation<G>>(app: App) => Layer.Layer<never, BuildError<App>, BuildContext<App> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", RequestContext<App>> | Etag.Generator | FileSystem | HttpPlatform.HttpPlatform | Path>;
-  /** Direct action methods backed by the native HTTP client and its codecs. */
-  readonly client: (options?: ClientOptions) => Effect.Effect<Client<G>, never, HttpClient.HttpClient>;
+  readonly layer: <const Apps extends ReadonlyArray<AnyImplementation<Groups[number]>>>(...apps: Apps) => Layer.Layer<never, BuildError<Apps[number]>, BuildContext<Apps[number]> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", RequestContext<Apps[number]>> | Etag.Generator | FileSystem | HttpPlatform.HttpPlatform | Path>;
 }
 /**
- * Bind the contract-level configuration once. The native API is built here and
- * shared by the routes and clients, so they cannot disagree.
+ * Bind the contract-level configuration once. Every route is `POST
+ * <apiPath>/<group>/<action>`, so action names may repeat across groups.
  */
-export declare function make<const G extends ReadonlyArray<Actions>>(options: Options, ...groups: G): Http<G[number]>;
+export declare function make<const G extends ReadonlyArray<Actions>>(options: Options, ...groups: G): Http<G>;
 //#endregion
-export { ActionHttp_d_exports as t };
+export { ActionHttp_d_exports };

package/dist/ActionHttp.mjs

@@ -1,73 +1,66 @@
-import { n as assertDistinct, r as served, t as Implementation } from "./implementation-4Q2BESw5.mjs";
-import { Context, Effect, Layer, Schema } from "effect";
-import { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
+import { assertDistinct } from "./internal/actions.mjs";
+import { dispatch } from "./internal/implementation.mjs";
+import { Effect, Layer } from "effect";
+import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
 //#region src/ActionHttp.ts
-const endpoint = (apiPath, action, errors) => HttpApiEndpoint.post(action.name, `${apiPath}/${action.name}`, {
+const httpActions = (group) => group.actions.filter((action) => action.http);
+const endpoint = (apiPath, group, action) => HttpApiEndpoint.post(action.name, `${apiPath}/${group.name}/${action.name}`, {
 	payload: action.input,
 	success: action.success,
-	error: [...action.errors, ...errors]
+	error: [...action.errors, ...group.schemaError?.errors ?? []]
 }).annotate(OpenApi.Description, action.description);
-function erasedApi(views, options) {
-	const [first, ...rest] = views.flatMap(({ group, actions }) => {
-		const [head, ...tail] = actions.map((action) => endpoint(options.apiPath, action, group.schemaError?.errors ?? []));
-		return head === void 0 ? [] : [HttpApiGroup.make(group.name).add(head, ...tail)];
+function erasedApi(groups, options) {
+	const [first, ...rest] = groups.flatMap((group) => {
+		const [first, ...rest] = httpActions(group).map((action) => endpoint(options.apiPath, group, action));
+		return first === void 0 ? [] : [HttpApiGroup.make(group.name).add(first, ...rest)];
 	});
 	const empty = HttpApi.make("actions");
 	return first === void 0 ? empty : empty.add(first, ...rest);
 }
 const schemaErrorMiddleware = (policy) => {
-	class SchemaErrors extends HttpApiMiddleware.Service()("effect-actions/http/SchemaErrors", { error: policy?.errors ?? [] }) {}
+	class SchemaErrors extends HttpApiMiddleware.Service()("effect-actions/http/SchemaErrors", { error: policy.errors }) {}
 	return {
 		SchemaErrors,
-		layer: HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrors, (failure) => Effect.fail(policy === void 0 ? failure : policy.map({
-			phase: failure.kind === "Body" || failure.kind === "ResponseHeaders" ? "output" : "input",
-			cause: failure.cause
-		})))
+		layer: HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrors, (failure) => Effect.fail(policy.map(failure)))
 	};
 };
-/** One group registers its own routes, so middleware provided to this layer is its alone. */
-const erasedLayer = (binding, app) => {
-	if (!binding.groups.includes(app.group)) throw new Error(`Implementation of group "${app.group.name}" is not served by this adapter`);
-	const view = binding.views.find(({ group }) => group === app.group);
-	if (view === void 0) return Layer.empty;
-	const schemaErrors = schemaErrorMiddleware(view.group.schemaError);
-	const httpApi = erasedApi([view], binding.options).middleware(schemaErrors.SchemaErrors);
-	return Implementation.register([{
-		app,
-		actions: view.actions
-	}], (bound) => {
-		const handlers = bound.map((implementation) => HttpApiBuilder.group(httpApi, implementation.group.name, (builder) => builder.handleAll(Object.fromEntries(implementation.actions.map((action) => {
-			const handle = implementation.handle(action);
-			return [action.name, (request) => handle(request.payload)];
-		})))));
-		const isolated = Layer.fromBuildMemo((memoMap, scope) => Layer.buildWithMemoMap(Layer.mergeAll(Layer.empty, ...handlers).pipe(Layer.provide(schemaErrors.layer)), memoMap, scope).pipe(Effect.setContext(Context.empty())));
-		return HttpApiBuilder.layer(httpApi).pipe(Layer.provide(isolated));
+/**
+* `HttpApiBuilder.handleAll` registers a dynamically assembled record. The
+* action selected by the native router determines the input before `dispatch`
+* calls its handler, so this is the one adapter boundary where exact handlers
+* are viewed as an erased record. `HandlersContext` remains on the dispatch
+* effect and is restored by `Http.layer`'s public signature.
+*/
+const erasedHandlers = (handlers) => {
+	return handlers;
+};
+/** Build routes for one group. Handler erasure is limited to native dynamic endpoint registration. */
+const groupLayer = (options, app) => {
+	const actions = httpActions(app.group);
+	if (actions.length === 0) return Layer.empty;
+	const api = erasedApi([app.group], options);
+	const entries = (record) => Object.fromEntries(actions.map((action) => [action.name, (request) => dispatch(app.group, action, record)(request.payload)]));
+	const handlers = (record) => HttpApiBuilder.group(api, app.group.name, (builder) => builder.handleAll(entries(record)));
+	if (app.group.schemaError === void 0) return Layer.unwrap(Effect.map(app.build, (record) => HttpApiBuilder.layer(api).pipe(Layer.provide(handlers(erasedHandlers(record))))));
+	const schemaErrors = schemaErrorMiddleware(app.group.schemaError);
+	const policyApi = api.middleware(schemaErrors.SchemaErrors);
+	const policyHandlers = (record) => HttpApiBuilder.group(policyApi, app.group.name, (builder) => {
+		const dynamicEntries = entries(record);
+		return builder.handleAll(dynamicEntries);
 	});
+	return Layer.unwrap(Effect.map(app.build, (record) => HttpApiBuilder.layer(policyApi).pipe(Layer.provide(policyHandlers(erasedHandlers(record))), Layer.provide(schemaErrors.layer))));
 };
-const erasedClient = (api, views, connection) => Effect.map(HttpApiClient.make(api, connection), (native) => {
-	const acceptsUndefined = new Set(views.flatMap(({ actions }) => actions.flatMap((action) => Schema.is(action.input)(void 0) ? [action.name] : [])));
-	return Object.fromEntries(Object.values(native).flatMap((methods) => Object.entries(methods).map(([name, method]) => {
-		if (name === "then") throw new Error("Action \"then\" requires the native grouped HttpApiClient");
-		return [name, (input) => method({
-			payload: input === void 0 && !acceptsUndefined.has(name) ? {} : input,
-			responseMode: "decoded-only"
-		})];
-	})));
-});
 function make(options, ...groups) {
-	const views = served(groups, (action) => action.http);
 	assertDistinct("action group", groups.map((group) => group.name));
-	assertDistinct("action", views.flatMap(({ actions }) => actions.map((action) => action.name)));
-	const api = erasedApi(views, options);
-	const binding = {
-		groups,
-		views,
-		options
+	const layer = (...apps) => {
+		assertDistinct("implementation group", apps.map((app) => app.group.name));
+		for (const app of apps) if (!groups.includes(app.group)) throw new Error(`Implementation of group "${app.group.name}" is not served by this adapter`);
+		return apps.map((app) => groupLayer(options, app)).reduce((all, app) => Layer.merge(all, app), Layer.empty);
 	};
 	return {
-		api,
-		layer: (app) => erasedLayer(binding, app),
-		client: (connection) => erasedClient(api, views, connection)
+		groups,
+		api: erasedApi(groups, options),
+		layer
 	};
 }
 //#endregion

package/dist/ActionMcp.d.mts

@@ -1,20 +1,41 @@
-import { a as RequestContext, n as BuildContext, r as BuildError, t as AnyImplementation } from "./implementation-DTqp_0DW.mjs";
+import { AnyImplementation, BuildContext, BuildError, RequestContext } from "./internal/implementation.mjs";
 import { Cause, Layer } from "effect";
-import { McpProtocol } from "effect/unstable/ai";
+import { McpServer } from "effect/unstable/ai";
 import { HttpRouter } from "effect/unstable/http";
-import { NonEmptyReadonlyArray } from "effect/Array";
+import { Stdio } from "effect/Stdio";
 //#region src/ActionMcp.d.ts
+/** One Streamable HTTP MCP endpoint; its fields become the native server info. */
 export interface Options {
   readonly name: string;
   readonly version: string;
+  /** Native protocol adapters to serve; negotiation and sessions are owned by Effect. */
+  readonly protocols: Parameters<typeof McpServer.layerHttp>[0]["protocols"];
+  /** Route of the Streamable HTTP endpoint; no default. */
   readonly path: HttpRouter.PathInput;
-  readonly protocols?: NonEmptyReadonlyArray<McpProtocol.ProtocolAdapter>;
+  /** Browser origins accepted by the native server; passed through to `McpServer.layerHttp`. */
   readonly allowedOrigins?: ReadonlyArray<string>;
   readonly instructions?: string;
 }
+/** Server information for an MCP subprocess connected through standard I/O. */
+export interface StdioOptions {
+  readonly name: string;
+  readonly version: string;
+  /** Native protocol adapters to serve; negotiation is owned by Effect. */
+  readonly protocols: Parameters<typeof McpServer.layerStdio>[0]["protocols"];
+  readonly instructions?: string;
+}
+/**
+ * Serve MCP tools over one Streamable HTTP endpoint.
+ *
+ * Middleware provided around this layer has the normal HTTP lifetime. Native
+ * context capture applies: never provide request-identity tags at startup.
+ */
+export declare function layerHttp<const Apps extends ReadonlyArray<AnyImplementation>>(options: Options, ...apps: Apps): Layer.Layer<never, BuildError<Apps[number]> | Cause.IllegalArgumentError, BuildContext<Apps[number]> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", RequestContext<Apps[number]>>>;
 /**
- * One Streamable HTTP MCP endpoint serving every MCP-enabled action of `apps`.
- * An endpoint is one route, so middleware provided to this layer covers all of its tools.
+ * Serve MCP tools through newline-delimited JSON-RPC on standard I/O.
+ *
+ * The host supplies the `Stdio` service. Arguments are tool input only and
+ * never establish request identity or authority.
  */
-export declare function layer<const Apps extends ReadonlyArray<AnyImplementation>>(options: Options, ...apps: Apps): Layer.Layer<never, BuildError<Apps[number]> | Cause.IllegalArgumentError, BuildContext<Apps[number]> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", RequestContext<Apps[number]>>>;
+export declare function layerStdio<const Apps extends ReadonlyArray<AnyImplementation>>(options: StdioOptions, ...apps: Apps): Layer.Layer<never, BuildError<Apps[number]> | Cause.IllegalArgumentError, BuildContext<Apps[number]> | Stdio | RequestContext<Apps[number]>>;
 //#endregion

package/dist/ActionMcp.mjs

@@ -1,133 +1,25 @@
-import { n as assertDistinct, r as served, t as Implementation } from "./implementation-4Q2BESw5.mjs";
-import { Context, Effect, JsonPointer, Layer, Predicate, Schema } from "effect";
-import { McpProtocol, McpSchema, McpServer, Tool } from "effect/unstable/ai";
-import { HttpRouter } from "effect/unstable/http";
+import "./internal/implementation.mjs";
+import { bindTools } from "./internal/tools.mjs";
+import { Layer } from "effect";
+import { McpServer } from "effect/unstable/ai";
 //#region src/ActionMcp.ts
-/** Protocol revisions served over Streamable HTTP by default; 2026-07-28 is stateless. */
-const protocols = [
-	McpProtocol.v2026_07_28,
-	McpProtocol.v2025_11_25,
-	McpProtocol.v2025_06_18,
-	McpProtocol.v2025_03_26,
-	McpProtocol.v2024_11_05
-];
-const toolResult = (structuredContent, isError) => new McpSchema.CallToolResult({
-	isError,
-	structuredContent,
-	content: [{
-		type: "text",
-		text: JSON.stringify(structuredContent)
-	}]
-});
-const resolveReference = (name, what, schema, definitions) => {
-	if (!Predicate.isString(schema.$ref)) return schema;
-	const reference = schema.$ref;
-	const path = JsonPointer.parseUriFragment(reference);
-	const key = path?.[1];
-	if (path?.length !== 2 || path[0] !== "$defs" || key === void 0) throw new Error(`${name}: unsupported MCP ${what} reference ${reference}`);
-	const definition = Object.hasOwn(definitions, key) ? definitions[key] : void 0;
-	if (definition === void 0) throw new Error(`${name}: missing MCP ${what} reference ${reference}`);
-	return definition;
+const registration = (apps) => {
+	const binding = bindTools(apps, "mcp");
+	return Layer.effectDiscard(McpServer.registerToolkit(binding.toolkit)).pipe(Layer.provide(binding.layer));
 };
-/** MCP `inputSchema` requires a literal object root. */
-const inputJsonSchema = (action) => {
-	const { schema, definitions } = Schema.toJsonSchemaDocument(action.input);
-	const root = resolveReference(action.name, "input", schema, definitions);
-	if (root.type !== "object") throw new Error(`${action.name}: MCP input must have an object root; omit input for no arguments`);
-	return Object.keys(definitions).length === 0 ? root : {
-		...root,
-		$defs: definitions
-	};
-};
-/** Declared errors are published as-is in `structuredContent`, so each must encode to an object. */
-const assertObjectError = (owner, error) => {
-	const { schema, definitions } = Schema.toJsonSchemaDocument(error);
-	const visited = /* @__PURE__ */ new Set();
-	const encodesObject = (candidate) => {
-		const root = resolveReference(owner, "error", candidate, definitions);
-		if (root.type === "object" || visited.has(root)) return true;
-		visited.add(root);
-		const members = root.anyOf ?? root.oneOf;
-		return Array.isArray(members) && members.length > 0 && members.every(encodesObject);
-	};
-	if (!encodesObject(schema)) throw new Error(`${owner}: MCP error must have an object root`);
-};
-const registerTool = (app, action, policy) => Effect.gen(function* () {
-	if (action.mcp === false) return;
-	const server = yield* McpServer.McpServer;
-	const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJson)(inputJsonSchema(action)).pipe(Effect.orDie);
-	const errors = [...action.errors, ...policy?.errors ?? []];
-	for (const error of action.errors) assertObjectError(action.name, error);
-	const input = Schema.toCodecJson(action.input);
-	const success = Schema.toCodecJson(action.success);
-	const failure = Schema.toCodecJson(Schema.Union(errors));
-	const handle = app.handle(action);
-	const failureResult = (error) => Schema.encodeUnknownEffect(failure)(error).pipe(Effect.orDie, Effect.map((json) => toolResult(json, true)));
-	const schemaFailure = (phase, cause) => {
-		if (policy !== void 0) return failureResult(policy.map({
-			phase,
-			cause
-		}));
-		if (phase === "input") return Effect.fail(new McpSchema.InvalidParams({ message: cause.message }));
-		return Effect.die(cause);
-	};
-	const successResult = (value) => Schema.encodeUnknownEffect(success)(value).pipe(Effect.matchEffect({
-		onFailure: (cause) => schemaFailure("output", cause),
-		onSuccess: (json) => Effect.succeed(toolResult({ value: json }, false))
+const server = (apps, transport) => registration(apps).pipe(Layer.provide(transport), Layer.fresh);
+function layerHttp(options, ...apps) {
+	return server(apps, McpServer.layerHttp({
+		name: options.name,
+		version: options.version,
+		instructions: options.instructions,
+		path: options.path,
+		protocols: options.protocols,
+		allowedOrigins: options.allowedOrigins
 	}));
-	yield* server.addTool({
-		tool: new McpSchema.Tool({
-			name: action.mcp.name,
-			description: action.description,
-			inputSchema,
-			outputSchema: Tool.getJsonSchemaFromSchema(Schema.Struct({ value: action.success })),
-			annotations: {
-				readOnlyHint: action.mcp.readOnly,
-				destructiveHint: action.mcp.destructive
-			}
-		}),
-		annotations: Context.empty(),
-		handle: (payload) => Schema.decodeUnknownEffect(input)(payload).pipe(Effect.matchEffect({
-			onFailure: (cause) => schemaFailure("input", cause),
-			onSuccess: (decoded) => handle(decoded).pipe(Effect.matchEffect({
-				onSuccess: successResult,
-				onFailure: failureResult
-			}))
-		}))
-	});
-});
-const registrationRouter = (router, context) => HttpRouter.HttpRouter.of({
-	...router,
-	add: (method, path, handler, options) => router.add(method, path, handler, options).pipe(Effect.provideContext(context)),
-	addAll: (routes) => router.addAll(routes).pipe(Effect.provideContext(context)),
-	prefixed: (prefix) => registrationRouter(router.prefixed(prefix), context)
-});
-const erasedLayer = (apps, options) => {
-	const serving = apps.flatMap((app) => served([app.group], (action) => action.mcp !== false).map(({ actions }) => ({
-		app,
-		actions
-	})));
-	assertDistinct("MCP tool", serving.flatMap(({ actions }) => actions.flatMap((action) => action.mcp === false ? [] : [action.mcp.name])));
-	return Implementation.register(serving, (bound) => {
-		const native = Layer.effectDiscard(Effect.gen(function* () {
-			for (const app of bound) for (const error of app.group.schemaError?.errors ?? []) assertObjectError(`Schema-error policy of group ${app.group.name}`, error);
-			yield* Effect.forEach(bound.flatMap((app) => app.actions.map((action) => [app, action])), ([app, action]) => registerTool(app, action, app.group.schemaError), { discard: true });
-		})).pipe(Layer.provide(McpServer.layerHttp({
-			name: options.name,
-			version: options.version,
-			instructions: options.instructions,
-			path: options.path,
-			protocols: options.protocols ?? protocols,
-			allowedOrigins: options.allowedOrigins
-		})), Layer.fresh);
-		return Layer.fromBuildMemo((memoMap, scope) => Effect.gen(function* () {
-			const router = registrationRouter(yield* HttpRouter.HttpRouter, yield* Effect.context());
-			return yield* Layer.buildWithMemoMap(native, memoMap, scope).pipe(Effect.setContext(Context.make(HttpRouter.HttpRouter, router)));
-		}));
-	});
-};
-function layer(options, ...apps) {
-	return erasedLayer(apps, options);
+}
+function layerStdio(options, ...apps) {
+	return server(apps, McpServer.layerStdio(options));
 }
 //#endregion
-export { layer };
+export { layerHttp, layerStdio };

package/dist/ActionToolkit.d.mts

@@ -0,0 +1,37 @@
+import { Action_d_exports, Any } from "./Action.mjs";
+import { AnyImplementation, BuildContext, BuildError, HandlerContext, Implementation } from "./internal/implementation.mjs";
+import { Layer, Schema } from "effect";
+import { Tool, Toolkit } from "effect/unstable/ai";
+//#region src/ActionToolkit.d.ts
+/** A native tool corresponding to an MCP-enabled action. */
+type NativeTool<A extends Any, R> = A extends {
+  readonly mcp: {
+    readonly name: infer Name extends string;
+  };
+} ? Tool.Tool<Name, {
+  readonly parameters: A["input"];
+  readonly success: A["success"];
+  readonly failure: Schema.Union<A["errors"]>;
+  readonly failureMode: "return";
+}, R> : never;
+type HandlersOf<App extends AnyImplementation> = App extends Implementation<any, infer H, any, any> ? H : never;
+type ToolForAction<App extends AnyImplementation, A extends Any> = A extends {
+  readonly mcp: object;
+} ? NativeTool<A, HandlerContext<HandlersOf<App>, Extract<A["name"], keyof HandlersOf<App>>>> : never;
+type ToolsFor<App extends AnyImplementation> = App extends AnyImplementation ? ToolForAction<App, App["group"]["actions"][number]> : never;
+type ToolkitTools<Apps extends ReadonlyArray<AnyImplementation>> = { readonly [T in ToolsFor<Apps[number]> as T["name"]]: T; };
+/** Native tools and the layer that binds their action implementations. */
+export interface Binding<Tools extends Record<string, Tool.Any>, E = never, R = never> {
+  readonly toolkit: Toolkit.Toolkit<Tools>;
+  /** Acquires handlers once in the layer scope; handler requirements remain at invocation. */
+  readonly layer: Layer.Layer<Tool.HandlersFor<Tools>, E, R>;
+}
+/**
+ * Project implementations into Effect's native AI toolkit.
+ *
+ * Unlike MCP, calls return the action's native success/failure values directly.
+ * Build services are needed to construct `layer`; request services are needed
+ * when the resulting toolkit handles a call.
+ */
+export declare function make<const Apps extends ReadonlyArray<AnyImplementation>>(...apps: Apps): Binding<ToolkitTools<Apps>, BuildError<Apps[number]>, BuildContext<Apps[number]>>;
+//#endregion

package/dist/ActionToolkit.mjs

@@ -0,0 +1,10 @@
+import "./internal/implementation.mjs";
+import { bindTools } from "./internal/tools.mjs";
+import "effect";
+import "effect/unstable/ai";
+//#region src/ActionToolkit.ts
+function make(...apps) {
+	return bindTools(apps, "native");
+}
+//#endregion
+export { make };

package/dist/Authentication.d.mts

@@ -1,20 +1,16 @@
-import { i as Codec, n as Action_d_exports } from "./Action-CXsfTEhx.mjs";
 import { Context, Effect } from "effect";
-import { Headers, HttpRouter } from "effect/unstable/http";
+import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
 import { NonEmptyReadonlyArray } from "effect/Array";
 //#region src/Authentication.d.ts
-export interface Options<A, Errors extends ReadonlyArray<Codec>, R> {
-  readonly authenticate: Effect.Effect<A, Errors[number]["Type"], R>;
-  readonly errors: Errors;
-  readonly headers?: (error: Errors[number]["Type"]) => Headers.Input;
-}
 /**
  * Authenticate each request and provide its identity to the downstream handler.
- * Only authentication failures are encoded, using each schema's httpApiStatus.
- * Dependencies remain native router request requirements. Acquired resources live
- * until the request scope closes, including while the handler is running.
+ * `authenticate` fails with the response to send instead, so the host owns its
+ * status, body and challenge headers. Dependencies remain native router request
+ * requirements. Acquired resources live until the request scope closes, including
+ * while the handler is running. Every response is marked `Cache-Control: no-store`,
+ * including private failures serialized by enclosing middleware.
  */
-export declare const middleware: <I, A, const Errors extends ReadonlyArray<Codec>, R>(service: Context.Key<I, A>, options: Options<NoInfer<A>, Errors, R>) => HttpRouter.Middleware<{
+export declare const middleware: <I, A, R>(service: Context.Key<I, A>, authenticate: Effect.Effect<NoInfer<A>, HttpServerResponse.HttpServerResponse, R>) => HttpRouter.Middleware<{
   provides: I;
   handles: never;
   error: never;
@@ -22,13 +18,15 @@ export declare const middleware: <I, A, const Errors extends ReadonlyArray<Codec
   layerError: never;
   layerRequires: never;
 }>;
+/** RFC 9728 metadata to publish; the host is responsible for these being valid OAuth URLs. */
 export interface ProtectedResourceOptions {
-  /** Exact OAuth resource identifier. HTTPS, or HTTP on loopback for development. */
+  /** Exact OAuth resource identifier; its path and query select the discovery path. */
   readonly resource: string;
   readonly authorizationServers: NonEmptyReadonlyArray<string>;
   readonly scopesSupported?: ReadonlyArray<string>;
   readonly resourceName?: string;
 }
+/** Parameters of one `WWW-Authenticate: Bearer` challenge, RFC 6750 §3. */
 export interface BearerChallengeOptions {
   readonly error?: "invalid_token" | "insufficient_scope";
   readonly errorDescription?: string;
@@ -42,6 +40,7 @@ export interface BearerChallengeOptions {
 export declare const protectedResource: (options: ProtectedResourceOptions) => {
   layer: import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter>;
   metadataUrl: string;
+  /** The `WWW-Authenticate` value; parameter values are quoted and escaped. */
   challenge: (challenge?: BearerChallengeOptions) => string;
 };
 //#endregion