@krak-stack/registry 0.1.36 → 0.1.38

package/README.md

@@ -55,7 +55,7 @@ import { makeAgentApiGroup } from "@krak-stack/registry/agent/schema";
 import {
   HttpApiToolkit,
   HttpApiToolkitLayer,
-} from "@krak-stack/registry/httpapi-toolkit";
+} from "@krak-stack/registry/httpapi/toolkit";
 import { ApiClient } from "@krak-stack/registry/httpapi/client";
 import { HttpApiSpec } from "@krak-stack/registry/httpapi/helpers";
 import { HttpApiOtlp } from "@krak-stack/registry/opentelemetry/api";
@@ -133,6 +133,53 @@ HTTP API client, schema, AI tool, CLI, and MCP utilities are available under
 the `@krak-stack/registry/httpapi/*` subpaths. Keep application-specific API
 layers, handlers, authentication, and client bindings in the application.
 
+Use `@krak-stack/registry/httpapi/toolkit` for HTTP API tools. The old
+`@krak-stack/registry/httpapi-toolkit` export has been removed in `0.1.38`.
+
+### HTTP API tools and MCP
+
+CLI, toolkit, and MCP adapters share `HttpApiSpec.operations`. Each operation
+contains its tool name, typed `inputSchema`, derived `inputJsonSchema`, and method
+annotations. Inputs use `{ params, query, headers, body }`; only the CLI turns
+terminal arguments into that shape. The generated HTTP client handles wire
+encoding, and payload codecs retain their transformations.
+
+The old flat/wire-input helpers and `HttpApiSpec` schema lookup methods have been
+removed in `0.1.38`. Use the schemas on each operation definition and
+`executeHttpApiOperation` from `@krak-stack/registry/httpapi/client` instead.
+
+Use `makeHttpApiToolkit(config)` to construct matching tools and handlers once:
+
+```ts
+import { makeHttpApiToolkit } from "@krak-stack/registry/httpapi/toolkit";
+
+const { toolkit, handlers } = yield * makeHttpApiToolkit({});
+const tools = yield * toolkit.pipe(Effect.provide(handlers));
+```
+
+Provide `HttpApiSpec` and `ApiClient` through the surrounding Effect layers.
+`HttpApiToolkit` and `HttpApiToolkitLayer` remain available for integrations that
+need to construct definitions and handlers separately.
+
+For an HTTP MCP server, use the single-layer factory:
+
+```ts
+import { Layer } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { HttpApiMcp } from "@krak-stack/registry/httpapi/mcp";
+import { AppApi } from "@/api";
+
+export const mcpLayer = HttpApiMcp.layerHttp({
+  api: AppApi,
+  baseUrl: "http://localhost:3000",
+}).pipe(Layer.provide(FetchHttpClient.layer));
+```
+
+The factory defaults to `/api/mcp` and GET operations only. Set `path`, `methods`,
+`include`, or `toolMetaKey` when needed. Provide an authenticated `HttpClient`
+instead of `FetchHttpClient.layer` when the downstream API requires credentials.
+Inbound MCP authentication remains application-owned.
+
 Documentation consumers load and compile their application-owned MDX on the
 server, then pass the validated page records to `createDocsSource` and
 `makeDocs`:

package/dist/components/ui/data-table.js

@@ -1056,7 +1056,7 @@ var DEFAULT_WIDTH = 208;
 var DEFAULT_MAX_WIDTH = 640;
 var DEFAULT_QUERY = {
   page: 0,
-  pageSize: 10
+  pageSize: 20
 };
 var DEFAULT_UI_STATE = {
   columnVisibility: {},

package/dist/lib/docs.server.js

@@ -362,7 +362,7 @@ var compileMarkdown = (source) => {
       codeBlocks.push({ code, language });
       return `<markdown-code-block data-index="${index}"></markdown-code-block>`;
     },
-    codespan: (children) => `<code data-inline-code>${escapeHtml(children)}</code>`,
+    codespan: (children) => `<code data-inline-code>${children}</code>`,
     emphasis: (children) => `<em>${children}</em>`,
     heading: (children, { id, level }) => {
       const headingId = escapeHtml(id ?? "");

package/dist/lib/httpapi-cli.js

@@ -25,6 +25,15 @@ import {
   HttpApiClient as EffectHttpApiClient,
   OpenApi
 } from "effect/http-api";
+var executeHttpApiOperation = Effect.fn("HttpApiClient.executeOperation")((options, client) => client.execute({
+  operation: options.operation,
+  input: {
+    body: options.input.body,
+    headers: options.input.headers ?? {},
+    params: options.input.params ?? {},
+    query: options.input.query ?? {}
+  }
+}));
 var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
   decode: () => {
     return;
@@ -125,15 +134,7 @@ class ApiClient extends Context.Service()("ApiClient") {
 }
 
 // ../../src/lib/httpapi-helpers.tsx
-import {
-  Context as Context2,
-  Effect as Effect2,
-  JsonSchema,
-  Layer as Layer2,
-  Option,
-  Schema as Schema2,
-  SchemaRepresentation
-} from "effect";
+import { Context as Context2, Effect as Effect2, Layer as Layer2, Option, Schema as Schema2 } from "effect";
 import { HttpApi as HttpApi2, OpenApi as OpenApi2 } from "effect/http-api";
 var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
   identifier: "HttpJsonObject",
@@ -143,23 +144,6 @@ var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
 });
 var JsonObjectFromString = Schema2.fromJsonString(JsonObjectSchema);
 var JsonValueFromString = Schema2.fromJsonString(Schema2.Json);
-var JsonSchemaAnnotations = Schema2.Struct({
-  title: Schema2.optional(Schema2.String),
-  description: Schema2.optional(Schema2.String),
-  examples: Schema2.optional(Schema2.Array(Schema2.Json))
-}).annotate({
-  identifier: "HttpJsonSchemaAnnotations",
-  title: "HTTP JSON Schema annotations",
-  description: "JSON Schema annotations surfaced on generated tool inputs."
-});
-var HttpApiToolInputSchema = Schema2.Struct({
-  body: Schema2.optional(Schema2.Json)
-}).annotate({
-  identifier: "HttpApiToolInput",
-  title: "HTTP API tool input",
-  description: "Input accepted by an HTTP API-backed tool.",
-  examples: [{ body: { id: "example-id" } }]
-});
 var HttpApiMethods = [
   "get",
   "post",
@@ -183,130 +167,12 @@ var httpApiOperations = ({
   for (const [path, pathItem] of Object.entries(spec.paths)) {
     for (const method of methods) {
       const operation = decodeHttpApiOperation(pathItem[method]);
-      if (Option.isSome(operation)) {
+      if (Option.isSome(operation))
         operations.push({ method, path, operation: operation.value });
-      }
     }
   }
   return operations;
 };
-var httpApiToolEntries = Effect2.fn("Http.toolEntries")(function* (operations) {
-  return yield* Effect2.try({
-    try: () => {
-      const names = new Set;
-      return operations.map((entry) => {
-        const name = httpApiToolName(entry.method, entry.path, entry.operation);
-        if (!name || names.has(name)) {
-          throw new Error(`Duplicate or empty HTTP API tool name: ${name}`);
-        }
-        names.add(name);
-        return { ...entry, name };
-      });
-    },
-    catch: (error) => error instanceof Error ? error : new Error(String(error))
-  });
-});
-var decodeAnnotations = Schema2.decodeUnknownOption(JsonSchemaAnnotations);
-var schemaWithVisibleAnnotations = (schema) => {
-  const directAnnotations = decodeAnnotations(schema).pipe(Option.getOrElse(() => ({})));
-  const allOf = Array.isArray(schema.allOf) ? schema.allOf : [];
-  const annotations = allOf.reduce((acc, item) => ({
-    ...acc,
-    ...decodeAnnotations(item).pipe(Option.getOrElse(() => ({})))
-  }), directAnnotations);
-  const visible = { ...schema };
-  if ("title" in annotations && !("title" in schema)) {
-    visible.title = annotations.title;
-  }
-  if ("description" in annotations && !("description" in schema)) {
-    visible.description = annotations.description;
-  }
-  if ("examples" in annotations && !("examples" in schema)) {
-    visible.examples = annotations.examples;
-  }
-  return visible;
-};
-var referencedDefinitions = (schema, definitions) => {
-  const names = new Set;
-  const pending = [Schema2.decodeUnknownSync(Schema2.Json)(schema)];
-  while (pending.length > 0) {
-    const current = pending.pop();
-    if (Array.isArray(current)) {
-      pending.push(...current);
-      continue;
-    }
-    const record = Schema2.decodeUnknownOption(Schema2.Record(Schema2.String, Schema2.Json))(current);
-    if (Option.isNone(record))
-      continue;
-    for (const [key, value] of Object.entries(record.value)) {
-      if (key === "$ref" && Schema2.is(Schema2.String)(value)) {
-        const name = value.match(/^#\/(?:\$defs|components\/schemas)\/(.+)$/)?.[1];
-        if (name && !names.has(name) && definitions[name]) {
-          names.add(name);
-          pending.push(Schema2.decodeUnknownSync(Schema2.Json)(definitions[name]));
-        }
-      } else if (key !== "$defs") {
-        pending.push(value);
-      }
-    }
-  }
-  return Object.fromEntries([...names].map((name) => [name, definitions[name]]));
-};
-var operationParameters = (parameters, location) => parameters.filter((parameter) => parameter.in === location);
-var httpApiOperationInputSchema = (operation) => {
-  const parameters = operation.parameters ?? [];
-  const pathParameters = operationParameters(parameters, "path");
-  const queryParameters = operationParameters(parameters, "query");
-  const headerParameters = operationParameters(parameters, "header");
-  const properties = {};
-  const required = [];
-  const body = operation.requestBody?.content?.["application/json"]?.schema;
-  for (const parameter of [
-    ...pathParameters,
-    ...queryParameters,
-    ...headerParameters
-  ]) {
-    const property = {
-      ...parameter.schema ? schemaWithVisibleAnnotations(parameter.schema) : { type: "string" }
-    };
-    if (parameter.description)
-      property.description = parameter.description;
-    properties[parameter.name] = property;
-    if (parameter.required)
-      required.push(parameter.name);
-  }
-  if (body) {
-    properties.body = body;
-    if (operation.requestBody?.required)
-      required.push("body");
-  }
-  return {
-    type: "object",
-    properties,
-    required,
-    additionalProperties: false
-  };
-};
-var decodeJsonObject = Schema2.decodeUnknownOption(JsonObjectSchema);
-var decodeHttpApiOperationInput = Effect2.fn("Http.decodeApiOperationInput")(function* (input, operation) {
-  const payload = yield* Schema2.decodeUnknownEffect(JsonObjectSchema)(input ?? {}).pipe(Effect2.mapError(() => new Error("Tool input must be a JSON object")));
-  const decoded = yield* Schema2.decodeUnknownEffect(HttpApiToolInputSchema)(payload).pipe(Effect2.mapError(() => new Error("Tool input must be a JSON object")));
-  const parameters = operation.parameters ?? [];
-  const pickParameters = (location) => {
-    const nestedKey = location === "path" ? "params" : location;
-    const nested = decodeJsonObject(payload[nestedKey]).pipe(Option.getOrElse(() => ({})));
-    return Object.fromEntries(operationParameters(parameters, location).map((parameter) => [
-      parameter.name,
-      nested[parameter.name] ?? payload[parameter.name]
-    ]).filter(([, value]) => value !== undefined));
-  };
-  return {
-    ...decoded,
-    headers: pickParameters("header"),
-    params: pickParameters("path"),
-    query: pickParameters("query")
-  };
-});
 var reflectedSchema2 = (schema) => Schema2.make(schema.ast);
 var reflectedOperationInputSchemas = (api) => {
   const schemas = new Map;
@@ -318,23 +184,18 @@ var reflectedOperationInputSchemas = (api) => {
       const operationId = Context2.getOrElse(endpoint.annotations, OpenApi2.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
       const fields = {};
       if (endpoint.params)
-        fields.params = reflectedSchema2(endpoint.params);
-      if (endpoint.query) {
-        fields.query = Schema2.optionalKey(reflectedSchema2(endpoint.query));
-      }
-      if (endpoint.headers) {
-        fields.headers = Schema2.optionalKey(reflectedSchema2(endpoint.headers));
-      }
-      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) {
-        fields.body = Schema2.Union(payloadSchemas);
-      }
-      const inputSchema = Object.keys(fields).length === 0 ? Schema2.Record(Schema2.String, Schema2.Never) : Schema2.Struct(fields);
-      schemas.set(operationId, inputSchema.annotate({
-        identifier: `${sanitizeHttpName(operationId)}ToolInput`
-      }));
+        fields.params = Schema2.toType(reflectedSchema2(endpoint.params));
+      if (endpoint.query)
+        fields.query = Schema2.optionalKey(Schema2.toType(reflectedSchema2(endpoint.query)));
+      if (endpoint.headers)
+        fields.headers = Schema2.optionalKey(Schema2.toType(reflectedSchema2(endpoint.headers)));
+      const payloads = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema2));
+      if (payloads.length === 1 && payloads[0])
+        fields.body = payloads[0];
+      else if (payloads.length > 1)
+        fields.body = Schema2.Union(payloads);
+      const input = Object.keys(fields).length === 0 ? Schema2.Record(Schema2.String, Schema2.Never) : Schema2.Struct(fields);
+      schemas.set(operationId, Schema2.make(Schema2.toCodecJson(input).ast).annotate({ identifier: `${sanitizeHttpName(operationId)}ToolInput` }));
     }
   });
   return schemas;
@@ -354,42 +215,37 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
   make: (config) => Effect2.try({
     try: () => {
       const api = config.api;
-      if (!HttpApi2.isHttpApi(api)) {
+      if (!HttpApi2.isHttpApi(api))
         throw new Error("HttpApiSpec requires a valid HttpApi");
-      }
       const spec = OpenApi2.fromApi(api);
-      const reflectedSchemas = reflectedOperationInputSchemas(api);
+      const schemas = reflectedOperationInputSchemas(api);
+      const names = new Set;
       const operations = httpApiOperations({
         spec,
         methods: config.methods
-      }).filter((operation) => config.include?.(operation) ?? true);
-      const operationJsonSchema = (operation) => {
-        const schema = httpApiOperationInputSchema(operation);
-        const document = JsonSchema.fromSchemaOpenApi3_1({
-          ...schema,
-          $defs: spec.components?.schemas
-        });
-        const definitions = document.definitions ?? {};
-        const usedDefinitions = referencedDefinitions(document.schema, definitions);
-        const result = { ...document.schema };
-        if (Object.keys(usedDefinitions).length > 0) {
-          result.$defs = usedDefinitions;
-        }
-        return result;
-      };
-      return {
-        info: spec.info,
-        operations,
-        decodeOperationInput: decodeHttpApiOperationInput,
-        operationJsonSchema,
-        operationSchema: (operation) => {
-          const reflected = operation.operationId ? reflectedSchemas.get(operation.operationId) : undefined;
-          if (reflected)
-            return reflected;
-          const document = JsonSchema.fromSchemaOpenApi3_1(operationJsonSchema(operation));
-          return reflectedSchema2(SchemaRepresentation.fromJsonSchemaDocument(document));
-        }
-      };
+      }).filter((entry) => config.include?.(entry) ?? true).map((entry) => {
+        const name = httpApiToolName(entry.method, entry.path, entry.operation);
+        if (!name || names.has(name))
+          throw new Error(`Duplicate or empty HTTP API tool name: ${name}`);
+        names.add(name);
+        const inputSchema = entry.operation.operationId ? schemas.get(entry.operation.operationId) : undefined;
+        if (!inputSchema)
+          throw new Error(`Missing endpoint schema for ${entry.operation.operationId}`);
+        const document = Schema2.toJsonSchemaDocument(inputSchema.annotate({ identifier: undefined }));
+        return {
+          ...entry,
+          name,
+          inputSchema,
+          inputJsonSchema: {
+            ...document.schema,
+            $defs: document.definitions
+          },
+          readOnly: entry.method === "get",
+          destructive: entry.method === "delete",
+          idempotent: entry.method === "get" || entry.method === "put" || entry.method === "delete"
+        };
+      });
+      return { info: spec.info, operations };
     },
     catch: (error) => toHttpError("Failed to build HTTP API spec", error)
   })
@@ -418,12 +274,6 @@ var CliParsedOption = Schema3.declare((value) => Option2.isOption(value) && Opti
   onSome: Schema3.is(Schema3.Json)
 })).annotate({ identifier: "HttpApiCliParsedOption" });
 var CliParsedConfig = Schema3.Record(Schema3.String, Schema3.Union([Schema3.Json, CliParsedOption])).annotate({ identifier: "HttpApiCliParsedConfig" });
-var DecodedOperationInput = Schema3.Struct({
-  body: Schema3.optional(Schema3.Unknown),
-  headers: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown)),
-  params: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown)),
-  query: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown))
-}).annotate({ identifier: "HttpApiCliDecodedOperationInput" });
 
 class HttpApiCli extends Context3.Service()("HttpApiCli", {
   make: () => Effect3.gen(function* () {
@@ -443,22 +293,12 @@ var operationIdParts = (operation) => operation.operationId?.split(".").filter(B
 var operationGroupName = (operation) => fallbackName(operationIdParts(operation)[0] ?? operation.tags?.[0] ?? "default", "default");
 var operationGroupTitle = (operation) => operation.tags?.[0] ?? operationGroupName(operation);
 var operationName = (method, path, operation) => fallbackName(operationIdParts(operation).at(-1) ?? `${method}_${path.replace(/^\/api\//, "").replace(/[/:{}]/g, "_")}`, `${method}_operation`);
-var toCliOperation = ({
-  inputJsonSchema,
-  inputSchema,
-  method,
-  operation,
-  path
-}) => ({
-  groupName: operationGroupName(operation),
-  groupTitle: operationGroupTitle(operation),
-  name: operationName(method, path, operation),
-  method,
-  path,
-  summary: operation.summary ?? operation.description ?? "",
-  operation,
-  inputSchema,
-  inputJsonSchema
+var toCliOperation = (entry) => ({
+  ...entry,
+  groupName: operationGroupName(entry.operation),
+  groupTitle: operationGroupTitle(entry.operation),
+  name: operationName(entry.method, entry.path, entry.operation),
+  summary: entry.operation.summary ?? entry.operation.description ?? ""
 });
 var httpApiCliOperationGroups = (operations) => {
   const groups = new Map;
@@ -504,28 +344,18 @@ var schemaType = (schema) => {
   return schemaType(effectiveSchema(schema));
 };
 var schemaEnum = (schema) => Schema3.decodeUnknownOption(Schema3.Array(Schema3.String))(effectiveSchema(schema).enum).pipe(Option2.getOrElse(() => []));
-var hasNumericPattern = (schema) => {
-  const effective = effectiveSchema(schema);
-  if (effective.pattern?.includes("\\d"))
-    return true;
-  return (effective.allOf ?? []).some((part) => hasNumericPattern(cliJsonSchema(part)));
-};
-var isBooleanSchema = (schema) => {
-  const values = schemaEnum(schema);
-  return schemaType(schema) === "boolean" || values.includes("true") && values.includes("false");
-};
 var jsonFlag = (name) => Flag.String(name).pipe(Flag.mapTryCatch((value) => Schema3.decodeUnknownSync(JsonFromString)(value), () => `--${name} must be valid JSON`));
 var primitiveFlag = (name, schema, required) => {
   const type = schemaType(schema);
   const choices = schemaEnum(schema);
   let flag;
-  if (isBooleanSchema(schema)) {
+  if (type === "boolean") {
     flag = required ? Flag.Literals(name, ["true", "false"]).pipe(Flag.map((value) => value === "true")) : Flag.Boolean(name);
   } else if (choices.length > 0) {
     flag = Flag.Literals(name, choices);
   } else if (type === "integer") {
     flag = Flag.Int(name);
-  } else if (type === "number" || hasNumericPattern(schema)) {
+  } else if (type === "number") {
     flag = Flag.Finite(name);
   } else if (type === "object" || type === "array") {
     flag = jsonFlag(name);
@@ -544,7 +374,7 @@ var primitiveArgument = (name, schema) => {
     argument = Argument.Literals(name, choices);
   } else if (type === "integer") {
     argument = Argument.Int(name);
-  } else if (type === "number" || hasNumericPattern(schema)) {
+  } else if (type === "number") {
     argument = Argument.Finite(name);
   } else {
     argument = Argument.String(name);
@@ -556,26 +386,26 @@ var operationInputDrafts = (operation) => {
   const document = cliJsonSchema(operation.inputJsonSchema);
   const definitions = document.$defs ?? {};
   const resolveSchema = (value) => {
-    const schema = cliJsonSchema(value);
+    const schema = effectiveSchema(cliJsonSchema(value));
     const name = schema.$ref?.match(/^#\/(?:\$defs|components\/schemas)\/(.+)$/)?.[1];
     return name && definitions[name] ? effectiveSchema(cliJsonSchema(definitions[name])) : effectiveSchema(schema);
   };
   const properties = document.properties ?? {};
-  const drafts = (operation.operation.parameters ?? []).flatMap((parameter) => {
-    if (parameter.in === "cookie")
-      return [];
-    const location = parameter.in === "path" ? "params" : parameter.in === "header" ? "headers" : "query";
-    return [
-      {
+  const drafts = [];
+  for (const location of ["params", "headers", "query"]) {
+    const group = resolveSchema(properties[location]);
+    const required = new Set(group.required ?? []);
+    for (const [name, schema] of Object.entries(group.properties ?? {})) {
+      drafts.push({
         location,
-        name: parameter.name,
-        preferredName: fallbackName(parameter.name, location),
-        required: parameter.required ?? false,
-        schema: resolveSchema(properties[parameter.name] ?? parameter.schema)
-      }
-    ];
-  });
-  const body = resolveSchema(properties.body ?? operation.operation.requestBody?.content?.["application/json"]?.schema);
+        name,
+        preferredName: fallbackName(name, location),
+        required: required.has(name),
+        schema: resolveSchema(schema)
+      });
+    }
+  }
+  const body = resolveSchema(properties.body);
   if (schemaType(body) === "object" && body.properties) {
     const required = new Set(body.required ?? []);
     for (const [name, schema] of Object.entries(body.properties)) {
@@ -587,12 +417,12 @@ var operationInputDrafts = (operation) => {
         schema: resolveSchema(schema)
       });
     }
-  } else if (operation.operation.requestBody) {
+  } else if (properties.body) {
     drafts.push({
       location: "body",
       name: "body",
       preferredName: "body",
-      required: operation.operation.requestBody.required ?? false,
+      required: document.required?.includes("body") ?? false,
       schema: body
     });
   }
@@ -618,7 +448,6 @@ var operationInputs = (operation) => {
       location: draft.location,
       name: draft.name,
       optionName,
-      wireString: draft.location !== "body" && schemaType(draft.schema) === "string",
       param: draft.location === "params" ? primitiveArgument(optionName, draft.schema) : primitiveFlag(optionName, draft.schema, draft.required)
     };
   });
@@ -632,7 +461,7 @@ var printHttpApiCliResult = Effect3.fn("HttpApiCli.printResult")(function* (resp
   const encoded = yield* client.encodeResult(response, operation);
   return yield* print(JSON.stringify(encoded, null, 2) ?? "null");
 });
-var callOperation = (operation, inputs, callConfig, client) => Effect3.gen(function* () {
+var callOperation = Effect3.fn("HttpApiCli.callOperation")(function* (operation, inputs, callConfig, client) {
   const emptyValues = () => ({});
   const assembled = {
     body: emptyValues(),
@@ -644,10 +473,10 @@ var callOperation = (operation, inputs, callConfig, client) => Effect3.gen(funct
     const parsed = callConfig[input2.configKey];
     const value = Option2.isOption(parsed) ? Option2.getOrUndefined(parsed) : parsed;
     if (value !== undefined) {
-      assembled[input2.location][input2.name] = input2.wireString ? String(value) : value;
+      assembled[input2.location][input2.name] = value;
     }
   }
-  const bodyInput = inputs.some((input2) => input2.location === "body" && input2.name === "body") ? assembled.body.body : Object.keys(assembled.body).length > 0 || operation.operation.requestBody?.required ? assembled.body : undefined;
+  const bodyInput = inputs.some((input2) => input2.location === "body" && input2.name === "body") ? assembled.body.body : Object.keys(assembled.body).length > 0 || cliJsonSchema(operation.inputJsonSchema).required?.includes("body") ? assembled.body : undefined;
   const rawInput = {};
   if (inputs.some((input2) => input2.location === "params")) {
     rawInput.params = assembled.params;
@@ -660,26 +489,9 @@ var callOperation = (operation, inputs, callConfig, client) => Effect3.gen(funct
   }
   if (bodyInput !== undefined)
     rawInput.body = bodyInput;
-  const decoded = yield* Schema3.decodeUnknownEffect(operation.inputSchema)(rawInput).pipe(Effect3.mapError((error) => new Error(`Invalid input for ${operation.groupName} ${operation.name}: ${error.message}`)));
-  const input = yield* Schema3.decodeUnknownEffect(DecodedOperationInput)(decoded);
-  const response = yield* client.execute({
-    operation: {
-      method: operation.method,
-      path: operation.path,
-      operation: operation.operation
-    },
-    input: {
-      body: input.body,
-      headers: input.headers ?? {},
-      params: input.params ?? {},
-      query: input.query ?? {}
-    }
-  });
-  return yield* printHttpApiCliResult(response, {
-    method: operation.method,
-    path: operation.path,
-    operation: operation.operation
-  }, client);
+  const input = yield* Schema3.decodeUnknownEffect(operation.inputSchema)(rawInput).pipe(Effect3.mapError((error) => new Error(`Invalid input for ${operation.groupName} ${operation.name}: ${error.message}`)));
+  const response = yield* executeHttpApiOperation({ operation, input }, client);
+  return yield* printHttpApiCliResult(response, operation, client);
 });
 var listCommand = (groups) => Command.make("list", {}, () => print([
   "GROUP\tTITLE\tCOMMANDS",
@@ -706,11 +518,7 @@ var makeHttpApiCliCommand = Effect3.fn("HttpApiCli.makeCommand")(function* () {
   const client = yield* ApiClient;
   const name = fallbackName(spec.info.title, "api");
   const groups = yield* Effect3.try({
-    try: () => httpApiCliOperationGroups(spec.operations.map((operation) => toCliOperation({
-      ...operation,
-      inputSchema: spec.operationSchema(operation.operation),
-      inputJsonSchema: spec.operationJsonSchema(operation.operation)
-    }))),
+    try: () => httpApiCliOperationGroups(spec.operations.map(toCliOperation)),
     catch: (error) => error instanceof Error ? error : new Error(String(error))
   });
   const groupCommands = yield* Effect3.all(groups.map((group) => groupCommand(group, client)));

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

@@ -12,6 +12,10 @@ export type ApiClientExecuteOptions = {
     readonly operation: HttpApiOperationEntry;
     readonly input: HttpApiOperationInput;
 };
+export declare const executeHttpApiOperation: (options: {
+    readonly operation: HttpApiOperationEntry;
+    readonly input: Partial<HttpApiOperationInput>;
+}, client: ApiClientService) => Effect.Effect<unknown, Error, never>;
 export type HttpApiOperationResultValue = null | undefined | string | number | boolean | Date | Uint8Array | ReadonlyArray<HttpApiOperationResultValue> | {
     readonly [key: string]: HttpApiOperationResultValue;
 };

package/dist/lib/httpapi-client.js

@@ -6,6 +6,15 @@ import {
   HttpApiClient as EffectHttpApiClient,
   OpenApi
 } from "effect/http-api";
+var executeHttpApiOperation = Effect.fn("HttpApiClient.executeOperation")((options, client) => client.execute({
+  operation: options.operation,
+  input: {
+    body: options.input.body,
+    headers: options.input.headers ?? {},
+    params: options.input.params ?? {},
+    query: options.input.query ?? {}
+  }
+}));
 var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
   decode: () => {
     return;
@@ -108,5 +117,6 @@ export {
   ApiClient,
   HttpApiOperationResult,
   encodeHttpApiOperationResult,
+  executeHttpApiOperation,
   makeHttpApiOperationResultEncoder
 };