@gjermundgaraba/effect-actions 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/implementation-D75QAcD3.d.mts

@@ -1,21 +0,0 @@
-import { Any, t as Action_d_exports } from "./Action.mjs";
-import { Effect, Layer, Scope } from "effect";
-//#region src/internal/implementation.d.ts
-type Erased<R> = {
-  handle(input: unknown): Effect.Effect<unknown, unknown, R>;
-}["handle"];
-type Handlers<R> = Readonly<Record<string, Erased<R>>>;
-/**
- * Opaque implementation value; only its type is public. `R` is required per
- * request, `EX`/`RX` describe handler acquisition at Layer build. Layer
- * memoization lets both adapters share one handler build per runtime.
- */
-declare class Implementation<Actions extends ReadonlyArray<Any>, R, EX, RX> {
-  #private;
-  readonly actions: Actions;
-  private constructor();
-  static make<Actions extends ReadonlyArray<Any>, R, EX, RX>(actions: Actions, build: Effect.Effect<Handlers<R>, EX, RX>): Implementation<Actions, R, EX, Exclude<RX, Scope.Scope>>;
-  static register<Actions extends ReadonlyArray<Any>, R, EX, RX, Out, E, In>(app: Implementation<Actions, R, EX, RX>, make: (handlers: Handlers<R>) => Layer.Layer<Out, E, In>): Layer.Layer<Out, E | EX, In | RX>;
-}
-//#endregion
-export { Implementation as t };

package/dist/index.d.mts

@@ -1,6 +0,0 @@
-import { t as Action_d_exports } from "./Action.mjs";
-import { t as ActionGroup_d_exports } from "./ActionGroup.mjs";
-import { t as ActionHttp_d_exports } from "./http.mjs";
-import { t as ActionMcp_d_exports } from "./mcp.mjs";
-import { t as Authentication_d_exports } from "./authentication.mjs";
-export { Action_d_exports as Action, ActionGroup_d_exports as ActionGroup, ActionHttp_d_exports as ActionHttp, ActionMcp_d_exports as ActionMcp, Authentication_d_exports as Authentication };

package/dist/index.mjs

@@ -1,6 +0,0 @@
-import { t as Action_exports } from "./Action.mjs";
-import { t as ActionGroup_exports } from "./ActionGroup.mjs";
-import { t as ActionHttp_exports } from "./http.mjs";
-import { t as ActionMcp_exports } from "./mcp.mjs";
-import { t as Authentication_exports } from "./authentication.mjs";
-export { Action_exports as Action, ActionGroup_exports as ActionGroup, ActionHttp_exports as ActionHttp, ActionMcp_exports as ActionMcp, Authentication_exports as Authentication };

package/dist/mcp.d.mts

@@ -1,46 +0,0 @@
-import { Any, Codec, SchemaErrorPolicy, t as Action_d_exports } from "./Action.mjs";
-import { t as Implementation } from "./implementation-D75QAcD3.mjs";
-import { Cause, Layer } from "effect";
-import { McpProtocol } from "effect/unstable/ai";
-import { HttpRouter } from "effect/unstable/http";
-import { NonEmptyReadonlyArray } from "effect/Array";
-declare namespace ActionMcp_d_exports {
-  export { BearerChallengeOptions, Options, ProtectedResourceOptions, layer, protectedResource, protocols };
-}
-export interface Options<Errors extends ReadonlyArray<Codec> = []> {
-  readonly schemaError?: SchemaErrorPolicy<Errors>;
-  readonly name: string;
-  readonly version: string;
-  readonly path: HttpRouter.PathInput;
-  readonly protocols?: NonEmptyReadonlyArray<McpProtocol.ProtocolAdapter>;
-  readonly allowedOrigins?: ReadonlyArray<string>;
-  readonly instructions?: string;
-}
-/** Protocol revisions served over Streamable HTTP; 2026-07-28 is stateless. */
-export declare const protocols: NonEmptyReadonlyArray<McpProtocol.ProtocolAdapter>;
-/** A Streamable HTTP MCP endpoint serving the group's MCP-enabled actions. */
-export declare const layer: <Actions extends ReadonlyArray<Any>, R, EX, RX, Errors extends ReadonlyArray<Codec> = []>(app: Implementation<Actions, R, EX, RX>, options: Options<Errors>) => Layer.Layer<never, EX | Cause.IllegalArgumentError, RX | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", R>>;
-export interface ProtectedResourceOptions {
-  /** Exact OAuth resource identifier. HTTPS, or HTTP on loopback for development. */
-  readonly resource: string;
-  readonly authorizationServers: NonEmptyReadonlyArray<string>;
-  readonly scopesSupported?: ReadonlyArray<string>;
-  readonly resourceName?: string;
-}
-export interface BearerChallengeOptions {
-  readonly error?: "invalid_token" | "insufficient_scope";
-  readonly errorDescription?: string;
-  /** Space-separated scopes needed for this request, not all supported scopes. */
-  readonly scope?: string;
-}
-/**
- * Publish RFC 9728 discovery independently from the authenticated MCP route.
- * This supplies metadata and challenges; the host still verifies access tokens.
- */
-export declare const protectedResource: (options: ProtectedResourceOptions) => {
-  layer: Layer.Layer<never, never, HttpRouter.HttpRouter>;
-  metadataUrl: string;
-  challenge: (challenge?: BearerChallengeOptions) => string;
-};
-//#endregion
-export { ActionMcp_d_exports as t };

package/dist/mcp.mjs

@@ -1,189 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { n as handlerFor, t as Implementation } from "./implementation-BkLqMWtv.mjs";
-import { Context, Effect, JsonPointer, Layer, Schema } from "effect";
-import { McpProtocol, McpSchema, McpServer, Tool } from "effect/unstable/ai";
-import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-//#region src/ActionMcp.ts
-var ActionMcp_exports = /* @__PURE__ */ __exportAll({
-	layer: () => layer,
-	protectedResource: () => protectedResource,
-	protocols: () => protocols
-});
-/** Protocol revisions served over Streamable HTTP; 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 (typeof schema.$ref !== "string") 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;
-};
-/** 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; use Action.NoInput 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 = (action, table, 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 = handlerFor(table, 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))
-	}));
-	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)
-});
-/** A Streamable HTTP MCP endpoint serving the group's MCP-enabled actions. */
-const layer = (app, options) => Implementation.register(app, (table) => {
-	const native = Layer.effectDiscard(Effect.gen(function* () {
-		if (app.actions.some((action) => action.mcp !== false)) for (const error of options.schemaError?.errors ?? []) assertObjectError("Schema-error policy", error);
-		yield* Effect.forEach(app.actions, (action) => registerTool(action, table, options.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)));
-	}));
-});
-const oauthUrl = (value) => {
-	const url = new URL(value);
-	const loopback = [
-		"localhost",
-		"127.0.0.1",
-		"[::1]"
-	].includes(url.hostname);
-	if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback) || url.username !== "" || url.password !== "" || value.includes("#")) throw new Error("OAuth URLs must use HTTPS (or loopback HTTP) without credentials or fragment");
-	return url;
-};
-const scopeToken = /^[\x21\x23-\x5B\x5D-\x7E]+$/;
-/**
-* Publish RFC 9728 discovery independently from the authenticated MCP route.
-* This supplies metadata and challenges; the host still verifies access tokens.
-*/
-const protectedResource = (options) => {
-	const resource = oauthUrl(options.resource);
-	if (options.authorizationServers.length === 0) throw new Error("An authorization server is required");
-	for (const issuer of options.authorizationServers) {
-		oauthUrl(issuer);
-		if (issuer.includes("?")) throw new Error("Authorization server issuers must not contain a query");
-	}
-	for (const scope of options.scopesSupported ?? []) if (!scopeToken.test(scope)) throw new Error("Invalid OAuth scope token");
-	const path = `/.well-known/oauth-protected-resource${resource.pathname === "/" ? "" : resource.pathname}`;
-	const discoveryUrl = new URL(resource);
-	discoveryUrl.pathname = path;
-	const metadataUrl = discoveryUrl.href;
-	const target = metadataUrl.slice(discoveryUrl.origin.length);
-	const metadata = {
-		resource: options.resource,
-		authorization_servers: options.authorizationServers,
-		bearer_methods_supported: ["header"],
-		...options.scopesSupported?.length ? { scopes_supported: options.scopesSupported } : {},
-		...options.resourceName === void 0 ? {} : { resource_name: options.resourceName }
-	};
-	const response = HttpServerResponse.jsonUnsafe(metadata);
-	return {
-		layer: HttpRouter.middleware((next) => Effect.gen(function* () {
-			const request = yield* HttpServerRequest.HttpServerRequest;
-			const url = new URL(request.url, resource.origin);
-			if ((request.method === "GET" || request.method === "HEAD") && url.href.slice(url.origin.length) === target) return response;
-			return yield* next;
-		}), { global: true }),
-		metadataUrl,
-		challenge: (challenge = {}) => {
-			const parameters = [`resource_metadata="${metadataUrl.replace(/["\\]/g, "\\$&")}"`];
-			if (challenge.error !== void 0) parameters.push(`error="${challenge.error}"`);
-			if (challenge.errorDescription !== void 0) {
-				if (!/^[\x20-\x21\x23-\x5B\x5D-\x7E]*$/.test(challenge.errorDescription)) throw new Error("Invalid OAuth error description");
-				parameters.push(`error_description="${challenge.errorDescription}"`);
-			}
-			if (challenge.scope !== void 0) {
-				if (!challenge.scope.split(" ").every((scope) => scopeToken.test(scope))) throw new Error("Invalid OAuth challenge scope");
-				parameters.push(`scope="${challenge.scope}"`);
-			}
-			return `Bearer ${parameters.join(", ")}`;
-		}
-	};
-};
-//#endregion
-export { layer, protectedResource, protocols, ActionMcp_exports as t };

package/dist/testing/client.d.mts

@@ -1,11 +0,0 @@
-import { Client } from "@modelcontextprotocol/client";
-//#region src/TestingClient.d.ts
-export interface McpClientOptions {
-  readonly path: string;
-  readonly mode?: "legacy" | "modern";
-  readonly baseUrl?: string | URL;
-  readonly headers?: ConstructorParameters<typeof Headers>[0];
-}
-/** Connect an official client and always close its transport after the callback. */
-export declare const withMcpClient: <A>(fetch: (request: Request) => Promise<Response>, run: (client: Client) => Promise<A>, { mode, path, baseUrl, headers }: McpClientOptions) => Promise<A>;
-//#endregion

package/dist/testing.d.mts

@@ -1,10 +0,0 @@
-//#region src/Testing.d.ts
-/** A stateless 2026-07-28 request. */
-export interface McpRequestOptions {
-  readonly url: string | URL;
-  readonly headers?: ConstructorParameters<typeof Headers>[0];
-}
-export declare const mcpRequest: (method: string, params: (Record<string, unknown> & {
-  readonly _meta?: Record<string, unknown>;
-}) | undefined, options: McpRequestOptions) => Request;
-//#endregion

package/dist/testing.mjs

@@ -1,34 +0,0 @@
-//#region src/Testing.ts
-const mcpRequest = (method, params = {}, options) => {
-	const headers = new Headers(options.headers);
-	for (const [name, value] of Object.entries({
-		"content-type": "application/json",
-		accept: "application/json, text/event-stream",
-		"mcp-protocol-version": "2026-07-28",
-		"mcp-method": method,
-		...typeof params.name === "string" ? { "mcp-name": params.name } : {}
-	})) headers.set(name, value);
-	return new Request(options.url, {
-		method: "POST",
-		headers,
-		body: JSON.stringify({
-			jsonrpc: "2.0",
-			id: 1,
-			method,
-			params: {
-				...params,
-				_meta: {
-					"io.modelcontextprotocol/clientCapabilities": {},
-					"io.modelcontextprotocol/clientInfo": {
-						name: "test",
-						version: "0"
-					},
-					...params._meta,
-					"io.modelcontextprotocol/protocolVersion": "2026-07-28"
-				}
-			}
-		})
-	});
-};
-//#endregion
-export { mcpRequest };