skedyul 0.1.10 → 0.1.12

package/dist/cli/commands/validate.js

@@ -177,7 +177,6 @@ async function validateCommand(args) {
             name: config.name,
             version: config.version,
             computeLayer: config.computeLayer,
-            runtime: config.runtime,
             tools: config.tools,
             workflows: config.workflows,
             globalEnvKeys: envKeys.global,
@@ -200,7 +199,6 @@ async function validateCommand(args) {
     if (verbose) {
         console.log('Configuration:');
         console.log(`  Compute Layer: ${config.computeLayer || 'dedicated (default)'}`);
-        console.log(`  Runtime:       ${config.runtime || 'node-22 (default)'}`);
         console.log(`  Tools:         ${config.tools || './src/registry.ts (default)'}`);
         console.log(`  Workflows:     ${config.workflows || './workflows (default)'}`);
         console.log('');

package/dist/config.d.ts

@@ -36,7 +36,6 @@ export interface InstallConfig {
     appModels?: AppModelDefinition[];
 }
 export type ComputeLayerType = 'serverless' | 'dedicated';
-export type RuntimeType = 'node-22' | 'node-20' | 'node-18';
 export interface SkedyulConfig {
     /** App name */
     name: string;
@@ -46,8 +45,6 @@ export interface SkedyulConfig {
     description?: string;
     /** Compute layer: 'serverless' (Lambda) or 'dedicated' (ECS/Docker) */
     computeLayer?: ComputeLayerType;
-    /** Runtime environment */
-    runtime?: RuntimeType;
     /** Path to the tool registry file (default: './src/registry.ts') */
     tools?: string;
     /** Path to the workflows directory (default: './workflows') */

package/dist/config.js

@@ -172,10 +172,6 @@ function validateConfig(config) {
     if (config.computeLayer && !['serverless', 'dedicated'].includes(config.computeLayer)) {
         errors.push(`Invalid computeLayer: ${config.computeLayer}. Must be 'serverless' or 'dedicated'`);
     }
-    // Validate runtime
-    if (config.runtime && !['node-22', 'node-20', 'node-18'].includes(config.runtime)) {
-        errors.push(`Invalid runtime: ${config.runtime}. Must be 'node-22', 'node-20', or 'node-18'`);
-    }
     // Validate env schema
     if (config.env) {
         for (const [key, def] of Object.entries(config.env)) {

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export * from './types';
 export { server } from './server';
 export { workplace, communicationChannel } from './core/client';
 export { defineConfig, loadConfig, validateConfig, getRequiredInstallEnvKeys, getAllEnvKeys, CONFIG_FILE_NAMES, } from './config';
-export type { SkedyulConfig, EnvVariableDefinition, EnvSchema, EnvVisibility, InstallConfig, AppModelDefinition, ComputeLayerType, RuntimeType, } from './config';
+export type { SkedyulConfig, EnvVariableDefinition, EnvSchema, EnvVisibility, InstallConfig, AppModelDefinition, ComputeLayerType, } from './config';

package/dist/server.js

@@ -338,27 +338,15 @@ function createCallToolHandler(registry, state, onMaxRequests) {
             });
             const billing = normalizeBilling(functionResult.billing);
             return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(functionResult.output),
-                    },
-                ],
+                output: functionResult.output,
                 billing,
             };
         }
         catch (error) {
             return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            error: error instanceof Error ? error.message : String(error ?? ''),
-                        }),
-                    },
-                ],
+                output: null,
                 billing: { credits: 0 },
-                isError: true,
+                error: error instanceof Error ? error.message : String(error ?? ''),
             };
         }
         finally {
@@ -443,21 +431,43 @@ function createSkedyulServer(config, registry) {
         const toolName = tool.name || toolKey;
         const inputZodSchema = getZodSchema(tool.inputs);
         const outputZodSchema = getZodSchema(tool.outputSchema);
+        // Wrap the input schema to accept Skedyul format: { inputs: {...}, env: {...} }
+        // This allows the MCP SDK to pass through the wrapper without stripping fields
+        const wrappedInputSchema = z.object({
+            inputs: inputZodSchema ?? z.record(z.string(), z.unknown()).optional(),
+            env: z.record(z.string(), z.string()).optional(),
+        }).passthrough();
         mcpServer.registerTool(toolName, {
             title: toolName,
             description: tool.description,
-            inputSchema: inputZodSchema,
+            inputSchema: wrappedInputSchema,
             outputSchema: outputZodSchema,
         }, async (args) => {
-            const validatedArgs = inputZodSchema ? inputZodSchema.parse(args) : args;
+            // Args are in Skedyul format: { inputs: {...}, env: {...} }
+            const rawArgs = args;
+            const toolInputs = (rawArgs.inputs ?? {});
+            const toolEnv = rawArgs.env;
+            const validatedInputs = inputZodSchema ? inputZodSchema.parse(toolInputs) : toolInputs;
             const result = await callTool(toolKey, {
-                inputs: validatedArgs,
+                inputs: validatedInputs,
+                env: toolEnv,
             });
+            // Handle error case
+            if (result.error) {
+                const errorOutput = { error: result.error };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errorOutput) }],
+                    structuredContent: errorOutput,
+                    isError: true,
+                    billing: result.billing,
+                };
+            }
+            // Transform internal format to MCP protocol format
+            const outputData = result.output;
             return {
-                content: result.content,
-                structuredContent: result.isError
-                    ? undefined
-                    : JSON.parse(result.content[0]?.text ?? '{}'),
+                content: [{ type: 'text', text: JSON.stringify(result.output) }],
+                structuredContent: outputData ?? undefined,
+                billing: result.billing,
             };
         });
     }
@@ -771,7 +781,13 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
                         }
                         else if (rpcMethod === 'tools/call') {
                             const toolName = params?.name;
-                            const toolArgs = params?.arguments ?? {};
+                            // Support both formats:
+                            // 1. Skedyul format: { inputs: {...}, env: {...} }
+                            // 2. Standard MCP format: { ...directArgs }
+                            const rawArgs = (params?.arguments ?? {});
+                            const hasSkedyulFormat = 'inputs' in rawArgs || 'env' in rawArgs;
+                            const toolInputs = hasSkedyulFormat ? (rawArgs.inputs ?? {}) : rawArgs;
+                            const toolEnv = hasSkedyulFormat ? rawArgs.env : undefined;
                             // Find tool by name (check both registry key and tool.name)
                             let toolKey = null;
                             let tool = null;
@@ -794,12 +810,33 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
                             }
                             try {
                                 const inputSchema = getZodSchema(tool.inputs);
-                                const validatedArgs = inputSchema
-                                    ? inputSchema.parse(toolArgs)
-                                    : toolArgs;
-                                result = await callTool(toolKey, {
-                                    inputs: validatedArgs,
+                                const outputSchema = getZodSchema(tool.outputSchema);
+                                const hasOutputSchema = Boolean(outputSchema);
+                                const validatedInputs = inputSchema
+                                    ? inputSchema.parse(toolInputs)
+                                    : toolInputs;
+                                const toolResult = await callTool(toolKey, {
+                                    inputs: validatedInputs,
+                                    env: toolEnv,
                                 });
+                                // Transform internal format to MCP protocol format
+                                if (toolResult.error) {
+                                    const errorOutput = { error: toolResult.error };
+                                    result = {
+                                        content: [{ type: 'text', text: JSON.stringify(errorOutput) }],
+                                        structuredContent: errorOutput,
+                                        isError: true,
+                                        billing: toolResult.billing,
+                                    };
+                                }
+                                else {
+                                    const outputData = toolResult.output;
+                                    result = {
+                                        content: [{ type: 'text', text: JSON.stringify(toolResult.output) }],
+                                        structuredContent: outputData ?? undefined,
+                                        billing: toolResult.billing,
+                                    };
+                                }
                             }
                             catch (validationError) {
                                 return createResponse(200, {

package/dist/types.d.ts

@@ -97,12 +97,9 @@ export interface APIGatewayProxyResult {
     body: string;
 }
 export interface ToolCallResponse {
-    content: {
-        type: 'text';
-        text: string;
-    }[];
-    billing?: BillingInfo;
-    isError?: boolean;
+    output: unknown;
+    billing: BillingInfo;
+    error?: string;
 }
 export interface DedicatedServerInstance {
     listen(port?: number): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skedyul",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",