@lantos1618/better-ui 0.8.0 → 0.9.1

package/dist/mcp/index.d.mts

@@ -1,5 +1,6 @@
 import { T as Tool, g as ToolContext } from '../tool-yZTixiN2.mjs';
-import { z } from 'zod';
+export { z as zodToJsonSchema } from '../schema-DdZf6066.mjs';
+import 'zod';
 import 'react';
 
 /**
@@ -127,33 +128,4 @@ declare class MCPServer {
  */
 declare function createMCPServer(config: MCPServerConfig): MCPServer;
 
-/**
- * Lightweight Zod-to-JSON-Schema converter.
- * Handles common Zod types without requiring zod-to-json-schema dependency.
- */
-
-interface JsonSchema {
-    type?: string;
-    properties?: Record<string, JsonSchema>;
-    required?: string[];
-    items?: JsonSchema;
-    enum?: unknown[];
-    description?: string;
-    default?: unknown;
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: string;
-    anyOf?: JsonSchema[];
-    oneOf?: JsonSchema[];
-    nullable?: boolean;
-    additionalProperties?: boolean | JsonSchema;
-    [key: string]: unknown;
-}
-declare function zodToJsonSchema(schema: z.ZodType | {
-    [key: string]: any;
-}): JsonSchema;
-
-export { MCPServer, type MCPServerConfig, createMCPServer, zodToJsonSchema };
+export { MCPServer, type MCPServerConfig, createMCPServer };

package/dist/mcp/index.d.ts

@@ -1,5 +1,6 @@
 import { T as Tool, g as ToolContext } from '../tool-yZTixiN2.js';
-import { z } from 'zod';
+export { z as zodToJsonSchema } from '../schema-DdZf6066.js';
+import 'zod';
 import 'react';
 
 /**
@@ -127,33 +128,4 @@ declare class MCPServer {
  */
 declare function createMCPServer(config: MCPServerConfig): MCPServer;
 
-/**
- * Lightweight Zod-to-JSON-Schema converter.
- * Handles common Zod types without requiring zod-to-json-schema dependency.
- */
-
-interface JsonSchema {
-    type?: string;
-    properties?: Record<string, JsonSchema>;
-    required?: string[];
-    items?: JsonSchema;
-    enum?: unknown[];
-    description?: string;
-    default?: unknown;
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: string;
-    anyOf?: JsonSchema[];
-    oneOf?: JsonSchema[];
-    nullable?: boolean;
-    additionalProperties?: boolean | JsonSchema;
-    [key: string]: unknown;
-}
-declare function zodToJsonSchema(schema: z.ZodType | {
-    [key: string]: any;
-}): JsonSchema;
-
-export { MCPServer, type MCPServerConfig, createMCPServer, zodToJsonSchema };
+export { MCPServer, type MCPServerConfig, createMCPServer };

package/dist/openapi/index.d.mts

@@ -0,0 +1,122 @@
+import { T as Tool, g as ToolContext } from '../tool-yZTixiN2.mjs';
+import { J as JsonSchema } from '../schema-DdZf6066.mjs';
+import 'zod';
+import 'react';
+
+interface OpenAPISpecConfig {
+    /** API title */
+    title: string;
+    /** API version */
+    version: string;
+    /** Tool registry */
+    tools: Record<string, Tool>;
+    /** API description */
+    description?: string;
+    /** Base URL for servers (default: '/') */
+    serverUrl?: string;
+    /** Base path prefix for tool endpoints (default: '/api/tools') */
+    basePath?: string;
+    /** Tags to group endpoints */
+    tags?: Array<{
+        name: string;
+        description?: string;
+    }>;
+}
+interface OpenAPISpec {
+    openapi: '3.1.0';
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers: Array<{
+        url: string;
+    }>;
+    paths: Record<string, PathItem>;
+    components: {
+        schemas: Record<string, JsonSchema>;
+    };
+    tags?: Array<{
+        name: string;
+        description?: string;
+    }>;
+}
+interface PathItem {
+    post: {
+        operationId: string;
+        summary: string;
+        description?: string;
+        tags?: string[];
+        requestBody: {
+            required: true;
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: string;
+                    };
+                };
+            };
+        };
+        responses: Record<string, {
+            description: string;
+            content?: {
+                'application/json': {
+                    schema: {
+                        $ref: string;
+                    } | JsonSchema;
+                };
+            };
+        }>;
+    };
+}
+/**
+ * Generate an OpenAPI 3.1 spec from a Better UI tool registry.
+ */
+declare function generateOpenAPISpec(config: OpenAPISpecConfig): OpenAPISpec;
+/**
+ * Create a request handler that serves the OpenAPI spec as JSON.
+ *
+ * @example
+ * ```typescript
+ * // Next.js route: app/api/openapi/route.ts
+ * export const GET = openAPIHandler({
+ *   title: 'My Tools',
+ *   version: '1.0.0',
+ *   tools,
+ * });
+ * ```
+ */
+declare function openAPIHandler(config: OpenAPISpecConfig): (req: Request) => Response;
+interface ToolRouterConfig {
+    /** Tool registry */
+    tools: Record<string, Tool>;
+    /** Base path prefix (default: '/api/tools') */
+    basePath?: string;
+    /** Optional context passed to every tool execution */
+    context?: Partial<ToolContext>;
+    /** Called before tool execution — throw to reject */
+    onBeforeExecute?: (toolName: string, input: unknown, req: Request) => Promise<void> | void;
+}
+/**
+ * Create a request handler that routes to individual tool endpoints.
+ * Each tool is callable at `POST {basePath}/{toolName}`.
+ *
+ * Also serves the OpenAPI spec at `GET {basePath}` and a Swagger UI at `GET {basePath}/docs`.
+ *
+ * @example
+ * ```typescript
+ * // Next.js catch-all: app/api/tools/[...path]/route.ts
+ * import { toolRouter } from '@lantos1618/better-ui/openapi';
+ * const router = toolRouter({ tools });
+ * export const GET = router;
+ * export const POST = router;
+ *
+ * // Now callable:
+ * // POST /api/tools/weather  { "city": "Tokyo" }  -> { "result": { "temp": 22, ... } }
+ * // GET  /api/tools           -> OpenAPI JSON spec
+ * // GET  /api/tools/docs      -> Swagger UI
+ * ```
+ */
+declare function toolRouter(config: ToolRouterConfig): (req: Request) => Promise<Response>;
+
+export { type OpenAPISpec, type OpenAPISpecConfig, type ToolRouterConfig, generateOpenAPISpec, openAPIHandler, toolRouter };

package/dist/openapi/index.d.ts

@@ -0,0 +1,122 @@
+import { T as Tool, g as ToolContext } from '../tool-yZTixiN2.js';
+import { J as JsonSchema } from '../schema-DdZf6066.js';
+import 'zod';
+import 'react';
+
+interface OpenAPISpecConfig {
+    /** API title */
+    title: string;
+    /** API version */
+    version: string;
+    /** Tool registry */
+    tools: Record<string, Tool>;
+    /** API description */
+    description?: string;
+    /** Base URL for servers (default: '/') */
+    serverUrl?: string;
+    /** Base path prefix for tool endpoints (default: '/api/tools') */
+    basePath?: string;
+    /** Tags to group endpoints */
+    tags?: Array<{
+        name: string;
+        description?: string;
+    }>;
+}
+interface OpenAPISpec {
+    openapi: '3.1.0';
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers: Array<{
+        url: string;
+    }>;
+    paths: Record<string, PathItem>;
+    components: {
+        schemas: Record<string, JsonSchema>;
+    };
+    tags?: Array<{
+        name: string;
+        description?: string;
+    }>;
+}
+interface PathItem {
+    post: {
+        operationId: string;
+        summary: string;
+        description?: string;
+        tags?: string[];
+        requestBody: {
+            required: true;
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: string;
+                    };
+                };
+            };
+        };
+        responses: Record<string, {
+            description: string;
+            content?: {
+                'application/json': {
+                    schema: {
+                        $ref: string;
+                    } | JsonSchema;
+                };
+            };
+        }>;
+    };
+}
+/**
+ * Generate an OpenAPI 3.1 spec from a Better UI tool registry.
+ */
+declare function generateOpenAPISpec(config: OpenAPISpecConfig): OpenAPISpec;
+/**
+ * Create a request handler that serves the OpenAPI spec as JSON.
+ *
+ * @example
+ * ```typescript
+ * // Next.js route: app/api/openapi/route.ts
+ * export const GET = openAPIHandler({
+ *   title: 'My Tools',
+ *   version: '1.0.0',
+ *   tools,
+ * });
+ * ```
+ */
+declare function openAPIHandler(config: OpenAPISpecConfig): (req: Request) => Response;
+interface ToolRouterConfig {
+    /** Tool registry */
+    tools: Record<string, Tool>;
+    /** Base path prefix (default: '/api/tools') */
+    basePath?: string;
+    /** Optional context passed to every tool execution */
+    context?: Partial<ToolContext>;
+    /** Called before tool execution — throw to reject */
+    onBeforeExecute?: (toolName: string, input: unknown, req: Request) => Promise<void> | void;
+}
+/**
+ * Create a request handler that routes to individual tool endpoints.
+ * Each tool is callable at `POST {basePath}/{toolName}`.
+ *
+ * Also serves the OpenAPI spec at `GET {basePath}` and a Swagger UI at `GET {basePath}/docs`.
+ *
+ * @example
+ * ```typescript
+ * // Next.js catch-all: app/api/tools/[...path]/route.ts
+ * import { toolRouter } from '@lantos1618/better-ui/openapi';
+ * const router = toolRouter({ tools });
+ * export const GET = router;
+ * export const POST = router;
+ *
+ * // Now callable:
+ * // POST /api/tools/weather  { "city": "Tokyo" }  -> { "result": { "temp": 22, ... } }
+ * // GET  /api/tools           -> OpenAPI JSON spec
+ * // GET  /api/tools/docs      -> Swagger UI
+ * ```
+ */
+declare function toolRouter(config: ToolRouterConfig): (req: Request) => Promise<Response>;
+
+export { type OpenAPISpec, type OpenAPISpecConfig, type ToolRouterConfig, generateOpenAPISpec, openAPIHandler, toolRouter };

package/dist/openapi/index.js

@@ -0,0 +1,339 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/openapi/index.ts
+var openapi_exports = {};
+__export(openapi_exports, {
+  generateOpenAPISpec: () => generateOpenAPISpec,
+  openAPIHandler: () => openAPIHandler,
+  toolRouter: () => toolRouter
+});
+module.exports = __toCommonJS(openapi_exports);
+
+// src/mcp/schema.ts
+function zodToJsonSchema(schema) {
+  return convert(schema);
+}
+function convert(schema) {
+  const def = schema._def;
+  const typeName = def?.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return convertString(def);
+    case "ZodNumber":
+      return convertNumber(def);
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodNull":
+      return { type: "null" };
+    case "ZodLiteral":
+      return { enum: [def.value] };
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    case "ZodNativeEnum":
+      return { enum: Object.values(def.values) };
+    case "ZodObject":
+      return convertObject(def);
+    case "ZodArray":
+      return convertArray(def);
+    case "ZodOptional":
+      return convert(def.innerType);
+    case "ZodNullable": {
+      const inner = convert(def.innerType);
+      return { anyOf: [inner, { type: "null" }] };
+    }
+    case "ZodDefault":
+      return { ...convert(def.innerType), default: def.defaultValue() };
+    case "ZodUnion":
+      return { anyOf: def.options.map((o) => convert(o)) };
+    case "ZodDiscriminatedUnion":
+      return { oneOf: [...def.options.values()].map((o) => convert(o)) };
+    case "ZodRecord":
+      return {
+        type: "object",
+        additionalProperties: convert(def.valueType)
+      };
+    case "ZodTuple": {
+      const items = def.items.map((item) => convert(item));
+      return { type: "array", items: items.length === 1 ? items[0] : void 0, prefixItems: items };
+    }
+    case "ZodEffects":
+      return convert(def.schema);
+    case "ZodPipeline":
+      return convert(def.in);
+    case "ZodLazy":
+      return convert(def.getter());
+    case "ZodAny":
+      return {};
+    case "ZodUnknown":
+      return {};
+    default:
+      return {};
+  }
+}
+function convertString(def) {
+  const schema = { type: "string" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          schema.minLength = check.value;
+          break;
+        case "max":
+          schema.maxLength = check.value;
+          break;
+        case "email":
+          schema.format = "email";
+          break;
+        case "url":
+          schema.format = "uri";
+          break;
+        case "uuid":
+          schema.format = "uuid";
+          break;
+        case "regex":
+          schema.pattern = check.regex.source;
+          break;
+      }
+    }
+  }
+  if (def.description) schema.description = def.description;
+  return schema;
+}
+function convertNumber(def) {
+  const schema = { type: "number" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          schema.minimum = check.value;
+          if (check.inclusive === false) schema.exclusiveMinimum = check.value;
+          break;
+        case "max":
+          schema.maximum = check.value;
+          if (check.inclusive === false) schema.exclusiveMaximum = check.value;
+          break;
+        case "int":
+          schema.type = "integer";
+          break;
+      }
+    }
+  }
+  if (def.description) schema.description = def.description;
+  return schema;
+}
+function convertObject(def) {
+  const shape = def.shape();
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(shape)) {
+    properties[key] = convert(value);
+    const fieldDef = value._def;
+    const isOptional = fieldDef?.typeName === "ZodOptional" || fieldDef?.typeName === "ZodDefault";
+    if (!isOptional) {
+      required.push(key);
+    }
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) schema.required = required;
+  if (def.description) schema.description = def.description;
+  return schema;
+}
+function convertArray(def) {
+  const schema = {
+    type: "array",
+    items: convert(def.type)
+  };
+  if (def.minLength) schema.minItems = def.minLength.value;
+  if (def.maxLength) schema.maxItems = def.maxLength.value;
+  if (def.description) schema.description = def.description;
+  return schema;
+}
+
+// src/openapi/index.ts
+function generateOpenAPISpec(config) {
+  const basePath = config.basePath ?? "/api/tools";
+  const paths = {};
+  const schemas = {};
+  const autoTags = /* @__PURE__ */ new Set();
+  for (const [key, tool] of Object.entries(config.tools)) {
+    const name = tool.name || key;
+    const inputSchemaName = `${name}Input`;
+    const outputSchemaName = `${name}Output`;
+    schemas[inputSchemaName] = zodToJsonSchema(tool.inputSchema);
+    if (tool.outputSchema) {
+      schemas[outputSchemaName] = zodToJsonSchema(tool.outputSchema);
+    }
+    const toolTags = tool.tags.length > 0 ? tool.tags : [name];
+    for (const t of toolTags) autoTags.add(t);
+    const responseSchema = tool.outputSchema ? { $ref: `#/components/schemas/${outputSchemaName}` } : { type: "object" };
+    const hints = [];
+    if (tool.hints.destructive) hints.push("destructive");
+    if (tool.hints.readOnly) hints.push("read-only");
+    if (tool.hints.idempotent) hints.push("idempotent");
+    if (tool.requiresConfirmation) hints.push("requires confirmation");
+    const hintsStr = hints.length > 0 ? ` [${hints.join(", ")}]` : "";
+    paths[`${basePath}/${name}`] = {
+      post: {
+        operationId: name,
+        summary: tool.description || name,
+        description: (tool.description || "") + hintsStr,
+        tags: tool.tags.length > 0 ? tool.tags : void 0,
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: `#/components/schemas/${inputSchemaName}` }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Successful tool execution",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    result: responseSchema
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            description: "Invalid input (Zod validation error)"
+          },
+          "404": {
+            description: "Tool not found"
+          },
+          "500": {
+            description: "Tool execution failed"
+          }
+        }
+      }
+    };
+  }
+  const tags = config.tags ?? [...autoTags].map((t) => ({ name: t }));
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: config.title,
+      version: config.version,
+      ...config.description ? { description: config.description } : {}
+    },
+    servers: [{ url: config.serverUrl ?? "/" }],
+    paths,
+    components: { schemas },
+    ...tags.length > 0 ? { tags } : {}
+  };
+}
+function openAPIHandler(config) {
+  const spec = generateOpenAPISpec(config);
+  const json = JSON.stringify(spec, null, 2);
+  return () => new Response(json, {
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function toolRouter(config) {
+  const basePath = config.basePath ?? "/api/tools";
+  return async (req) => {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    if (req.method === "OPTIONS") {
+      return new Response(null, {
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, Authorization"
+        }
+      });
+    }
+    if (req.method === "GET" && (path === basePath || path === basePath + "/")) {
+      const spec = generateOpenAPISpec({
+        title: "Tool API",
+        version: "1.0.0",
+        tools: config.tools,
+        basePath,
+        serverUrl: url.origin
+      });
+      return new Response(JSON.stringify(spec, null, 2), {
+        headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+      });
+    }
+    if (req.method === "GET" && (path === basePath + "/docs" || path === basePath + "/docs/")) {
+      const html = `<!DOCTYPE html><html><head><meta charset="utf-8"><title>API Docs</title>
+<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+</head><body><div id="swagger-ui"></div>
+<script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+<script>SwaggerUIBundle({url:'${basePath}',dom_id:'#swagger-ui',deepLinking:true});</script>
+</body></html>`;
+      return new Response(html, {
+        headers: { "Content-Type": "text/html", "Access-Control-Allow-Origin": "*" }
+      });
+    }
+    if (req.method === "POST" && path.startsWith(basePath + "/")) {
+      const toolName = path.slice(basePath.length + 1).replace(/\/$/, "");
+      if (!toolName) {
+        return Response.json({ error: "Missing tool name" }, { status: 400 });
+      }
+      if (!Object.prototype.hasOwnProperty.call(config.tools, toolName)) {
+        return Response.json({ error: "Tool not found" }, { status: 404 });
+      }
+      const tool = config.tools[toolName];
+      let input;
+      try {
+        input = await req.json();
+      } catch {
+        return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+      }
+      try {
+        if (config.onBeforeExecute) {
+          await config.onBeforeExecute(toolName, input, req);
+        }
+        const result = await tool.run(input, {
+          isServer: true,
+          headers: req.headers,
+          ...config.context
+        });
+        return Response.json({ result }, {
+          headers: { "Access-Control-Allow-Origin": "*" }
+        });
+      } catch (error) {
+        if (error instanceof Error && error.name === "ZodError") {
+          return Response.json({ error: error.message }, { status: 400 });
+        }
+        return Response.json(
+          { error: error instanceof Error ? error.message : "Tool execution failed" },
+          { status: 500 }
+        );
+      }
+    }
+    return Response.json({ error: "Not found" }, { status: 404 });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateOpenAPISpec,
+  openAPIHandler,
+  toolRouter
+});

package/dist/openapi/index.mjs

@@ -0,0 +1,175 @@
+import {
+  zodToJsonSchema
+} from "../chunk-OH73K7I5.mjs";
+import "../chunk-Y6FXYEAI.mjs";
+
+// src/openapi/index.ts
+function generateOpenAPISpec(config) {
+  const basePath = config.basePath ?? "/api/tools";
+  const paths = {};
+  const schemas = {};
+  const autoTags = /* @__PURE__ */ new Set();
+  for (const [key, tool] of Object.entries(config.tools)) {
+    const name = tool.name || key;
+    const inputSchemaName = `${name}Input`;
+    const outputSchemaName = `${name}Output`;
+    schemas[inputSchemaName] = zodToJsonSchema(tool.inputSchema);
+    if (tool.outputSchema) {
+      schemas[outputSchemaName] = zodToJsonSchema(tool.outputSchema);
+    }
+    const toolTags = tool.tags.length > 0 ? tool.tags : [name];
+    for (const t of toolTags) autoTags.add(t);
+    const responseSchema = tool.outputSchema ? { $ref: `#/components/schemas/${outputSchemaName}` } : { type: "object" };
+    const hints = [];
+    if (tool.hints.destructive) hints.push("destructive");
+    if (tool.hints.readOnly) hints.push("read-only");
+    if (tool.hints.idempotent) hints.push("idempotent");
+    if (tool.requiresConfirmation) hints.push("requires confirmation");
+    const hintsStr = hints.length > 0 ? ` [${hints.join(", ")}]` : "";
+    paths[`${basePath}/${name}`] = {
+      post: {
+        operationId: name,
+        summary: tool.description || name,
+        description: (tool.description || "") + hintsStr,
+        tags: tool.tags.length > 0 ? tool.tags : void 0,
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: `#/components/schemas/${inputSchemaName}` }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Successful tool execution",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    result: responseSchema
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            description: "Invalid input (Zod validation error)"
+          },
+          "404": {
+            description: "Tool not found"
+          },
+          "500": {
+            description: "Tool execution failed"
+          }
+        }
+      }
+    };
+  }
+  const tags = config.tags ?? [...autoTags].map((t) => ({ name: t }));
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: config.title,
+      version: config.version,
+      ...config.description ? { description: config.description } : {}
+    },
+    servers: [{ url: config.serverUrl ?? "/" }],
+    paths,
+    components: { schemas },
+    ...tags.length > 0 ? { tags } : {}
+  };
+}
+function openAPIHandler(config) {
+  const spec = generateOpenAPISpec(config);
+  const json = JSON.stringify(spec, null, 2);
+  return () => new Response(json, {
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function toolRouter(config) {
+  const basePath = config.basePath ?? "/api/tools";
+  return async (req) => {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    if (req.method === "OPTIONS") {
+      return new Response(null, {
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, Authorization"
+        }
+      });
+    }
+    if (req.method === "GET" && (path === basePath || path === basePath + "/")) {
+      const spec = generateOpenAPISpec({
+        title: "Tool API",
+        version: "1.0.0",
+        tools: config.tools,
+        basePath,
+        serverUrl: url.origin
+      });
+      return new Response(JSON.stringify(spec, null, 2), {
+        headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+      });
+    }
+    if (req.method === "GET" && (path === basePath + "/docs" || path === basePath + "/docs/")) {
+      const html = `<!DOCTYPE html><html><head><meta charset="utf-8"><title>API Docs</title>
+<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+</head><body><div id="swagger-ui"></div>
+<script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+<script>SwaggerUIBundle({url:'${basePath}',dom_id:'#swagger-ui',deepLinking:true});</script>
+</body></html>`;
+      return new Response(html, {
+        headers: { "Content-Type": "text/html", "Access-Control-Allow-Origin": "*" }
+      });
+    }
+    if (req.method === "POST" && path.startsWith(basePath + "/")) {
+      const toolName = path.slice(basePath.length + 1).replace(/\/$/, "");
+      if (!toolName) {
+        return Response.json({ error: "Missing tool name" }, { status: 400 });
+      }
+      if (!Object.prototype.hasOwnProperty.call(config.tools, toolName)) {
+        return Response.json({ error: "Tool not found" }, { status: 404 });
+      }
+      const tool = config.tools[toolName];
+      let input;
+      try {
+        input = await req.json();
+      } catch {
+        return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+      }
+      try {
+        if (config.onBeforeExecute) {
+          await config.onBeforeExecute(toolName, input, req);
+        }
+        const result = await tool.run(input, {
+          isServer: true,
+          headers: req.headers,
+          ...config.context
+        });
+        return Response.json({ result }, {
+          headers: { "Access-Control-Allow-Origin": "*" }
+        });
+      } catch (error) {
+        if (error instanceof Error && error.name === "ZodError") {
+          return Response.json({ error: error.message }, { status: 400 });
+        }
+        return Response.json(
+          { error: error instanceof Error ? error.message : "Tool execution failed" },
+          { status: 500 }
+        );
+      }
+    }
+    return Response.json({ error: "Not found" }, { status: 404 });
+  };
+}
+export {
+  generateOpenAPISpec,
+  openAPIHandler,
+  toolRouter
+};

package/dist/schema-DdZf6066.d.mts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+/**
+ * Lightweight Zod-to-JSON-Schema converter.
+ * Handles common Zod types without requiring zod-to-json-schema dependency.
+ */
+
+interface JsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    enum?: unknown[];
+    description?: string;
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    nullable?: boolean;
+    additionalProperties?: boolean | JsonSchema;
+    [key: string]: unknown;
+}
+declare function zodToJsonSchema(schema: z.ZodType | {
+    [key: string]: any;
+}): JsonSchema;
+
+export { type JsonSchema as J, zodToJsonSchema as z };

package/dist/schema-DdZf6066.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+/**
+ * Lightweight Zod-to-JSON-Schema converter.
+ * Handles common Zod types without requiring zod-to-json-schema dependency.
+ */
+
+interface JsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    enum?: unknown[];
+    description?: string;
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    nullable?: boolean;
+    additionalProperties?: boolean | JsonSchema;
+    [key: string]: unknown;
+}
+declare function zodToJsonSchema(schema: z.ZodType | {
+    [key: string]: any;
+}): JsonSchema;
+
+export { type JsonSchema as J, zodToJsonSchema as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lantos1618/better-ui",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "A minimal, type-safe AI-first UI framework for building tools",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -41,6 +41,11 @@
       "import": "./dist/agui/index.mjs",
       "require": "./dist/agui/index.js"
     },
+    "./openapi": {
+      "types": "./dist/openapi/index.d.ts",
+      "import": "./dist/openapi/index.mjs",
+      "require": "./dist/openapi/index.js"
+    },
     "./theme.css": "./src/theme.css"
   },
   "files": [
@@ -69,7 +74,7 @@
   },
   "scripts": {
     "build": "npm run build:lib",
-    "build:lib": "tsup src/index.ts src/react/index.ts src/components/index.ts src/auth/index.ts src/persistence/index.ts src/mcp/index.ts src/agui/index.ts --format cjs,esm --dts --clean --tsconfig tsconfig.lib.json",
+    "build:lib": "tsup src/index.ts src/react/index.ts src/components/index.ts src/auth/index.ts src/persistence/index.ts src/mcp/index.ts src/agui/index.ts src/openapi/index.ts --format cjs,esm --dts --clean --tsconfig tsconfig.lib.json",
     "test": "jest",
     "type-check": "tsc --noEmit",
     "prepublishOnly": "npm run build:lib"