@gjermundgaraba/effect-actions 0.9.0 → 0.11.0

package/dist/ActionMcp.mjs

@@ -1,98 +1,249 @@
-import "./internal/implementation.mjs";
-import { TextField, bindTools } from "./internal/tools.mjs";
-import { Context, Effect, Layer, Option, Predicate, Schema } from "effect";
-import { McpProtocol, McpSchema, McpServer } from "effect/ai";
+import { Anyone } from "./internal/actions.mjs";
+import { provideHandlers, select, toList } from "./internal/implementation.mjs";
+import { assertAuthentication, promote } from "./internal/authentication.mjs";
+import { fieldKey, httpProtocol, isMisplaced, liftOf, liftedFrom } from "./internal/mcp.mjs";
+import { recordStepUp } from "./internal/refusal.mjs";
+import { logToStderr } from "./internal/console.mjs";
+import { bindTools } from "./internal/tools.mjs";
+import { Cause, Context, Effect, ErrorReporter, Exit, Fiber, JsonPointer, Layer, Option, Predicate, References, Result, Schema, Stream } from "effect";
+import { HttpRouter, HttpServerRequest } from "effect/http";
+import { AiError, McpProtocol, McpSchema, McpServer, Tool, Toolkit } from "effect/ai";
 //#region src/ActionMcp.ts
 /**
-* The one protocol revision served. 2026-07-28 is stateless over HTTP: no
-* initialize handshake and no session, so every request stands alone.
+* The revisions served over stdio: 2026-07-28 and the stateful revisions hosts open stdio
+* with, newest first; a host asking for another is offered 2025-11-25. A success is sent as it
+* is on each. 2026-07-28 carries any success as `structuredContent`; the adapters of 2025-11-25
+* and 2025-06-18 carry only an object there, and list only an object-rooted `outputSchema`. A
+* success they do not structure is text alone, a string as itself.
 */
-const protocols = [McpProtocol.v2026_07_28];
-/** The parts of a listed output schema a text field is removed from. */
-const decodeOutput = Schema.decodeUnknownOption(Schema.Struct({
-	properties: Schema.Record(Schema.String, Schema.Json),
-	required: Schema.optionalKey(Schema.Array(Schema.String))
-}));
-/** A JSON value that is an object: neither null, a scalar nor an array. */
-const isJsonObject = (value) => Predicate.isObject(value);
-/** Split a JSON object into one field and the rest. */
-const detach = (value, field) => {
-	const { [field]: detached, ...rest } = value;
-	return {
-		detached,
-		rest
+const stdioProtocols = [
+	McpProtocol.v2026_07_28,
+	McpProtocol.v2025_11_25,
+	McpProtocol.v2025_06_18
+];
+/**
+* MCP has a JSON-only wire contract. Success is the encoded success as structured content,
+* and its JSON as text, but for its media, each lifted into a block of its own; declared
+* failures are returned as JSON text. The native server refuses undeclared arguments and
+* publishes closed input schemas.
+*/
+const projection = {
+	label: "MCP tool",
+	tool: (tool) => tool.annotate(Tool.Strict, true)
+};
+/** Whether a JSON Schema is one the native server takes for a tool's arguments. */
+const isToolJson = Schema.is(McpSchema.ToolJson);
+/**
+* The JSON Schema of `schema`, a JSON codec, as the native server lists it for a tool: a
+* `$ref` at its root resolved, as MCP requires an object root, and its definitions as `$defs`.
+* A strict one refuses undeclared keys.
+*/
+const toolJsonSchema = (schema, strict) => {
+	const document = Schema.toJsonSchemaDocument(schema, { onExcessProperty: strict ? "error" : "ignore" });
+	const [scope, key] = Predicate.isString(document.schema.$ref) ? JsonPointer.parseUriFragment(document.schema.$ref) ?? [] : [];
+	const root = scope === "$defs" && key !== void 0 ? document.definitions[key] : document.schema;
+	return root === void 0 || Object.keys(document.definitions).length === 0 ? root : {
+		...root,
+		$defs: document.definitions
 	};
 };
 /**
-* The listed output schema without the text field. Only a top-level property can be
-* detached; anything else fails the layer build rather than publish a schema the
-* structured content would not satisfy.
+* Refuse, when the server is made, the actions whose input is not one object, as the root of a
+* tool's arguments must be, naming every one, reading the JSON Schema the native
+* server reads: not a union, an array, a scalar, nor `Schema.Struct({})`, which takes any value
+* but `null`, where the native server dies when the layer builds, suggesting
+* `Tool.EmptyParams`. Then refuse those holding media where no tool lifts it, as each action's
+* `Lift` says.
 */
-const outputWithout = (tool, field) => {
-	const { properties: _, required: __, ...output } = tool.outputSchema ?? {};
-	const listed = Option.getOrUndefined(decodeOutput(tool.outputSchema));
-	if (listed === void 0 || !Object.hasOwn(listed.properties, field)) return Effect.die(`MCP tool '${tool.name}' cannot send '${field}' as text: it is not a top-level property of its success`);
-	const required = (listed.required ?? []).filter((key) => key !== field);
-	return Effect.succeed({
-		...output,
-		properties: detach(listed.properties, field).rest,
-		...required.length === 0 ? {} : { required }
-	});
+const assertShapes = (lifted) => {
+	const inputs = lifted.map(([action]) => action).filter((action) => !isToolJson(toolJsonSchema(Schema.toCodecJson(action.input), true))).map(({ name }) => name);
+	if (inputs.length > 0) throw new Error(`MCP tool input must be one object with keys, such as a struct: ${inputs.join(", ")}`);
+	const misplaced = lifted.filter(([action, lift]) => isMisplaced(action, lift)).map(([{ name }]) => name);
+	if (misplaced.length > 0) throw new Error(`MCP media must be the success or an array of it, or a top-level field of a struct success, one, optional or a required array: ${misplaced.join(", ")}`);
 };
 /**
-* A successful result with a string text field sent once, raw, before the structured
-* rest and its JSON copy. Any other result, such as a failure or a success without
-* the field, is the native one.
+* What the native server answers a call that fails other than as its contract declares: a
+* defect, an invalid success or error, or an unknown tool.
 */
-const textResult = (result, field) => {
-	const structured = result.structuredContent;
-	if (result.isError === true || !isJsonObject(structured)) return result;
-	const { detached, rest } = detach(structured, field);
-	if (!Predicate.isString(detached)) return result;
-	return new McpSchema.CallToolResult({
-		...result,
-		structuredContent: rest,
-		content: [{
-			type: "text",
-			text: detached
-		}, {
-			type: "text",
-			text: JSON.stringify(rest)
-		}]
+const internalError = "Tool execution failed due to an internal server error.";
+/** A tool's error result, `text` its one text block. */
+const errorResult = (text) => new McpSchema.CallToolResult({
+	isError: true,
+	content: [{
+		type: "text",
+		text
+	}]
+});
+/** The one text block holding `encoded`'s JSON, none for `undefined`, as the native server sends it. */
+const textOf = (encoded) => encoded === void 0 ? [] : [{
+	type: "text",
+	text: JSON.stringify(encoded)
+}];
+/** The content block a lifted media value is sent as, naming its field where it has one. */
+const blockOf = ({ kind, field, value }) => ({
+	type: kind,
+	data: value.data,
+	mimeType: value.mimeType,
+	...field === void 0 ? {} : { _meta: { [fieldKey]: field } }
+});
+/** Why a tool call's arguments failed to decode, as the native server tells it, if they did. */
+const invalidParameters = (error) => AiError.isAiError(error) && Predicate.isTagged(error.reason, "ToolParameterValidationError") ? error.reason : void 0;
+const omitRequestServices = Context.omit(McpSchema.McpRequestContext, McpSchema.McpServerClient, HttpServerRequest.HttpServerRequest, References.CurrentLogLevel);
+/**
+* Register the tools of `toolkit` on the endpoint's registry, as `McpServer.registerToolkit`
+* does, lifting the media `lifts` finds in a tool's success into blocks of their own. The native
+* registration sends every success as structured content and one JSON text block, and takes
+* no option, so this one follows it: its decode options, failure classification, defect
+* scrubbing and listing, and the request services it leaves out of what it retains. A tool
+* whose action holds no media is registered as the native one would be: a test compares their
+* listings and results, not the services each call runs with.
+*/
+const registerTools = Effect.fnUntraced(function* (toolkit, lifts) {
+	const registry = yield* McpServer.McpServer;
+	const built = yield* toolkit.pipe(Effect.updateContext((context) => Context.merge(context, Context.mergeAll(...Object.values(toolkit.tools).flatMap((tool) => {
+		const key = Context.Service(tool.id);
+		return Option.toArray(Context.getOption(context, key)).map((handler) => Context.make(key, {
+			...handler,
+			context: omitRequestServices(handler.context)
+		}));
+	})))));
+	const services = omitRequestServices(yield* Effect.context());
+	const internalToolError = (cause) => {
+		const failure = Cause.findFail(cause);
+		return Result.isFailure(failure) && !Cause.hasDies(cause) ? Effect.failCause(failure.failure) : Effect.logError(cause).pipe(Effect.andThen(Effect.provideContext(ErrorReporter.report(cause), services)), Effect.as(errorResult(internalError)));
+	};
+	const handleCause = (cause) => {
+		const failure = Cause.findFail(cause);
+		if (Result.isSuccess(failure)) {
+			const { error } = failure.success;
+			const invalid = Context.get(Cause.reasonAnnotations(failure.success), Toolkit.FailureOrigin) === "parameters" ? invalidParameters(error) : void 0;
+			if (invalid !== void 0) return Effect.fail(new McpSchema.InvalidParams({ message: invalid.message }));
+		}
+		return internalToolError(cause);
+	};
+	const registrations = yield* Effect.forEach(Object.entries(built.tools), ([name, tool]) => Effect.gen(function* () {
+		const strict = Tool.getStrictMode(tool) === true;
+		const decodeOptions = {
+			onExcessProperty: strict ? "error" : "ignore",
+			errors: "all"
+		};
+		const lift = lifts.get(name);
+		const media = lift === void 0 || lift.fields.length === 0 ? void 0 : lift;
+		const structured = media === void 0 ? tool.successSchema : media.rest === void 0 ? void 0 : Schema.toCodecJson(media.rest);
+		const outputSchema = structured === void 0 ? void 0 : yield* Schema.decodeUnknownEffect(McpSchema.ToolOutputJson)(toolJsonSchema(structured, false)).pipe(Effect.orDie);
+		const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJson)(toolJsonSchema(tool.parametersSchema, strict)).pipe(Effect.orDie);
+		const lifted = new Set(media?.fields.map(({ name }) => name));
+		const succeeded = ({ encodedResult, result }) => {
+			if (media === void 0) return new McpSchema.CallToolResult({
+				isError: false,
+				structuredContent: encodedResult,
+				content: textOf(encodedResult)
+			});
+			const blocks = liftedFrom(media, result).map(blockOf);
+			if (structured === void 0) return new McpSchema.CallToolResult({
+				isError: false,
+				content: blocks
+			});
+			const rest = Predicate.isObject(encodedResult) ? Object.fromEntries(Object.entries(encodedResult).filter(([key]) => !lifted.has(key))) : encodedResult;
+			return new McpSchema.CallToolResult({
+				isError: false,
+				structuredContent: rest,
+				content: [...textOf(rest), ...blocks]
+			});
+		};
+		return {
+			tool: new McpSchema.Tool({
+				name,
+				description: Tool.getDescription(tool),
+				inputSchema,
+				outputSchema,
+				annotations: {
+					...Context.getOption(tool.annotations, Tool.Title).pipe(Option.map((title) => ({ title })), Option.getOrUndefined),
+					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: Context.getOrUndefined(tool.annotations, Tool.Meta)
+			}),
+			annotations: tool.annotations,
+			handle: (payload) => built.handle(name, payload ?? {}, void 0, decodeOptions).pipe(Stream.unwrap, Stream.runLast, Effect.flatMap(Effect.fromOption), Effect.flatMap((result) => !result.isFailure ? Effect.succeed(succeeded(result)) : result.failureOrigin === "handler" ? Effect.succeed(new McpSchema.CallToolResult({
+				isError: true,
+				content: textOf(result.encodedResult)
+			})) : Effect.failCause(Cause.annotate(Cause.fail(result.result), Context.make(Toolkit.FailureOrigin, result.failureOrigin ?? "result")))), Effect.catchCause(handleCause), Effect.provideContext(services))
+		};
+	}));
+	for (const registration of registrations) yield* registry.addTool(registration);
+});
+const server = (apps, transport, features = Layer.empty, authentication) => {
+	const binding = bindTools(apps, authentication === void 0 ? projection : {
+		...projection,
+		handler: (run, action) => (input) => action.caller === Anyone ? run(input) : recordStepUp(promote(authentication, run(input)))
+	});
+	const lifted = apps.flatMap((app) => app.actions.map((action) => [action, liftOf(action.success)]));
+	assertShapes(lifted);
+	const lifts = new Map(lifted.map(([{ name }, lift]) => [name, lift]));
+	const register = Effect.gen(function* () {
+		const registry = yield* McpServer.McpServer;
+		const claimed = registry.tools.flatMap(({ tool }) => lifts.has(tool.name) ? [tool.name] : []);
+		if (claimed.length > 0) return yield* Effect.die(/* @__PURE__ */ new Error(`Duplicate MCP tool: ${claimed.join(", ")}, claimed by an action and a native feature`));
+		const handlers = yield* Layer.build(binding.layer);
+		yield* registerTools(binding.toolkit, lifts).pipe(Effect.setContext(Context.add(handlers, McpServer.McpServer, registry)));
 	});
+	return Layer.effectDiscard(register).pipe(Layer.provide(features), Layer.provide(transport), Layer.fresh, provideHandlers(apps));
 };
-/** A native registration whose success sends `field` as text. */
-const withText = (registration, field) => Effect.map(outputWithout(registration.tool, field), (outputSchema) => ({
-	...registration,
-	tool: new McpSchema.Tool({
-		...registration.tool,
-		outputSchema
-	}),
-	handle: (payload) => Effect.map(registration.handle(payload), (result) => Predicate.isTagged(result, "InputRequired") ? result : textResult(result, field))
-}));
-const registration = (apps, options) => {
-	const binding = bindTools(apps, "mcp", options);
-	const registered = McpServer.registerToolkit(binding.toolkit).pipe(Effect.updateService(McpServer.McpServer, (server) => ({
-		...server,
-		addTool: (tool) => {
-			const field = Context.get(tool.annotations, TextField);
-			return field === void 0 ? server.addTool(tool) : Effect.flatMap(withText(tool, field), server.addTool);
-		}
-	})));
-	return Layer.effectDiscard(registered).pipe(Layer.provide(binding.layer));
+/**
+* What an anonymous caller of a mixed endpoint may send besides a public tool's call:
+* discovering the server and its tools, which the contracts describe, and cancelling.
+* Everything else, a native feature's listing, completion or subscription among them, and
+* any method a later revision adds, authenticates.
+*/
+const anonymous = /* @__PURE__ */ new Set([
+	"server/discover",
+	"tools/list",
+	"notifications/cancelled"
+]);
+/**
+* Whether a request to an endpoint serving `actions` must authenticate before the native
+* server reads its body. An endpoint whose every tool is protected authenticates every
+* request, so a host signs in when it connects. Otherwise the request's routing headers
+* decide, which the native server refuses when they disagree with the body: discovery and a
+* call of a public tool authenticate only a caller presenting credentials, and everything
+* else authenticates, so native features are protected too. A request whose headers name
+* no public tool as it is authenticates: it fails closed.
+*/
+const requiresAuthentication = (actions) => {
+	const open = new Set(actions.filter(({ caller }) => caller === Anyone).map(({ name }) => name));
+	return (headers) => {
+		if (open.size === 0) return true;
+		const method = headers["mcp-method"];
+		if (method === void 0) return true;
+		if (anonymous.has(method)) return false;
+		if (method !== "tools/call") return true;
+		const name = headers["mcp-name"];
+		return name === void 0 || !open.has(name);
+	};
 };
-const server = (apps, options, transport) => registration(apps, options).pipe(Layer.provide(transport), Layer.fresh);
-function layerHttp(apps, options) {
-	return server(apps, options, McpServer.layerHttp({
+function layerHttp(apps, { actions, features, path, authentication, ...options }) {
+	const selected = select(toList(apps), actions);
+	const served = selected.flatMap((app) => app.actions);
+	assertAuthentication(served, authentication);
+	const transport = server(selected, McpServer.layerHttp({
 		...options,
-		protocols
-	}));
+		path: path ?? "/mcp",
+		protocols: [httpProtocol]
+	}), features, authentication);
+	if (authentication === void 0) return transport;
+	const required = requiresAuthentication(served);
+	const middleware = HttpRouter.middleware(Effect.map(authentication["~provider"], (runtime) => (route) => Effect.flatMap(HttpServerRequest.HttpServerRequest, (request) => runtime.http(route, !required(request.headers)))));
+	return transport.pipe(Layer.provide(middleware.layer));
 }
-function layerStdio(apps, options) {
-	return server(apps, options, McpServer.layerStdio({
+function runStdio(apps, { actions, features, ...options }) {
+	const transport = server(select(toList(apps), actions), McpServer.layerStdio({
 		...options,
-		protocols
-	}));
+		protocols: stdioProtocols
+	}), features);
+	return Layer.launch(transport).pipe(logToStderr, Effect.forkChild, Effect.flatMap(Fiber.await), Effect.flatMap((exit) => Exit.isFailure(exit) && !Cause.hasInterruptsOnly(exit.cause) ? Effect.failCause(exit.cause) : Effect.void));
 }
 //#endregion
-export { layerHttp, layerStdio };
+export { layerHttp, runStdio };

package/dist/ActionToolkit.d.mts

@@ -1,40 +1,69 @@
-import { Action_d_exports, Any, Codec } from "./Action.mjs";
-import { AnyImplementation, BuildContext, BuildError, HandlerContext, HiddenFromMcp, Implementation } from "./internal/implementation.mjs";
-import { SurfaceOptions } from "./internal/tools.mjs";
-import { Layer, Schema } from "effect";
+import { BuiltIns } from "./internal/errors.mjs";
+import { ActionOf, BuildError, BuildServices, Holding, Known, Member, Offered, OptionalUnless, RequestOf, SelectedOf, Served, Serving } from "./internal/implementation.mjs";
+import { Action_d_exports, Any } from "./Action.mjs";
+import { Effect, Layer, Schema } from "effect";
 import { Tool, Toolkit } from "effect/ai";
 //#region src/ActionToolkit.d.ts
-/** What the in-process caller binds around the implementations it projects. */
-export type Options<Errors extends ReadonlyArray<Codec> = [], R = never> = SurfaceOptions<Errors, R>;
-/** A native tool corresponding to an action MCP may serve, named by its tool metadata. */
-type NativeTool<A extends Any, E extends Codec, R> = Extract<A["mcp"], object> extends {
-  readonly name: infer Name extends string;
-} ? Tool.Tool<Name, {
-  readonly parameters: A["input"];
-  readonly success: A["success"];
-  readonly failure: Schema.Union<ReadonlyArray<A["errors"][number] | E>>;
+/** A native tool named after its action, taking and giving JSON. */
+type NativeTool<A extends Any, R> = Tool.Tool<A["name"], {
+  readonly parameters: Schema.toCodecJson<A["input"]>;
+  readonly success: Schema.toCodecJson<A["success"]>;
+  readonly failure: Schema.toCodecJson<Schema.Union<ReadonlyArray<A["error"][number] | BuiltIns>>>;
   readonly failureMode: "return";
-}, R> : never;
-type HandlersOf<App extends AnyImplementation> = App extends Implementation<any, infer H, any, any> ? H : never;
+}, R>;
 /**
- * A tool needs what its handler needs, plus what the binding's `before` hook needs. The
- * rule is `ActionMcp`'s: only an action certainly hidden from MCP has no tool.
+ * The tool of each action of `App` among `Listed`. A tool needs what its handler and its
+ * implementation's authorization need.
  */
-type ToolForAction<App extends AnyImplementation, A extends Any, E extends Codec, RB> = A extends HiddenFromMcp ? never : NativeTool<A, E, HandlerContext<HandlersOf<App>, Extract<A["name"], keyof HandlersOf<App>>> | RB>;
-type ToolsFor<App extends AnyImplementation, E extends Codec, RB> = App extends AnyImplementation ? ToolForAction<App, App["group"]["actions"][number], E, RB> : never;
-type ToolkitTools<Apps extends ReadonlyArray<AnyImplementation>, E extends Codec, RB> = { readonly [T in ToolsFor<Apps[number], E, RB> 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>;
+type ToolFor<App, Listed extends Any> = App extends unknown ? Serving<App, Listed> extends (infer A extends Any) ? A extends Any ? NativeTool<A, RequestOf<App, A>> : never : never : never;
+/**
+ * Native tools bound to their action implementations: a native `Toolkit` and the layer of
+ * its handlers, for `LanguageModel`, `Toolkit.merge` or `handle`. Tools belong to their
+ * implementations: the `layer` of a `make` call serves the tools it selected in any `toolkit`
+ * of the same implementations, while two implementations never run each other's handlers,
+ * even with tools of one name.
+ */
+export interface Tools<T extends Record<string, Tool.Any>, E, R> {
+  /**
+   * The native toolkit: its `tools` are the definitions, by name, with schemas, hints and approval.
+   */
+  readonly toolkit: Toolkit.Toolkit<T>;
   /** Acquires handlers once in the layer scope; handler requirements remain at invocation. */
-  readonly layer: Layer.Layer<Tool.HandlersFor<Tools>, E, R>;
+  readonly layer: Layer.Layer<Tool.HandlersFor<T>, E, R>;
+}
+/**
+ * One call of a tool, as `needsApproval` receives it: its action's name, the action, and
+ * the call's decoded input. Checking `name` narrows the other two to that action's.
+ */
+export type ToolCall<A extends Any = Any> = A extends Any ? {
+  readonly name: A["name"];
+  readonly action: A;
+  readonly input: A["input"]["Type"];
+} : never;
+/** How `make` projects its tools, the actions `A`. */
+export interface Options<A extends Any> {
+  /**
+   * The actions that are tools, among the implementations' actions: `[GetUser, RenameUser]`.
+   * Each keeps its implementation's authorization and builder. Defaults to every action of them.
+   */
+  readonly actions?: ReadonlyArray<A> | undefined;
+  /**
+   * Whether a model's call needs approval before it runs: a boolean, or an Effect of one, for
+   * each call, with Effect's native approval context. `LanguageModel` asks for approval
+   * instead of calling the tool when it is `true`. The Effect runs in the caller's context and
+   * requires nothing, so it reads the caller with `Effect.serviceOption`. Defaults to none.
+   */
+  readonly needsApproval?: (call: ToolCall<A>, context: Tool.NeedsApprovalContext) => boolean | Effect.Effect<boolean>;
 }
 /**
- * Project implementations into Effect's native AI toolkit.
+ * Project implementations into Effect's native AI toolkit: one tool per action, keyed by its
+ * name, of the listed `actions` or, without them, of every action of the implementations.
  *
  * 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.
+ * when the resulting toolkit handles a call, the identity an implementation's `authorize`
+ * reads included: the caller provides it. `needsApproval` marks the calls a model must have
+ * approved; it authorizes nothing, which stays `authorize`'s.
  */
-export declare function make<const Apps extends ReadonlyArray<AnyImplementation>, const Errors extends ReadonlyArray<Codec> = [], RB = never>(apps: readonly [...Apps], options?: Options<Errors, RB>): Binding<ToolkitTools<Apps, Errors[number], RB>, BuildError<Apps[number], HiddenFromMcp>, BuildContext<Apps[number], HiddenFromMcp>>;
+export declare function make<const Apps extends Served, const O extends Options<ActionOf<Member<Apps>>> = {}>(implementations: Apps, ...options: OptionalUnless<O, Options<ActionOf<Member<Apps>>> & O & NoInfer<Known<O, Options<Any>>>>): Tools<{ readonly [T in ToolFor<Member<Apps>, Offered<O, ActionOf<Member<Apps>>>> as T["name"]]: T; }, BuildError<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>, BuildServices<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>>;
 //#endregion

package/dist/ActionToolkit.mjs

@@ -1,10 +1,21 @@
-import "./internal/implementation.mjs";
+import { Implementation, provideHandlers, select, toList } from "./internal/implementation.mjs";
 import { bindTools } from "./internal/tools.mjs";
-import "effect";
-import "effect/ai";
 //#region src/ActionToolkit.ts
-function make(apps, options = {}) {
-	return bindTools(apps, "native", options);
+function make(apps, options) {
+	const served = select(toList(apps), options?.actions);
+	const needsApproval = options?.needsApproval;
+	const { toolkit, layer } = bindTools(served, {
+		label: "tool",
+		tool: (tool, action, app) => Object.assign(needsApproval === void 0 ? tool : tool.setNeedsApproval((input, context) => needsApproval({
+			name: action.name,
+			action,
+			input
+		}, context)), { id: `${Implementation.runKey(app)}/${action.name}` })
+	});
+	return {
+		toolkit,
+		layer: layer.pipe(provideHandlers(served))
+	};
 }
 //#endregion
 export { make };