@krak-stack/registry 0.1.36 → 0.1.38

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

@@ -3,7 +3,6 @@ import type { Json } from "effect/Schema";
 import { HttpApi, OpenApi } from "effect/http-api";
 export declare const JsonObjectSchema: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
 export type JsonObject = typeof JsonObjectSchema.Type;
-type HttpBoundaryError = ErrorOptions["cause"];
 export type HttpApiDocument = ReturnType<typeof OpenApi.fromApi>;
 export type HttpApiMethod = "get" | "post" | "put" | "patch" | "delete";
 export declare const HttpApiMethods: ReadonlyArray<HttpApiMethod>;
@@ -40,58 +39,37 @@ export type HttpApiOperationInput = {
     readonly params: HttpApiOperationInputValues;
     readonly query: HttpApiOperationInputValues;
 };
+export type HttpApiOperationDefinition = HttpApiOperationEntry & {
+    readonly name: string;
+    readonly inputSchema: Schema.Codec<Partial<HttpApiOperationInput>, Json>;
+    readonly inputJsonSchema: JsonSchema.JsonSchema;
+    readonly readOnly: boolean;
+    readonly destructive: boolean;
+    readonly idempotent: boolean;
+};
 export type HttpApiSpecConfig = {
     readonly api: HttpApi.Constraint;
     readonly methods?: ReadonlyArray<HttpApiMethod>;
     readonly include?: (operation: HttpApiOperationEntry) => boolean;
 };
-export declare const toHttpError: (message: string, error: HttpBoundaryError) => Error;
+export declare const toHttpError: (message: string, error: ErrorOptions["cause"]) => Error;
 export declare const sanitizeHttpName: (name: string) => string;
 export declare const httpApiToolName: (method: string, path: string, operation: HttpApiOperation) => string;
 export declare const httpApiOperations: ({ spec, methods, }: {
     readonly spec: HttpApiDocument;
     readonly methods?: ReadonlyArray<HttpApiMethod>;
 }) => ReadonlyArray<HttpApiOperationEntry>;
-export declare const httpApiToolEntries: (operations: readonly HttpApiOperationEntry[]) => Effect.Effect<{
-    method: HttpApiMethod;
-    path: string;
-    operation: HttpApiOperation;
-    name: string;
-}[], Error, never>;
-export declare const httpApiOperationInputSchema: (operation: HttpApiOperation) => JsonSchema.JsonSchema;
-export declare const decodeHttpApiOperationInput: (input: Json, operation: HttpApiOperation) => Effect.Effect<{
-    body?: Json | undefined;
-    headers: any;
-    params: any;
-    query: any;
-}, Error, never>;
 export declare const parseJsonObject: (value: string | undefined, label: string) => Effect.Effect<{
     readonly [x: string]: Json;
 }, Error, never>;
 export declare const parseJsonValue: (value: string | undefined, label: string) => Effect.Effect<Json | undefined, Error, never>;
 declare const HttpApiSpec_base: Context.ServiceClass<HttpApiSpec, "HttpApiSpec", {
     info: OpenApi.OpenAPISpecInfo;
-    operations: HttpApiOperationEntry[];
-    decodeOperationInput: (input: Json, operation: HttpApiOperation) => Effect.Effect<{
-        body?: Json | undefined;
-        headers: any;
-        params: any;
-        query: any;
-    }, Error, never>;
-    operationJsonSchema: (operation: HttpApiOperation) => JsonSchema.JsonSchema;
-    operationSchema: (operation: HttpApiOperation) => Schema.Codec<unknown, unknown, never, never>;
+    operations: readonly HttpApiOperationDefinition[];
 }> & {
     readonly make: (config: HttpApiSpecConfig) => Effect.Effect<{
         info: OpenApi.OpenAPISpecInfo;
-        operations: HttpApiOperationEntry[];
-        decodeOperationInput: (input: Json, operation: HttpApiOperation) => Effect.Effect<{
-            body?: Json | undefined;
-            headers: any;
-            params: any;
-            query: any;
-        }, Error, never>;
-        operationJsonSchema: (operation: HttpApiOperation) => JsonSchema.JsonSchema;
-        operationSchema: (operation: HttpApiOperation) => Schema.Codec<unknown, unknown, never, never>;
+        operations: readonly HttpApiOperationDefinition[];
     }, Error, never>;
 };
 export declare class HttpApiSpec extends HttpApiSpec_base {

package/dist/lib/httpapi-helpers.js

@@ -1,13 +1,5 @@
 // ../../src/lib/httpapi-helpers.tsx
-import {
-  Context,
-  Effect,
-  JsonSchema,
-  Layer,
-  Option,
-  Schema,
-  SchemaRepresentation
-} from "effect";
+import { Context, Effect, Layer, Option, Schema } from "effect";
 import { HttpApi, OpenApi } from "effect/http-api";
 var JsonObjectSchema = Schema.Record(Schema.String, Schema.Json).annotate({
   identifier: "HttpJsonObject",
@@ -17,23 +9,6 @@ var JsonObjectSchema = Schema.Record(Schema.String, Schema.Json).annotate({
 });
 var JsonObjectFromString = Schema.fromJsonString(JsonObjectSchema);
 var JsonValueFromString = Schema.fromJsonString(Schema.Json);
-var JsonSchemaAnnotations = Schema.Struct({
-  title: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String),
-  examples: Schema.optional(Schema.Array(Schema.Json))
-}).annotate({
-  identifier: "HttpJsonSchemaAnnotations",
-  title: "HTTP JSON Schema annotations",
-  description: "JSON Schema annotations surfaced on generated tool inputs."
-});
-var HttpApiToolInputSchema = Schema.Struct({
-  body: Schema.optional(Schema.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",
@@ -57,130 +32,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 = Effect.fn("Http.toolEntries")(function* (operations) {
-  return yield* Effect.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 = Schema.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 = [Schema.decodeUnknownSync(Schema.Json)(schema)];
-  while (pending.length > 0) {
-    const current = pending.pop();
-    if (Array.isArray(current)) {
-      pending.push(...current);
-      continue;
-    }
-    const record = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Json))(current);
-    if (Option.isNone(record))
-      continue;
-    for (const [key, value] of Object.entries(record.value)) {
-      if (key === "$ref" && Schema.is(Schema.String)(value)) {
-        const name = value.match(/^#\/(?:\$defs|components\/schemas)\/(.+)$/)?.[1];
-        if (name && !names.has(name) && definitions[name]) {
-          names.add(name);
-          pending.push(Schema.decodeUnknownSync(Schema.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 = Schema.decodeUnknownOption(JsonObjectSchema);
-var decodeHttpApiOperationInput = Effect.fn("Http.decodeApiOperationInput")(function* (input, operation) {
-  const payload = yield* Schema.decodeUnknownEffect(JsonObjectSchema)(input ?? {}).pipe(Effect.mapError(() => new Error("Tool input must be a JSON object")));
-  const decoded = yield* Schema.decodeUnknownEffect(HttpApiToolInputSchema)(payload).pipe(Effect.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 reflectedSchema = (schema) => Schema.make(schema.ast);
 var reflectedOperationInputSchemas = (api) => {
   const schemas = new Map;
@@ -192,23 +49,18 @@ var reflectedOperationInputSchemas = (api) => {
       const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
       const fields = {};
       if (endpoint.params)
-        fields.params = reflectedSchema(endpoint.params);
-      if (endpoint.query) {
-        fields.query = Schema.optionalKey(reflectedSchema(endpoint.query));
-      }
-      if (endpoint.headers) {
-        fields.headers = Schema.optionalKey(reflectedSchema(endpoint.headers));
-      }
-      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema));
-      if (payloadSchemas.length === 1 && payloadSchemas[0]) {
-        fields.body = payloadSchemas[0];
-      } else if (payloadSchemas.length > 1) {
-        fields.body = Schema.Union(payloadSchemas);
-      }
-      const inputSchema = Object.keys(fields).length === 0 ? Schema.Record(Schema.String, Schema.Never) : Schema.Struct(fields);
-      schemas.set(operationId, inputSchema.annotate({
-        identifier: `${sanitizeHttpName(operationId)}ToolInput`
-      }));
+        fields.params = Schema.toType(reflectedSchema(endpoint.params));
+      if (endpoint.query)
+        fields.query = Schema.optionalKey(Schema.toType(reflectedSchema(endpoint.query)));
+      if (endpoint.headers)
+        fields.headers = Schema.optionalKey(Schema.toType(reflectedSchema(endpoint.headers)));
+      const payloads = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema));
+      if (payloads.length === 1 && payloads[0])
+        fields.body = payloads[0];
+      else if (payloads.length > 1)
+        fields.body = Schema.Union(payloads);
+      const input = Object.keys(fields).length === 0 ? Schema.Record(Schema.String, Schema.Never) : Schema.Struct(fields);
+      schemas.set(operationId, Schema.make(Schema.toCodecJson(input).ast).annotate({ identifier: `${sanitizeHttpName(operationId)}ToolInput` }));
     }
   });
   return schemas;
@@ -228,42 +80,37 @@ class HttpApiSpec extends Context.Service()("HttpApiSpec", {
   make: (config) => Effect.try({
     try: () => {
       const api = config.api;
-      if (!HttpApi.isHttpApi(api)) {
+      if (!HttpApi.isHttpApi(api))
         throw new Error("HttpApiSpec requires a valid HttpApi");
-      }
       const spec = OpenApi.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 reflectedSchema(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 = Schema.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)
   })
@@ -274,10 +121,7 @@ export {
   HttpApiMethods,
   HttpApiSpec,
   JsonObjectSchema,
-  decodeHttpApiOperationInput,
-  httpApiOperationInputSchema,
   httpApiOperations,
-  httpApiToolEntries,
   httpApiToolName,
   parseJsonObject,
   parseJsonValue,

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

@@ -1,20 +1,25 @@
 import { Context, Effect, Layer } from "effect";
-import { McpSchema, McpServer } from "effect/ai";
-import { ApiClient } from "./httpapi-client.js";
-import { HttpApiSpec } from "./httpapi-helpers.js";
+import { McpServer } from "effect/ai";
+import type { HttpApiGroup } from "effect/http-api";
+import { ApiClient, type ApiClientConfig } from "./httpapi-client.js";
+import { HttpApiSpec, type HttpApiSpecConfig } from "./httpapi-helpers.js";
 export type HttpApiMcpConfig = {
     readonly toolMetaKey?: string;
 };
+export type HttpApiMcpHttpConfig<Id extends string, Groups extends HttpApiGroup.Constraint> = ApiClientConfig<Id, Groups> & Pick<HttpApiSpecConfig, "methods" | "include"> & HttpApiMcpConfig & {
+    readonly path?: Parameters<typeof McpServer.layerHttp>[0]["path"];
+};
 declare const HttpApiMcp_base: Context.ServiceClass<HttpApiMcp, "HttpApiMcp", {
-    registerTools: Effect.Effect<void, Error, McpServer.McpServer>;
+    registerTools: Effect.Effect<void, never, ApiClient | McpServer.McpServer>;
 }> & {
     readonly make: (config: HttpApiMcpConfig) => Effect.Effect<{
-        registerTools: Effect.Effect<void, Error, McpServer.McpServer>;
-    }, never, ApiClient | HttpApiSpec>;
+        registerTools: Effect.Effect<void, never, ApiClient | McpServer.McpServer>;
+    }, never, HttpApiSpec>;
 };
 export declare class HttpApiMcp extends HttpApiMcp_base {
-    static readonly layer: (config: HttpApiMcpConfig) => Layer.Layer<HttpApiMcp, never, ApiClient | HttpApiSpec>;
+    static readonly layer: (config: HttpApiMcpConfig) => Layer.Layer<HttpApiMcp, never, HttpApiSpec>;
+    static readonly layerHttp: <Id extends string, Groups extends HttpApiGroup.Constraint>(config: HttpApiMcpHttpConfig<Id, Groups>) => Layer.Layer<McpServer.McpServer | import("effect/ai/McpSchema").McpServerClient, Error | import("effect/Cause").IllegalArgumentError, import("effect/http/HttpClient").HttpClient | import("effect/http/HttpRouter").HttpRouter | Exclude<import("effect/http-api/HttpApiMiddleware").MiddlewareClient<import("effect/http-api/HttpApiEndpoint").Middleware<HttpApiGroup.Endpoints<Groups>>>, import("effect/Scope").Scope>>;
 }
-export declare const httpApiMcpToolsLayer: Layer.Layer<never, Error, HttpApiMcp | McpServer.McpServer>;
-export declare const httpApiMcpServerLayer: (path: Parameters<typeof McpServer.layerHttp>[0]["path"]) => Layer.Layer<McpServer.McpServer | McpSchema.McpServerClient, import("effect/Cause").IllegalArgumentError, HttpApiSpec | import("effect/http/HttpRouter").HttpRouter>;
+export declare const httpApiMcpToolsLayer: Layer.Layer<never, never, ApiClient | HttpApiMcp | McpServer.McpServer>;
+export declare const httpApiMcpServerLayer: (path: Parameters<typeof McpServer.layerHttp>[0]["path"]) => Layer.Layer<McpServer.McpServer | import("effect/ai/McpSchema").McpServerClient, import("effect/Cause").IllegalArgumentError, HttpApiSpec | import("effect/http/HttpRouter").HttpRouter>;
 export {};