skedyul 0.1.6 → 0.1.8

package/dist/server.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,7 +41,8 @@ exports.createSkedyulServer = createSkedyulServer;
 const http_1 = __importDefault(require("http"));
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const z = __importStar(require("zod"));
+const zod_json_schema_compat_js_1 = require("@modelcontextprotocol/sdk/server/zod-json-schema-compat.js");
 const service_1 = require("./core/service");
 function normalizeBilling(billing) {
     if (!billing || typeof billing.credits !== 'number') {
@@ -16,34 +50,45 @@ function normalizeBilling(billing) {
     }
     return billing;
 }
-// Loosely-typed wrapper around zod-to-json-schema to avoid version/type
-// mismatches between the zod dependency used here and the one used by the
-// library. At runtime the schemas are compatible.
-const zodToJsonSchemaLoose = zod_to_json_schema_1.zodToJsonSchema;
-let schemaIdCounter = 0;
 function toJsonSchema(schema) {
     if (!schema)
         return undefined;
     try {
-        const schemaName = `ToolSchema${schemaIdCounter++}`;
-        const json = zodToJsonSchemaLoose(schema, schemaName);
-        if (typeof json === 'object' &&
-            json !== null &&
-            '$ref' in json &&
-            typeof json.$ref === 'string' &&
-            json.$ref.startsWith('#/definitions/')) {
-            const defName = json.$ref.split('/').pop();
-            const definitions = json.definitions;
-            if (defName && definitions && definitions[defName]) {
-                return definitions[defName];
-            }
-        }
-        return json;
+        return (0, zod_json_schema_compat_js_1.toJsonSchemaCompat)(schema, {
+            target: 'jsonSchema7',
+            pipeStrategy: 'input',
+        });
     }
     catch {
         return undefined;
     }
 }
+function isToolSchemaWithJson(schema) {
+    return Boolean(schema &&
+        typeof schema === 'object' &&
+        'zod' in schema &&
+        schema.zod instanceof z.ZodType);
+}
+function getZodSchema(schema) {
+    if (!schema)
+        return undefined;
+    if (schema instanceof z.ZodType) {
+        return schema;
+    }
+    if (isToolSchemaWithJson(schema)) {
+        return schema.zod;
+    }
+    return undefined;
+}
+function getJsonSchemaFromToolSchema(schema) {
+    if (!schema)
+        return undefined;
+    if (isToolSchemaWithJson(schema) && schema.jsonSchema) {
+        return schema.jsonSchema;
+    }
+    const zodSchema = getZodSchema(schema);
+    return toJsonSchema(zodSchema);
+}
 function parseJsonRecord(value) {
     if (!value) {
         return {};
@@ -213,8 +258,8 @@ function buildToolMetadata(registry) {
     return Object.values(registry).map((tool) => ({
         name: tool.name,
         description: tool.description,
-        inputSchema: toJsonSchema(tool.inputs),
-        outputSchema: toJsonSchema(tool.outputSchema),
+        inputSchema: getJsonSchemaFromToolSchema(tool.inputs),
+        outputSchema: getJsonSchemaFromToolSchema(tool.outputSchema),
     }));
 }
 function createRequestState(maxRequests, ttlExtendSeconds, runtimeLabel, toolNames) {
@@ -378,17 +423,17 @@ function createSkedyulServer(config, registry) {
     for (const [toolKey, tool] of Object.entries(registry)) {
         // Use the tool's name or fall back to the registry key
         const toolName = tool.name || toolKey;
+        const inputZodSchema = getZodSchema(tool.inputs);
+        const outputZodSchema = getZodSchema(tool.outputSchema);
         mcpServer.registerTool(toolName, {
             title: toolName,
             description: tool.description,
-            // The MCP SDK expects Zod schemas here; it will handle JSON Schema
-            // conversion for tools/list responses.
-            inputSchema: tool.inputs,
-            outputSchema: tool.outputSchema,
+            inputSchema: inputZodSchema,
+            outputSchema: outputZodSchema,
         }, async (args) => {
-            // Args will be the parsed Zod schema values directly
+            const validatedArgs = inputZodSchema ? inputZodSchema.parse(args) : args;
             const result = await callTool(toolKey, {
-                inputs: args,
+                inputs: validatedArgs,
             });
             return {
                 content: result.content,
@@ -652,8 +697,9 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
                                 },
                             }, headers);
                         }
+                        const inputSchema = getZodSchema(tool.inputs);
                         // Validate arguments against Zod schema
-                        const validatedArgs = tool.inputs.parse(toolArgs);
+                        const validatedArgs = inputSchema ? inputSchema.parse(toolArgs) : toolArgs;
                         const estimateResponse = await callTool(toolKey, {
                             inputs: validatedArgs,
                             estimate: true,
@@ -728,9 +774,11 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
                                     },
                                 }, headers);
                             }
-                            // Validate arguments against Zod schema
                             try {
-                                const validatedArgs = tool.inputs.parse(toolArgs);
+                                const inputSchema = getZodSchema(tool.inputs);
+                                const validatedArgs = inputSchema
+                                    ? inputSchema.parse(toolArgs)
+                                    : toolArgs;
                                 result = await callTool(toolKey, {
                                     inputs: validatedArgs,
                                 });

package/dist/types.d.ts

@@ -15,21 +15,26 @@ export interface ToolExecutionResult<Output = unknown> {
     output: Output;
     billing: BillingInfo;
 }
+export interface ToolSchemaWithJson<Schema extends z.ZodTypeAny = z.ZodTypeAny> {
+    zod: Schema;
+    jsonSchema?: Record<string, unknown>;
+}
+export type ToolSchema<Schema extends z.ZodTypeAny = z.ZodTypeAny> = Schema | ToolSchemaWithJson<Schema>;
 export type ToolHandler<Input, Output> = (params: ToolParams<Input, Output>) => Promise<ToolExecutionResult<Output>> | ToolExecutionResult<Output>;
 export interface ToolDefinition<Input = unknown, Output = unknown, InputSchema extends z.ZodTypeAny = z.ZodType<Input>, OutputSchema extends z.ZodTypeAny = z.ZodType<Output>> {
     name: string;
     description: string;
-    inputs: InputSchema;
+    inputs: ToolSchema<InputSchema>;
     handler: ToolHandler<Input, Output>;
-    outputSchema?: OutputSchema;
+    outputSchema?: ToolSchema<OutputSchema>;
     [key: string]: unknown;
 }
 export interface ToolRegistryEntry {
     name: string;
     description: string;
-    inputs: z.ZodTypeAny;
+    inputs: ToolSchema;
     handler: unknown;
-    outputSchema?: z.ZodTypeAny;
+    outputSchema?: ToolSchema;
     [key: string]: unknown;
 }
 export type ToolRegistry = Record<string, ToolRegistryEntry>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skedyul",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,7 +23,7 @@
   "author": "Skedyul <support@skedyul.com>",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.23.0",
     "zod": "^4.0.0",
     "zod-to-json-schema": "^3.23.0"
   },