@toolsdk.ai/registry 1.0.97 → 1.0.99

package/dist/schema.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from '@hono/zod-openapi';
 export const PackageKeySchema = z.string();
 export const HostingBlackListSchema = z.array(PackageKeySchema);
 export const FeaturedListSchema = z.array(PackageKeySchema);
@@ -17,9 +17,18 @@ export const MCPServerPackageConfigSchema = z.object({
     type: z.literal('mcp-server'),
     runtime: z.enum(['node', 'python', 'java', 'go']),
     packageName: z.string().describe('Name of the node, python, java package '),
-    packageVersion: z.string().optional().describe('Version of the package, if not provided then it will use latest version'),
-    bin: z.string().optional().describe('Binary Command to run the MCP server, if not provided then it will use the package name'),
-    binArgs: z.array(z.string()).optional().describe('Binary Arguments to pass to the command, if not provided then it will use an empty array'),
+    packageVersion: z
+        .string()
+        .optional()
+        .describe('Version of the package, if not provided then it will use latest version'),
+    bin: z
+        .string()
+        .optional()
+        .describe('Binary Command to run the MCP server, if not provided then it will use the package name'),
+    binArgs: z
+        .array(z.string())
+        .optional()
+        .describe('Binary Arguments to pass to the command, if not provided then it will use an empty array'),
     // if no custom key then would use name
     key: z.string().optional().describe('Unique key for url and slug'),
     name: z.string().optional().describe('Custom name for display, if empty then it will use the package name'),
@@ -27,8 +36,11 @@ export const MCPServerPackageConfigSchema = z.object({
     readme: z.string().optional().describe('URL to the README file, if not provided then it will use the package URL'),
     url: z.string().optional(),
     license: z.string().optional().describe('Open source license lie MIT, AGPL, GPL, etc'),
-    logo: z.string().optional().describe('URL to custom logo image, if undefined and the URL is Github, then it will use the Github logo'),
-    author: z.string().optional().describe('Author name of the ToolSDK.ai\'s developer ID'),
+    logo: z
+        .string()
+        .optional()
+        .describe('URL to custom logo image, if undefined and the URL is Github, then it will use the Github logo'),
+    author: z.string().optional().describe("Author name of the ToolSDK.ai's developer ID"),
     env: z
         .record(z.object({
         description: z.string(),
@@ -48,8 +60,70 @@ export const PackagesListSchema = z.record(z.object({
     category: z.string().optional(),
     path: z.string(),
     validated: z.boolean().optional(),
-    tools: z.record(z.object({
+    tools: z
+        .record(z.object({
         name: z.string().optional(),
         description: z.string().optional(),
-    })).optional(),
+    }))
+        .optional(),
 }));
+export const BaseResponseSchema = z.object({
+    success: z.boolean(),
+    code: z.number(),
+    message: z.string(),
+});
+export const ErrorResponseSchema = BaseResponseSchema.omit({ success: true }).extend({
+    success: z.literal(false),
+});
+export const FeaturedResponseSchema = BaseResponseSchema.extend({
+    data: z.array(z.string()).optional(),
+});
+export const CategoriesResponseSchema = BaseResponseSchema.extend({
+    data: z.array(CategoryConfigSchema).optional(),
+});
+export const PackagesListResponseSchema = BaseResponseSchema.extend({
+    data: PackagesListSchema.optional(),
+});
+export const PackageDetailDataSchema = MCPServerPackageConfigSchema.extend({
+    tools: z
+        .array(z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        inputSchema: z
+            .object({
+            type: z.string(),
+            properties: z.record(z.unknown()).optional(),
+            required: z.array(z.string()).optional(),
+        })
+            .optional(),
+    }))
+        .optional(),
+});
+export const PackageDetailResponseSchema = BaseResponseSchema.extend({
+    data: PackageDetailDataSchema.optional(),
+});
+export const ToolDataSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    inputSchema: z
+        .object({
+        type: z.string(),
+        properties: z.record(z.unknown()).optional(),
+        required: z.array(z.string()).optional(),
+    })
+        .optional(),
+});
+export const ToolsResponseSchema = BaseResponseSchema.extend({
+    data: z.array(ToolDataSchema).optional(),
+});
+export const ExecuteToolResponseSchema = BaseResponseSchema.extend({
+    data: z.unknown().optional(),
+});
+export const createSuccessResponseSchema = (dataSchema) => {
+    return BaseResponseSchema.extend({
+        data: dataSchema.optional(),
+    });
+};
+export const packageNameQuerySchema = z.object({
+    packageName: z.string().optional(),
+});

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { CategoryConfigSchema, PackageConfigSchema, MCPServerPackageConfigSchema, PackagesListSchema, ToolExecuteSchema } from './schema';
+import type { CategoryConfigSchema, PackageConfigSchema, MCPServerPackageConfigSchema, PackagesListSchema, ToolExecuteSchema, BaseResponseSchema, FeaturedResponseSchema, CategoriesResponseSchema, PackagesListResponseSchema, PackageDetailDataSchema, PackageDetailResponseSchema, ToolDataSchema, ToolsResponseSchema, ExecuteToolResponseSchema, ErrorResponseSchema } from './schema';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 export type MCPServerPackageConfig = z.infer<typeof MCPServerPackageConfigSchema>;
 export type PackageConfig = z.infer<typeof PackageConfigSchema>;
@@ -15,3 +15,13 @@ export interface Response<T> {
 export type MCPServerPackageConfigWithTools = MCPServerPackageConfig & {
     tools?: Tool[];
 };
+export type BaseResponse = z.infer<typeof BaseResponseSchema>;
+export type FeaturedResponse = z.infer<typeof FeaturedResponseSchema>;
+export type CategoriesResponse = z.infer<typeof CategoriesResponseSchema>;
+export type PackagesListResponse = z.infer<typeof PackagesListResponseSchema>;
+export type PackageDetailData = z.infer<typeof PackageDetailDataSchema>;
+export type PackageDetailResponse = z.infer<typeof PackageDetailResponseSchema>;
+export type ToolData = z.infer<typeof ToolDataSchema>;
+export type ToolsResponse = z.infer<typeof ToolsResponseSchema>;
+export type ExecuteToolResponse = z.infer<typeof ExecuteToolResponseSchema>;
+export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;

package/dist/utils.d.ts

@@ -0,0 +1,21 @@
+import { z } from '@hono/zod-openapi';
+import type { Response } from './types';
+export declare const createResponse: <T>(data: T, options?: {
+    success?: boolean;
+    code?: number;
+    message?: string;
+}) => Response<T>;
+export declare const createErrorResponse: (message: string, code?: number) => {
+    success: boolean;
+    code: number;
+    message: string;
+};
+export declare const createRouteResponses: <T extends z.ZodTypeAny>(successSchema: T, options?: {
+    successDescription?: string;
+    includeErrorResponses?: boolean;
+}) => Record<number, {
+    content: Record<string, {
+        schema: z.ZodTypeAny;
+    }>;
+    description: string;
+}>;

package/dist/utils.js

@@ -0,0 +1,57 @@
+import { ErrorResponseSchema } from './schema';
+export const createResponse = (data, options) => {
+    const { success = true, code = 200, message = 'Success' } = options || {};
+    return {
+        success,
+        code,
+        message,
+        data,
+    };
+};
+export const createErrorResponse = (message, code = 400) => {
+    return {
+        success: false,
+        code,
+        message,
+    };
+};
+export const createRouteResponses = (successSchema, options) => {
+    const { successDescription = 'Success', includeErrorResponses = false } = options || {};
+    const responses = {
+        200: {
+            content: {
+                'application/json': {
+                    schema: successSchema,
+                },
+            },
+            description: successDescription,
+        },
+    };
+    if (includeErrorResponses) {
+        responses[400] = {
+            content: {
+                'application/json': {
+                    schema: ErrorResponseSchema,
+                },
+            },
+            description: 'Bad Request',
+        };
+        responses[404] = {
+            content: {
+                'application/json': {
+                    schema: ErrorResponseSchema,
+                },
+            },
+            description: 'Not Found',
+        };
+        responses[500] = {
+            content: {
+                'application/json': {
+                    schema: ErrorResponseSchema,
+                },
+            },
+            description: 'Internal Server Error',
+        };
+    }
+    return responses;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolsdk.ai/registry",
-  "version": "1.0.97",
+  "version": "1.0.99",
   "description": "An Open, Structured, and Standard Registry for MCP Servers and Packages.",
   "exports": {
     "./config/*": "./config/*",
@@ -30,8 +30,10 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "@hono/node-server": "1.15.0",
+    "@hono/swagger-ui": "^0.5.2",
+    "@hono/zod-openapi": "^0.16.4",
     "lodash": "^4.17.21",
-    "zod": "^3.23.30",
+    "zod": "^3.25.67",
     "axios": "^1.9.0",
     "hono": "4.8.3",
     "semver": "^7.5.4",