@krak-stack/registry 0.1.38 → 0.1.39

package/dist/services/agent/index.js

@@ -282,8 +282,8 @@ class AgentService extends Context.Service()("AgentService", {
         }));
       });
       const complete = Stream.fromEffect(Effect.gen(function* () {
-        const history2 = yield* conversation.exportJson;
-        return { type: "history", value: history2 };
+        const history = yield* conversation.exportJson;
+        return { type: "history", value: history };
       })).pipe(Stream.concat(Stream.succeed({ type: "finish" })));
       const response = Stream.concat(renderedRounds, complete).pipe(Stream.provideService(LanguageModel.LanguageModel, model), Stream.catch((error) => Stream.fromEffect(Effect.logError("Agent stream failed", streamErrorDetails(error))).pipe(Stream.drain, Stream.concat(Stream.make({
         type: "error",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krak-stack/registry",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "description": "Tree-shakable KrakStack components and Effect services.",
   "license": "MIT",
   "repository": {
@@ -37,17 +37,9 @@
       "types": "./dist/lib/httpapi-cli.d.ts",
       "import": "./dist/lib/httpapi-cli.js"
     },
-    "./httpapi/client": {
-      "types": "./dist/lib/httpapi-client.d.ts",
-      "import": "./dist/lib/httpapi-client.js"
-    },
-    "./httpapi/helpers": {
-      "types": "./dist/lib/httpapi-helpers.d.ts",
-      "import": "./dist/lib/httpapi-helpers.js"
-    },
-    "./httpapi/mcp": {
-      "types": "./dist/lib/httpapi-mcp.d.ts",
-      "import": "./dist/lib/httpapi-mcp.js"
+    "./httpapi/adapter": {
+      "types": "./dist/lib/httpapi-adapter.d.ts",
+      "import": "./dist/lib/httpapi-adapter.js"
     },
     "./opentelemetry/api": {
       "types": "./dist/services/opentelemetry/api.d.ts",

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

@@ -1,34 +0,0 @@
-import { Context, Effect, Layer, Schema } from "effect";
-import { HttpClient } from "effect/http";
-import { HttpApi, HttpApiGroup } from "effect/http-api";
-import type { HttpApiOperationEntry, HttpApiOperationInput } from "./httpapi-helpers.js";
-import type { Json } from "effect/Schema";
-export type ApiClientConfig<Id extends string, Groups extends HttpApiGroup.Constraint> = {
-    readonly api: HttpApi.HttpApi<Id, Groups>;
-    readonly baseUrl: string;
-    readonly encodeResult?: (result: ErrorOptions["cause"], operation: HttpApiOperationEntry) => Effect.Effect<Json, Error>;
-};
-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;
-};
-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>;
-};
-declare const ApiClient_base: Context.ServiceClass<ApiClient, "ApiClient", ApiClientService>;
-export declare class ApiClient extends ApiClient_base {
-    static readonly layer: <Id extends string, Groups extends HttpApiGroup.Constraint>(config: ApiClientConfig<Id, Groups>) => Layer.Layer<ApiClient, never, HttpClient.HttpClient | Exclude<import("effect/http-api/HttpApiMiddleware").MiddlewareClient<import("effect/http-api/HttpApiEndpoint").Middleware<HttpApiGroup.Endpoints<Groups>>>, import("effect/Scope").Scope>>;
-}
-export {};

package/dist/lib/httpapi-client.js

@@ -1,122 +0,0 @@
-// ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
-import { HttpClient } from "effect/http";
-import {
-  HttpApi,
-  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;
-  },
-  encode: () => null
-})));
-var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
-  Schema.Null,
-  UndefinedFromNull,
-  Schema.String,
-  Schema.Number,
-  Schema.Boolean,
-  Schema.DateFromString,
-  Schema.Uint8ArrayFromBase64,
-  Schema.Array(HttpApiOperationResultValue),
-  Schema.Record(Schema.String, HttpApiOperationResultValue)
-]));
-var HttpApiOperationResult = Schema.Union([
-  HttpApiOperationResultValue,
-  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, {
-  baseUrl,
-  httpClient: http
-});
-var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperation")(function* (client, { input, operation: entry }) {
-  const operationId = entry.operation.operationId;
-  if (!operationId) {
-    return yield* Effect.fail(new Error(`No generated API client operation for ${entry.method} ${entry.path}`));
-  }
-  const target = Object(client);
-  const groupName = Object.keys(target).filter((name) => operationId.startsWith(`${name}.`)).sort((a, b) => b.length - a.length)[0];
-  const group = groupName ? Object.entries(target).find(([name]) => name === groupName)?.[1] : target;
-  const endpointName = groupName ? operationId.slice(groupName.length + 1) : operationId;
-  const endpointCandidate = group instanceof Function ? undefined : Object.entries(Object(group)).find(([name]) => name === endpointName)?.[1];
-  const endpoint = Schema.decodeUnknownOption(GeneratedOperation)(endpointCandidate);
-  if (endpoint._tag === "None") {
-    return yield* Effect.fail(new Error(`No generated API client operation for ${operationId}`));
-  }
-  const result = Schema.decodeUnknownOption(GeneratedOperationEffect)(endpoint.value({
-    headers: input.headers,
-    params: input.params,
-    query: input.query,
-    payload: input.body
-  }));
-  if (result._tag === "None") {
-    return yield* Effect.fail(new Error(`Generated API client operation ${operationId} is invalid`));
-  }
-  return yield* result.value;
-});
-
-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, operation) => encodeResult(result, operation)),
-      execute: Effect.fn("ApiClient.execute")(function* (options) {
-        return yield* executeGeneratedOperation(client, options);
-      })
-    };
-  }));
-}
-export {
-  ApiClient,
-  HttpApiOperationResult,
-  encodeHttpApiOperationResult,
-  executeHttpApiOperation,
-  makeHttpApiOperationResultEncoder
-};

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

@@ -1,79 +0,0 @@
-import { Context, Effect, JsonSchema, Layer, Schema } from "effect";
-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;
-export type HttpApiDocument = ReturnType<typeof OpenApi.fromApi>;
-export type HttpApiMethod = "get" | "post" | "put" | "patch" | "delete";
-export declare const HttpApiMethods: ReadonlyArray<HttpApiMethod>;
-export type HttpApiParameter = {
-    readonly name: string;
-    readonly in: "path" | "query" | "header" | "cookie";
-    readonly required?: boolean;
-    readonly description?: string;
-    readonly schema?: JsonSchema.JsonSchema;
-};
-export type HttpApiOperation = {
-    readonly operationId?: string;
-    readonly summary?: string;
-    readonly description?: string;
-    readonly parameters?: ReadonlyArray<HttpApiParameter>;
-    readonly requestBody?: {
-        readonly required?: boolean;
-        readonly content?: Record<string, {
-            readonly schema?: JsonSchema.JsonSchema;
-        }>;
-    };
-    readonly tags?: ReadonlyArray<string>;
-};
-export type HttpApiOperationEntry = {
-    readonly method: HttpApiMethod;
-    readonly path: string;
-    readonly operation: HttpApiOperation;
-};
-export type HttpApiOperationInputValue = ErrorOptions["cause"];
-export type HttpApiOperationInputValues = Readonly<Record<string, HttpApiOperationInputValue>>;
-export type HttpApiOperationInput = {
-    readonly body?: HttpApiOperationInputValue;
-    readonly headers: HttpApiOperationInputValues;
-    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: 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 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: readonly HttpApiOperationDefinition[];
-}> & {
-    readonly make: (config: HttpApiSpecConfig) => Effect.Effect<{
-        info: OpenApi.OpenAPISpecInfo;
-        operations: readonly HttpApiOperationDefinition[];
-    }, Error, never>;
-};
-export declare class HttpApiSpec extends HttpApiSpec_base {
-    static readonly layer: (config: HttpApiSpecConfig) => Layer.Layer<HttpApiSpec, Error, never>;
-}
-export type HttpApiSpecService = typeof HttpApiSpec.Service;
-export {};

package/dist/lib/httpapi-helpers.js

@@ -1,130 +0,0 @@
-// ../../src/lib/httpapi-helpers.tsx
-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",
-  title: "HTTP JSON object",
-  description: "A JSON object passed to an HTTP API operation.",
-  examples: [{ id: "example-id" }]
-});
-var JsonObjectFromString = Schema.fromJsonString(JsonObjectSchema);
-var JsonValueFromString = Schema.fromJsonString(Schema.Json);
-var HttpApiMethods = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete"
-];
-var HttpApiOperationSchema = Schema.declare((value) => Schema.is(JsonObjectSchema)(value)).annotate({ identifier: "HttpApiOperation" });
-var decodeHttpApiOperation = Schema.decodeUnknownOption(HttpApiOperationSchema);
-var toHttpError = (message, error) => new Error(message, { cause: error });
-var sanitizeHttpName = (name) => name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
-var httpApiToolName = (method, path, operation) => {
-  const fallback = `${method}_${path.replace(/^\/api\//, "").replace(/[/:{}]/g, "_")}`;
-  return (operation.operationId || fallback).replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").slice(0, 64);
-};
-var httpApiOperations = ({
-  spec,
-  methods = HttpApiMethods
-}) => {
-  const operations = [];
-  for (const [path, pathItem] of Object.entries(spec.paths)) {
-    for (const method of methods) {
-      const operation = decodeHttpApiOperation(pathItem[method]);
-      if (Option.isSome(operation))
-        operations.push({ method, path, operation: operation.value });
-    }
-  }
-  return operations;
-};
-var reflectedSchema = (schema) => Schema.make(schema.ast);
-var reflectedOperationInputSchemas = (api) => {
-  const schemas = new Map;
-  HttpApi.reflect(api, {
-    onGroup: () => {
-      return;
-    },
-    onEndpoint: ({ endpoint, group }) => {
-      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
-      const fields = {};
-      if (endpoint.params)
-        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;
-};
-var parseJsonObject = Effect.fn("Http.parseJsonObject")(function* (value, label) {
-  if (!value)
-    return {};
-  return yield* Schema.decodeUnknownEffect(JsonObjectFromString)(value).pipe(Effect.mapError(() => new Error(`${label} must be a JSON object`)));
-});
-var parseJsonValue = Effect.fn("Http.parseJsonValue")(function* (value, label) {
-  if (!value)
-    return;
-  return yield* Schema.decodeUnknownEffect(JsonValueFromString)(value).pipe(Effect.mapError(() => new Error(`${label} must be valid JSON`)));
-});
-
-class HttpApiSpec extends Context.Service()("HttpApiSpec", {
-  make: (config) => Effect.try({
-    try: () => {
-      const api = config.api;
-      if (!HttpApi.isHttpApi(api))
-        throw new Error("HttpApiSpec requires a valid HttpApi");
-      const spec = OpenApi.fromApi(api);
-      const schemas = reflectedOperationInputSchemas(api);
-      const names = new Set;
-      const operations = httpApiOperations({
-        spec,
-        methods: config.methods
-      }).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)
-  })
-}) {
-  static layer = (config) => Layer.effect(this, this.make(config));
-}
-export {
-  HttpApiMethods,
-  HttpApiSpec,
-  JsonObjectSchema,
-  httpApiOperations,
-  httpApiToolName,
-  parseJsonObject,
-  parseJsonValue,
-  sanitizeHttpName,
-  toHttpError
-};

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

@@ -1,25 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-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, never, ApiClient | McpServer.McpServer>;
-}> & {
-    readonly make: (config: HttpApiMcpConfig) => Effect.Effect<{
-        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, 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, 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 {};