skedyul 1.2.32 → 1.2.34

package/dist/cli/index.js

@@ -2429,13 +2429,6 @@ function getDefaultHeaders(options) {
     "Access-Control-Allow-Headers": options?.allowHeaders ?? "Content-Type"
   };
 }
-function createResponse(statusCode, body, headers) {
-  return {
-    statusCode,
-    headers,
-    body: JSON.stringify(body)
-  };
-}
 function getListeningPort(config) {
   const envPort = Number.parseInt(process.env.PORT ?? "", 10);
   if (!Number.isNaN(envPort)) {
@@ -2693,10 +2686,174 @@ function createCallToolHandler(registry, state, onMaxRequests) {
 }
 
 // src/server/dedicated.ts
-var fs7 = __toESM(require("fs"));
 var import_http2 = __toESM(require("http"));
 var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 
+// src/server/startup-logger.ts
+function padEnd(str, length) {
+  if (str.length >= length) {
+    return str.slice(0, length);
+  }
+  return str + " ".repeat(length - str.length);
+}
+function printStartupLog(config, tools, port) {
+  if (process.env.NODE_ENV === "test") {
+    return;
+  }
+  const webhookRegistry = config.webhooks;
+  const webhookCount = webhookRegistry ? Object.keys(webhookRegistry).length : 0;
+  const webhookNames = webhookRegistry ? Object.keys(webhookRegistry) : [];
+  const maxRequests = config.maxRequests ?? parseNumberEnv(process.env.MCP_MAX_REQUESTS) ?? null;
+  const ttlExtendSeconds = config.ttlExtendSeconds ?? parseNumberEnv(process.env.MCP_TTL_EXTEND) ?? 3600;
+  const executableId = process.env.SKEDYUL_EXECUTABLE_ID || "local";
+  const divider = "\u2550".repeat(70);
+  const thinDivider = "\u2500".repeat(70);
+  console.log("");
+  console.log(`\u2554${divider}\u2557`);
+  console.log(`\u2551  \u{1F680} Skedyul MCP Server Starting                                      \u2551`);
+  console.log(`\u2560${divider}\u2563`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u2551  \u{1F4E6} Server:       ${padEnd(config.name, 49)}\u2551`);
+  console.log(`\u2551  \u{1F3F7}\uFE0F  Version:      ${padEnd(config.version ?? "N/A", 49)}\u2551`);
+  console.log(`\u2551  \u26A1 Compute:      ${padEnd(config.computeLayer ?? "serverless", 49)}\u2551`);
+  if (port) {
+    console.log(`\u2551  \u{1F310} Port:         ${padEnd(String(port), 49)}\u2551`);
+  }
+  console.log(`\u2551  \u{1F511} Executable:   ${padEnd(executableId, 49)}\u2551`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u255F${thinDivider}\u2562`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u2551  \u{1F527} Tools (${tools.length}):                                                       \u2551`);
+  const maxToolsToShow = 10;
+  const toolsToShow = tools.slice(0, maxToolsToShow);
+  for (const tool of toolsToShow) {
+    console.log(`\u2551     \u2022 ${padEnd(tool.name, 61)}\u2551`);
+  }
+  if (tools.length > maxToolsToShow) {
+    console.log(`\u2551     ... and ${tools.length - maxToolsToShow} more                                              \u2551`);
+  }
+  if (webhookCount > 0) {
+    console.log(`\u2551                                                                      \u2551`);
+    console.log(`\u2551  \u{1FA9D} Webhooks (${webhookCount}):                                                     \u2551`);
+    const maxWebhooksToShow = 5;
+    const webhooksToShow = webhookNames.slice(0, maxWebhooksToShow);
+    for (const name of webhooksToShow) {
+      console.log(`\u2551     \u2022 /webhooks/${padEnd(name, 51)}\u2551`);
+    }
+    if (webhookCount > maxWebhooksToShow) {
+      console.log(`\u2551     ... and ${webhookCount - maxWebhooksToShow} more                                              \u2551`);
+    }
+  }
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u255F${thinDivider}\u2562`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u2551  \u2699\uFE0F  Configuration:                                                   \u2551`);
+  console.log(`\u2551     Max Requests:    ${padEnd(maxRequests !== null ? String(maxRequests) : "unlimited", 46)}\u2551`);
+  console.log(`\u2551     TTL Extend:      ${padEnd(`${ttlExtendSeconds}s`, 46)}\u2551`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u255F${thinDivider}\u2562`);
+  console.log(`\u2551  \u2705 Ready at ${padEnd((/* @__PURE__ */ new Date()).toISOString(), 55)}\u2551`);
+  console.log(`\u255A${divider}\u255D`);
+  console.log("");
+}
+
+// src/server/route-handlers/adapters.ts
+function fromLambdaEvent(event) {
+  const path17 = event.path || event.rawPath || "/";
+  const method = event.httpMethod || event.requestContext?.http?.method || "POST";
+  const forwardedProto = event.headers?.["x-forwarded-proto"] ?? event.headers?.["X-Forwarded-Proto"];
+  const protocol = forwardedProto ?? "https";
+  const host = event.headers?.host ?? event.headers?.Host ?? "localhost";
+  const queryString = event.queryStringParameters ? "?" + new URLSearchParams(
+    event.queryStringParameters
+  ).toString() : "";
+  const url = `${protocol}://${host}${path17}${queryString}`;
+  return {
+    path: path17,
+    method,
+    headers: event.headers,
+    query: event.queryStringParameters ?? {},
+    body: event.body,
+    url
+  };
+}
+function toLambdaResponse(response, defaultHeaders) {
+  return {
+    statusCode: response.status,
+    headers: {
+      ...defaultHeaders,
+      ...response.headers
+    },
+    body: response.body !== void 0 ? typeof response.body === "string" ? response.body : JSON.stringify(response.body) : ""
+  };
+}
+function parseJsonBody(req, errorCode = -32700, errorMessage = "Parse error") {
+  try {
+    const data = req.body ? JSON.parse(req.body) : {};
+    return { success: true, data };
+  } catch {
+    return {
+      success: false,
+      error: {
+        status: 400,
+        body: {
+          error: {
+            code: errorCode,
+            message: errorMessage
+          }
+        }
+      }
+    };
+  }
+}
+function parseJsonRpcBody(req) {
+  try {
+    const data = req.body ? JSON.parse(req.body) : {};
+    return { success: true, data };
+  } catch {
+    return {
+      success: false,
+      error: {
+        status: 400,
+        body: {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32700,
+            message: "Parse error"
+          }
+        }
+      }
+    };
+  }
+}
+function getHeader(req, name) {
+  const value = req.headers[name.toLowerCase()] ?? req.headers[name];
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+function getContentType(req) {
+  return getHeader(req, "content-type") ?? "";
+}
+function parseBodyByContentType(req) {
+  const contentType = getContentType(req);
+  const rawBody = req.body ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      return rawBody ? JSON.parse(rawBody) : {};
+    } catch {
+      return rawBody;
+    }
+  }
+  return rawBody;
+}
+
+// src/server/route-handlers/handlers.ts
+var fs7 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+
 // src/server/core-api-handler.ts
 async function handleCoreMethod(method, params) {
   const service = coreApiService.getService();
@@ -2840,74 +2997,6 @@ async function handleCoreMethod(method, params) {
   };
 }
 
-// src/server/startup-logger.ts
-function padEnd(str, length) {
-  if (str.length >= length) {
-    return str.slice(0, length);
-  }
-  return str + " ".repeat(length - str.length);
-}
-function printStartupLog(config, tools, port) {
-  if (process.env.NODE_ENV === "test") {
-    return;
-  }
-  const webhookRegistry = config.webhooks;
-  const webhookCount = webhookRegistry ? Object.keys(webhookRegistry).length : 0;
-  const webhookNames = webhookRegistry ? Object.keys(webhookRegistry) : [];
-  const maxRequests = config.maxRequests ?? parseNumberEnv(process.env.MCP_MAX_REQUESTS) ?? null;
-  const ttlExtendSeconds = config.ttlExtendSeconds ?? parseNumberEnv(process.env.MCP_TTL_EXTEND) ?? 3600;
-  const executableId = process.env.SKEDYUL_EXECUTABLE_ID || "local";
-  const divider = "\u2550".repeat(70);
-  const thinDivider = "\u2500".repeat(70);
-  console.log("");
-  console.log(`\u2554${divider}\u2557`);
-  console.log(`\u2551  \u{1F680} Skedyul MCP Server Starting                                      \u2551`);
-  console.log(`\u2560${divider}\u2563`);
-  console.log(`\u2551                                                                      \u2551`);
-  console.log(`\u2551  \u{1F4E6} Server:       ${padEnd(config.name, 49)}\u2551`);
-  console.log(`\u2551  \u{1F3F7}\uFE0F  Version:      ${padEnd(config.version ?? "N/A", 49)}\u2551`);
-  console.log(`\u2551  \u26A1 Compute:      ${padEnd(config.computeLayer ?? "serverless", 49)}\u2551`);
-  if (port) {
-    console.log(`\u2551  \u{1F310} Port:         ${padEnd(String(port), 49)}\u2551`);
-  }
-  console.log(`\u2551  \u{1F511} Executable:   ${padEnd(executableId, 49)}\u2551`);
-  console.log(`\u2551                                                                      \u2551`);
-  console.log(`\u255F${thinDivider}\u2562`);
-  console.log(`\u2551                                                                      \u2551`);
-  console.log(`\u2551  \u{1F527} Tools (${tools.length}):                                                       \u2551`);
-  const maxToolsToShow = 10;
-  const toolsToShow = tools.slice(0, maxToolsToShow);
-  for (const tool of toolsToShow) {
-    console.log(`\u2551     \u2022 ${padEnd(tool.name, 61)}\u2551`);
-  }
-  if (tools.length > maxToolsToShow) {
-    console.log(`\u2551     ... and ${tools.length - maxToolsToShow} more                                              \u2551`);
-  }
-  if (webhookCount > 0) {
-    console.log(`\u2551                                                                      \u2551`);
-    console.log(`\u2551  \u{1FA9D} Webhooks (${webhookCount}):                                                     \u2551`);
-    const maxWebhooksToShow = 5;
-    const webhooksToShow = webhookNames.slice(0, maxWebhooksToShow);
-    for (const name of webhooksToShow) {
-      console.log(`\u2551     \u2022 /webhooks/${padEnd(name, 51)}\u2551`);
-    }
-    if (webhookCount > maxWebhooksToShow) {
-      console.log(`\u2551     ... and ${webhookCount - maxWebhooksToShow} more                                              \u2551`);
-    }
-  }
-  console.log(`\u2551                                                                      \u2551`);
-  console.log(`\u255F${thinDivider}\u2562`);
-  console.log(`\u2551                                                                      \u2551`);
-  console.log(`\u2551  \u2699\uFE0F  Configuration:                                                   \u2551`);
-  console.log(`\u2551     Max Requests:    ${padEnd(maxRequests !== null ? String(maxRequests) : "unlimited", 46)}\u2551`);
-  console.log(`\u2551     TTL Extend:      ${padEnd(`${ttlExtendSeconds}s`, 46)}\u2551`);
-  console.log(`\u2551                                                                      \u2551`);
-  console.log(`\u255F${thinDivider}\u2562`);
-  console.log(`\u2551  \u2705 Ready at ${padEnd((/* @__PURE__ */ new Date()).toISOString(), 55)}\u2551`);
-  console.log(`\u255A${divider}\u255D`);
-  console.log("");
-}
-
 // src/server/config-serializer.ts
 function serializeConfig(config) {
   const registry = config.tools;
@@ -3226,7 +3315,7 @@ async function handleOAuthCallback(parsedBody, hooks) {
 }
 
 // src/server/handlers/webhook-handler.ts
-function parseWebhookRequest(parsedBody, method, url, path16, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
+function parseWebhookRequest(parsedBody, method, url, path17, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
   const isEnvelope = typeof parsedBody === "object" && parsedBody !== null && "env" in parsedBody && "request" in parsedBody && "context" in parsedBody;
   if (isEnvelope) {
     const envelope = parsedBody;
@@ -3280,7 +3369,7 @@ function parseWebhookRequest(parsedBody, method, url, path16, headers, query, ra
   const webhookRequest = {
     method,
     url,
-    path: path16,
+    path: path17,
     headers,
     query,
     body: parsedBody,
@@ -3335,322 +3424,517 @@ function isMethodAllowed(webhookRegistry, handle, method) {
   const allowedMethods = webhookDef.methods ?? ["POST"];
   return allowedMethods.includes(method);
 }
-
-// src/server/dedicated.ts
-var CONFIG_FILE_PATH = ".skedyul/config.json";
+
+// src/server/route-handlers/handlers.ts
+function getConfigFilePath() {
+  return process.env.LAMBDA_TASK_ROOT ? path7.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
+}
+function handleHealthRoute(ctx) {
+  return {
+    status: 200,
+    body: ctx.state.getHealthStatus()
+  };
+}
+function handleConfigRoute(ctx) {
+  const configFilePath = getConfigFilePath();
+  try {
+    console.log(`[/config] Checking for config file at: ${configFilePath}`);
+    if (fs7.existsSync(configFilePath)) {
+      const fileConfig = JSON.parse(fs7.readFileSync(configFilePath, "utf-8"));
+      console.log(
+        `[/config] Loaded config from file: tools=${fileConfig.tools?.length ?? 0}, webhooks=${fileConfig.webhooks?.length ?? 0}`
+      );
+      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}`
+  );
+  return { status: 200, body: serialized };
+}
+async function handleCoreRoute(req, ctx) {
+  const parseResult = parseJsonBody(req);
+  if (!parseResult.success) {
+    return parseResult.error;
+  }
+  const coreBody = parseResult.data;
+  if (!coreBody?.method) {
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: -32602,
+          message: "Missing method"
+        }
+      }
+    };
+  }
+  const result = await handleCoreMethod(coreBody.method, coreBody.params);
+  return { status: result.status, body: result.payload };
+}
+async function handleCoreWebhookRoute(req, ctx) {
+  const rawBody = req.body ?? "";
+  let webhookBody;
+  try {
+    webhookBody = rawBody ? JSON.parse(rawBody) : {};
+  } catch {
+    return { status: 400, body: { status: "parse-error" } };
+  }
+  const coreWebhookRequest = {
+    method: req.method,
+    headers: req.headers,
+    body: webhookBody,
+    query: req.query,
+    url: req.url,
+    path: req.path,
+    rawBody: rawBody ? Buffer.from(rawBody, "utf-8") : void 0
+  };
+  const webhookResponse = await coreApiService.dispatchWebhook(coreWebhookRequest);
+  return {
+    status: webhookResponse.status,
+    body: webhookResponse.body ?? {}
+  };
+}
+async function handleEstimateRoute(req, ctx) {
+  const parseResult = parseJsonBody(req);
+  if (!parseResult.success) {
+    return parseResult.error;
+  }
+  const estimateBody = parseResult.data;
+  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) {
+      return {
+        status: 400,
+        body: {
+          error: {
+            code: -32602,
+            message: `Tool "${toolName}" not found`
+          }
+        }
+      };
+    }
+    const inputSchema = getZodSchema3(tool.inputSchema);
+    const validatedArgs = inputSchema ? inputSchema.parse(toolArgs) : toolArgs;
+    const estimateResponse = await ctx.callTool(toolKey, {
+      inputs: validatedArgs,
+      estimate: true
+    });
+    return {
+      status: 200,
+      body: {
+        billing: estimateResponse.billing ?? { credits: 0 }
+      }
+    };
+  } catch (err) {
+    return {
+      status: 500,
+      body: {
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : String(err ?? "")
+        }
+      }
+    };
+  }
+}
+async function handleInstallRoute(req, ctx) {
+  const parseResult = parseJsonBody(req);
+  if (!parseResult.success) {
+    return parseResult.error;
+  }
+  const result = await handleInstall(parseResult.data, ctx.config.hooks);
+  return { status: result.status, body: result.body };
+}
+async function handleUninstallRoute(req, ctx) {
+  const parseResult = parseJsonBody(req);
+  if (!parseResult.success) {
+    return parseResult.error;
+  }
+  const result = await handleUninstall(parseResult.data, ctx.config.hooks);
+  return { status: result.status, body: result.body };
+}
+async function handleProvisionRoute(req, ctx) {
+  const parseResult = parseJsonBody(req);
+  if (!parseResult.success) {
+    return parseResult.error;
+  }
+  const result = await handleProvision(parseResult.data, ctx.config.hooks);
+  return { status: result.status, body: result.body };
+}
+async function handleOAuthCallbackRoute(req, ctx) {
+  const parseResult = parseJsonBody(req);
+  if (!parseResult.success) {
+    console.error("[OAuth Callback] Failed to parse JSON body");
+    return parseResult.error;
+  }
+  const result = await handleOAuthCallback(parseResult.data, ctx.config.hooks);
+  return { status: result.status, body: result.body };
+}
+async function handleWebhookRoute(req, handle, ctx) {
+  if (!ctx.webhookRegistry) {
+    return { status: 404, body: { error: `Webhook handler '${handle}' not found` } };
+  }
+  if (!ctx.webhookRegistry[handle]) {
+    return { status: 404, body: { error: `Webhook handler '${handle}' not found` } };
+  }
+  if (!isMethodAllowed(ctx.webhookRegistry, handle, req.method)) {
+    return { status: 405, body: { error: `Method ${req.method} not allowed` } };
+  }
+  const rawBody = req.body ?? "";
+  const parsedBody = parseBodyByContentType(req);
+  const parseResult = parseWebhookRequest(
+    parsedBody,
+    req.method,
+    req.url,
+    req.path,
+    req.headers,
+    req.query,
+    rawBody,
+    getHeader(req, "x-skedyul-app-id"),
+    getHeader(req, "x-skedyul-app-version-id")
+  );
+  if ("error" in parseResult) {
+    return { status: 400, body: { error: parseResult.error } };
+  }
+  const result = await executeWebhookHandler(handle, ctx.webhookRegistry, parseResult);
+  return {
+    status: result.status,
+    body: result.body,
+    headers: result.headers
+  };
+}
+async function handleMcpRoute(req, ctx) {
+  const parseResult = parseJsonRpcBody(req);
+  if (!parseResult.success) {
+    return parseResult.error;
+  }
+  const body = parseResult.data;
+  try {
+    const { jsonrpc, id, method: rpcMethod, params } = body;
+    if (jsonrpc !== "2.0") {
+      return {
+        status: 400,
+        body: {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32600,
+            message: "Invalid Request"
+          }
+        }
+      };
+    }
+    let result;
+    if (rpcMethod === "tools/list") {
+      result = { tools: ctx.tools };
+    } else if (rpcMethod === "tools/call") {
+      return handleMcpToolsCall(params, id, ctx);
+    } else if (rpcMethod === "webhooks/list") {
+      const webhooks = ctx.webhookRegistry ? Object.values(ctx.webhookRegistry).map((w) => ({
+        name: w.name,
+        description: w.description,
+        methods: w.methods ?? ["POST"],
+        type: w.type ?? "WEBHOOK"
+      })) : [];
+      result = { webhooks };
+    } else {
+      return {
+        status: 200,
+        body: {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${rpcMethod}`
+          }
+        }
+      };
+    }
+    return {
+      status: 200,
+      body: {
+        jsonrpc: "2.0",
+        id,
+        result
+      }
+    };
+  } catch (err) {
+    return {
+      status: 500,
+      body: {
+        jsonrpc: "2.0",
+        id: body?.id ?? null,
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : String(err ?? "")
+        }
+      }
+    };
+  }
+}
+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) {
+    return {
+      status: 200,
+      body: {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32602,
+          message: `Tool "${toolName}" not found`
+        }
+      }
+    };
+  }
+  try {
+    const inputSchema = getZodSchema3(tool.inputSchema);
+    const outputSchema = getZodSchema3(tool.outputSchema);
+    const hasOutputSchema = Boolean(outputSchema);
+    const validatedInputs = inputSchema ? inputSchema.parse(toolInputs) : toolInputs;
+    const toolResult = await ctx.callTool(toolKey, {
+      inputs: validatedInputs,
+      context: toolContext,
+      env: toolEnv,
+      invocation: toolInvocation
+    });
+    let result;
+    if (toolResult.error) {
+      const errorOutput = { error: toolResult.error };
+      result = {
+        content: [{ type: "text", text: JSON.stringify(errorOutput) }],
+        structuredContent: hasOutputSchema ? void 0 : errorOutput,
+        isError: true,
+        billing: toolResult.billing
+      };
+    } else {
+      const outputData = toolResult.output;
+      let structuredContent;
+      if (outputData) {
+        structuredContent = { ...outputData, __effect: toolResult.effect };
+      } else if (toolResult.effect) {
+        structuredContent = { __effect: toolResult.effect };
+      } else if (hasOutputSchema) {
+        structuredContent = {};
+      }
+      result = {
+        content: [{ type: "text", text: JSON.stringify(toolResult.output) }],
+        structuredContent,
+        billing: toolResult.billing
+      };
+    }
+    return {
+      status: 200,
+      body: {
+        jsonrpc: "2.0",
+        id,
+        result
+      }
+    };
+  } catch (validationError) {
+    return {
+      status: 200,
+      body: {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32602,
+          message: validationError instanceof Error ? validationError.message : "Invalid arguments"
+        }
+      }
+    };
+  }
+}
+function createNotFoundResponse() {
+  return {
+    status: 404,
+    body: {
+      jsonrpc: "2.0",
+      id: null,
+      error: {
+        code: -32601,
+        message: "Not Found"
+      }
+    }
+  };
+}
+function createOptionsResponse() {
+  return {
+    status: 200,
+    body: { message: "OK" }
+  };
+}
+function createErrorResponse(err) {
+  return {
+    status: 500,
+    body: {
+      jsonrpc: "2.0",
+      id: null,
+      error: {
+        code: -32603,
+        message: err instanceof Error ? err.message : String(err ?? "")
+      }
+    }
+  };
+}
+
+// src/server/route-handlers/router.ts
+async function routeRequest(req, ctx) {
+  try {
+    if (req.method === "OPTIONS") {
+      return createOptionsResponse();
+    }
+    if (req.path.startsWith("/webhooks/") && ctx.webhookRegistry) {
+      const handle = req.path.slice("/webhooks/".length);
+      return handleWebhookRoute(req, handle, ctx);
+    }
+    if (req.path === "/core" && req.method === "POST") {
+      return handleCoreRoute(req, ctx);
+    }
+    if (req.path === "/core/webhook" && req.method === "POST") {
+      return handleCoreWebhookRoute(req, ctx);
+    }
+    if (req.path === "/estimate" && req.method === "POST") {
+      return handleEstimateRoute(req, ctx);
+    }
+    if (req.path === "/install" && req.method === "POST") {
+      return handleInstallRoute(req, ctx);
+    }
+    if (req.path === "/uninstall" && req.method === "POST") {
+      return handleUninstallRoute(req, ctx);
+    }
+    if (req.path === "/provision" && req.method === "POST") {
+      return handleProvisionRoute(req, ctx);
+    }
+    if (req.path === "/oauth_callback" && req.method === "POST") {
+      return handleOAuthCallbackRoute(req, ctx);
+    }
+    if (req.path === "/health" && req.method === "GET") {
+      return handleHealthRoute(ctx);
+    }
+    if (req.path === "/config" && req.method === "GET") {
+      return handleConfigRoute(ctx);
+    }
+    if (req.path === "/mcp" && req.method === "POST") {
+      return handleMcpRoute(req, ctx);
+    }
+    return createNotFoundResponse();
+  } catch (err) {
+    return createErrorResponse(err);
+  }
+}
+
+// src/server/dedicated.ts
+function fromHttpRequest(req, url, rawBody) {
+  return {
+    path: url.pathname,
+    method: req.method ?? "GET",
+    headers: req.headers,
+    query: Object.fromEntries(url.searchParams.entries()),
+    body: rawBody,
+    url: url.toString()
+  };
+}
+function sendUnifiedResponse(res, response, defaultHeaders) {
+  const headers = {
+    ...defaultHeaders,
+    ...response.headers
+  };
+  if (!headers["Content-Type"] && !headers["content-type"]) {
+    headers["Content-Type"] = "application/json";
+  }
+  res.writeHead(response.status, headers);
+  if (response.body !== void 0) {
+    if (typeof response.body === "string") {
+      res.end(response.body);
+    } else {
+      res.end(JSON.stringify(response.body));
+    }
+  } else {
+    res.end();
+  }
+}
 function createDedicatedServerInstance(config, tools, callTool, state, mcpServer) {
   const port = getListeningPort(config);
+  const defaultHeaders = getDefaultHeaders(config.cors);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
+  const ctx = {
+    config,
+    tools,
+    registry,
+    webhookRegistry,
+    callTool,
+    state,
+    mcpServer,
+    defaultHeaders
+  };
   const httpServer = import_http2.default.createServer(
     async (req, res) => {
-      function sendCoreResult(result) {
-        sendJSON(res, result.status, result.payload);
-      }
       try {
         const url = new URL(
           req.url || "/",
           `http://${req.headers.host || "localhost"}`
         );
         const pathname = url.pathname;
-        if (pathname === "/health" && req.method === "GET") {
-          sendJSON(res, 200, state.getHealthStatus());
-          return;
-        }
-        if (pathname === "/config" && req.method === "GET") {
-          try {
-            if (fs7.existsSync(CONFIG_FILE_PATH)) {
-              const fileConfig = JSON.parse(fs7.readFileSync(CONFIG_FILE_PATH, "utf-8"));
-              sendJSON(res, 200, fileConfig);
-              return;
-            }
-          } catch (err) {
-            console.warn("[/config] Failed to read config file, falling back to runtime serialization:", err);
-          }
-          sendJSON(res, 200, serializeConfig(config));
-          return;
-        }
-        if (pathname.startsWith("/webhooks/") && webhookRegistry) {
-          const handle = pathname.slice("/webhooks/".length);
-          if (!webhookRegistry[handle]) {
-            sendJSON(res, 404, { error: `Webhook handler '${handle}' not found` });
-            return;
-          }
-          if (!isMethodAllowed(webhookRegistry, handle, req.method ?? "POST")) {
-            sendJSON(res, 405, { error: `Method ${req.method} not allowed` });
-            return;
-          }
-          let rawBody;
-          try {
-            rawBody = await readRawRequestBody(req);
-          } catch {
-            sendJSON(res, 400, { error: "Failed to read request body" });
-            return;
-          }
-          let parsedBody;
-          const contentType = req.headers["content-type"] ?? "";
-          if (contentType.includes("application/json")) {
-            try {
-              parsedBody = rawBody ? JSON.parse(rawBody) : {};
-            } catch {
-              parsedBody = rawBody;
-            }
-          } else {
-            parsedBody = rawBody;
-          }
-          const parseResult = parseWebhookRequest(
-            parsedBody,
-            req.method ?? "POST",
-            url.toString(),
-            pathname,
-            req.headers,
-            Object.fromEntries(url.searchParams.entries()),
-            rawBody,
-            req.headers["x-skedyul-app-id"],
-            req.headers["x-skedyul-app-version-id"]
-          );
-          if ("error" in parseResult) {
-            sendJSON(res, 400, { error: parseResult.error });
-            return;
-          }
-          const result = await executeWebhookHandler(handle, webhookRegistry, parseResult);
-          const responseHeaders = {
-            ...result.headers
-          };
-          if (!responseHeaders["Content-Type"] && !responseHeaders["content-type"]) {
-            responseHeaders["Content-Type"] = "application/json";
-          }
-          res.writeHead(result.status, responseHeaders);
-          if (result.body !== void 0) {
-            if (typeof result.body === "string") {
-              res.end(result.body);
-            } else {
-              res.end(JSON.stringify(result.body));
-            }
-          } else {
-            res.end();
-          }
-          return;
-        }
-        if (pathname === "/estimate" && req.method === "POST") {
-          let estimateBody;
-          try {
-            estimateBody = await parseJSONBody(req);
-          } catch {
-            sendJSON(res, 400, {
-              error: {
-                code: -32700,
-                message: "Parse error"
-              }
-            });
-            return;
-          }
-          try {
-            const estimateResponse = await callTool(estimateBody.name, {
-              inputs: estimateBody.inputs,
-              estimate: true
-            });
-            sendJSON(res, 200, {
-              billing: estimateResponse.billing ?? { credits: 0 }
-            });
-          } catch (err) {
-            sendJSON(res, 500, {
-              error: {
-                code: -32603,
-                message: err instanceof Error ? err.message : String(err ?? "")
-              }
-            });
-          }
-          return;
-        }
-        if (pathname === "/oauth_callback" && req.method === "POST") {
-          let parsedBody;
-          try {
-            parsedBody = await parseJSONBody(req);
-          } catch (err) {
-            console.error("[OAuth Callback] Failed to parse JSON body:", err);
-            sendJSON(res, 400, {
-              error: { code: -32700, message: "Parse error" }
-            });
-            return;
-          }
-          const result = await handleOAuthCallback(parsedBody, config.hooks);
-          sendJSON(res, result.status, result.body);
-          return;
-        }
-        if (pathname === "/install" && req.method === "POST") {
-          let installBody;
-          try {
-            installBody = await parseJSONBody(req);
-          } catch {
-            sendJSON(res, 400, {
-              error: { code: -32700, message: "Parse error" }
-            });
-            return;
-          }
-          const result = await handleInstall(installBody, config.hooks);
-          sendJSON(res, result.status, result.body);
-          return;
-        }
-        if (pathname === "/uninstall" && req.method === "POST") {
-          let uninstallBody;
-          try {
-            uninstallBody = await parseJSONBody(req);
-          } catch {
-            sendJSON(res, 400, {
-              error: { code: -32700, message: "Parse error" }
-            });
-            return;
-          }
-          const result = await handleUninstall(uninstallBody, config.hooks);
-          sendJSON(res, result.status, result.body);
-          return;
-        }
-        if (pathname === "/provision" && req.method === "POST") {
-          let provisionBody;
-          try {
-            provisionBody = await parseJSONBody(req);
-          } catch {
-            sendJSON(res, 400, {
-              error: { code: -32700, message: "Parse error" }
-            });
-            return;
-          }
-          const result = await handleProvision(provisionBody, config.hooks);
-          sendJSON(res, result.status, result.body);
-          return;
-        }
-        if (pathname === "/core" && req.method === "POST") {
-          let coreBody;
-          try {
-            coreBody = await parseJSONBody(req);
-          } catch {
-            sendJSON(res, 400, {
-              error: {
-                code: -32700,
-                message: "Parse error"
-              }
-            });
-            return;
-          }
-          if (!coreBody?.method) {
-            sendJSON(res, 400, {
-              error: {
-                code: -32602,
-                message: "Missing method"
-              }
-            });
-            return;
-          }
-          const method = coreBody.method;
-          const result = await handleCoreMethod(method, coreBody.params);
-          sendCoreResult(result);
-          return;
-        }
-        if (pathname === "/core/webhook" && req.method === "POST") {
-          let rawWebhookBody;
-          try {
-            rawWebhookBody = await readRawRequestBody(req);
-          } catch {
-            sendJSON(res, 400, { status: "parse-error" });
-            return;
-          }
-          let webhookBody;
-          try {
-            webhookBody = rawWebhookBody ? JSON.parse(rawWebhookBody) : {};
-          } catch {
-            sendJSON(res, 400, { status: "parse-error" });
-            return;
-          }
-          const normalizedHeaders = Object.fromEntries(
-            Object.entries(req.headers).map(([key, value]) => [
-              key,
-              typeof value === "string" ? value : value?.[0] ?? ""
-            ])
-          );
-          const coreWebhookRequest = {
-            method: req.method ?? "POST",
-            headers: normalizedHeaders,
-            body: webhookBody,
-            query: Object.fromEntries(url.searchParams.entries()),
-            url: url.toString(),
-            path: url.pathname,
-            rawBody: rawWebhookBody ? Buffer.from(rawWebhookBody, "utf-8") : void 0
-          };
-          const webhookResponse = await coreApiService.dispatchWebhook(
-            coreWebhookRequest
-          );
-          res.writeHead(webhookResponse.status, {
-            "Content-Type": "application/json"
-          });
-          res.end(JSON.stringify(webhookResponse.body ?? {}));
+        if (pathname === "/mcp" && req.method === "POST") {
+          await handleMcpWithSdkTransport(req, res, url, ctx, mcpServer);
           return;
         }
-        if (pathname === "/mcp" && req.method === "POST") {
-          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",
-                id: body.id ?? null,
-                result: { tools }
-              });
-              return;
-            }
-            if (body?.method === "webhooks/list") {
-              const webhooks = webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-                name: w.name,
-                description: w.description,
-                methods: w.methods ?? ["POST"],
-                type: w.type ?? "WEBHOOK"
-              })) : [];
-              sendJSON(res, 200, {
-                jsonrpc: "2.0",
-                id: body.id ?? null,
-                result: { webhooks }
-              });
-              return;
-            }
-            const transport = new import_streamableHttp.StreamableHTTPServerTransport({
-              sessionIdGenerator: void 0,
-              enableJsonResponse: true
-            });
-            res.on("close", () => {
-              transport.close();
-            });
-            await mcpServer.connect(transport);
-            await transport.handleRequest(req, res, body);
-          } catch (err) {
-            sendJSON(res, 500, {
-              jsonrpc: "2.0",
-              id: null,
-              error: {
-                code: -32603,
-                message: err instanceof Error ? err.message : String(err ?? "")
-              }
-            });
-          }
+        let rawBody;
+        try {
+          rawBody = await readRawRequestBody(req);
+        } catch {
+          sendJSON(res, 400, { error: "Failed to read request body" });
           return;
         }
-        sendJSON(res, 404, {
-          jsonrpc: "2.0",
-          id: null,
-          error: {
-            code: -32601,
-            message: "Not Found"
-          }
-        });
+        const unifiedReq = fromHttpRequest(req, url, rawBody);
+        const response = await routeRequest(unifiedReq, ctx);
+        sendUnifiedResponse(res, response, defaultHeaders);
       } catch (err) {
         sendJSON(res, 500, {
           jsonrpc: "2.0",
@@ -3677,485 +3961,95 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
     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",
+        id: body.id ?? null,
+        result: { tools: ctx.tools }
+      });
+      return;
+    }
+    if (body?.method === "webhooks/list") {
+      const webhooks = ctx.webhookRegistry ? Object.values(ctx.webhookRegistry).map((w) => ({
+        name: w.name,
+        description: w.description,
+        methods: w.methods ?? ["POST"],
+        type: w.type ?? "WEBHOOK"
+      })) : [];
+      sendJSON(res, 200, {
+        jsonrpc: "2.0",
+        id: body.id ?? null,
+        result: { webhooks }
+      });
+      return;
+    }
+    const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      enableJsonResponse: true
+    });
+    res.on("close", () => {
+      transport.close();
+    });
+    await mcpServer.connect(transport);
+    await transport.handleRequest(req, res, body);
+  } catch (err) {
+    sendJSON(res, 500, {
+      jsonrpc: "2.0",
+      id: null,
+      error: {
+        code: -32603,
+        message: err instanceof Error ? err.message : String(err ?? "")
+      }
+    });
+  }
+}
 
 // src/server/serverless.ts
-var fs8 = __toESM(require("fs"));
-var CONFIG_FILE_PATH2 = ".skedyul/config.json";
 function createServerlessInstance(config, tools, callTool, state, mcpServer) {
-  const headers = getDefaultHeaders(config.cors);
+  const defaultHeaders = getDefaultHeaders(config.cors);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
   let hasLoggedStartup = false;
+  const ctx = {
+    config,
+    tools,
+    registry,
+    webhookRegistry,
+    callTool,
+    state,
+    mcpServer,
+    defaultHeaders
+  };
   return {
     async handler(event) {
       if (!hasLoggedStartup) {
         printStartupLog(config, tools);
         hasLoggedStartup = true;
       }
-      try {
-        const path16 = event.path || event.rawPath || "/";
-        const method = event.httpMethod || event.requestContext?.http?.method || "POST";
-        if (method === "OPTIONS") {
-          return createResponse(200, { message: "OK" }, headers);
-        }
-        if (path16.startsWith("/webhooks/") && webhookRegistry) {
-          const handle = path16.slice("/webhooks/".length);
-          if (!webhookRegistry[handle]) {
-            return createResponse(404, { error: `Webhook handler '${handle}' not found` }, headers);
-          }
-          if (!isMethodAllowed(webhookRegistry, handle, method)) {
-            return createResponse(405, { error: `Method ${method} not allowed` }, headers);
-          }
-          const rawBody = event.body ?? "";
-          let parsedBody;
-          const contentType = event.headers?.["content-type"] ?? event.headers?.["Content-Type"] ?? "";
-          if (contentType.includes("application/json")) {
-            try {
-              parsedBody = rawBody ? JSON.parse(rawBody) : {};
-            } catch {
-              parsedBody = rawBody;
-            }
-          } else {
-            parsedBody = rawBody;
-          }
-          const forwardedProto = event.headers?.["x-forwarded-proto"] ?? event.headers?.["X-Forwarded-Proto"];
-          const protocol = forwardedProto ?? "https";
-          const host = event.headers?.host ?? event.headers?.Host ?? "localhost";
-          const queryString = event.queryStringParameters ? "?" + new URLSearchParams(event.queryStringParameters).toString() : "";
-          const webhookUrl = `${protocol}://${host}${path16}${queryString}`;
-          const parseResult = parseWebhookRequest(
-            parsedBody,
-            method,
-            webhookUrl,
-            path16,
-            event.headers,
-            event.queryStringParameters ?? {},
-            rawBody,
-            event.headers?.["x-skedyul-app-id"] ?? event.headers?.["X-Skedyul-App-Id"],
-            event.headers?.["x-skedyul-app-version-id"] ?? event.headers?.["X-Skedyul-App-Version-Id"]
-          );
-          if ("error" in parseResult) {
-            return createResponse(400, { error: parseResult.error }, headers);
-          }
-          const result = await executeWebhookHandler(handle, webhookRegistry, parseResult);
-          const responseHeaders = {
-            ...headers,
-            ...result.headers
-          };
-          return {
-            statusCode: result.status,
-            headers: responseHeaders,
-            body: result.body !== void 0 ? typeof result.body === "string" ? result.body : JSON.stringify(result.body) : ""
-          };
-        }
-        if (path16 === "/core" && method === "POST") {
-          let coreBody;
-          try {
-            coreBody = event.body ? JSON.parse(event.body) : {};
-          } catch {
-            return createResponse(
-              400,
-              {
-                error: {
-                  code: -32700,
-                  message: "Parse error"
-                }
-              },
-              headers
-            );
-          }
-          if (!coreBody?.method) {
-            return createResponse(
-              400,
-              {
-                error: {
-                  code: -32602,
-                  message: "Missing method"
-                }
-              },
-              headers
-            );
-          }
-          const coreMethod = coreBody.method;
-          const result = await handleCoreMethod(coreMethod, coreBody.params);
-          return createResponse(result.status, result.payload, headers);
-        }
-        if (path16 === "/core/webhook" && method === "POST") {
-          const rawWebhookBody = event.body ?? "";
-          let webhookBody;
-          try {
-            webhookBody = rawWebhookBody ? JSON.parse(rawWebhookBody) : {};
-          } catch {
-            return createResponse(
-              400,
-              { status: "parse-error" },
-              headers
-            );
-          }
-          const forwardedProto = event.headers?.["x-forwarded-proto"] ?? event.headers?.["X-Forwarded-Proto"];
-          const protocol = forwardedProto ?? "https";
-          const host = event.headers?.host ?? event.headers?.Host ?? "localhost";
-          const webhookUrl = `${protocol}://${host}${path16}`;
-          const coreWebhookRequest = {
-            method,
-            headers: event.headers ?? {},
-            body: webhookBody,
-            query: event.queryStringParameters ?? {},
-            url: webhookUrl,
-            path: path16,
-            rawBody: rawWebhookBody ? Buffer.from(rawWebhookBody, "utf-8") : void 0
-          };
-          const webhookResponse = await coreApiService.dispatchWebhook(
-            coreWebhookRequest
-          );
-          return createResponse(
-            webhookResponse.status,
-            webhookResponse.body ?? {},
-            headers
-          );
-        }
-        if (path16 === "/estimate" && method === "POST") {
-          let estimateBody;
-          try {
-            estimateBody = event.body ? JSON.parse(event.body) : {};
-          } catch {
-            return createResponse(
-              400,
-              {
-                error: {
-                  code: -32700,
-                  message: "Parse error"
-                }
-              },
-              headers
-            );
-          }
-          try {
-            const toolName = estimateBody.name;
-            const toolArgs = estimateBody.inputs ?? {};
-            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
-              );
-            }
-            const inputSchema = getZodSchema3(tool.inputSchema);
-            const validatedArgs = inputSchema ? inputSchema.parse(toolArgs) : toolArgs;
-            const estimateResponse = await callTool(toolKey, {
-              inputs: validatedArgs,
-              estimate: true
-            });
-            return createResponse(
-              200,
-              {
-                billing: estimateResponse.billing ?? { credits: 0 }
-              },
-              headers
-            );
-          } catch (err) {
-            return createResponse(
-              500,
-              {
-                error: {
-                  code: -32603,
-                  message: err instanceof Error ? err.message : String(err ?? "")
-                }
-              },
-              headers
-            );
-          }
-        }
-        if (path16 === "/install" && method === "POST") {
-          let installBody;
-          try {
-            installBody = event.body ? JSON.parse(event.body) : {};
-          } catch {
-            return createResponse(
-              400,
-              { error: { code: -32700, message: "Parse error" } },
-              headers
-            );
-          }
-          const result = await handleInstall(installBody, config.hooks);
-          return createResponse(result.status, result.body, headers);
-        }
-        if (path16 === "/uninstall" && method === "POST") {
-          let uninstallBody;
-          try {
-            uninstallBody = event.body ? JSON.parse(event.body) : {};
-          } catch {
-            return createResponse(
-              400,
-              { error: { code: -32700, message: "Parse error" } },
-              headers
-            );
-          }
-          const result = await handleUninstall(uninstallBody, config.hooks);
-          return createResponse(result.status, result.body, headers);
-        }
-        if (path16 === "/provision" && method === "POST") {
-          let provisionBody;
-          try {
-            provisionBody = event.body ? JSON.parse(event.body) : {};
-          } catch {
-            return createResponse(
-              400,
-              { error: { code: -32700, message: "Parse error" } },
-              headers
-            );
-          }
-          const result = await handleProvision(provisionBody, config.hooks);
-          return createResponse(result.status, result.body, headers);
-        }
-        if (path16 === "/oauth_callback" && method === "POST") {
-          let parsedBody;
-          try {
-            parsedBody = event.body ? JSON.parse(event.body) : {};
-          } catch (err) {
-            console.error("[OAuth Callback] Failed to parse JSON body:", err);
-            return createResponse(
-              400,
-              { error: { code: -32700, message: "Parse error" } },
-              headers
-            );
-          }
-          const result = await handleOAuthCallback(parsedBody, config.hooks);
-          return createResponse(result.status, result.body, headers);
-        }
-        if (path16 === "/health" && method === "GET") {
-          return createResponse(200, state.getHealthStatus(), headers);
-        }
-        if (path16 === "/config" && method === "GET") {
-          try {
-            if (fs8.existsSync(CONFIG_FILE_PATH2)) {
-              const fileConfig = JSON.parse(fs8.readFileSync(CONFIG_FILE_PATH2, "utf-8"));
-              return createResponse(200, fileConfig, headers);
-            }
-          } catch (err) {
-            console.warn("[/config] Failed to read config file, falling back to runtime serialization:", err);
-          }
-          return createResponse(200, serializeConfig(config), headers);
-        }
-        if (path16 === "/mcp" && method === "POST") {
-          let body;
-          try {
-            body = event.body ? JSON.parse(event.body) : {};
-          } catch {
-            return createResponse(
-              400,
-              {
-                jsonrpc: "2.0",
-                id: null,
-                error: {
-                  code: -32700,
-                  message: "Parse error"
-                }
-              },
-              headers
-            );
-          }
-          try {
-            const { jsonrpc, id, method: rpcMethod, params } = body;
-            if (jsonrpc !== "2.0") {
-              return createResponse(
-                400,
-                {
-                  jsonrpc: "2.0",
-                  id,
-                  error: {
-                    code: -32600,
-                    message: "Invalid Request"
-                  }
-                },
-                headers
-              );
-            }
-            let result;
-            if (rpcMethod === "tools/list") {
-              result = { tools };
-            } else if (rpcMethod === "tools/call") {
-              const toolName = params?.name;
-              const rawArgs = params?.arguments ?? {};
-              console.log("[serverless.ts /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("[serverless.ts /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(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
-                );
-              }
-              try {
-                const inputSchema = getZodSchema3(tool.inputSchema);
-                const outputSchema = getZodSchema3(tool.outputSchema);
-                const hasOutputSchema = Boolean(outputSchema);
-                const validatedInputs = inputSchema ? inputSchema.parse(toolInputs) : toolInputs;
-                const toolResult = await callTool(toolKey, {
-                  inputs: validatedInputs,
-                  context: toolContext,
-                  env: toolEnv,
-                  invocation: toolInvocation
-                });
-                if (toolResult.error) {
-                  const errorOutput = { error: toolResult.error };
-                  result = {
-                    content: [{ type: "text", text: JSON.stringify(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,
-                    isError: true,
-                    billing: toolResult.billing
-                  };
-                } else {
-                  const outputData = toolResult.output;
-                  let structuredContent;
-                  if (outputData) {
-                    structuredContent = { ...outputData, __effect: toolResult.effect };
-                  } else if (toolResult.effect) {
-                    structuredContent = { __effect: toolResult.effect };
-                  } else if (hasOutputSchema) {
-                    structuredContent = {};
-                  }
-                  result = {
-                    content: [{ type: "text", text: JSON.stringify(toolResult.output) }],
-                    structuredContent,
-                    billing: toolResult.billing
-                  };
-                }
-              } catch (validationError) {
-                return createResponse(
-                  200,
-                  {
-                    jsonrpc: "2.0",
-                    id,
-                    error: {
-                      code: -32602,
-                      message: validationError instanceof Error ? validationError.message : "Invalid arguments"
-                    }
-                  },
-                  headers
-                );
-              }
-            } else if (rpcMethod === "webhooks/list") {
-              const webhooks = webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-                name: w.name,
-                description: w.description,
-                methods: w.methods ?? ["POST"],
-                type: w.type ?? "WEBHOOK"
-              })) : [];
-              result = { webhooks };
-            } else {
-              return createResponse(
-                200,
-                {
-                  jsonrpc: "2.0",
-                  id,
-                  error: {
-                    code: -32601,
-                    message: `Method not found: ${rpcMethod}`
-                  }
-                },
-                headers
-              );
-            }
-            return createResponse(
-              200,
-              {
-                jsonrpc: "2.0",
-                id,
-                result
-              },
-              headers
-            );
-          } catch (err) {
-            return createResponse(
-              500,
-              {
-                jsonrpc: "2.0",
-                id: body?.id ?? null,
-                error: {
-                  code: -32603,
-                  message: err instanceof Error ? err.message : String(err ?? "")
-                }
-              },
-              headers
-            );
-          }
-        }
-        return createResponse(
-          404,
-          {
-            jsonrpc: "2.0",
-            id: null,
-            error: {
-              code: -32601,
-              message: "Not Found"
-            }
-          },
-          headers
-        );
-      } catch (err) {
-        return createResponse(
-          500,
-          {
-            jsonrpc: "2.0",
-            id: null,
-            error: {
-              code: -32603,
-              message: err instanceof Error ? err.message : String(err ?? "")
-            }
-          },
-          headers
-        );
-      }
+      const req = fromLambdaEvent(event);
+      const response = await routeRequest(req, ctx);
+      return toLambdaResponse(response, defaultHeaders);
     },
     getHealthStatus: () => state.getHealthStatus()
   };
@@ -4983,13 +4877,13 @@ Press Ctrl+C to stop`);
 }
 
 // src/cli/commands/validate.ts
-var fs10 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 init_utils();
 
 // src/config/loader.ts
-var fs9 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var CONFIG_FILE_NAMES = [
   "skedyul.config.ts",
@@ -4998,13 +4892,13 @@ var CONFIG_FILE_NAMES = [
   "skedyul.config.cjs"
 ];
 async function transpileTypeScript(filePath) {
-  const content = fs9.readFileSync(filePath, "utf-8");
-  const configDir = path7.dirname(path7.resolve(filePath));
+  const content = fs8.readFileSync(filePath, "utf-8");
+  const configDir = path8.dirname(path8.resolve(filePath));
   let transpiled = content.replace(/import\s+type\s+\{[^}]+\}\s+from\s+['"][^'"]+['"]\s*;?\n?/g, "").replace(/import\s+\{\s*defineConfig\s*\}\s+from\s+['"]skedyul['"]\s*;?\n?/g, "").replace(/:\s*SkedyulConfig/g, "").replace(/export\s+default\s+/, "module.exports = ").replace(/defineConfig\s*\(\s*\{/, "{").replace(/\}\s*\)\s*;?\s*$/, "}");
   transpiled = transpiled.replace(
     /import\s+(\w+)\s+from\s+['"](\.[^'"]+)['"]\s*(?:with\s*\{[^}]*\})?/g,
     (match, varName, relativePath) => {
-      const absolutePath = path7.resolve(configDir, relativePath);
+      const absolutePath = path8.resolve(configDir, relativePath);
       return `const ${varName} = require('${absolutePath.replace(/\\/g, "/")}')`;
     }
   );
@@ -5012,8 +4906,8 @@ async function transpileTypeScript(filePath) {
   return transpiled;
 }
 async function loadConfig(configPath) {
-  const absolutePath = path7.resolve(configPath);
-  if (!fs9.existsSync(absolutePath)) {
+  const absolutePath = path8.resolve(configPath);
+  if (!fs8.existsSync(absolutePath)) {
     throw new Error(`Config file not found: ${absolutePath}`);
   }
   const isTypeScript = absolutePath.endsWith(".ts");
@@ -5022,8 +4916,8 @@ async function loadConfig(configPath) {
     if (isTypeScript) {
       const transpiled = await transpileTypeScript(absolutePath);
       const tempDir = os2.tmpdir();
-      const tempFile = path7.join(tempDir, `skedyul-config-${Date.now()}.cjs`);
-      fs9.writeFileSync(tempFile, transpiled);
+      const tempFile = path8.join(tempDir, `skedyul-config-${Date.now()}.cjs`);
+      fs8.writeFileSync(tempFile, transpiled);
       moduleToLoad = tempFile;
       try {
         const module3 = require(moduleToLoad);
@@ -5037,7 +4931,7 @@ async function loadConfig(configPath) {
         return config2;
       } finally {
         try {
-          fs9.unlinkSync(tempFile);
+          fs8.unlinkSync(tempFile);
         } catch {
         }
       }
@@ -5069,9 +4963,9 @@ function validateConfig(config) {
 }
 
 // src/config/resolver.ts
-var path8 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 async function loadAndResolveConfig(configPath) {
-  const absolutePath = path8.resolve(configPath);
+  const absolutePath = path9.resolve(configPath);
   const module2 = await import(absolutePath);
   const config = module2.default;
   if (!config || typeof config !== "object") {
@@ -5174,8 +5068,8 @@ Examples:
 }
 function findConfigFile2(startDir) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path9.join(startDir, fileName);
-    if (fs10.existsSync(filePath)) {
+    const filePath = path10.join(startDir, fileName);
+    if (fs9.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -5209,9 +5103,9 @@ async function validateCommand(args2) {
     }
     configPath = foundConfig;
   } else {
-    configPath = path9.resolve(process.cwd(), configPath);
+    configPath = path10.resolve(process.cwd(), configPath);
   }
-  if (!fs10.existsSync(configPath)) {
+  if (!fs9.existsSync(configPath)) {
     const result2 = {
       valid: false,
       configPath,
@@ -5256,8 +5150,8 @@ async function validateCommand(args2) {
   if (provision?.workflows) {
     for (const workflow of provision.workflows) {
       if (workflow.path) {
-        const absoluteWorkflowPath = path9.resolve(path9.dirname(configPath), workflow.path);
-        if (!fs10.existsSync(absoluteWorkflowPath)) {
+        const absoluteWorkflowPath = path10.resolve(path10.dirname(configPath), workflow.path);
+        if (!fs9.existsSync(absoluteWorkflowPath)) {
           warnings.push(`Workflow file not found: ${workflow.path}`);
         }
       }
@@ -5352,8 +5246,8 @@ async function validateCommand(args2) {
 }
 
 // src/cli/commands/diff.ts
-var fs11 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 init_utils();
 function printHelp6() {
   console.log(`
@@ -5386,8 +5280,8 @@ Examples:
 }
 function findConfigFile3(startDir) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path10.join(startDir, fileName);
-    if (fs11.existsSync(filePath)) {
+    const filePath = path11.join(startDir, fileName);
+    if (fs10.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -5443,9 +5337,9 @@ async function diffCommand(args2) {
     }
     configPath = foundConfig;
   } else {
-    configPath = path10.resolve(process.cwd(), configPath);
+    configPath = path11.resolve(process.cwd(), configPath);
   }
-  if (!fs11.existsSync(configPath)) {
+  if (!fs10.existsSync(configPath)) {
     if (jsonOutput) {
       console.log(JSON.stringify({ error: `Config file not found: ${configPath}` }));
     } else {
@@ -5487,7 +5381,7 @@ async function diffCommand(args2) {
   const registryPath = flags.registry || flags.r;
   if (registryPath) {
     try {
-      const registry = await loadRegistry(path10.resolve(process.cwd(), registryPath));
+      const registry = await loadRegistry(path11.resolve(process.cwd(), registryPath));
       const toolNames = Object.values(registry).map((t) => t.name);
       toolsDiff = {
         added: toolNames,
@@ -5560,8 +5454,8 @@ async function diffCommand(args2) {
 }
 
 // src/cli/commands/deploy.ts
-var fs12 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var readline2 = __toESM(require("readline"));
 init_utils();
 function printHelp7() {
@@ -5597,8 +5491,8 @@ Examples:
 }
 function findConfigFile4(startDir) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path11.join(startDir, fileName);
-    if (fs12.existsSync(filePath)) {
+    const filePath = path12.join(startDir, fileName);
+    if (fs11.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -5712,9 +5606,9 @@ async function deployCommand(args2) {
     }
     configPath = foundConfig;
   } else {
-    configPath = path11.resolve(process.cwd(), configPath);
+    configPath = path12.resolve(process.cwd(), configPath);
   }
-  if (!fs12.existsSync(configPath)) {
+  if (!fs11.existsSync(configPath)) {
     if (jsonOutput) {
       console.log(JSON.stringify({ error: `Config file not found: ${configPath}` }));
     } else {
@@ -6031,8 +5925,8 @@ async function logoutCommand(args2) {
 }
 
 // src/cli/commands/auth/status.ts
-var fs13 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 init_utils();
 function printHelp10() {
   console.log(`
@@ -6106,17 +6000,17 @@ async function statusCommand(args2) {
     console.log("");
     console.log("  * = active profile");
   }
-  const linksDir = path12.join(process.cwd(), ".skedyul", "links");
+  const linksDir = path13.join(process.cwd(), ".skedyul", "links");
   console.log("");
   console.log("LINKED WORKPLACES (this project)");
   console.log("\u2500".repeat(60));
-  if (fs13.existsSync(linksDir)) {
-    const linkFiles = fs13.readdirSync(linksDir).filter((f) => f.endsWith(".json"));
+  if (fs12.existsSync(linksDir)) {
+    const linkFiles = fs12.readdirSync(linksDir).filter((f) => f.endsWith(".json"));
     if (linkFiles.length > 0) {
       for (const file2 of linkFiles) {
         const subdomain = file2.replace(".json", "");
         try {
-          const content = fs13.readFileSync(path12.join(linksDir, file2), "utf-8");
+          const content = fs12.readFileSync(path13.join(linksDir, file2), "utf-8");
           const link = JSON.parse(content);
           console.log(`  - ${subdomain} (${link.appHandle})`);
         } catch {
@@ -6473,8 +6367,8 @@ EXAMPLES
 }
 
 // src/cli/commands/config-export.ts
-var fs14 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 function printHelp13() {
   console.log(`
 SKEDYUL CONFIG:EXPORT - Export resolved config to JSON
@@ -6520,8 +6414,8 @@ async function configExportCommand(args2) {
   const cwd = process.cwd();
   let configPath = null;
   for (const name of CONFIG_FILE_NAMES) {
-    const testPath = path13.join(cwd, name);
-    if (fs14.existsSync(testPath)) {
+    const testPath = path14.join(cwd, name);
+    if (fs13.existsSync(testPath)) {
       configPath = testPath;
       break;
     }
@@ -6531,16 +6425,16 @@ async function configExportCommand(args2) {
     console.error("Make sure you are in the root of your integration project.");
     process.exit(1);
   }
-  console.log(`Loading config from ${path13.basename(configPath)}...`);
+  console.log(`Loading config from ${path14.basename(configPath)}...`);
   try {
     const resolvedConfig = await loadAndResolveConfig(configPath);
     const serialized = serializeResolvedConfig(resolvedConfig);
-    const outputDir = path13.dirname(path13.resolve(cwd, outputPath));
-    if (!fs14.existsSync(outputDir)) {
-      fs14.mkdirSync(outputDir, { recursive: true });
+    const outputDir = path14.dirname(path14.resolve(cwd, outputPath));
+    if (!fs13.existsSync(outputDir)) {
+      fs13.mkdirSync(outputDir, { recursive: true });
     }
-    const fullOutputPath = path13.resolve(cwd, outputPath);
-    fs14.writeFileSync(fullOutputPath, JSON.stringify(serialized, null, 2), "utf-8");
+    const fullOutputPath = path14.resolve(cwd, outputPath);
+    fs13.writeFileSync(fullOutputPath, JSON.stringify(serialized, null, 2), "utf-8");
     console.log(``);
     console.log(`Config exported successfully!`);
     console.log(`  Output: ${outputPath}`);
@@ -7123,8 +7017,8 @@ async function handleCreateMany(modelHandle, flags) {
     console.error("Usage: skedyul instances create-many <model> --file data.json --workplace <subdomain>");
     process.exit(1);
   }
-  const fs17 = await import("fs");
-  const fileContent = fs17.readFileSync(filePath, "utf-8");
+  const fs16 = await import("fs");
+  const fileContent = fs16.readFileSync(filePath, "utf-8");
   const items = JSON.parse(fileContent);
   if (!Array.isArray(items)) {
     console.error("Error: File must contain a JSON array of items");
@@ -7151,8 +7045,8 @@ async function handleUpsertMany(modelHandle, flags) {
     console.error("Usage: skedyul instances upsert-many <model> --file data.json --match-field <field> --workplace <subdomain>");
     process.exit(1);
   }
-  const fs17 = await import("fs");
-  const fileContent = fs17.readFileSync(filePath, "utf-8");
+  const fs16 = await import("fs");
+  const fileContent = fs16.readFileSync(filePath, "utf-8");
   const items = JSON.parse(fileContent);
   if (!Array.isArray(items)) {
     console.error("Error: File must contain a JSON array of items");
@@ -7164,8 +7058,8 @@ async function handleUpsertMany(modelHandle, flags) {
 
 // src/cli/commands/build.ts
 var import_child_process = require("child_process");
-var fs15 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 function printBuildHelp() {
   console.log(`
 SKEDYUL BUILD - Build your integration
@@ -7234,8 +7128,8 @@ async function buildCommand(args2) {
   const cwd = process.cwd();
   let configPath = null;
   for (const name of CONFIG_FILE_NAMES) {
-    const testPath = path14.join(cwd, name);
-    if (fs15.existsSync(testPath)) {
+    const testPath = path15.join(cwd, name);
+    if (fs14.existsSync(testPath)) {
       configPath = testPath;
       break;
     }
@@ -7245,8 +7139,8 @@ async function buildCommand(args2) {
     console.error("Make sure you are in the root of your integration project.");
     process.exit(1);
   }
-  console.log(`Loading config from ${path14.basename(configPath)}...`);
-  const tempConfigPath = path14.join(cwd, ".skedyul-tsup.config.mjs");
+  console.log(`Loading config from ${path15.basename(configPath)}...`);
+  const tempConfigPath = path15.join(cwd, ".skedyul-tsup.config.mjs");
   let createdTempConfig = false;
   try {
     const config = await loadConfig(configPath);
@@ -7255,8 +7149,8 @@ async function buildCommand(args2) {
     const baseExternals = ["skedyul", `skedyul/${computeLayer}`, "zod"];
     const userExternals = config.build && "external" in config.build ? config.build.external ?? [] : [];
     const allExternals = [...baseExternals, ...userExternals];
-    const userTsupConfig = path14.join(cwd, "tsup.config.ts");
-    const hasUserConfig = fs15.existsSync(userTsupConfig);
+    const userTsupConfig = path15.join(cwd, "tsup.config.ts");
+    const hasUserConfig = fs14.existsSync(userTsupConfig);
     console.log(``);
     console.log(`Building ${config.name ?? "integration"}...`);
     console.log(`  Compute layer: ${computeLayer}`);
@@ -7276,7 +7170,7 @@ async function buildCommand(args2) {
       }
     } else {
       const tsupConfigContent = generateTsupConfig(format, allExternals);
-      fs15.writeFileSync(tempConfigPath, tsupConfigContent, "utf-8");
+      fs14.writeFileSync(tempConfigPath, tsupConfigContent, "utf-8");
       createdTempConfig = true;
       tsupArgs = [
         "tsup",
@@ -7294,14 +7188,14 @@ async function buildCommand(args2) {
     });
     tsup.on("error", (error) => {
       console.error("Failed to start tsup:", error.message);
-      if (createdTempConfig && fs15.existsSync(tempConfigPath)) {
-        fs15.unlinkSync(tempConfigPath);
+      if (createdTempConfig && fs14.existsSync(tempConfigPath)) {
+        fs14.unlinkSync(tempConfigPath);
       }
       process.exit(1);
     });
     tsup.on("close", (code) => {
-      if (createdTempConfig && fs15.existsSync(tempConfigPath)) {
-        fs15.unlinkSync(tempConfigPath);
+      if (createdTempConfig && fs14.existsSync(tempConfigPath)) {
+        fs14.unlinkSync(tempConfigPath);
       }
       if (code === 0) {
         console.log(``);
@@ -7310,8 +7204,8 @@ async function buildCommand(args2) {
       process.exit(code ?? 0);
     });
   } catch (error) {
-    if (createdTempConfig && fs15.existsSync(tempConfigPath)) {
-      fs15.unlinkSync(tempConfigPath);
+    if (createdTempConfig && fs14.existsSync(tempConfigPath)) {
+      fs14.unlinkSync(tempConfigPath);
     }
     console.error(
       "Error loading config:",
@@ -7324,8 +7218,8 @@ async function buildCommand(args2) {
 // src/cli/commands/smoke-test.ts
 var import_child_process2 = require("child_process");
 var http3 = __toESM(require("http"));
-var fs16 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var SMOKE_TEST_PORT = 3456;
 var HEALTH_CHECK_INTERVAL_MS = 500;
 var HEALTH_CHECK_MAX_RETRIES = 30;
@@ -7356,13 +7250,13 @@ WHAT IT DOES
   6. Exits with code 0 (success) or 1 (failure)
 `);
 }
-function makeRequest(port, path16, method, body) {
+function makeRequest(port, path17, method, body) {
   return new Promise((resolve10, reject) => {
     const postData = body ? JSON.stringify(body) : void 0;
     const options = {
       hostname: "localhost",
       port,
-      path: path16,
+      path: path17,
       method,
       headers: {
         "Content-Type": "application/json",
@@ -7450,8 +7344,8 @@ async function smokeTestCommand(args2) {
   const cwd = process.cwd();
   let configPath = null;
   for (const name of CONFIG_FILE_NAMES) {
-    const testPath = path15.join(cwd, name);
-    if (fs16.existsSync(testPath)) {
+    const testPath = path16.join(cwd, name);
+    if (fs15.existsSync(testPath)) {
       configPath = testPath;
       break;
     }
@@ -7467,10 +7361,10 @@ async function smokeTestCommand(args2) {
   }
   const serverExt = computeLayer === "serverless" ? "mjs" : "js";
   let serverPath = `dist/server/mcp_server.${serverExt}`;
-  if (!fs16.existsSync(serverPath)) {
+  if (!fs15.existsSync(serverPath)) {
     const fallbackExt = serverExt === "mjs" ? "js" : "mjs";
     const fallbackPath = `dist/server/mcp_server.${fallbackExt}`;
-    if (fs16.existsSync(fallbackPath)) {
+    if (fs15.existsSync(fallbackPath)) {
       console.warn(`[SmokeTest] Warning: Expected ${serverPath} but found ${fallbackPath}`);
       console.warn(`[SmokeTest] Using ${fallbackPath} instead`);
       serverPath = fallbackPath;