skedyul 1.2.44 → 1.2.48

package/dist/server.js

@@ -149,10 +149,24 @@ function parseNumberEnv(value) {
   const parsed = Number.parseInt(value, 10);
   return Number.isNaN(parsed) ? null : parsed;
 }
+function getBakedExecutableEnv() {
+  return {
+    ...parseJsonRecord(process.env.MCP_ENV_JSON),
+    ...parseJsonRecord(process.env.MCP_ENV)
+  };
+}
+function buildToolExecutionEnv(requestEnv = {}) {
+  const bakedEnv = getBakedExecutableEnv();
+  const merged = { ...bakedEnv };
+  for (const [key, value] of Object.entries(requestEnv)) {
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
 function mergeRuntimeEnv() {
-  const bakedEnv = parseJsonRecord(process.env.MCP_ENV_JSON);
-  const runtimeEnv = parseJsonRecord(process.env.MCP_ENV);
-  const merged = { ...bakedEnv, ...runtimeEnv };
+  const merged = getBakedExecutableEnv();
   Object.assign(process.env, merged);
 }
 
@@ -197,6 +211,48 @@ function getListeningPort(config) {
   return config.defaultPort ?? 3e3;
 }
 
+// src/server/utils/mcp-response.ts
+function serializeMcpContentText(value) {
+  return JSON.stringify(value ?? null);
+}
+function isToolCallFailure(result) {
+  const isNewShapeFailure = "success" in result && result.success === false;
+  const isLegacyErrorFailure = "error" in result && result.error != null;
+  const isLegacyMetaFailure = "meta" in result && result.meta != null && typeof result.meta === "object" && "success" in result.meta && result.meta.success === false;
+  return isNewShapeFailure || isLegacyErrorFailure || isLegacyMetaFailure;
+}
+function buildToolCallErrorOutput(result) {
+  const isNewShapeFailure = "success" in result && result.success === false;
+  const isLegacyErrorFailure = "error" in result && result.error != null;
+  const isLegacyMetaFailure = "meta" in result && result.meta != null && typeof result.meta === "object" && "success" in result.meta && result.meta.success === false;
+  if (isNewShapeFailure && "error" in result) {
+    return {
+      error: result.error,
+      retry: "retry" in result ? result.retry : void 0
+    };
+  }
+  if (isLegacyErrorFailure && "error" in result) {
+    return { error: result.error };
+  }
+  if (isLegacyMetaFailure && "meta" in result && result.meta) {
+    const meta = result.meta;
+    return {
+      error: {
+        code: "TOOL_FAILED",
+        message: meta.message ?? "Tool execution failed",
+        category: "internal"
+      }
+    };
+  }
+  return {
+    error: {
+      code: "TOOL_FAILED",
+      message: "Tool execution failed",
+      category: "internal"
+    }
+  };
+}
+
 // src/core/client.ts
 var import_async_hooks = require("async_hooks");
 var import_v4 = require("zod/v4");
@@ -320,14 +376,19 @@ function createContextLogger() {
 function buildToolMetadata(registry) {
   return Object.values(registry).map((tool) => {
     const toolConfig = tool.config ?? {};
-    const timeout = typeof toolConfig.timeout === "number" && toolConfig.timeout > 0 ? toolConfig.timeout : 1e4;
-    const retries = typeof toolConfig.retries === "number" && toolConfig.retries >= 1 ? toolConfig.retries : 1;
+    const rawTimeout = tool.timeout ?? toolConfig.timeout;
+    const rawRetries = tool.retries ?? toolConfig.retries;
+    const timeout = typeof rawTimeout === "number" && rawTimeout > 0 ? rawTimeout : 1e4;
+    const retries = typeof rawRetries === "number" && rawRetries >= 1 ? rawRetries : 1;
     return {
       name: tool.name,
       displayName: tool.label || tool.name,
       description: tool.description,
       inputSchema: getJsonSchemaFromToolSchema(tool.inputSchema),
       outputSchema: getJsonSchemaFromToolSchema(tool.outputSchema),
+      // Include timeout/retries at top-level for tools/list response (used by syncExecutableTools)
+      timeout,
+      retries,
       config: {
         timeout,
         retries,
@@ -381,8 +442,9 @@ function createCallToolHandler(registry, state, onMaxRequests) {
       }
     }
     const requestEnv = args.env ?? {};
+    const toolEnv = buildToolExecutionEnv(requestEnv);
     const originalEnv = { ...process.env };
-    Object.assign(process.env, requestEnv);
+    Object.assign(process.env, toolEnv);
     const invocation = args.invocation;
     try {
       const inputs = args.inputs ?? {};
@@ -395,7 +457,16 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         executionContext = {
           trigger: "provision",
           app,
-          env: process.env,
+          env: toolEnv,
+          mode: estimateMode ? "estimate" : "execute",
+          invocation,
+          log
+        };
+      } else if (trigger === "developer_page_action" || trigger === "developer_form_submit") {
+        executionContext = {
+          trigger,
+          app,
+          env: toolEnv,
           mode: estimateMode ? "estimate" : "execute",
           invocation,
           log
@@ -404,7 +475,7 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         const workplace = rawContext.workplace;
         const request = rawContext.request;
         const appInstallationId = rawContext.appInstallationId;
-        const envVars = process.env;
+        const envVars = toolEnv;
         const modeValue = estimateMode ? "estimate" : "execute";
         if (trigger === "field_change") {
           const field = rawContext.field;
@@ -424,8 +495,8 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         }
       }
       const requestConfig = {
-        baseUrl: requestEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
-        apiToken: requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+        baseUrl: toolEnv.SKEDYUL_API_URL ?? "",
+        apiToken: toolEnv.SKEDYUL_API_TOKEN ?? ""
       };
       const functionResult = await runWithConfig(requestConfig, async () => {
         return await runWithLogContext({ invocation }, async () => {
@@ -433,7 +504,17 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         });
       });
       const billing = normalizeBilling(functionResult.billing);
+      if ("success" in functionResult && functionResult.success === false) {
+        return {
+          success: false,
+          output: null,
+          billing,
+          error: "error" in functionResult ? functionResult.error : void 0,
+          effect: "effect" in functionResult ? functionResult.effect : void 0
+        };
+      }
       return {
+        success: true,
         output: functionResult.output,
         billing,
         meta: functionResult.meta ?? {
@@ -442,7 +523,8 @@ function createCallToolHandler(registry, state, onMaxRequests) {
           toolName
         },
         effect: functionResult.effect,
-        dataBlocks: functionResult.dataBlocks
+        dataBlocks: functionResult.dataBlocks,
+        cursor: functionResult.cursor
       };
     } catch (error) {
       if (error instanceof AppAuthInvalidError) {
@@ -805,8 +887,9 @@ function serializeConfig(config) {
     tools: registry ? Object.entries(registry).map(([key, tool]) => ({
       name: tool.name || key,
       description: tool.description,
-      timeout: tool.config?.timeout,
-      retries: tool.config?.retries
+      // Read timeout/retries from top-level first, then fallback to config
+      timeout: tool.timeout ?? tool.config?.timeout,
+      retries: tool.retries ?? tool.config?.retries
     })) : [],
     webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
       name: w.name,
@@ -1225,6 +1308,34 @@ function isMethodAllowed(webhookRegistry, handle, method) {
 function getConfigFilePath() {
   return process.env.LAMBDA_TASK_ROOT ? path.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
 }
+function findToolInRegistry(registry, toolName) {
+  for (const [key, t] of Object.entries(registry)) {
+    if (t.name === toolName || key === toolName) {
+      return { toolKey: key, tool: t };
+    }
+  }
+  const inputParts = toolName.split(":");
+  const inputShortName = inputParts[inputParts.length - 1];
+  if (inputParts.length > 1) {
+    for (const [key, t] of Object.entries(registry)) {
+      if (t.name === inputShortName || key === inputShortName) {
+        return { toolKey: key, tool: t };
+      }
+    }
+  }
+  const matches = [];
+  for (const [key, t] of Object.entries(registry)) {
+    const registryParts = t.name.split(":");
+    const registryShortName = registryParts[registryParts.length - 1];
+    if (registryShortName === toolName) {
+      matches.push({ toolKey: key, tool: t });
+    }
+  }
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  return null;
+}
 function handleHealthRoute(ctx) {
   return {
     status: 200,
@@ -1234,34 +1345,14 @@ function handleHealthRoute(ctx) {
 function handleConfigRoute(ctx) {
   const configFilePath = getConfigFilePath();
   try {
-    console.log(`[/config] Checking for config file at: ${configFilePath}`);
     if (fs.existsSync(configFilePath)) {
       const fileConfig = JSON.parse(fs.readFileSync(configFilePath, "utf-8"));
-      console.log(
-        `[/config] Loaded config from file: tools=${fileConfig.tools?.length ?? 0}, webhooks=${fileConfig.webhooks?.length ?? 0}`
-      );
-      console.log(
-        `[/config] SENDING config with keys: ${Object.keys(fileConfig).join(", ")}`
-      );
-      console.log(
-        `[/config] SENDING full config: ${JSON.stringify(fileConfig).substring(0, 2e3)}...`
-      );
       return { status: 200, body: fileConfig };
     }
-    console.log("[/config] Config file not found, falling back to runtime serialization");
   } catch (err) {
     console.warn("[/config] Failed to read config file, falling back to runtime serialization:", err);
   }
   const serialized = serializeConfig(ctx.config);
-  console.log(
-    `[/config] Runtime serialization: tools=${serialized.tools?.length ?? 0}, webhooks=${serialized.webhooks?.length ?? 0}`
-  );
-  console.log(
-    `[/config] SENDING serialized config with keys: ${Object.keys(serialized).join(", ")}`
-  );
-  console.log(
-    `[/config] SENDING full serialized config: ${JSON.stringify(serialized).substring(0, 2e3)}...`
-  );
   return { status: 200, body: serialized };
 }
 async function handleCoreRoute(req, ctx) {
@@ -1316,16 +1407,8 @@ async function handleEstimateRoute(req, ctx) {
   try {
     const toolName = estimateBody.name;
     const toolArgs = estimateBody.inputs ?? {};
-    let toolKey = null;
-    let tool = null;
-    for (const [key, t] of Object.entries(ctx.registry)) {
-      if (t.name === toolName || key === toolName) {
-        toolKey = key;
-        tool = t;
-        break;
-      }
-    }
-    if (!tool || !toolKey) {
+    const found = findToolInRegistry(ctx.registry, toolName);
+    if (!found) {
       return {
         status: 400,
         body: {
@@ -1336,6 +1419,7 @@ async function handleEstimateRoute(req, ctx) {
         }
       };
     }
+    const { toolKey, tool } = found;
     const inputSchema = getZodSchema(tool.inputSchema);
     const validatedArgs = inputSchema ? inputSchema.parse(toolArgs) : toolArgs;
     const estimateResponse = await ctx.callTool(toolKey, {
@@ -1498,35 +1582,13 @@ async function handleMcpRoute(req, ctx) {
 async function handleMcpToolsCall(params, id, ctx) {
   const toolName = params?.name;
   const rawArgs = params?.arguments ?? {};
-  console.log("[route-handlers /mcp] Received tools/call request:", JSON.stringify({
-    toolName,
-    hasArguments: !!params?.arguments,
-    argumentKeys: rawArgs ? Object.keys(rawArgs) : [],
-    hasEnv: "env" in rawArgs,
-    envKeys: rawArgs.env ? Object.keys(rawArgs.env) : [],
-    hasApiToken: !!rawArgs.env?.SKEDYUL_API_TOKEN
-  }, null, 2));
   const hasSkedyulFormat = "inputs" in rawArgs || "env" in rawArgs || "context" in rawArgs || "invocation" in rawArgs;
   const toolInputs = hasSkedyulFormat ? rawArgs.inputs ?? {} : rawArgs;
   const toolContext = hasSkedyulFormat ? rawArgs.context : void 0;
   const toolEnv = hasSkedyulFormat ? rawArgs.env : void 0;
   const toolInvocation = hasSkedyulFormat ? rawArgs.invocation : void 0;
-  console.log("[route-handlers /mcp] Extracted env:", JSON.stringify({
-    hasSkedyulFormat,
-    hasToolEnv: !!toolEnv,
-    toolEnvKeys: toolEnv ? Object.keys(toolEnv) : [],
-    hasApiToken: toolEnv?.SKEDYUL_API_TOKEN ? `yes (${toolEnv.SKEDYUL_API_TOKEN.length} chars)` : "no"
-  }, null, 2));
-  let toolKey = null;
-  let tool = null;
-  for (const [key, t] of Object.entries(ctx.registry)) {
-    if (t.name === toolName || key === toolName) {
-      toolKey = key;
-      tool = t;
-      break;
-    }
-  }
-  if (!tool || !toolKey) {
+  const found = findToolInRegistry(ctx.registry, toolName);
+  if (!found) {
     return {
       status: 200,
       body: {
@@ -1539,6 +1601,7 @@ async function handleMcpToolsCall(params, id, ctx) {
       }
     };
   }
+  const { toolKey, tool } = found;
   try {
     const inputSchema = getZodSchema(tool.inputSchema);
     const outputSchema = getZodSchema(tool.outputSchema);
@@ -1551,68 +1614,45 @@ async function handleMcpToolsCall(params, id, ctx) {
       invocation: toolInvocation
     });
     let result;
-    const isNewShapeFailure = "success" in toolResult && toolResult.success === false;
-    const isLegacyErrorFailure = "error" in toolResult && toolResult.error != null;
-    const isLegacyMetaFailure = "meta" in toolResult && toolResult.meta != null && typeof toolResult.meta === "object" && "success" in toolResult.meta && toolResult.meta.success === false;
-    const isFailure = isNewShapeFailure || isLegacyErrorFailure || isLegacyMetaFailure;
+    const isFailure = isToolCallFailure(toolResult);
     if (isFailure) {
-      let errorOutput;
-      if (isNewShapeFailure && "error" in toolResult) {
-        errorOutput = {
-          error: toolResult.error,
-          retry: "retry" in toolResult ? toolResult.retry : void 0
-        };
-      } else if (isLegacyErrorFailure && "error" in toolResult) {
-        errorOutput = { error: toolResult.error };
-      } else if (isLegacyMetaFailure && "meta" in toolResult && toolResult.meta) {
-        const meta = toolResult.meta;
-        errorOutput = {
-          error: {
-            code: "TOOL_FAILED",
-            message: meta.message ?? "Tool execution failed",
-            category: "internal"
-          }
-        };
-      } else {
-        errorOutput = {
-          error: {
-            code: "TOOL_FAILED",
-            message: "Tool execution failed",
-            category: "internal"
-          }
-        };
-      }
+      const errorOutput = buildToolCallErrorOutput(toolResult);
       result = {
-        content: [{ type: "text", text: JSON.stringify(errorOutput) }],
+        content: [{ type: "text", text: serializeMcpContentText(errorOutput) }],
         structuredContent: hasOutputSchema ? void 0 : errorOutput,
         isError: true,
         billing: "billing" in toolResult ? toolResult.billing : void 0
       };
     } else {
-      const outputData = "output" in toolResult ? toolResult.output : null;
+      const rawOutput = "output" in toolResult ? toolResult.output : null;
+      const outputData = rawOutput ?? null;
       const effect = "effect" in toolResult ? toolResult.effect : void 0;
       const warnings = "warnings" in toolResult ? toolResult.warnings : void 0;
       const pagination = "pagination" in toolResult ? toolResult.pagination : void 0;
+      const cursor = "cursor" in toolResult ? toolResult.cursor : void 0;
       let structuredContent;
       if (outputData) {
         structuredContent = {
           ...outputData,
           __effect: effect,
           __warnings: warnings,
-          __pagination: pagination
+          __pagination: pagination,
+          __cursor: cursor
         };
-      } else if (effect || warnings || pagination) {
+      } else if (effect || warnings || pagination || cursor) {
         structuredContent = {
           __effect: effect,
           __warnings: warnings,
-          __pagination: pagination
+          __pagination: pagination,
+          __cursor: cursor
         };
       } else if (hasOutputSchema) {
         structuredContent = {};
       }
       result = {
-        content: [{ type: "text", text: JSON.stringify(outputData) }],
+        content: [{ type: "text", text: serializeMcpContentText(outputData) }],
         structuredContent,
+        cursor,
         billing: "billing" in toolResult ? toolResult.billing : void 0
       };
     }
@@ -1638,6 +1678,94 @@ async function handleMcpToolsCall(params, id, ctx) {
     };
   }
 }
+async function handleMcpBatchRoute(req, ctx) {
+  const parseResult = parseJsonBody(req);
+  if (!parseResult.success) {
+    return parseResult.error;
+  }
+  const { calls, deadline, env: batchEnv, context: batchContext } = parseResult.data;
+  if (!calls || !Array.isArray(calls) || calls.length === 0) {
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: -32602,
+          message: "Missing or invalid calls array"
+        }
+      }
+    };
+  }
+  const perCallTimeoutMs = deadline ? Math.min(deadline, 25e3) : 25e3;
+  const executeWithTimeout = async (call, timeoutMs) => {
+    return new Promise(async (resolve) => {
+      const timeoutHandle = setTimeout(() => {
+        resolve({
+          id: call.id,
+          success: false,
+          error: "Timeout",
+          timedOut: true
+        });
+      }, timeoutMs);
+      try {
+        const toolName = call.name;
+        const toolArgs = call.arguments ?? {};
+        const found = findToolInRegistry(ctx.registry, toolName);
+        if (!found) {
+          clearTimeout(timeoutHandle);
+          resolve({
+            id: call.id,
+            success: false,
+            error: `Tool "${toolName}" not found`
+          });
+          return;
+        }
+        const { toolKey, tool } = found;
+        const inputSchema = getZodSchema(tool.inputSchema);
+        const validatedInputs = inputSchema ? inputSchema.parse(toolArgs) : toolArgs;
+        const toolResult = await ctx.callTool(toolKey, {
+          inputs: validatedInputs,
+          context: batchContext,
+          env: batchEnv
+        });
+        clearTimeout(timeoutHandle);
+        const isFailure = "success" in toolResult && toolResult.success === false || "error" in toolResult && toolResult.error != null;
+        if (isFailure) {
+          resolve({
+            id: call.id,
+            success: false,
+            error: "error" in toolResult && toolResult.error ? typeof toolResult.error === "string" ? toolResult.error : JSON.stringify(toolResult.error) : "Tool execution failed"
+          });
+        } else {
+          resolve({
+            id: call.id,
+            success: true,
+            result: "output" in toolResult ? toolResult.output : toolResult
+          });
+        }
+      } catch (err) {
+        clearTimeout(timeoutHandle);
+        resolve({
+          id: call.id,
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    });
+  };
+  const results = await Promise.all(
+    calls.map((call) => executeWithTimeout(call, perCallTimeoutMs))
+  );
+  return {
+    status: 200,
+    body: {
+      results,
+      totalCalls: calls.length,
+      successCount: results.filter((r) => r.success).length,
+      failedCount: results.filter((r) => !r.success).length,
+      timedOutCount: results.filter((r) => r.timedOut).length
+    }
+  };
+}
 function createNotFoundResponse() {
   return {
     status: 404,
@@ -1711,6 +1839,9 @@ async function routeRequest(req, ctx) {
     if (req.path === "/mcp" && req.method === "POST") {
       return handleMcpRoute(req, ctx);
     }
+    if (req.path === "/mcp/batch" && req.method === "POST") {
+      return handleMcpBatchRoute(req, ctx);
+    }
     return createNotFoundResponse();
   } catch (err) {
     return createErrorResponse(err);
@@ -1807,30 +1938,22 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
         httpServer.once("error", reject);
       });
     },
+    async close() {
+      return new Promise((resolve, reject) => {
+        const closable = httpServer;
+        closable.closeAllConnections?.();
+        httpServer.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    },
     getHealthStatus: () => state.getHealthStatus()
   };
 }
 async function handleMcpWithSdkTransport(req, res, url, ctx, mcpServer) {
   try {
     const body = await parseJSONBody(req);
-    if (body?.method === "tools/call") {
-      console.log(
-        "[dedicated.ts /mcp] Received tools/call request:",
-        JSON.stringify(
-          {
-            method: body.method,
-            toolName: body.params?.name,
-            hasArguments: !!body.params?.arguments,
-            argumentKeys: body.params?.arguments ? Object.keys(body.params.arguments) : [],
-            hasEnv: !!body.params?.arguments?.env,
-            envKeys: body.params?.arguments?.env ? Object.keys(body.params.arguments.env) : [],
-            hasApiToken: !!body.params?.arguments?.env?.SKEDYUL_API_TOKEN
-          },
-          null,
-          2
-        )
-      );
-    }
     if (body?.method === "tools/list") {
       sendJSON(res, 200, {
         jsonrpc: "2.0",
@@ -1905,65 +2028,46 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer) {
 }
 
 // src/server/index.ts
-console.log("[skedyul-node/server] Module loading - imports done");
-console.log("[skedyul-node/server] All imports complete");
-console.log("[skedyul-node/server] Installing context logger...");
 installContextLogger();
-console.log("[skedyul-node/server] Context logger installed");
 function createSkedyulServer(config) {
-  console.log("[createSkedyulServer] Step 1: mergeRuntimeEnv()");
   mergeRuntimeEnv();
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
-  console.log("[createSkedyulServer] Step 2: coreApi setup");
   if (config.coreApi?.service) {
     coreApiService.register(config.coreApi.service);
     if (config.coreApi.webhookHandler) {
       coreApiService.setWebhookHandler(config.coreApi.webhookHandler);
     }
   }
-  console.log("[createSkedyulServer] Step 3: buildToolMetadata()");
   const tools = buildToolMetadata(registry);
-  console.log("[createSkedyulServer] Step 3 done, tools:", tools.length);
   const toolNames = Object.values(registry).map((tool) => tool.name);
   const runtimeLabel = config.computeLayer ?? "serverless";
   const maxRequests = config.maxRequests ?? parseNumberEnv(process.env.MCP_MAX_REQUESTS) ?? null;
   const ttlExtendSeconds = config.ttlExtendSeconds ?? parseNumberEnv(process.env.MCP_TTL_EXTEND) ?? 3600;
-  console.log("[createSkedyulServer] Step 4: createRequestState()");
   const state = createRequestState(
     maxRequests,
     ttlExtendSeconds,
     runtimeLabel,
     toolNames
   );
-  console.log("[createSkedyulServer] Step 4 done");
-  console.log("[createSkedyulServer] Step 5: new McpServer()");
   const mcpServer = new import_mcp.McpServer({
     name: config.name,
     version: config.version ?? "0.0.0"
   });
-  console.log("[createSkedyulServer] Step 5 done");
   const dedicatedShutdown = () => {
     console.log("Max requests reached, shutting down...");
     setTimeout(() => process.exit(0), 1e3);
   };
-  console.log("[createSkedyulServer] Step 6: createCallToolHandler()");
   const callTool = createCallToolHandler(
     registry,
     state,
     config.computeLayer === "dedicated" ? dedicatedShutdown : void 0
   );
-  console.log("[createSkedyulServer] Step 6 done");
-  console.log("[createSkedyulServer] Step 7: Registering tools...");
   for (const [toolKey, tool] of Object.entries(registry)) {
-    console.log(`[createSkedyulServer] Registering tool: ${toolKey}`);
     const toolName = tool.name || toolKey;
     const toolDisplayName = tool.label || toolName;
-    console.log(`[createSkedyulServer] Getting input schema for ${toolKey}`);
     const inputZodSchema = getZodSchema(tool.inputSchema);
-    console.log(`[createSkedyulServer] Getting output schema for ${toolKey}`);
     const outputZodSchema = getZodSchema(tool.outputSchema);
-    console.log(`[createSkedyulServer] Creating wrapped schema for ${toolKey}`);
     const wrappedInputSchema = z3.object({
       inputs: inputZodSchema ?? z3.record(z3.string(), z3.unknown()).optional(),
       context: z3.record(z3.string(), z3.unknown()).optional(),
@@ -1971,7 +2075,6 @@ function createSkedyulServer(config) {
       invocation: z3.record(z3.string(), z3.unknown()).optional(),
       estimate: z3.boolean().optional()
     }).passthrough();
-    console.log(`[createSkedyulServer] Calling mcpServer.registerTool for ${toolKey}`);
     mcpServer.registerTool(
       toolName,
       {
@@ -1983,20 +2086,11 @@ function createSkedyulServer(config) {
         // outputSchema: outputZodSchema,
       },
       async (args) => {
-        console.log(`[mcpServer.registerTool] Tool ${toolName} received raw args:`, JSON.stringify(args, null, 2));
         const rawArgs = args;
         const toolInputs = rawArgs.inputs ?? {};
         const toolContext = rawArgs.context;
         const toolEnv = rawArgs.env;
         const toolInvocation = rawArgs.invocation;
-        console.log(`[mcpServer.registerTool] Tool ${toolName} extracted:`, {
-          hasInputs: !!rawArgs.inputs,
-          hasContext: !!rawArgs.context,
-          hasEnv: !!rawArgs.env,
-          hasInvocation: !!rawArgs.invocation,
-          envKeys: toolEnv ? Object.keys(toolEnv) : [],
-          hasApiToken: toolEnv?.SKEDYUL_API_TOKEN ? `yes (${toolEnv.SKEDYUL_API_TOKEN.length} chars)` : "no"
-        });
         let validatedInputs = toolInputs;
         if (inputZodSchema) {
           try {
@@ -2030,10 +2124,10 @@ function createSkedyulServer(config) {
           invocation: toolInvocation
         });
         const hasOutputSchema = Boolean(outputZodSchema);
-        if (result.error) {
-          const errorOutput = { error: result.error };
+        if (isToolCallFailure(result)) {
+          const errorOutput = buildToolCallErrorOutput(result);
           return {
-            content: [{ type: "text", text: JSON.stringify(errorOutput) }],
+            content: [{ type: "text", text: serializeMcpContentText(errorOutput) }],
             // Don't provide structuredContent for error responses when tool has outputSchema
             // because the error response won't match the success schema and MCP SDK validates it
             structuredContent: hasOutputSchema ? void 0 : errorOutput,
@@ -2041,7 +2135,8 @@ function createSkedyulServer(config) {
             billing: result.billing
           };
         }
-        const outputData = result.output;
+        const rawOutput = "output" in result ? result.output : null;
+        const outputData = rawOutput ?? null;
         const dataBlocks = result.dataBlocks;
         let structuredContent;
         if (outputData) {
@@ -2059,18 +2154,15 @@ function createSkedyulServer(config) {
           structuredContent = {};
         }
         return {
-          content: [{ type: "text", text: JSON.stringify(result.output) }],
+          // Ensure text is always a string - JSON.stringify(undefined) returns undefined, not a string
+          content: [{ type: "text", text: serializeMcpContentText(outputData) }],
           structuredContent,
           billing: result.billing
         };
       }
     );
-    console.log(`[createSkedyulServer] Tool ${toolKey} registered successfully`);
   }
-  console.log("[createSkedyulServer] Step 7 done - all tools registered");
-  console.log("[createSkedyulServer] Step 8: Creating server instance");
   if (config.computeLayer === "dedicated") {
-    console.log("[createSkedyulServer] Creating dedicated instance");
     return createDedicatedServerInstance(
       config,
       tools,
@@ -2079,10 +2171,7 @@ function createSkedyulServer(config) {
       mcpServer
     );
   }
-  console.log("[createSkedyulServer] Creating serverless instance");
-  const serverlessInstance = createServerlessInstance(config, tools, callTool, state, mcpServer);
-  console.log("[createSkedyulServer] Serverless instance created successfully");
-  return serverlessInstance;
+  return createServerlessInstance(config, tools, callTool, state, mcpServer);
 }
 var server = {
   create: createSkedyulServer