skedyul 0.1.0 → 0.1.1

package/dist/server.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.server = void 0;
 exports.createSkedyulServer = createSkedyulServer;
 const http_1 = __importDefault(require("http"));
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 const service_1 = require("./core/service");
 function normalizeBilling(billing) {
     if (!billing || typeof billing.credits !== 'number') {
@@ -181,9 +181,9 @@ async function handleCoreMethod(method, params) {
     };
 }
 function buildToolMetadata(registry) {
-    return Object.keys(registry).map((name) => ({
-        name,
-        description: `Function: ${name}`,
+    return Object.values(registry).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
         inputSchema: {
             type: 'object',
             properties: {
@@ -224,13 +224,14 @@ function createRequestState(maxRequests, ttlExtendSeconds, runtimeLabel, toolNam
 function createCallToolHandler(registry, state, onMaxRequests) {
     return async function callTool(nameRaw, argsRaw) {
         const toolName = String(nameRaw);
-        const fn = registry[toolName];
-        if (!fn) {
+        const tool = registry[toolName];
+        if (!tool) {
             throw new Error(`Tool "${toolName}" not found in registry`);
         }
-        if (typeof fn !== 'function') {
-            throw new Error(`Registry entry "${toolName}" is not a function`);
+        if (!tool.handler || typeof tool.handler !== 'function') {
+            throw new Error(`Tool "${toolName}" handler is not a function`);
         }
+        const fn = tool.handler;
         const args = (argsRaw ?? {});
         const estimateMode = args.estimate === true;
         if (!estimateMode) {
@@ -333,7 +334,7 @@ function createSkedyulServer(config, registry) {
         }
     }
     const tools = buildToolMetadata(registry);
-    const toolNames = tools.map((tool) => tool.name);
+    const toolNames = Object.values(registry).map((tool) => tool.name);
     const runtimeLabel = config.computeLayer;
     const maxRequests = config.maxRequests ??
         parseNumberEnv(process.env.MCP_MAX_REQUESTS) ??
@@ -342,13 +343,9 @@ function createSkedyulServer(config, registry) {
         parseNumberEnv(process.env.MCP_TTL_EXTEND) ??
         3600;
     const state = createRequestState(maxRequests, ttlExtendSeconds, runtimeLabel, toolNames);
-    const server = new index_js_1.Server({
+    const mcpServer = new mcp_js_1.McpServer({
         name: config.metadata.name,
         version: config.metadata.version,
-    }, {
-        capabilities: {
-            tools: {},
-        },
     });
     const dedicatedShutdown = () => {
         // eslint-disable-next-line no-console
@@ -356,16 +353,34 @@ function createSkedyulServer(config, registry) {
         setTimeout(() => process.exit(0), 1000);
     };
     const callTool = createCallToolHandler(registry, state, config.computeLayer === 'dedicated' ? dedicatedShutdown : undefined);
-    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-        tools,
-    }));
-    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => callTool(request.params.name, request.params.arguments));
+    // Register all tools from the 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;
+        mcpServer.registerTool(toolName, {
+            title: toolName,
+            description: tool.description,
+            inputSchema: tool.inputs,
+            outputSchema: tool.outputSchema,
+        }, async (args) => {
+            // Args will be the parsed Zod schema values directly
+            const result = await callTool(toolKey, {
+                inputs: args,
+            });
+            return {
+                content: result.content,
+                structuredContent: result.isError
+                    ? undefined
+                    : JSON.parse(result.content[0]?.text ?? '{}'),
+            };
+        });
+    }
     if (config.computeLayer === 'dedicated') {
-        return createDedicatedServerInstance(config, tools, callTool, state);
+        return createDedicatedServerInstance(config, tools, callTool, state, mcpServer);
     }
-    return createServerlessInstance(config, tools, callTool, state);
+    return createServerlessInstance(config, tools, callTool, state, mcpServer, registry);
 }
-function createDedicatedServerInstance(config, tools, callTool, state) {
+function createDedicatedServerInstance(config, tools, callTool, state, mcpServer) {
     const port = getListeningPort(config);
     const httpServer = http_1.default.createServer(async (req, res) => {
         function sendCoreResult(result) {
@@ -465,62 +480,22 @@ function createDedicatedServerInstance(config, tools, callTool, state) {
                 return;
             }
             if (pathname === '/mcp' && req.method === 'POST') {
-                let body;
-                try {
-                    body = (await parseJSONBody(req));
-                }
-                catch {
-                    sendJSON(res, 400, {
-                        jsonrpc: '2.0',
-                        id: null,
-                        error: {
-                            code: -32700,
-                            message: 'Parse error',
-                        },
-                    });
-                    return;
-                }
+                const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                    sessionIdGenerator: undefined,
+                    enableJsonResponse: true,
+                });
+                res.on('close', () => {
+                    transport.close();
+                });
                 try {
-                    const { jsonrpc, id, method, params } = body;
-                    if (jsonrpc !== '2.0') {
-                        sendJSON(res, 400, {
-                            jsonrpc: '2.0',
-                            id,
-                            error: {
-                                code: -32600,
-                                message: 'Invalid Request',
-                            },
-                        });
-                        return;
-                    }
-                    let result;
-                    if (method === 'tools/list') {
-                        result = { tools };
-                    }
-                    else if (method === 'tools/call') {
-                        result = await callTool(params?.name, params?.arguments);
-                    }
-                    else {
-                        sendJSON(res, 200, {
-                            jsonrpc: '2.0',
-                            id,
-                            error: {
-                                code: -32601,
-                                message: `Method not found: ${method}`,
-                            },
-                        });
-                        return;
-                    }
-                    sendJSON(res, 200, {
-                        jsonrpc: '2.0',
-                        id,
-                        result,
-                    });
+                    const body = await parseJSONBody(req);
+                    await mcpServer.connect(transport);
+                    await transport.handleRequest(req, res, body);
                 }
                 catch (err) {
                     sendJSON(res, 500, {
                         jsonrpc: '2.0',
-                        id: body?.id ?? null,
+                        id: null,
                         error: {
                             code: -32603,
                             message: err instanceof Error ? err.message : String(err ?? ''),
@@ -568,7 +543,7 @@ function createDedicatedServerInstance(config, tools, callTool, state) {
         getHealthStatus: () => state.getHealthStatus(),
     };
 }
-function createServerlessInstance(config, tools, callTool, state) {
+function createServerlessInstance(config, tools, callTool, state, mcpServer, registry) {
     const headers = getDefaultHeaders(config.cors);
     return {
         async handler(event) {
@@ -634,8 +609,30 @@ function createServerlessInstance(config, tools, callTool, state) {
                         }, headers);
                     }
                     try {
-                        const estimateResponse = await callTool(estimateBody.name, {
-                            inputs: estimateBody.inputs,
+                        const toolName = estimateBody.name;
+                        const toolArgs = estimateBody.inputs ?? {};
+                        // Find tool by name
+                        let toolKey = null;
+                        let tool = null;
+                        for (const [key, t] of Object.entries(registry)) {
+                            if (t.name === toolName || key === toolName) {
+                                toolKey = key;
+                                tool = t;
+                                break;
+                            }
+                        }
+                        if (!tool || !toolKey) {
+                            return createResponse(400, {
+                                error: {
+                                    code: -32602,
+                                    message: `Tool "${toolName}" not found`,
+                                },
+                            }, headers);
+                        }
+                        // Validate arguments against Zod schema
+                        const validatedArgs = tool.inputs.parse(toolArgs);
+                        const estimateResponse = await callTool(toolKey, {
+                            inputs: validatedArgs,
                             estimate: true,
                         });
                         return createResponse(200, {
@@ -686,7 +683,47 @@ function createServerlessInstance(config, tools, callTool, state) {
                             result = { tools };
                         }
                         else if (rpcMethod === 'tools/call') {
-                            result = await callTool(params?.name, params?.arguments);
+                            const toolName = params?.name;
+                            const toolArgs = params?.arguments ?? {};
+                            // Find tool by name (check both registry key and tool.name)
+                            let toolKey = null;
+                            let tool = null;
+                            for (const [key, t] of Object.entries(registry)) {
+                                if (t.name === toolName || key === toolName) {
+                                    toolKey = key;
+                                    tool = t;
+                                    break;
+                                }
+                            }
+                            if (!tool || !toolKey) {
+                                return createResponse(200, {
+                                    jsonrpc: '2.0',
+                                    id,
+                                    error: {
+                                        code: -32602,
+                                        message: `Tool "${toolName}" not found`,
+                                    },
+                                }, headers);
+                            }
+                            // Validate arguments against Zod schema
+                            try {
+                                const validatedArgs = tool.inputs.parse(toolArgs);
+                                result = await callTool(toolKey, {
+                                    inputs: validatedArgs,
+                                });
+                            }
+                            catch (validationError) {
+                                return createResponse(200, {
+                                    jsonrpc: '2.0',
+                                    id,
+                                    error: {
+                                        code: -32602,
+                                        message: validationError instanceof Error
+                                            ? validationError.message
+                                            : 'Invalid arguments',
+                                    },
+                                }, headers);
+                            }
                         }
                         else {
                             return createResponse(200, {

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { CoreApiConfig } from './core/types';
+import type { z } from 'zod';
 export interface ToolContext {
     env: Record<string, string | undefined>;
     mode?: 'execute' | 'estimate';
@@ -15,7 +16,15 @@ export interface ToolExecutionResult<Output = unknown> {
     billing: BillingInfo;
 }
 export type ToolHandler<Input, Output> = (params: ToolParams<Input, Output>) => Promise<ToolExecutionResult<Output>> | ToolExecutionResult<Output>;
-export type ToolRegistry = Record<string, ToolHandler<unknown, unknown>>;
+export interface ToolDefinition<Input = unknown, Output = unknown, InputSchema extends z.ZodType<Input> = z.ZodType<Input>, OutputSchema extends z.ZodType<Output> = z.ZodType<Output>> {
+    name: string;
+    description: string;
+    inputs: InputSchema;
+    handler: ToolHandler<Input, Output>;
+    outputSchema?: OutputSchema;
+    [key: string]: unknown;
+}
+export type ToolRegistry = Record<string, ToolDefinition<unknown, unknown>>;
 export type ToolName<T extends ToolRegistry> = Extract<keyof T, string>;
 export interface ToolMetadata {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skedyul",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,7 +23,8 @@
   "author": "Skedyul <support@skedyul.com>",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",