@gjermundgaraba/effect-actions 0.13.0 → 0.15.0

package/examples/notes-service/src/worker.ts

@@ -0,0 +1,20 @@
+import { Layer } from "effect";
+import { HttpRouter, HttpServer } from "effect/http";
+import { NoteStore } from "./notes/store.js";
+import { requestScopedRoutes } from "./routes.js";
+
+// Entrypoint for a host that calls `fetch` per request and runs nothing between requests, such
+// as Cloudflare Workers, which takes this default export. The handler is built once, when the
+// module loads, as Effect's `HttpRouter.toWebHandler` asks on Workers: a build started inside
+// `fetch` would belong to that request. Building these routes does no I/O, which Workers refuses
+// outside a request. `toWebHandler` reads no `MaxBodySize`, so the host limits request bodies.
+const app = HttpRouter.toWebHandler(
+  requestScopedRoutes.pipe(
+    // DEMO ONLY: each instance of the worker holds notes of its own, lost when it stops. A
+    // deployment provides a store every instance reaches.
+    Layer.provide(NoteStore.layerMemory),
+    Layer.provide(HttpServer.layerServices),
+  ),
+);
+
+export default { fetch: (request: Request) => app.handler(request) };

package/examples/notes-service/test/commands.test.ts

@@ -22,7 +22,8 @@ import { NoteStore } from "../src/notes/store.js";
 import { routes } from "../src/routes.js";
 
 // What the commands add to the routes: their syntax and what they print. They call the real
-// routes in memory, as a client with a token does, where cli.ts connects them to a server.
+// routes in memory, as a client with a token does, where cli.ts connects them to a server. A
+// service a builder yields is provided here too (routes.test.ts).
 const served = Testing.layer(routes).pipe(Layer.provide(NoteStore.layerMemory));
 
 // Effect's own runner, given arguments instead of the process's. The console of `it.effect`

package/examples/notes-service/test/routes.test.ts

@@ -3,6 +3,7 @@ import { Effect, Layer } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/http";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
 import * as Testing from "@gjermundgaraba/effect-actions/Testing";
 import { Http } from "../src/Api.js";
 import { Notes } from "../src/notes/Notes.js";
@@ -11,7 +12,9 @@ import { routes } from "../src/routes.js";
 import { GetStatus } from "../src/status/Status.js";
 
 // What the wire adds: the real routes, behind their real authentication, answering in memory.
-// No port is opened. The caller is the token each client sends, as in production.
+// No port is opened. The caller is the token each client sends, as in production. A service a
+// builder yields is provided here, as server.ts provides it: one left out is a `Scope` error at
+// every `it.effect` (docs/Testing-failures.md).
 const served = Testing.layer(routes).pipe(Layer.provide(NoteStore.layerMemory));
 
 const as = (token: string) => ({
@@ -65,7 +68,7 @@ describe("the service, over HTTP and MCP", () => {
   it.effect("serves one store to both surfaces: a note written over HTTP is read as a tool", () =>
     Effect.gen(function* () {
       const http = yield* ActionHttp.client(Http, as("ada"));
-      const mcp = yield* Testing.mcpClient([GetStatus, ...Notes], as("ada"));
+      const mcp = yield* ActionMcp.client([GetStatus, ...Notes], as("ada"));
       const note = yield* http.createNote({ title: "Plan", body: "Draft" });
 
       expect(yield* mcp.getNote({ id: note.id })).toEqual(note);
@@ -75,7 +78,7 @@ describe("the service, over HTTP and MCP", () => {
 
   it.effect("lists every tool to a signed-out MCP client, as one of them is public", () =>
     Effect.gen(function* () {
-      const response = yield* HttpClient.execute(Testing.mcpRequest("tools/list"));
+      const response = yield* HttpClient.execute(ActionMcp.request("tools/list"));
 
       expect(response.status).toBe(200);
       expect(yield* response.text).toContain('"name":"createNote"');

package/examples/notes-service/test/worker.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Effect } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { CreateNote, GetNote } from "../src/notes/Notes.js";
+import { GetStatus } from "../src/status/Status.js";
+import worker from "../src/worker.js";
+
+// What a host calling the worker's `fetch` gets: the module's own handler, answering in memory.
+const served = Testing.layer(worker.fetch);
+
+const as = (token: string) => ({
+  transformClient: HttpClient.mapRequest(HttpClientRequest.bearerToken(token)),
+});
+
+describe("the worker", () => {
+  it.effect("serves the tools, each request as the caller it authenticates", () =>
+    Effect.gen(function* () {
+      const anyone = yield* ActionMcp.client([GetStatus, GetNote]);
+      const ada = yield* ActionMcp.client([CreateNote, GetNote], as("ada"));
+
+      expect(yield* anyone.getStatus()).toMatchObject({ service: "notes-service" });
+
+      const note = yield* ada.createNote({ title: "Plan", body: "First draft" });
+
+      expect(yield* ada.getNote({ id: note.id })).toEqual(note);
+      expect(yield* Effect.flip(anyone.getNote({ id: note.id }))).toBeInstanceOf(
+        Action.Unauthenticated,
+      );
+    }).pipe(Effect.provide(served)),
+  );
+});

package/examples/quickstart/test/greeting/greeting.test.ts

@@ -1,6 +1,7 @@
 import { expect, it } from "@effect/vitest";
 import { Effect } from "effect";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
 import * as Testing from "@gjermundgaraba/effect-actions/Testing";
 import { Http } from "../../src/Api.js";
 import { Greet } from "../../src/greeting/Greeting.js";
@@ -10,7 +11,7 @@ import { routes } from "../../src/routes.js";
 it.effect("greets over HTTP and as an MCP tool", () =>
   Effect.gen(function* () {
     const http = yield* ActionHttp.client(Http);
-    const mcp = yield* Testing.mcpClient([Greet]);
+    const mcp = yield* ActionMcp.client([Greet]);
 
     expect(yield* http.greet({ name: "Ada" })).toBe("Hello, Ada!");
     expect(yield* mcp.greet({ name: "Ada" })).toBe("Hello, Ada!");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjermundgaraba/effect-actions",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Define Effect action contracts once and project them onto HTTP, MCP, Effect RPC, native Toolkits, and CLIs.",
   "keywords": [
     "ai-agents",
@@ -49,11 +49,11 @@
     "access": "public"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.3",
-    "@effect/vitest": "4.0.3",
+    "@effect/platform-node": "4.0.4",
+    "@effect/vitest": "4.0.4",
     "@modelcontextprotocol/client": "2.3.1",
     "@types/node": "26.6.4",
-    "effect": "4.0.3",
+    "effect": "4.0.4",
     "tsx": "4.23.15",
     "typescript": "7.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
@@ -61,7 +61,7 @@
     "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "effect": "~4.0.3"
+    "effect": "~4.0.4"
   },
   "devEngines": {
     "packageManager": {

package/dist/http/declared.mjs

@@ -1,20 +0,0 @@
-import { unsuspended } from "../contract/rules.mjs";
-import { Schema, SchemaAST } from "effect";
-import { HttpServerResponse } from "effect/http";
-import { HttpApiSchema } from "effect/http-api";
-//#region src/http/declared.ts
-const httpApiStatusOf = SchemaAST.resolveAt("httpApiStatus");
-const statusThroughSuspensions = (ast) => httpApiStatusOf(ast) ?? (SchemaAST.isSuspend(ast) ? statusThroughSuspensions(ast.thunk()) : void 0);
-const declared = (error) => {
-	const status = statusThroughSuspensions(error.ast);
-	if (status !== void 0) return [httpApiStatusOf(error.ast) === void 0 ? HttpApiSchema.status(status)(error) : error];
-	const resolved = unsuspended(error.ast);
-	if (SchemaAST.isUnion(resolved) && resolved.checks === void 0 && resolved.encoding === void 0) return resolved.types.flatMap((member) => declared(Schema.make(member)));
-	return [HttpApiSchema.status(422)(error)];
-};
-const declaredResponse = (errors, error) => {
-	const schema = errors.flatMap(declared).find((each) => Schema.is(each)(error));
-	return schema === void 0 ? void 0 : HttpServerResponse.jsonUnsafe(Schema.encodeUnknownSync(Schema.toCodecJson(schema))(error), { status: httpApiStatusOf(schema.ast) ?? 422 });
-};
-//#endregion
-export { declared, declaredResponse };

package/dist/mcp/protocol.d.mts

@@ -1,18 +0,0 @@
-import "../contract/implementation.mjs";
-import "../contract/media.mjs";
-import "../Action.mjs";
-import { Schema } from "effect";
-import { McpProtocol } from "effect/ai";
-//#region src/mcp/protocol.d.ts
-/**
- * An MCP request's parameters, as `Testing.mcpRequest` takes them: JSON, with any `_meta`, leaving
- * out an `undefined` one, as a caller may. A helper passing on whole params types them as this,
- * and a tool's `arguments` as `Schema.Json`, never `unknown`.
- */
-export interface Params {
-  readonly _meta?: {
-    readonly [key: string]: Schema.Json;
-  };
-  readonly [key: string]: Schema.Json | undefined;
-}
-//#endregion

package/dist/toolkit/tools.mjs

@@ -1,29 +0,0 @@
-import { assertOnce, projectedErrors } from "../contract/rules.mjs";
-import { acquire } from "../contract/implementation.mjs";
-import { Effect, Schema } from "effect";
-import { Tool, Toolkit } from "effect/ai";
-//#region src/toolkit/tools.ts
-const annotateIfGiven = (tool, key, value) => value === void 0 ? tool : tool.annotate(key, value);
-const annotateFromContract = (tool, { readOnly, mcp }) => {
-	const destructiveUnlessReadOnly = mcp.destructiveHint ?? (readOnly ? false : void 0);
-	const meta = mcp._meta === void 0 ? void 0 : { ...mcp._meta };
-	const hinted = annotateIfGiven(annotateIfGiven(annotateIfGiven(tool.annotate(Tool.Readonly, readOnly), Tool.Destructive, destructiveUnlessReadOnly), Tool.Idempotent, mcp.idempotentHint), Tool.OpenWorld, mcp.openWorldHint);
-	return annotateIfGiven(annotateIfGiven(hinted, Tool.Title, mcp.title), Tool.Meta, meta);
-};
-const jsonToolOf = (action) => Tool.make(action.name, {
-	description: action.description,
-	parameters: Schema.toCodecJson(action.input),
-	success: Schema.toCodecJson(action.success),
-	failure: Schema.toCodecJson(Schema.Union(projectedErrors(action))),
-	failureMode: "return"
-});
-const bindTools = (apps, projection) => {
-	assertOnce(projection.label, apps.flatMap((app) => app.actions));
-	const toolkit = Toolkit.make(...apps.flatMap((app) => app.actions.map((action) => annotateFromContract(projection.tool(jsonToolOf(action), action, app), action))));
-	return {
-		toolkit,
-		layer: toolkit.toLayer(Effect.map(acquire(apps), (bound) => Object.fromEntries(bound.map(([action, run]) => [action.name, projection.handler?.(run, action) ?? run]))))
-	};
-};
-//#endregion
-export { bindTools };