@krak-stack/registry 0.1.19 → 0.1.21

package/dist/lib/httpapi-cli.js

@@ -7,13 +7,14 @@ import {
   Exit,
   FileSystem,
   Layer as Layer3,
+  Option as Option2,
   Path,
   Schema as Schema3,
   Stdio,
   Stream,
   Terminal
 } from "effect";
-import { Command, Flag } from "effect/unstable/cli";
+import { Argument, Command, Flag } from "effect/unstable/cli";
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 
 // ../../src/lib/httpapi-client.ts
@@ -386,7 +387,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
           if (reflected)
             return reflected;
           const document = JsonSchema.fromSchemaOpenApi3_1(operationJsonSchema(operation));
-          return SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document));
+          return reflectedSchema2(SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document)));
         }
       };
     },
@@ -397,6 +398,33 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
 }
 
 // ../../src/lib/httpapi-cli.ts
+var CliJsonSchema = Schema3.Struct({
+  type: Schema3.optional(Schema3.Union([Schema3.String, Schema3.Array(Schema3.String)])),
+  description: Schema3.optional(Schema3.String),
+  enum: Schema3.optional(Schema3.Array(Schema3.Json)),
+  items: Schema3.optional(Schema3.Json),
+  properties: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Json)),
+  required: Schema3.optional(Schema3.Array(Schema3.String)),
+  pattern: Schema3.optional(Schema3.String),
+  allOf: Schema3.optional(Schema3.Array(Schema3.Json)),
+  anyOf: Schema3.optional(Schema3.Array(Schema3.Json)),
+  $ref: Schema3.optional(Schema3.String),
+  $defs: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Json))
+}).annotate({ identifier: "HttpApiCliJsonSchema" });
+var decodeCliJsonSchema = Schema3.decodeUnknownOption(CliJsonSchema);
+var JsonFromString = Schema3.fromJsonString(Schema3.Json);
+var CliParsedOption = Schema3.declare((value) => Option2.isOption(value) && Option2.match(value, {
+  onNone: () => true,
+  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* () {
     const spec = yield* HttpApiSpec;
@@ -409,12 +437,15 @@ class HttpApiCli extends Context3.Service()("HttpApiCli", {
 }) {
   static layer = Layer3.effect(this, this.make());
 }
-var fallbackName = (value, fallback) => sanitizeHttpName(value) || fallback;
+var toHttpApiCliName = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+var fallbackName = (value, fallback) => toHttpApiCliName(value) || fallback;
 var operationIdParts = (operation) => operation.operationId?.split(".").filter(Boolean) ?? [];
 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
@@ -425,13 +456,18 @@ var toCliOperation = ({
   method,
   path,
   summary: operation.summary ?? operation.description ?? "",
-  operation
+  operation,
+  inputSchema,
+  inputJsonSchema
 });
 var httpApiCliOperationGroups = (operations) => {
   const groups = new Map;
   for (const operation of operations) {
     const group = groups.get(operation.groupName);
     if (group) {
+      if (group.operations.some((entry) => entry.name === operation.name)) {
+        throw new Error(`Duplicate CLI command ${operation.groupName} ${operation.name}`);
+      }
       group.operations.push(operation);
     } else {
       groups.set(operation.groupName, {
@@ -447,9 +483,146 @@ var httpApiCliOperationGroups = (operations) => {
   })).sort((a, b) => a.name.localeCompare(b.name));
 };
 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 formatOperations = (operations) => [
+  "GROUP\tCOMMAND\tMETHOD\tPATH\tSUMMARY",
+  ...operations.map((operation) => `${operation.groupName}	${operation.name}	${operation.method.toUpperCase()}	${operation.path}	${operation.summary}`)
+].join(`
 `);
 var listOperations = (operations) => print(formatOperations(operations));
+var cliJsonSchema = (value) => decodeCliJsonSchema(value).pipe(Option2.getOrElse(() => ({})));
+var effectiveSchema = (schema) => {
+  const variant = (schema.anyOf ?? []).map(cliJsonSchema).find((candidate) => schemaType(candidate) !== "null");
+  return variant ? {
+    ...variant,
+    description: schema.description ?? variant.description
+  } : schema;
+};
+var schemaType = (schema) => {
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  if (type || !schema.anyOf)
+    return type;
+  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)) {
+    flag = required ? Flag.choice(name, ["true", "false"]).pipe(Flag.map((value) => value === "true")) : Flag.boolean(name);
+  } else if (choices.length > 0) {
+    flag = Flag.choice(name, choices);
+  } else if (type === "integer") {
+    flag = Flag.integer(name);
+  } else if (type === "number" || hasNumericPattern(schema)) {
+    flag = Flag.float(name);
+  } else if (type === "object" || type === "array") {
+    flag = jsonFlag(name);
+  } else {
+    flag = Flag.string(name);
+  }
+  const documented = flag.pipe(Flag.withMetavar(type === "object" || type === "array" ? "JSON" : name.toUpperCase()));
+  const described = schema.description ? documented.pipe(Flag.withDescription(schema.description)) : documented;
+  return required ? described : described.pipe(Flag.optional);
+};
+var primitiveArgument = (name, schema) => {
+  const type = schemaType(schema);
+  const choices = schemaEnum(schema);
+  let argument;
+  if (choices.length > 0) {
+    argument = Argument.choice(name, choices);
+  } else if (type === "integer") {
+    argument = Argument.integer(name);
+  } else if (type === "number" || hasNumericPattern(schema)) {
+    argument = Argument.float(name);
+  } else {
+    argument = Argument.string(name);
+  }
+  const documented = argument.pipe(Argument.withMetavar(name.toUpperCase()));
+  return schema.description ? documented.pipe(Argument.withDescription(schema.description)) : documented;
+};
+var operationInputDrafts = (operation) => {
+  const document = cliJsonSchema(operation.inputJsonSchema);
+  const definitions = document.$defs ?? {};
+  const resolveSchema = (value) => {
+    const schema = 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 [
+      {
+        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);
+  if (schemaType(body) === "object" && body.properties) {
+    const required = new Set(body.required ?? []);
+    for (const [name, schema] of Object.entries(body.properties)) {
+      drafts.push({
+        location: "body",
+        name,
+        preferredName: fallbackName(name, "body"),
+        required: required.has(name),
+        schema: resolveSchema(schema)
+      });
+    }
+  } else if (operation.operation.requestBody) {
+    drafts.push({
+      location: "body",
+      name: "body",
+      preferredName: "body",
+      required: operation.operation.requestBody.required ?? false,
+      schema: body
+    });
+  }
+  return drafts;
+};
+var operationInputs = (operation) => {
+  const drafts = operationInputDrafts(operation);
+  const preferredCounts = new Map;
+  for (const draft of drafts) {
+    if (draft.location === "params")
+      continue;
+    preferredCounts.set(draft.preferredName, (preferredCounts.get(draft.preferredName) ?? 0) + 1);
+  }
+  const optionNames = new Set;
+  return drafts.map((draft, index) => {
+    const optionName = draft.location === "params" || preferredCounts.get(draft.preferredName) === 1 ? draft.preferredName : `${draft.location.replace(/s$/, "")}-${draft.preferredName}`;
+    if (draft.location !== "params" && optionNames.has(optionName)) {
+      throw new Error(`Duplicate CLI option --${optionName} for ${operation.groupName} ${operation.name}`);
+    }
+    optionNames.add(optionName);
+    return {
+      configKey: `input${index}`,
+      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)
+    };
+  });
+};
 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);
@@ -459,18 +632,48 @@ 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, callConfig, client) => Effect3.gen(function* () {
-  const body = yield* parseJsonValue(callConfig.body, "--body");
-  const headers = yield* parseJsonObject(callConfig.headers, "--headers");
-  const params = yield* parseJsonObject(callConfig.params, "--params");
-  const query = yield* parseJsonObject(callConfig.query, "--query");
+var callOperation = (operation, inputs, callConfig, client) => Effect3.gen(function* () {
+  const emptyValues = () => ({});
+  const assembled = {
+    body: emptyValues(),
+    headers: emptyValues(),
+    params: emptyValues(),
+    query: emptyValues()
+  };
+  for (const input2 of inputs) {
+    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;
+    }
+  }
+  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 rawInput = {};
+  if (inputs.some((input2) => input2.location === "params")) {
+    rawInput.params = assembled.params;
+  }
+  if (inputs.some((input2) => input2.location === "headers")) {
+    rawInput.headers = assembled.headers;
+  }
+  if (inputs.some((input2) => input2.location === "query")) {
+    rawInput.query = assembled.query;
+  }
+  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, headers, params, query }
+    input: {
+      body: input.body,
+      headers: input.headers ?? {},
+      params: input.params ?? {},
+      query: input.query ?? {}
+    }
   });
   return yield* printHttpApiCliResult(response, {
     method: operation.method,
@@ -478,28 +681,40 @@ var callOperation = (operation, callConfig, client) => Effect3.gen(function* ()
     operation: operation.operation
   }, client);
 });
-var listCommand = (groups) => Command.make("list", {}, () => print(groups.map((group) => `${group.name}	${group.title}	${group.operations.length}`).join(`
+var listCommand = (groups) => Command.make("list", {}, () => print([
+  "GROUP\tTITLE\tCOMMANDS",
+  ...groups.map((group) => `${group.name}	${group.title}	${group.operations.length}`)
+].join(`
 `))).pipe(Command.withDescription("List command groups"));
 var groupListCommand = (group) => Command.make("list", {}, () => listOperations(group.operations)).pipe(Command.withDescription(`List ${group.title} operations`));
-var operationCommand = (operation, client) => Command.make(operation.name, {
-  body: Flag.string("body").pipe(Flag.withDefault(""), Flag.withDescription("JSON request body")),
-  headers: Flag.string("headers").pipe(Flag.withDefault("{}"), Flag.withDescription("JSON object for request headers")),
-  params: Flag.string("params").pipe(Flag.withDefault("{}"), Flag.withDescription("JSON object for path parameters")),
-  query: Flag.string("query").pipe(Flag.withDefault("{}"), Flag.withDescription("JSON object for query parameters"))
-}, (callConfig) => callOperation(operation, callConfig, client)).pipe(Command.withDescription(operation.summary || `${operation.method.toUpperCase()} ${operation.path}`));
-var groupCommand = (group, client) => Command.make(group.name).pipe(Command.withDescription(group.title), Command.withSubcommands([
+var operationCommand = (operation, client) => Effect3.sync(() => {
+  const inputs = operationInputs(operation);
+  const config = Object.fromEntries(inputs.map((input) => [input.configKey, input.param]));
+  return Command.make(operation.name, config, (callConfig) => Schema3.decodeUnknownEffect(CliParsedConfig)(callConfig).pipe(Effect3.flatMap((parsed) => callOperation(operation, inputs, parsed, client)))).pipe(Command.withDescription(operation.summary || `${operation.method.toUpperCase()} ${operation.path}`), Command.withExamples([
+    {
+      command: `${operation.groupName} ${operation.name}`,
+      description: `${operation.method.toUpperCase()} ${operation.path}`
+    }
+  ]));
+});
+var groupCommand = (group, client) => Effect3.all(group.operations.map((operation) => operationCommand(operation, client))).pipe(Effect3.map((operationCommands) => Command.make(group.name).pipe(Command.withDescription(group.title), Command.withSubcommands([
   groupListCommand(group),
-  ...group.operations.map((operation) => operationCommand(operation, client))
-]));
+  ...operationCommands
+]))));
 var makeHttpApiCliCommand = Effect3.fn("HttpApiCli.makeCommand")(function* () {
   const spec = yield* HttpApiSpec;
   const client = yield* ApiClient;
-  const name = sanitizeHttpName(spec.info.title);
-  const groups = httpApiCliOperationGroups(spec.operations.map(toCliOperation));
-  return Command.make(name).pipe(Command.withDescription(spec.info.description ?? spec.info.title), Command.withSubcommands([
-    listCommand(groups),
-    ...groups.map((group) => groupCommand(group, client))
-  ]));
+  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)
+    }))),
+    catch: (error) => error instanceof Error ? error : new Error(String(error))
+  });
+  const groupCommands = yield* Effect3.all(groups.map((group) => groupCommand(group, client)));
+  return Command.make(name).pipe(Command.withDescription(spec.info.description ?? spec.info.title), Command.withSubcommands([listCommand(groups), ...groupCommands]));
 });
 var cliEnvironmentLayer = (args) => Layer3.mergeAll(FileSystem.layerNoop({}), Path.layer, Stdio.layerTest({ args: Effect3.succeed(Array.from(args)) }), Layer3.succeed(Terminal.Terminal, Terminal.make({
   columns: Effect3.sync(() => process.stdout.columns ?? 80),
@@ -520,7 +735,13 @@ var httpApiCli = (args = process.argv.slice(2)) => Effect3.gen(function* () {
   const cli = yield* HttpApiCli;
   return yield* cli.run(args);
 });
-var formatHttpApiCliCause = Cause.pretty;
+var formatHttpApiCliCause = (cause) => {
+  const errors = Cause.prettyErrors(cause);
+  if (errors.length === 0)
+    return Cause.pretty(cause);
+  return errors.map((error) => error.message ? `${error.name}: ${error.message}` : error.name).join(`
+`);
+};
 var runHttpApiCli = (layer, args = process.argv.slice(2)) => {
   Effect3.runPromiseExit(httpApiCli(args).pipe(Effect3.provide(layer), Effect3.provide(httpApiCliEnvironmentLayer(args)))).then(Exit.match({
     onSuccess: () => {
@@ -533,11 +754,12 @@ var runHttpApiCli = (layer, args = process.argv.slice(2)) => {
   }));
 };
 export {
-  runHttpApiCli,
-  printHttpApiCliResult,
-  makeHttpApiCliCommand,
-  httpApiCliEnvironmentLayer,
-  httpApiCli,
+  HttpApiCli,
   formatHttpApiCliCause,
-  HttpApiCli
+  httpApiCli,
+  httpApiCliEnvironmentLayer,
+  makeHttpApiCliCommand,
+  printHttpApiCliResult,
+  runHttpApiCli,
+  toHttpApiCliName
 };

package/dist/lib/httpapi-client.js

@@ -105,8 +105,8 @@ class ApiClient extends Context.Service()("ApiClient") {
   }));
 }
 export {
-  makeHttpApiOperationResultEncoder,
-  encodeHttpApiOperationResult,
+  ApiClient,
   HttpApiOperationResult,
-  ApiClient
+  encodeHttpApiOperationResult,
+  makeHttpApiOperationResultEncoder
 };

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

@@ -32,11 +32,13 @@ export type HttpApiOperationEntry = {
     readonly path: string;
     readonly operation: HttpApiOperation;
 };
+export type HttpApiOperationInputValue = ErrorOptions["cause"];
+export type HttpApiOperationInputValues = Readonly<Record<string, HttpApiOperationInputValue>>;
 export type HttpApiOperationInput = {
-    readonly body?: Json;
-    readonly headers: JsonObject;
-    readonly params: JsonObject;
-    readonly query: JsonObject;
+    readonly body?: HttpApiOperationInputValue;
+    readonly headers: HttpApiOperationInputValues;
+    readonly params: HttpApiOperationInputValues;
+    readonly query: HttpApiOperationInputValues;
 };
 export type HttpApiSpecConfig = {
     readonly api: HttpApi.Constraint;
@@ -77,7 +79,7 @@ declare const HttpApiSpec_base: Context.ServiceClass<HttpApiSpec, "HttpApiSpec",
         query: any;
     }, Error, never>;
     operationJsonSchema: (operation: HttpApiOperation) => JsonSchema.JsonSchema;
-    operationSchema: (operation: HttpApiOperation) => Schema.Top;
+    operationSchema: (operation: HttpApiOperation) => Schema.Codec<unknown, unknown, never, never>;
 }> & {
     readonly make: (config: HttpApiSpecConfig) => Effect.Effect<{
         info: OpenApi.OpenAPISpecInfo;
@@ -89,7 +91,7 @@ declare const HttpApiSpec_base: Context.ServiceClass<HttpApiSpec, "HttpApiSpec",
             query: any;
         }, Error, never>;
         operationJsonSchema: (operation: HttpApiOperation) => JsonSchema.JsonSchema;
-        operationSchema: (operation: HttpApiOperation) => Schema.Top;
+        operationSchema: (operation: HttpApiOperation) => Schema.Codec<unknown, unknown, never, never>;
     }, Error, never>;
 };
 export declare class HttpApiSpec extends HttpApiSpec_base {

package/dist/lib/httpapi-helpers.js

@@ -261,7 +261,7 @@ class HttpApiSpec extends Context.Service()("HttpApiSpec", {
           if (reflected)
             return reflected;
           const document = JsonSchema.fromSchemaOpenApi3_1(operationJsonSchema(operation));
-          return SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document));
+          return reflectedSchema(SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document)));
         }
       };
     },
@@ -271,16 +271,16 @@ class HttpApiSpec extends Context.Service()("HttpApiSpec", {
   static layer = (config) => Layer.effect(this, this.make(config));
 }
 export {
-  toHttpError,
-  sanitizeHttpName,
-  parseJsonValue,
-  parseJsonObject,
-  httpApiToolName,
-  httpApiToolEntries,
-  httpApiOperations,
-  httpApiOperationInputSchema,
-  decodeHttpApiOperationInput,
-  JsonObjectSchema,
+  HttpApiMethods,
   HttpApiSpec,
-  HttpApiMethods
+  JsonObjectSchema,
+  decodeHttpApiOperationInput,
+  httpApiOperationInputSchema,
+  httpApiOperations,
+  httpApiToolEntries,
+  httpApiToolName,
+  parseJsonObject,
+  parseJsonValue,
+  sanitizeHttpName,
+  toHttpError
 };

package/dist/lib/httpapi-mcp.js

@@ -372,7 +372,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
           if (reflected)
             return reflected;
           const document = JsonSchema.fromSchemaOpenApi3_1(operationJsonSchema(operation));
-          return SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document));
+          return reflectedSchema2(SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document)));
         }
       };
     },
@@ -470,7 +470,7 @@ var httpApiMcpServerLayer = (path) => Layer3.unwrap(Effect3.gen(function* () {
   });
 }));
 export {
-  httpApiMcpToolsLayer,
+  HttpApiMcp,
   httpApiMcpServerLayer,
-  HttpApiMcp
+  httpApiMcpToolsLayer
 };

package/dist/lib/httpapi-toolkit.js

@@ -372,7 +372,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
           if (reflected)
             return reflected;
           const document = JsonSchema.fromSchemaOpenApi3_1(operationJsonSchema(operation));
-          return SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document));
+          return reflectedSchema2(SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document)));
         }
       };
     },
@@ -434,6 +434,6 @@ var HttpApiToolkitLayer = (config) => Layer3.unwrap(buildHttpApiToolkit(config).
   }).pipe(Effect3.mapError((error) => error instanceof Error ? error.message : String(error)))
 ])))))));
 export {
-  HttpApiToolkitLayer,
-  HttpApiToolkit
+  HttpApiToolkit,
+  HttpApiToolkitLayer
 };

package/dist/lib/markdown/content.d.ts

@@ -0,0 +1,13 @@
+export type MarkdownContentProps = {
+    readonly className?: string;
+    readonly codeBlocks: ReadonlyArray<{
+        readonly code: string;
+        readonly language: string;
+    }>;
+    readonly html: string;
+    readonly messages?: {
+        readonly copied?: string;
+        readonly copy?: string;
+    };
+};
+export declare const MarkdownContent: ({ className, codeBlocks, html, messages, }: MarkdownContentProps) => import("react").JSX.Element;

package/dist/lib/markdown/server.d.ts

@@ -0,0 +1,19 @@
+export type MarkdownCodeBlock = {
+    readonly code: string;
+    readonly language: string;
+};
+export declare const markdownOptions: {
+    autolinks: true;
+    headings: {
+        ids: true;
+    };
+    noHtmlBlocks: true;
+    noHtmlSpans: true;
+    tagFilter: true;
+};
+export declare const markdownPlainText: (source: string, includeCode?: boolean) => string;
+export declare const compileMarkdown: (source: string) => {
+    codeBlocks: MarkdownCodeBlock[];
+    html: string;
+    source: string;
+};

package/dist/lib/query.d.ts

@@ -22,8 +22,8 @@ export declare const SortParamsFromString: Schema.decodeTo<Schema.$Array<Schema.
     readonly direction: Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>;
 }>>, Schema.String, never, never>;
 export declare const Query: Schema.Struct<{
-    readonly page: Schema.Int;
-    readonly pageSize: Schema.Int;
+    readonly page: Schema.withDecodingDefaultKey<Schema.Int, never>;
+    readonly pageSize: Schema.withDecodingDefaultKey<Schema.Int, never>;
     readonly globalFilter: Schema.optional<Schema.String>;
     readonly sort: Schema.optional<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.$Array<Schema.Struct<{
         readonly id: Schema.NonEmptyString;
@@ -31,6 +31,7 @@ export declare const Query: Schema.Struct<{
     }>>, Schema.String, never, never>, never, never>>;
 }>;
 export type QueryType = typeof Query.Type;
+export declare const QueryStandard: ReturnType<typeof Schema.toStandardSchemaV1<typeof Query>>;
 export declare const PaginationMeta: Schema.Struct<{
     readonly page: Schema.Int;
     readonly pageSize: Schema.Int;

package/dist/lib/query.js

@@ -85,8 +85,8 @@ var SortParamSearch = SortParamsFromString.pipe(Schema.decodeTo(Schema.String, S
   examples: ["-name,age"]
 }));
 var Query = Schema.Struct({
-  page: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  pageSize: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })),
+  page: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(0))),
+  pageSize: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })).pipe(Schema.withDecodingDefaultKey(Effect.succeed(10))),
   globalFilter: Schema.optional(Schema.String),
   sort: Schema.optional(SortParamSearch)
 }).annotate({
@@ -102,6 +102,7 @@ var Query = Schema.Struct({
     }
   ]
 });
+var QueryStandard = Schema.toStandardSchemaV1(Query);
 var PaginationMeta = Schema.Struct({
   page: Schema.Int,
   pageSize: Schema.Int,
@@ -118,11 +119,12 @@ var PaginatedResponse = (items) => Schema.Struct({
   meta: PaginationMeta
 });
 export {
-  SortParamsFromString,
-  SortParamFromString,
-  SortParam,
-  SortDirection,
-  Query,
+  PaginatedResponse,
   PaginationMeta,
-  PaginatedResponse
+  Query,
+  QueryStandard,
+  SortDirection,
+  SortParam,
+  SortParamFromString,
+  SortParamsFromString
 };

package/dist/lib/seo.js

@@ -111,6 +111,6 @@ var createSeo = (defaults) => (options) => seo({
   ...options
 });
 export {
-  seo,
-  createSeo
+  createSeo,
+  seo
 };

package/dist/lib/webfetch-toolkit.js

@@ -266,11 +266,11 @@ var WebFetchToolkitLayer = (options = {}) => {
   }));
 };
 export {
-  defaultWebFetchToolkitOptions,
-  WebFetchToolkitOptions,
-  WebFetchToolkitLayer,
-  WebFetchToolkit,
-  WebFetchResponse,
+  WebFetchFailure,
   WebFetchRequest,
-  WebFetchFailure
+  WebFetchResponse,
+  WebFetchToolkit,
+  WebFetchToolkitLayer,
+  WebFetchToolkitOptions,
+  defaultWebFetchToolkitOptions
 };

package/dist/services/agent/client/atom.d.ts

@@ -10,6 +10,13 @@ export type AgentToolActivity = Extract<AgentEvent, {
 };
 export type AgentMessage = {
     readonly id: string;
+    readonly markdown?: {
+        readonly codeBlocks: ReadonlyArray<{
+            readonly code: string;
+            readonly language: string;
+        }>;
+        readonly html: string;
+    };
     readonly role: "user" | "assistant";
     readonly text: string;
     readonly tools: ReadonlyArray<AgentToolActivity>;