@krak-stack/registry 0.1.16 → 0.1.18

package/dist/lib/httpapi-cli.d.ts

@@ -1,22 +1,24 @@
-import { Context, Effect, FileSystem, Layer, Path, Stdio, Terminal } from "effect";
+import { Cause, Context, Effect, FileSystem, Layer, Path, Stdio, Terminal } from "effect";
 import { Command } from "effect/unstable/cli";
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
-import { ApiClient } from "./httpapi-client.js";
-import { HttpApiSpec } from "./httpapi-helpers.js";
+import { ApiClient, type ApiClientService } from "./httpapi-client.js";
+import { HttpApiSpec, type HttpApiOperationEntry } from "./httpapi-helpers.js";
 declare const HttpApiCli_base: Context.ServiceClass<HttpApiCli, "HttpApiCli", {
-    command: Command.Command<string, {}, {}, Error, never>;
-    run: (args: ReadonlyArray<string>) => Effect.Effect<void, Error | import("effect/unstable/cli/CliError").CliError, Command.Environment>;
+    command: Command.Command<string, {}, {}, unknown, never>;
+    run: (args: ReadonlyArray<string>) => Effect.Effect<void, unknown, Command.Environment>;
 }> & {
     readonly make: () => Effect.Effect<{
-        command: Command.Command<string, {}, {}, Error, never>;
-        run: (args: ReadonlyArray<string>) => Effect.Effect<void, Error | import("effect/unstable/cli/CliError").CliError, Command.Environment>;
+        command: Command.Command<string, {}, {}, unknown, never>;
+        run: (args: ReadonlyArray<string>) => Effect.Effect<void, unknown, Command.Environment>;
     }, never, ApiClient | HttpApiSpec>;
 };
 export declare class HttpApiCli extends HttpApiCli_base {
     static readonly layer: Layer.Layer<HttpApiCli, never, ApiClient | HttpApiSpec>;
 }
-export declare const makeHttpApiCliCommand: () => Effect.Effect<Command.Command<string, {}, {}, Error, never>, never, ApiClient | HttpApiSpec>;
+export declare const printHttpApiCliResult: (response: unknown, operation: HttpApiOperationEntry, client: ApiClientService) => Effect.Effect<void, unknown, never>;
+export declare const makeHttpApiCliCommand: () => Effect.Effect<Command.Command<string, {}, {}, unknown, never>, never, ApiClient | HttpApiSpec>;
 export declare const httpApiCliEnvironmentLayer: (args: ReadonlyArray<string>) => Layer.Layer<ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | Terminal.Terminal, never, never>;
-export declare const httpApiCli: (args?: string[]) => Effect.Effect<void, import("effect/unstable/cli/CliError").DuplicateOption | Error | import("effect/unstable/cli/CliError").InvalidValue | import("effect/unstable/cli/CliError").MissingArgument | import("effect/unstable/cli/CliError").MissingOption | import("effect/unstable/cli/CliError").ShowHelp | import("effect/unstable/cli/CliError").UnknownSubcommand | import("effect/unstable/cli/CliError").UnrecognizedOption, HttpApiCli | Command.Environment>;
+export declare const httpApiCli: (args?: string[]) => Effect.Effect<void, unknown, HttpApiCli | Command.Environment>;
+export declare const formatHttpApiCliCause: <E>(cause: Cause.Cause<E>) => string;
 export declare const runHttpApiCli: <E>(layer: Layer.Layer<HttpApiCli, E>, args?: string[]) => void;
 export {};

package/dist/lib/httpapi-cli.js

@@ -1,11 +1,14 @@
 // ../../src/lib/httpapi-cli.ts
 import {
+  Cause,
   Console,
   Context as Context3,
   Effect as Effect3,
+  Exit,
   FileSystem,
   Layer as Layer3,
   Path,
+  Schema as Schema3,
   Stdio,
   Stream,
   Terminal
@@ -14,13 +17,22 @@ import { Command, Flag } from "effect/unstable/cli";
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 
 // ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import {
-  HttpApiClient as EffectHttpApiClient
+  HttpApi,
+  HttpApiClient as EffectHttpApiClient,
+  OpenApi
 } from "effect/unstable/httpapi";
+var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
+  decode: () => {
+    return;
+  },
+  encode: () => null
+})));
 var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
   Schema.Null,
+  UndefinedFromNull,
   Schema.String,
   Schema.Number,
   Schema.Boolean,
@@ -34,6 +46,37 @@ var HttpApiOperationResult = Schema.Union([
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
 var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var reflectedSchema = (schema) => Schema.make(schema.ast);
+var operationResultSchemas = (api) => {
+  const schemas = new Map;
+  HttpApi.reflect(api, {
+    onGroup: () => {
+      return;
+    },
+    onEndpoint: ({ endpoint, group, successes }) => {
+      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+      if (operationSchemas.length === 1 && operationSchemas[0]) {
+        schemas.set(operationId, operationSchemas[0]);
+      } else if (operationSchemas.length > 1) {
+        schemas.set(operationId, Schema.Union(operationSchemas));
+      }
+    }
+  });
+  return schemas;
+};
+var makeHttpApiOperationResultEncoder = (api) => {
+  const schemas = operationResultSchemas(api);
+  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
+    const operationId = operation.operation.operationId;
+    const schema = operationId ? schemas.get(operationId) : undefined;
+    if (!schema)
+      return encodeHttpApiOperationResult(result);
+    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+      cause
+    })));
+  });
+};
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
 var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
@@ -69,9 +112,10 @@ var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperati
 class ApiClient extends Context.Service()("ApiClient") {
   static layer = (config) => Layer.effect(this, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
+    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
     const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
     return {
-      encodeResult: config.encodeResult ?? ((result) => encodeHttpApiOperationResult(result)),
+      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
       execute: Effect.fn("ApiClient.execute")(function* (options) {
         return yield* executeGeneratedOperation(client, options);
       })
@@ -89,7 +133,7 @@ import {
   Schema as Schema2,
   SchemaRepresentation
 } from "effect";
-import { HttpApi as HttpApi2, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi as HttpApi2, OpenApi as OpenApi2 } from "effect/unstable/httpapi";
 var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
   identifier: "HttpJsonObject",
   title: "HTTP JSON object",
@@ -262,7 +306,7 @@ var decodeHttpApiOperationInput = Effect2.fn("Http.decodeApiOperationInput")(fun
     query: pickParameters("query")
   };
 });
-var reflectedSchema = (schema) => Schema2.make(schema.ast);
+var reflectedSchema2 = (schema) => Schema2.make(schema.ast);
 var reflectedOperationInputSchemas = (api) => {
   const schemas = new Map;
   HttpApi2.reflect(api, {
@@ -270,17 +314,17 @@ var reflectedOperationInputSchemas = (api) => {
       return;
     },
     onEndpoint: ({ endpoint, group }) => {
-      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi2.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
       const fields = {};
       if (endpoint.params)
-        fields.params = reflectedSchema(endpoint.params);
+        fields.params = reflectedSchema2(endpoint.params);
       if (endpoint.query) {
-        fields.query = Schema2.optionalKey(reflectedSchema(endpoint.query));
+        fields.query = Schema2.optionalKey(reflectedSchema2(endpoint.query));
       }
       if (endpoint.headers) {
-        fields.headers = Schema2.optionalKey(reflectedSchema(endpoint.headers));
+        fields.headers = Schema2.optionalKey(reflectedSchema2(endpoint.headers));
       }
-      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema));
+      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema2));
       if (payloadSchemas.length === 1 && payloadSchemas[0]) {
         fields.body = payloadSchemas[0];
       } else if (payloadSchemas.length > 1) {
@@ -312,7 +356,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
       if (!HttpApi2.isHttpApi(api)) {
         throw new Error("HttpApiSpec requires a valid HttpApi");
       }
-      const spec = OpenApi.fromApi(api);
+      const spec = OpenApi2.fromApi(api);
       const reflectedSchemas = reflectedOperationInputSchemas(api);
       const operations = httpApiOperations({
         spec,
@@ -406,6 +450,15 @@ var print = (value) => Console.log(value);
 var formatOperations = (operations) => operations.map((operation) => `${operation.groupName}	${operation.name}	${operation.method.toUpperCase()}	${operation.path}	${operation.summary}`).join(`
 `);
 var listOperations = (operations) => print(formatOperations(operations));
+var HttpApiCliResultStream = Schema3.declare((value) => Stream.isStream(value)).annotate({ identifier: "HttpApiCliResultStream" });
+var printHttpApiCliResult = Effect3.fn("HttpApiCli.printResult")(function* (response, operation, client) {
+  const stream = Schema3.decodeUnknownOption(HttpApiCliResultStream)(response);
+  if (stream._tag === "Some") {
+    return yield* stream.value.pipe(Stream.mapEffect((event) => client.encodeResult(event, operation)), Stream.runForEach((event) => print(JSON.stringify(event))));
+  }
+  const encoded = yield* client.encodeResult(response, operation);
+  return yield* print(JSON.stringify(encoded, null, 2) ?? "null");
+});
 var callOperation = (operation, callConfig, client) => Effect3.gen(function* () {
   const body = yield* parseJsonValue(callConfig.body, "--body");
   const headers = yield* parseJsonObject(callConfig.headers, "--headers");
@@ -419,13 +472,11 @@ var callOperation = (operation, callConfig, client) => Effect3.gen(function* ()
     },
     input: { body, headers, params, query }
   });
-  const encoded = yield* client.encodeResult(response, {
+  return yield* printHttpApiCliResult(response, {
     method: operation.method,
     path: operation.path,
     operation: operation.operation
-  });
-  const formatted = JSON.stringify(encoded, null, 2) ?? "null";
-  return yield* print(formatted);
+  }, client);
 });
 var listCommand = (groups) => Command.make("list", {}, () => print(groups.map((group) => `${group.name}	${group.title}	${group.operations.length}`).join(`
 `))).pipe(Command.withDescription("List command groups"));
@@ -469,16 +520,24 @@ var httpApiCli = (args = process.argv.slice(2)) => Effect3.gen(function* () {
   const cli = yield* HttpApiCli;
   return yield* cli.run(args);
 });
+var formatHttpApiCliCause = Cause.pretty;
 var runHttpApiCli = (layer, args = process.argv.slice(2)) => {
-  Effect3.runPromise(httpApiCli(args).pipe(Effect3.provide(layer), Effect3.provide(httpApiCliEnvironmentLayer(args)))).catch((error) => {
-    console.error(error instanceof Error ? error.message : error);
-    process.exit(1);
-  });
+  Effect3.runPromiseExit(httpApiCli(args).pipe(Effect3.provide(layer), Effect3.provide(httpApiCliEnvironmentLayer(args)))).then(Exit.match({
+    onSuccess: () => {
+      return;
+    },
+    onFailure: (cause) => {
+      console.error(formatHttpApiCliCause(cause));
+      process.exitCode = 1;
+    }
+  }));
 };
 export {
   runHttpApiCli,
+  printHttpApiCliResult,
   makeHttpApiCliCommand,
   httpApiCliEnvironmentLayer,
   httpApiCli,
+  formatHttpApiCliCause,
   HttpApiCli
 };

package/dist/lib/httpapi-client.d.ts

@@ -12,12 +12,13 @@ export type ApiClientExecuteOptions = {
     readonly operation: HttpApiOperationEntry;
     readonly input: HttpApiOperationInput;
 };
-export type HttpApiOperationResultValue = null | string | number | boolean | Date | Uint8Array | ReadonlyArray<HttpApiOperationResultValue> | {
+export type HttpApiOperationResultValue = null | undefined | string | number | boolean | Date | Uint8Array | ReadonlyArray<HttpApiOperationResultValue> | {
     readonly [key: string]: HttpApiOperationResultValue;
 };
 export declare const HttpApiOperationResult: Schema.Union<readonly [Schema.Codec<HttpApiOperationResultValue, Json, never, never>, Schema.Undefined]>;
 export type HttpApiOperationResult = typeof HttpApiOperationResult.Type;
 export declare const encodeHttpApiOperationResult: (result: unknown) => Effect.Effect<string | number | boolean | Schema.JsonArray | Schema.JsonObject | null, Error, never>;
+export declare const makeHttpApiOperationResultEncoder: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>) => (result: unknown, operation: HttpApiOperationEntry) => Effect.Effect<string | number | boolean | Schema.JsonArray | Schema.JsonObject | null, Error, never>;
 export type ApiClientService = {
     readonly encodeResult: (result: ErrorOptions["cause"], operation: HttpApiOperationEntry) => Effect.Effect<Json, Error>;
     readonly execute: (options: ApiClientExecuteOptions) => Effect.Effect<ErrorOptions["cause"], Error>;

package/dist/lib/httpapi-client.js

@@ -1,11 +1,20 @@
 // ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import {
-  HttpApiClient as EffectHttpApiClient
+  HttpApi,
+  HttpApiClient as EffectHttpApiClient,
+  OpenApi
 } from "effect/unstable/httpapi";
+var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
+  decode: () => {
+    return;
+  },
+  encode: () => null
+})));
 var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
   Schema.Null,
+  UndefinedFromNull,
   Schema.String,
   Schema.Number,
   Schema.Boolean,
@@ -19,6 +28,37 @@ var HttpApiOperationResult = Schema.Union([
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
 var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var reflectedSchema = (schema) => Schema.make(schema.ast);
+var operationResultSchemas = (api) => {
+  const schemas = new Map;
+  HttpApi.reflect(api, {
+    onGroup: () => {
+      return;
+    },
+    onEndpoint: ({ endpoint, group, successes }) => {
+      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+      if (operationSchemas.length === 1 && operationSchemas[0]) {
+        schemas.set(operationId, operationSchemas[0]);
+      } else if (operationSchemas.length > 1) {
+        schemas.set(operationId, Schema.Union(operationSchemas));
+      }
+    }
+  });
+  return schemas;
+};
+var makeHttpApiOperationResultEncoder = (api) => {
+  const schemas = operationResultSchemas(api);
+  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
+    const operationId = operation.operation.operationId;
+    const schema = operationId ? schemas.get(operationId) : undefined;
+    if (!schema)
+      return encodeHttpApiOperationResult(result);
+    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+      cause
+    })));
+  });
+};
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
 var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
@@ -54,9 +94,10 @@ var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperati
 class ApiClient extends Context.Service()("ApiClient") {
   static layer = (config) => Layer.effect(this, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
+    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
     const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
     return {
-      encodeResult: config.encodeResult ?? ((result) => encodeHttpApiOperationResult(result)),
+      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
       execute: Effect.fn("ApiClient.execute")(function* (options) {
         return yield* executeGeneratedOperation(client, options);
       })
@@ -64,6 +105,7 @@ class ApiClient extends Context.Service()("ApiClient") {
   }));
 }
 export {
+  makeHttpApiOperationResultEncoder,
   encodeHttpApiOperationResult,
   HttpApiOperationResult,
   ApiClient

package/dist/lib/httpapi-mcp.js

@@ -3,13 +3,22 @@ import { Context as Context3, Effect as Effect3, Layer as Layer3, Option as Opti
 import { McpSchema, McpServer } from "effect/unstable/ai";
 
 // ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import {
-  HttpApiClient as EffectHttpApiClient
+  HttpApi,
+  HttpApiClient as EffectHttpApiClient,
+  OpenApi
 } from "effect/unstable/httpapi";
+var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
+  decode: () => {
+    return;
+  },
+  encode: () => null
+})));
 var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
   Schema.Null,
+  UndefinedFromNull,
   Schema.String,
   Schema.Number,
   Schema.Boolean,
@@ -23,6 +32,37 @@ var HttpApiOperationResult = Schema.Union([
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
 var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var reflectedSchema = (schema) => Schema.make(schema.ast);
+var operationResultSchemas = (api) => {
+  const schemas = new Map;
+  HttpApi.reflect(api, {
+    onGroup: () => {
+      return;
+    },
+    onEndpoint: ({ endpoint, group, successes }) => {
+      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+      if (operationSchemas.length === 1 && operationSchemas[0]) {
+        schemas.set(operationId, operationSchemas[0]);
+      } else if (operationSchemas.length > 1) {
+        schemas.set(operationId, Schema.Union(operationSchemas));
+      }
+    }
+  });
+  return schemas;
+};
+var makeHttpApiOperationResultEncoder = (api) => {
+  const schemas = operationResultSchemas(api);
+  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
+    const operationId = operation.operation.operationId;
+    const schema = operationId ? schemas.get(operationId) : undefined;
+    if (!schema)
+      return encodeHttpApiOperationResult(result);
+    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+      cause
+    })));
+  });
+};
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
 var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
@@ -58,9 +98,10 @@ var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperati
 class ApiClient extends Context.Service()("ApiClient") {
   static layer = (config) => Layer.effect(this, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
+    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
     const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
     return {
-      encodeResult: config.encodeResult ?? ((result) => encodeHttpApiOperationResult(result)),
+      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
       execute: Effect.fn("ApiClient.execute")(function* (options) {
         return yield* executeGeneratedOperation(client, options);
       })
@@ -78,7 +119,7 @@ import {
   Schema as Schema2,
   SchemaRepresentation
 } from "effect";
-import { HttpApi as HttpApi2, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi as HttpApi2, OpenApi as OpenApi2 } from "effect/unstable/httpapi";
 var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
   identifier: "HttpJsonObject",
   title: "HTTP JSON object",
@@ -251,7 +292,7 @@ var decodeHttpApiOperationInput = Effect2.fn("Http.decodeApiOperationInput")(fun
     query: pickParameters("query")
   };
 });
-var reflectedSchema = (schema) => Schema2.make(schema.ast);
+var reflectedSchema2 = (schema) => Schema2.make(schema.ast);
 var reflectedOperationInputSchemas = (api) => {
   const schemas = new Map;
   HttpApi2.reflect(api, {
@@ -259,17 +300,17 @@ var reflectedOperationInputSchemas = (api) => {
       return;
     },
     onEndpoint: ({ endpoint, group }) => {
-      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi2.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
       const fields = {};
       if (endpoint.params)
-        fields.params = reflectedSchema(endpoint.params);
+        fields.params = reflectedSchema2(endpoint.params);
       if (endpoint.query) {
-        fields.query = Schema2.optionalKey(reflectedSchema(endpoint.query));
+        fields.query = Schema2.optionalKey(reflectedSchema2(endpoint.query));
       }
       if (endpoint.headers) {
-        fields.headers = Schema2.optionalKey(reflectedSchema(endpoint.headers));
+        fields.headers = Schema2.optionalKey(reflectedSchema2(endpoint.headers));
       }
-      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema));
+      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema2));
       if (payloadSchemas.length === 1 && payloadSchemas[0]) {
         fields.body = payloadSchemas[0];
       } else if (payloadSchemas.length > 1) {
@@ -301,7 +342,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
       if (!HttpApi2.isHttpApi(api)) {
         throw new Error("HttpApiSpec requires a valid HttpApi");
       }
-      const spec = OpenApi.fromApi(api);
+      const spec = OpenApi2.fromApi(api);
       const reflectedSchemas = reflectedOperationInputSchemas(api);
       const operations = httpApiOperations({
         spec,

package/dist/lib/httpapi-toolkit.js

@@ -3,13 +3,22 @@ import { Effect as Effect3, Layer as Layer3, Schema as Schema3 } from "effect";
 import { Tool, Toolkit } from "effect/unstable/ai";
 
 // ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import {
-  HttpApiClient as EffectHttpApiClient
+  HttpApi,
+  HttpApiClient as EffectHttpApiClient,
+  OpenApi
 } from "effect/unstable/httpapi";
+var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
+  decode: () => {
+    return;
+  },
+  encode: () => null
+})));
 var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
   Schema.Null,
+  UndefinedFromNull,
   Schema.String,
   Schema.Number,
   Schema.Boolean,
@@ -23,6 +32,37 @@ var HttpApiOperationResult = Schema.Union([
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
 var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var reflectedSchema = (schema) => Schema.make(schema.ast);
+var operationResultSchemas = (api) => {
+  const schemas = new Map;
+  HttpApi.reflect(api, {
+    onGroup: () => {
+      return;
+    },
+    onEndpoint: ({ endpoint, group, successes }) => {
+      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+      if (operationSchemas.length === 1 && operationSchemas[0]) {
+        schemas.set(operationId, operationSchemas[0]);
+      } else if (operationSchemas.length > 1) {
+        schemas.set(operationId, Schema.Union(operationSchemas));
+      }
+    }
+  });
+  return schemas;
+};
+var makeHttpApiOperationResultEncoder = (api) => {
+  const schemas = operationResultSchemas(api);
+  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
+    const operationId = operation.operation.operationId;
+    const schema = operationId ? schemas.get(operationId) : undefined;
+    if (!schema)
+      return encodeHttpApiOperationResult(result);
+    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+      cause
+    })));
+  });
+};
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
 var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
@@ -58,9 +98,10 @@ var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperati
 class ApiClient extends Context.Service()("ApiClient") {
   static layer = (config) => Layer.effect(this, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
+    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
     const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
     return {
-      encodeResult: config.encodeResult ?? ((result) => encodeHttpApiOperationResult(result)),
+      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
       execute: Effect.fn("ApiClient.execute")(function* (options) {
         return yield* executeGeneratedOperation(client, options);
       })
@@ -78,7 +119,7 @@ import {
   Schema as Schema2,
   SchemaRepresentation
 } from "effect";
-import { HttpApi as HttpApi2, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi as HttpApi2, OpenApi as OpenApi2 } from "effect/unstable/httpapi";
 var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
   identifier: "HttpJsonObject",
   title: "HTTP JSON object",
@@ -251,7 +292,7 @@ var decodeHttpApiOperationInput = Effect2.fn("Http.decodeApiOperationInput")(fun
     query: pickParameters("query")
   };
 });
-var reflectedSchema = (schema) => Schema2.make(schema.ast);
+var reflectedSchema2 = (schema) => Schema2.make(schema.ast);
 var reflectedOperationInputSchemas = (api) => {
   const schemas = new Map;
   HttpApi2.reflect(api, {
@@ -259,17 +300,17 @@ var reflectedOperationInputSchemas = (api) => {
       return;
     },
     onEndpoint: ({ endpoint, group }) => {
-      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi2.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
       const fields = {};
       if (endpoint.params)
-        fields.params = reflectedSchema(endpoint.params);
+        fields.params = reflectedSchema2(endpoint.params);
       if (endpoint.query) {
-        fields.query = Schema2.optionalKey(reflectedSchema(endpoint.query));
+        fields.query = Schema2.optionalKey(reflectedSchema2(endpoint.query));
       }
       if (endpoint.headers) {
-        fields.headers = Schema2.optionalKey(reflectedSchema(endpoint.headers));
+        fields.headers = Schema2.optionalKey(reflectedSchema2(endpoint.headers));
       }
-      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema));
+      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema2));
       if (payloadSchemas.length === 1 && payloadSchemas[0]) {
         fields.body = payloadSchemas[0];
       } else if (payloadSchemas.length > 1) {
@@ -301,7 +342,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
       if (!HttpApi2.isHttpApi(api)) {
         throw new Error("HttpApiSpec requires a valid HttpApi");
       }
-      const spec = OpenApi.fromApi(api);
+      const spec = OpenApi2.fromApi(api);
       const reflectedSchemas = reflectedOperationInputSchemas(api);
       const operations = httpApiOperations({
         spec,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krak-stack/registry",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Tree-shakable KrakStack components and Effect services.",
   "license": "MIT",
   "repository": {