skedyul 1.2.19 → 1.2.23

package/dist/dedicated/server.js

@@ -30,32 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server.ts
 var server_exports = {};
 __export(server_exports, {
-  buildRequestFromRaw: () => buildRequestFromRaw,
-  buildRequestScopedConfig: () => buildRequestScopedConfig,
-  buildToolMetadata: () => buildToolMetadata,
-  createCallToolHandler: () => createCallToolHandler,
-  createDedicatedServerInstance: () => createDedicatedServerInstance,
-  createRequestState: () => createRequestState,
-  createResponse: () => createResponse,
-  createServerlessInstance: () => createServerlessInstance,
   createSkedyulServer: () => createSkedyulServer,
-  getDefaultHeaders: () => getDefaultHeaders,
   getJsonSchemaFromToolSchema: () => getJsonSchemaFromToolSchema,
-  getListeningPort: () => getListeningPort,
   getZodSchema: () => getZodSchema,
-  handleCoreMethod: () => handleCoreMethod,
   isToolSchemaWithJson: () => isToolSchemaWithJson,
-  mergeRuntimeEnv: () => mergeRuntimeEnv,
-  normalizeBilling: () => normalizeBilling,
-  padEnd: () => padEnd,
-  parseHandlerEnvelope: () => parseHandlerEnvelope,
-  parseJSONBody: () => parseJSONBody,
-  parseJsonRecord: () => parseJsonRecord,
-  parseNumberEnv: () => parseNumberEnv,
-  printStartupLog: () => printStartupLog,
-  readRawRequestBody: () => readRawRequestBody,
-  sendHTML: () => sendHTML,
-  sendJSON: () => sendJSON,
   server: () => server,
   toJsonSchema: () => toJsonSchema
 });
@@ -203,10 +181,6 @@ function sendJSON(res, statusCode, data) {
   res.writeHead(statusCode, { "Content-Type": "application/json" });
   res.end(JSON.stringify(data));
 }
-function sendHTML(res, statusCode, html) {
-  res.writeHead(statusCode, { "Content-Type": "text/html; charset=utf-8" });
-  res.end(html);
-}
 function getDefaultHeaders(options) {
   return {
     "Content-Type": "application/json",
@@ -392,8 +366,8 @@ function createRequestState(maxRequests, ttlExtendSeconds, runtimeLabel, toolNam
   };
 }
 function createCallToolHandler(registry, state, onMaxRequests) {
-  return async function callTool(nameRaw, argsRaw) {
-    const toolName = String(nameRaw);
+  return async function callTool(toolNameInput, toolArgsInput) {
+    const toolName = String(toolNameInput);
     const tool = registry[toolName];
     if (!tool) {
       throw new Error(`Tool "${toolName}" not found in registry`);
@@ -402,7 +376,7 @@ function createCallToolHandler(registry, state, onMaxRequests) {
       throw new Error(`Tool "${toolName}" handler is not a function`);
     }
     const fn = tool.handler;
-    const args = argsRaw ?? {};
+    const args = toolArgsInput ?? {};
     const estimateMode = args.estimate === true;
     if (!estimateMode) {
       state.incrementRequestCount();
@@ -657,51 +631,6 @@ async function handleCoreMethod(method, params) {
   };
 }
 
-// src/server/handler-helpers.ts
-function parseHandlerEnvelope(parsedBody) {
-  if (typeof parsedBody !== "object" || parsedBody === null || Array.isArray(parsedBody) || !("env" in parsedBody) || !("request" in parsedBody)) {
-    return null;
-  }
-  const envelope = parsedBody;
-  if (typeof envelope.env !== "object" || envelope.env === null || Array.isArray(envelope.env)) {
-    return null;
-  }
-  if (typeof envelope.request !== "object" || envelope.request === null || Array.isArray(envelope.request)) {
-    return null;
-  }
-  return {
-    env: envelope.env,
-    request: envelope.request,
-    context: envelope.context
-  };
-}
-function buildRequestFromRaw(raw) {
-  let parsedBody = raw.body;
-  const contentType = raw.headers["content-type"] ?? "";
-  if (contentType.includes("application/json")) {
-    try {
-      parsedBody = raw.body ? JSON.parse(raw.body) : {};
-    } catch {
-      parsedBody = raw.body;
-    }
-  }
-  return {
-    method: raw.method,
-    url: raw.url,
-    path: raw.path,
-    headers: raw.headers,
-    query: raw.query,
-    body: parsedBody,
-    rawBody: raw.body ? Buffer.from(raw.body, "utf-8") : void 0
-  };
-}
-function buildRequestScopedConfig(env) {
-  return {
-    baseUrl: env.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
-    apiToken: env.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
-  };
-}
-
 // src/server/startup-logger.ts
 function padEnd(str, length) {
   if (str.length >= length) {
@@ -709,10 +638,11 @@ function padEnd(str, length) {
   }
   return str + " ".repeat(length - str.length);
 }
-function printStartupLog(config, tools, webhookRegistry, port) {
+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;
@@ -725,9 +655,9 @@ function printStartupLog(config, tools, webhookRegistry, port) {
   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.metadata.name, 49)}\u2551`);
-  console.log(`\u2551  \u{1F3F7}\uFE0F  Version:      ${padEnd(config.metadata.version, 49)}\u2551`);
-  console.log(`\u2551  \u26A1 Compute:      ${padEnd(config.computeLayer, 49)}\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`);
   }
@@ -769,67 +699,439 @@ function printStartupLog(config, tools, webhookRegistry, port) {
   console.log("");
 }
 
-// src/config/resolve.ts
-async function resolveDynamicImport(value) {
-  if (value === void 0 || value === null) {
-    return void 0;
+// src/server/config-serializer.ts
+function serializeConfig(config) {
+  const registry = config.tools;
+  const webhookRegistry = config.webhooks;
+  return {
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    computeLayer: config.computeLayer,
+    tools: registry ? Object.entries(registry).map(([key, tool]) => ({
+      name: tool.name || key,
+      description: tool.description,
+      timeout: tool.timeout,
+      retries: tool.retries
+    })) : [],
+    webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
+      name: w.name,
+      description: w.description,
+      methods: w.methods ?? ["POST"],
+      type: w.type ?? "WEBHOOK"
+    })) : [],
+    provision: isProvisionConfig(config.provision) ? config.provision : void 0,
+    agents: config.agents
+  };
+}
+function isProvisionConfig(value) {
+  return value !== void 0 && value !== null && !(value instanceof Promise);
+}
+
+// src/server/handlers/install-handler.ts
+async function handleInstall(body, hooks) {
+  if (!hooks?.install) {
+    return {
+      status: 404,
+      body: { error: "Install handler not configured" }
+    };
   }
-  if (value instanceof Promise) {
-    const resolved = await value;
-    if (resolved && typeof resolved === "object" && "default" in resolved) {
-      return resolved.default;
+  if (!body.context?.appInstallationId || !body.context?.workplace) {
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: -32602,
+          message: "Missing context (appInstallationId and workplace required)"
+        }
+      }
+    };
+  }
+  const installContext = {
+    env: body.env ?? {},
+    workplace: body.context.workplace,
+    appInstallationId: body.context.appInstallationId,
+    app: body.context.app,
+    invocation: body.invocation,
+    log: createContextLogger()
+  };
+  const requestConfig = {
+    baseUrl: body.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+    apiToken: body.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+  };
+  try {
+    const installHook = hooks.install;
+    const installHandler = typeof installHook === "function" ? installHook : installHook.handler;
+    const result = await runWithLogContext({ invocation: body.invocation }, async () => {
+      return await runWithConfig(requestConfig, async () => {
+        return await installHandler(installContext);
+      });
+    });
+    return {
+      status: 200,
+      body: { env: result.env ?? {}, redirect: result.redirect }
+    };
+  } catch (err) {
+    if (err instanceof InstallError) {
+      return {
+        status: 400,
+        body: {
+          error: {
+            code: err.code,
+            message: err.message,
+            field: err.field
+          }
+        }
+      };
     }
-    return resolved;
+    return {
+      status: 500,
+      body: {
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : String(err ?? "")
+        }
+      }
+    };
   }
-  return value;
 }
-function serializeTools(registry) {
-  return Object.entries(registry).map(([key, tool]) => ({
-    name: tool.name || key,
-    displayName: tool.label,
-    description: tool.description,
-    timeout: tool.timeout,
-    retries: tool.retries
-  }));
+
+// src/server/handlers/uninstall-handler.ts
+async function handleUninstall(body, hooks) {
+  if (!hooks?.uninstall) {
+    return {
+      status: 404,
+      body: { error: "Uninstall handler not configured" }
+    };
+  }
+  if (!body.context?.appInstallationId || !body.context?.workplace || !body.context?.app) {
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: -32602,
+          message: "Missing context (appInstallationId, workplace and app required)"
+        }
+      }
+    };
+  }
+  const uninstallContext = {
+    env: body.env ?? {},
+    workplace: body.context.workplace,
+    appInstallationId: body.context.appInstallationId,
+    app: body.context.app,
+    invocation: body.invocation,
+    log: createContextLogger()
+  };
+  const requestConfig = {
+    baseUrl: body.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+    apiToken: body.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+  };
+  try {
+    const uninstallHook = hooks.uninstall;
+    const uninstallHandlerFn = typeof uninstallHook === "function" ? uninstallHook : uninstallHook.handler;
+    const result = await runWithLogContext({ invocation: body.invocation }, async () => {
+      return await runWithConfig(requestConfig, async () => {
+        return await uninstallHandlerFn(uninstallContext);
+      });
+    });
+    return {
+      status: 200,
+      body: { cleanedWebhookIds: result.cleanedWebhookIds ?? [] }
+    };
+  } catch (err) {
+    return {
+      status: 500,
+      body: {
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : String(err ?? "")
+        }
+      }
+    };
+  }
 }
-function serializeWebhooks(registry) {
-  return Object.values(registry).map((webhook) => ({
-    name: webhook.name,
-    description: webhook.description,
-    methods: webhook.methods ?? ["POST"],
-    type: webhook.type ?? "WEBHOOK"
-  }));
+
+// src/server/handlers/provision-handler.ts
+async function handleProvision(body, hooks) {
+  if (!hooks?.provision) {
+    return {
+      status: 404,
+      body: { error: "Provision handler not configured" }
+    };
+  }
+  if (!body.context?.app) {
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: -32602,
+          message: "Missing context (app required)"
+        }
+      }
+    };
+  }
+  const mergedEnv = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0) {
+      mergedEnv[key] = value;
+    }
+  }
+  Object.assign(mergedEnv, body.env ?? {});
+  const provisionContext = {
+    env: mergedEnv,
+    app: body.context.app,
+    invocation: body.invocation,
+    log: createContextLogger()
+  };
+  const requestConfig = {
+    baseUrl: mergedEnv.SKEDYUL_API_URL ?? "",
+    apiToken: mergedEnv.SKEDYUL_API_TOKEN ?? ""
+  };
+  try {
+    const provisionHook = hooks.provision;
+    const provisionHandler = typeof provisionHook === "function" ? provisionHook : provisionHook.handler;
+    const result = await runWithLogContext({ invocation: body.invocation }, async () => {
+      return await runWithConfig(requestConfig, async () => {
+        return await provisionHandler(provisionContext);
+      });
+    });
+    return {
+      status: 200,
+      body: result
+    };
+  } catch (err) {
+    return {
+      status: 500,
+      body: {
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : String(err ?? "")
+        }
+      }
+    };
+  }
 }
-async function resolveConfig(config, registry, webhookRegistry) {
-  const provision = await resolveDynamicImport(
-    config.provision
-  );
-  const install = await resolveDynamicImport(
-    config.install
-  );
-  const tools = serializeTools(registry);
-  const webhooks = webhookRegistry ? serializeWebhooks(webhookRegistry) : [];
+
+// src/server/handler-helpers.ts
+function parseHandlerEnvelope(parsedBody) {
+  if (typeof parsedBody !== "object" || parsedBody === null || Array.isArray(parsedBody) || !("env" in parsedBody) || !("request" in parsedBody)) {
+    return null;
+  }
+  const envelope = parsedBody;
+  if (typeof envelope.env !== "object" || envelope.env === null || Array.isArray(envelope.env)) {
+    return null;
+  }
+  if (typeof envelope.request !== "object" || envelope.request === null || Array.isArray(envelope.request)) {
+    return null;
+  }
   return {
-    name: config.name,
-    version: config.version,
-    description: config.description,
-    computeLayer: config.computeLayer,
-    tools,
-    webhooks,
-    provision,
-    agents: config.agents
+    env: envelope.env,
+    request: envelope.request,
+    context: envelope.context
+  };
+}
+function buildRequestFromRaw(raw) {
+  let parsedBody = raw.body;
+  const contentType = raw.headers["content-type"] ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      parsedBody = raw.body ? JSON.parse(raw.body) : {};
+    } catch {
+      parsedBody = raw.body;
+    }
+  }
+  return {
+    method: raw.method,
+    url: raw.url,
+    path: raw.path,
+    headers: raw.headers,
+    query: raw.query,
+    body: parsedBody,
+    rawBody: raw.body ? Buffer.from(raw.body, "utf-8") : void 0
+  };
+}
+function buildRequestScopedConfig(env) {
+  return {
+    baseUrl: env.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+    apiToken: env.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+  };
+}
+
+// src/server/handlers/oauth-callback-handler.ts
+async function handleOAuthCallback(parsedBody, hooks) {
+  if (!hooks?.oauth_callback) {
+    return {
+      status: 404,
+      body: { error: "OAuth callback handler not configured" }
+    };
+  }
+  const envelope = parseHandlerEnvelope(parsedBody);
+  if (!envelope) {
+    console.error("[OAuth Callback] Failed to parse envelope. Body:", JSON.stringify(parsedBody, null, 2));
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: -32602,
+          message: "Missing envelope format: expected { env, request }"
+        }
+      }
+    };
+  }
+  const invocation = parsedBody.invocation;
+  const oauthRequest = buildRequestFromRaw(envelope.request);
+  const requestConfig = buildRequestScopedConfig(envelope.env);
+  const oauthCallbackContext = {
+    request: oauthRequest,
+    invocation,
+    log: createContextLogger()
+  };
+  try {
+    const oauthCallbackHook = hooks.oauth_callback;
+    const oauthCallbackHandler = typeof oauthCallbackHook === "function" ? oauthCallbackHook : oauthCallbackHook.handler;
+    const result = await runWithLogContext({ invocation }, async () => {
+      return await runWithConfig(requestConfig, async () => {
+        return await oauthCallbackHandler(oauthCallbackContext);
+      });
+    });
+    return {
+      status: 200,
+      body: {
+        appInstallationId: result.appInstallationId,
+        env: result.env ?? {}
+      }
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err ?? "Unknown error");
+    return {
+      status: 500,
+      body: {
+        error: {
+          code: -32603,
+          message: errorMessage
+        }
+      }
+    };
+  }
+}
+
+// src/server/handlers/webhook-handler.ts
+function parseWebhookRequest(parsedBody, method, url, path, 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;
+    const requestEnv = envelope.env ?? {};
+    const invocation = envelope.invocation;
+    let originalParsedBody = envelope.request.body;
+    const originalContentType = envelope.request.headers["content-type"] ?? "";
+    if (originalContentType.includes("application/json")) {
+      try {
+        originalParsedBody = envelope.request.body ? JSON.parse(envelope.request.body) : {};
+      } catch {
+      }
+    }
+    const webhookRequest2 = {
+      method: envelope.request.method,
+      url: envelope.request.url,
+      path: envelope.request.path,
+      headers: envelope.request.headers,
+      query: envelope.request.query,
+      body: originalParsedBody,
+      rawBody: envelope.request.body ? Buffer.from(envelope.request.body, "utf-8") : void 0
+    };
+    const envVars = { ...process.env, ...requestEnv };
+    const app = envelope.context.app;
+    let webhookContext2;
+    if (envelope.context.appInstallationId && envelope.context.workplace) {
+      webhookContext2 = {
+        env: envVars,
+        app,
+        appInstallationId: envelope.context.appInstallationId,
+        workplace: envelope.context.workplace,
+        registration: envelope.context.registration ?? {},
+        invocation,
+        log: createContextLogger()
+      };
+    } else {
+      webhookContext2 = {
+        env: envVars,
+        app,
+        invocation,
+        log: createContextLogger()
+      };
+    }
+    return { webhookRequest: webhookRequest2, webhookContext: webhookContext2, requestEnv, invocation };
+  }
+  if (!appIdHeader || !appVersionIdHeader) {
+    return {
+      error: "Missing app info in webhook request (x-skedyul-app-id and x-skedyul-app-version-id headers required)"
+    };
+  }
+  const webhookRequest = {
+    method,
+    url,
+    path,
+    headers,
+    query,
+    body: parsedBody,
+    rawBody: rawBody ? Buffer.from(rawBody, "utf-8") : void 0
+  };
+  const webhookContext = {
+    env: process.env,
+    app: { id: appIdHeader, versionId: appVersionIdHeader },
+    log: createContextLogger()
   };
+  return { webhookRequest, webhookContext, requestEnv: {} };
 }
-function createMinimalConfig(name, version) {
+async function executeWebhookHandler(handle, webhookRegistry, data) {
+  const webhookDef = webhookRegistry[handle];
+  if (!webhookDef) {
+    return {
+      status: 404,
+      body: { error: `Webhook handler '${handle}' not found` }
+    };
+  }
+  const originalEnv = { ...process.env };
+  Object.assign(process.env, data.requestEnv);
+  const requestConfig = {
+    baseUrl: data.requestEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+    apiToken: data.requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+  };
+  let webhookResponse;
+  try {
+    webhookResponse = await runWithLogContext({ invocation: data.invocation }, async () => {
+      return await runWithConfig(requestConfig, async () => {
+        return await webhookDef.handler(data.webhookRequest, data.webhookContext);
+      });
+    });
+  } catch (err) {
+    console.error(`Webhook handler '${handle}' error:`, err);
+    return {
+      status: 500,
+      body: { error: "Webhook handler error" }
+    };
+  } finally {
+    process.env = originalEnv;
+  }
   return {
-    name,
-    version
+    status: webhookResponse.status ?? 200,
+    body: webhookResponse.body,
+    headers: webhookResponse.headers
   };
 }
+function isMethodAllowed(webhookRegistry, handle, method) {
+  const webhookDef = webhookRegistry[handle];
+  if (!webhookDef) return false;
+  const allowedMethods = webhookDef.methods ?? ["POST"];
+  return allowedMethods.includes(method);
+}
 
 // src/server/dedicated.ts
-function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
+function createDedicatedServerInstance(config, tools, callTool, state, mcpServer) {
   const port = getListeningPort(config);
+  const registry = config.tools;
+  const webhookRegistry = config.webhooks;
   const httpServer = import_http2.default.createServer(
     async (req, res) => {
       function sendCoreResult(result) {
@@ -846,30 +1148,16 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           return;
         }
         if (pathname === "/config" && req.method === "GET") {
-          let appConfig = config.appConfig;
-          if (!appConfig && config.appConfigLoader) {
-            const loaded = await config.appConfigLoader();
-            appConfig = loaded.default;
-          }
-          if (!appConfig) {
-            appConfig = createMinimalConfig(
-              config.metadata.name,
-              config.metadata.version
-            );
-          }
-          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
-          sendJSON(res, 200, serializedConfig);
+          sendJSON(res, 200, serializeConfig(config));
           return;
         }
         if (pathname.startsWith("/webhooks/") && webhookRegistry) {
           const handle = pathname.slice("/webhooks/".length);
-          const webhookDef = webhookRegistry[handle];
-          if (!webhookDef) {
+          if (!webhookRegistry[handle]) {
             sendJSON(res, 404, { error: `Webhook handler '${handle}' not found` });
             return;
           }
-          const allowedMethods = webhookDef.methods ?? ["POST"];
-          if (!allowedMethods.includes(req.method)) {
+          if (!isMethodAllowed(webhookRegistry, handle, req.method ?? "POST")) {
             sendJSON(res, 405, { error: `Method ${req.method} not allowed` });
             return;
           }
@@ -891,87 +1179,34 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           } else {
             parsedBody = rawBody;
           }
-          const envelope = parseHandlerEnvelope(parsedBody);
-          let webhookRequest;
-          let webhookContext;
-          let requestEnv = {};
-          let invocation;
-          if (envelope && "context" in envelope && envelope.context) {
-            const context = envelope.context;
-            requestEnv = envelope.env;
-            invocation = parsedBody.invocation;
-            webhookRequest = buildRequestFromRaw(envelope.request);
-            const envVars = { ...process.env, ...envelope.env };
-            const app = context.app;
-            if (context.appInstallationId && context.workplace) {
-              webhookContext = {
-                env: envVars,
-                app,
-                appInstallationId: context.appInstallationId,
-                workplace: context.workplace,
-                registration: context.registration ?? {},
-                invocation,
-                log: createContextLogger()
-              };
-            } else {
-              webhookContext = {
-                env: envVars,
-                app,
-                invocation,
-                log: createContextLogger()
-              };
-            }
-          } else {
-            const appId = req.headers["x-skedyul-app-id"];
-            const appVersionId = req.headers["x-skedyul-app-version-id"];
-            if (!appId || !appVersionId) {
-              throw new Error("Missing app info in webhook request (x-skedyul-app-id and x-skedyul-app-version-id headers required)");
-            }
-            webhookRequest = {
-              method: req.method ?? "POST",
-              url: url.toString(),
-              path: pathname,
-              headers: req.headers,
-              query: Object.fromEntries(url.searchParams.entries()),
-              body: parsedBody,
-              rawBody: rawBody ? Buffer.from(rawBody, "utf-8") : void 0
-            };
-            webhookContext = {
-              env: process.env,
-              app: { id: appId, versionId: appVersionId },
-              log: createContextLogger()
-            };
-          }
-          const originalEnv = { ...process.env };
-          Object.assign(process.env, requestEnv);
-          const requestConfig = buildRequestScopedConfig(requestEnv);
-          let webhookResponse;
-          try {
-            webhookResponse = await runWithLogContext({ invocation }, async () => {
-              return await runWithConfig(requestConfig, async () => {
-                return await webhookDef.handler(webhookRequest, webhookContext);
-              });
-            });
-          } catch (err) {
-            console.error(`Webhook handler '${handle}' error:`, err);
-            sendJSON(res, 500, { error: "Webhook handler error" });
+          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;
-          } finally {
-            process.env = originalEnv;
           }
-          const status = webhookResponse.status ?? 200;
+          const result = await executeWebhookHandler(handle, webhookRegistry, parseResult);
           const responseHeaders = {
-            ...webhookResponse.headers
+            ...result.headers
           };
           if (!responseHeaders["Content-Type"] && !responseHeaders["content-type"]) {
             responseHeaders["Content-Type"] = "application/json";
           }
-          res.writeHead(status, responseHeaders);
-          if (webhookResponse.body !== void 0) {
-            if (typeof webhookResponse.body === "string") {
-              res.end(webhookResponse.body);
+          res.writeHead(result.status, responseHeaders);
+          if (result.body !== void 0) {
+            if (typeof result.body === "string") {
+              res.end(result.body);
             } else {
-              res.end(JSON.stringify(webhookResponse.body));
+              res.end(JSON.stringify(result.body));
             }
           } else {
             res.end();
@@ -1010,10 +1245,6 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           return;
         }
         if (pathname === "/oauth_callback" && req.method === "POST") {
-          if (!config.hooks?.oauth_callback) {
-            sendJSON(res, 404, { error: "OAuth callback handler not configured" });
-            return;
-          }
           let parsedBody;
           try {
             parsedBody = await parseJSONBody(req);
@@ -1024,50 +1255,11 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
             });
             return;
           }
-          const envelope = parseHandlerEnvelope(parsedBody);
-          if (!envelope) {
-            console.error("[OAuth Callback] Failed to parse envelope. Body:", JSON.stringify(parsedBody, null, 2));
-            sendJSON(res, 400, {
-              error: { code: -32602, message: "Missing envelope format: expected { env, request }" }
-            });
-            return;
-          }
-          const invocation = parsedBody.invocation;
-          const oauthRequest = buildRequestFromRaw(envelope.request);
-          const oauthCallbackRequestConfig = buildRequestScopedConfig(envelope.env);
-          const oauthCallbackContext = {
-            request: oauthRequest,
-            invocation,
-            log: createContextLogger()
-          };
-          try {
-            const oauthCallbackHook = config.hooks.oauth_callback;
-            const oauthCallbackHandler = typeof oauthCallbackHook === "function" ? oauthCallbackHook : oauthCallbackHook.handler;
-            const result = await runWithLogContext({ invocation }, async () => {
-              return await runWithConfig(oauthCallbackRequestConfig, async () => {
-                return await oauthCallbackHandler(oauthCallbackContext);
-              });
-            });
-            sendJSON(res, 200, {
-              appInstallationId: result.appInstallationId,
-              env: result.env ?? {}
-            });
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err ?? "Unknown error");
-            sendJSON(res, 500, {
-              error: {
-                code: -32603,
-                message: errorMessage
-              }
-            });
-          }
+          const result = await handleOAuthCallback(parsedBody, config.hooks);
+          sendJSON(res, result.status, result.body);
           return;
         }
         if (pathname === "/install" && req.method === "POST") {
-          if (!config.hooks?.install) {
-            sendJSON(res, 404, { error: "Install handler not configured" });
-            return;
-          }
           let installBody;
           try {
             installBody = await parseJSONBody(req);
@@ -1077,61 +1269,11 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
             });
             return;
           }
-          if (!installBody.context?.appInstallationId || !installBody.context?.workplace) {
-            sendJSON(res, 400, {
-              error: { code: -32602, message: "Missing context (appInstallationId and workplace required)" }
-            });
-            return;
-          }
-          const installContext = {
-            env: installBody.env ?? {},
-            workplace: installBody.context.workplace,
-            appInstallationId: installBody.context.appInstallationId,
-            app: installBody.context.app,
-            invocation: installBody.invocation,
-            log: createContextLogger()
-          };
-          const installRequestConfig = {
-            baseUrl: installBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
-            apiToken: installBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
-          };
-          try {
-            const installHook = config.hooks.install;
-            const installHandler = typeof installHook === "function" ? installHook : installHook.handler;
-            const result = await runWithLogContext({ invocation: installBody.invocation }, async () => {
-              return await runWithConfig(installRequestConfig, async () => {
-                return await installHandler(installContext);
-              });
-            });
-            sendJSON(res, 200, {
-              env: result.env ?? {},
-              redirect: result.redirect
-            });
-          } catch (err) {
-            if (err instanceof InstallError) {
-              sendJSON(res, 400, {
-                error: {
-                  code: err.code,
-                  message: err.message,
-                  field: err.field
-                }
-              });
-            } else {
-              sendJSON(res, 500, {
-                error: {
-                  code: -32603,
-                  message: err instanceof Error ? err.message : String(err ?? "")
-                }
-              });
-            }
-          }
+          const result = await handleInstall(installBody, config.hooks);
+          sendJSON(res, result.status, result.body);
           return;
         }
         if (pathname === "/uninstall" && req.method === "POST") {
-          if (!config.hooks?.uninstall) {
-            sendJSON(res, 404, { error: "Uninstall handler not configured" });
-            return;
-          }
           let uninstallBody;
           try {
             uninstallBody = await parseJSONBody(req);
@@ -1141,53 +1283,11 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
             });
             return;
           }
-          if (!uninstallBody.context?.appInstallationId || !uninstallBody.context?.workplace || !uninstallBody.context?.app) {
-            sendJSON(res, 400, {
-              error: {
-                code: -32602,
-                message: "Missing context (appInstallationId, workplace and app required)"
-              }
-            });
-            return;
-          }
-          const uninstallContext = {
-            env: uninstallBody.env ?? {},
-            workplace: uninstallBody.context.workplace,
-            appInstallationId: uninstallBody.context.appInstallationId,
-            app: uninstallBody.context.app,
-            invocation: uninstallBody.invocation,
-            log: createContextLogger()
-          };
-          const uninstallRequestConfig = {
-            baseUrl: uninstallBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
-            apiToken: uninstallBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
-          };
-          try {
-            const uninstallHook = config.hooks.uninstall;
-            const uninstallHandlerFn = typeof uninstallHook === "function" ? uninstallHook : uninstallHook.handler;
-            const result = await runWithLogContext({ invocation: uninstallBody.invocation }, async () => {
-              return await runWithConfig(uninstallRequestConfig, async () => {
-                return await uninstallHandlerFn(uninstallContext);
-              });
-            });
-            sendJSON(res, 200, {
-              cleanedWebhookIds: result.cleanedWebhookIds ?? []
-            });
-          } catch (err) {
-            sendJSON(res, 500, {
-              error: {
-                code: -32603,
-                message: err instanceof Error ? err.message : String(err ?? "")
-              }
-            });
-          }
+          const result = await handleUninstall(uninstallBody, config.hooks);
+          sendJSON(res, result.status, result.body);
           return;
         }
         if (pathname === "/provision" && req.method === "POST") {
-          if (!config.hooks?.provision) {
-            sendJSON(res, 404, { error: "Provision handler not configured" });
-            return;
-          }
           let provisionBody;
           try {
             provisionBody = await parseJSONBody(req);
@@ -1197,46 +1297,8 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
             });
             return;
           }
-          if (!provisionBody.context?.app) {
-            sendJSON(res, 400, {
-              error: { code: -32602, message: "Missing context (app required)" }
-            });
-            return;
-          }
-          const mergedEnv = {};
-          for (const [key, value] of Object.entries(process.env)) {
-            if (value !== void 0) {
-              mergedEnv[key] = value;
-            }
-          }
-          Object.assign(mergedEnv, provisionBody.env ?? {});
-          const provisionContext = {
-            env: mergedEnv,
-            app: provisionBody.context.app,
-            invocation: provisionBody.invocation,
-            log: createContextLogger()
-          };
-          const provisionRequestConfig = {
-            baseUrl: mergedEnv.SKEDYUL_API_URL ?? "",
-            apiToken: mergedEnv.SKEDYUL_API_TOKEN ?? ""
-          };
-          try {
-            const provisionHook = config.hooks.provision;
-            const provisionHandler = typeof provisionHook === "function" ? provisionHook : provisionHook.handler;
-            const result = await runWithLogContext({ invocation: provisionBody.invocation }, async () => {
-              return await runWithConfig(provisionRequestConfig, async () => {
-                return await provisionHandler(provisionContext);
-              });
-            });
-            sendJSON(res, 200, result);
-          } catch (err) {
-            sendJSON(res, 500, {
-              error: {
-                code: -32603,
-                message: err instanceof Error ? err.message : String(err ?? "")
-              }
-            });
-          }
+          const result = await handleProvision(provisionBody, config.hooks);
+          sendJSON(res, result.status, result.body);
           return;
         }
         if (pathname === "/core" && req.method === "POST") {
@@ -1387,7 +1449,7 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
       const finalPort = listenPort ?? port;
       return new Promise((resolve, reject) => {
         httpServer.listen(finalPort, () => {
-          printStartupLog(config, tools, webhookRegistry, finalPort);
+          printStartupLog(config, tools, finalPort);
           resolve();
         });
         httpServer.once("error", reject);
@@ -1398,13 +1460,15 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
 }
 
 // src/server/serverless.ts
-function createServerlessInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
+function createServerlessInstance(config, tools, callTool, state, mcpServer) {
   const headers = getDefaultHeaders(config.cors);
+  const registry = config.tools;
+  const webhookRegistry = config.webhooks;
   let hasLoggedStartup = false;
   return {
     async handler(event) {
       if (!hasLoggedStartup) {
-        printStartupLog(config, tools, webhookRegistry);
+        printStartupLog(config, tools);
         hasLoggedStartup = true;
       }
       try {
@@ -1415,12 +1479,10 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
         }
         if (path.startsWith("/webhooks/") && webhookRegistry) {
           const handle = path.slice("/webhooks/".length);
-          const webhookDef = webhookRegistry[handle];
-          if (!webhookDef) {
+          if (!webhookRegistry[handle]) {
             return createResponse(404, { error: `Webhook handler '${handle}' not found` }, headers);
           }
-          const allowedMethods = webhookDef.methods ?? ["POST"];
-          if (!allowedMethods.includes(method)) {
+          if (!isMethodAllowed(webhookRegistry, handle, method)) {
             return createResponse(405, { error: `Method ${method} not allowed` }, headers);
           }
           const rawBody = event.body ?? "";
@@ -1435,107 +1497,34 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
           } else {
             parsedBody = rawBody;
           }
-          const isEnvelope = typeof parsedBody === "object" && parsedBody !== null && "env" in parsedBody && "request" in parsedBody && "context" in parsedBody;
-          let webhookRequest;
-          let webhookContext;
-          let requestEnv = {};
-          let invocation;
-          if (isEnvelope) {
-            const envelope = parsedBody;
-            requestEnv = envelope.env ?? {};
-            invocation = envelope.invocation;
-            let originalParsedBody = envelope.request.body;
-            const originalContentType = envelope.request.headers["content-type"] ?? "";
-            if (originalContentType.includes("application/json")) {
-              try {
-                originalParsedBody = envelope.request.body ? JSON.parse(envelope.request.body) : {};
-              } catch {
-              }
-            }
-            webhookRequest = {
-              method: envelope.request.method,
-              url: envelope.request.url,
-              path: envelope.request.path,
-              headers: envelope.request.headers,
-              query: envelope.request.query,
-              body: originalParsedBody,
-              rawBody: envelope.request.body ? Buffer.from(envelope.request.body, "utf-8") : void 0
-            };
-            const envVars = { ...process.env, ...requestEnv };
-            const app = envelope.context.app;
-            if (envelope.context.appInstallationId && envelope.context.workplace) {
-              webhookContext = {
-                env: envVars,
-                app,
-                appInstallationId: envelope.context.appInstallationId,
-                workplace: envelope.context.workplace,
-                registration: envelope.context.registration ?? {},
-                invocation,
-                log: createContextLogger()
-              };
-            } else {
-              webhookContext = {
-                env: envVars,
-                app,
-                invocation,
-                log: createContextLogger()
-              };
-            }
-          } else {
-            const appId = event.headers?.["x-skedyul-app-id"] ?? event.headers?.["X-Skedyul-App-Id"];
-            const appVersionId = event.headers?.["x-skedyul-app-version-id"] ?? event.headers?.["X-Skedyul-App-Version-Id"];
-            if (!appId || !appVersionId) {
-              throw new Error("Missing app info in webhook request (x-skedyul-app-id and x-skedyul-app-version-id headers required)");
-            }
-            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}${path}${queryString}`;
-            webhookRequest = {
-              method,
-              url: webhookUrl,
-              path,
-              headers: event.headers,
-              query: event.queryStringParameters ?? {},
-              body: parsedBody,
-              rawBody: rawBody ? Buffer.from(rawBody, "utf-8") : void 0
-            };
-            webhookContext = {
-              env: process.env,
-              app: { id: appId, versionId: appVersionId },
-              log: createContextLogger()
-            };
-          }
-          const originalEnv = { ...process.env };
-          Object.assign(process.env, requestEnv);
-          const requestConfig = {
-            baseUrl: requestEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
-            apiToken: requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
-          };
-          let webhookResponse;
-          try {
-            webhookResponse = await runWithLogContext({ invocation }, async () => {
-              return await runWithConfig(requestConfig, async () => {
-                return await webhookDef.handler(webhookRequest, webhookContext);
-              });
-            });
-          } catch (err) {
-            console.error(`Webhook handler '${handle}' error:`, err);
-            return createResponse(500, { error: "Webhook handler error" }, headers);
-          } finally {
-            process.env = originalEnv;
+          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}${path}${queryString}`;
+          const parseResult = parseWebhookRequest(
+            parsedBody,
+            method,
+            webhookUrl,
+            path,
+            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,
-            ...webhookResponse.headers
+            ...result.headers
           };
-          const status = webhookResponse.status ?? 200;
-          const body = webhookResponse.body;
           return {
-            statusCode: status,
+            statusCode: result.status,
             headers: responseHeaders,
-            body: body !== void 0 ? typeof body === "string" ? body : JSON.stringify(body) : ""
+            body: result.body !== void 0 ? typeof result.body === "string" ? result.body : JSON.stringify(result.body) : ""
           };
         }
         if (path === "/core" && method === "POST") {
@@ -1671,9 +1660,6 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
           }
         }
         if (path === "/install" && method === "POST") {
-          if (!config.hooks?.install) {
-            return createResponse(404, { error: "Install handler not configured" }, headers);
-          }
           let installBody;
           try {
             installBody = event.body ? JSON.parse(event.body) : {};
@@ -1684,68 +1670,10 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
               headers
             );
           }
-          if (!installBody.context?.appInstallationId || !installBody.context?.workplace) {
-            return createResponse(
-              400,
-              { error: { code: -32602, message: "Missing context (appInstallationId and workplace required)" } },
-              headers
-            );
-          }
-          const installContext = {
-            env: installBody.env ?? {},
-            workplace: installBody.context.workplace,
-            appInstallationId: installBody.context.appInstallationId,
-            app: installBody.context.app,
-            invocation: installBody.invocation,
-            log: createContextLogger()
-          };
-          const installRequestConfig = {
-            baseUrl: installBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
-            apiToken: installBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
-          };
-          try {
-            const installHook = config.hooks.install;
-            const installHandler = typeof installHook === "function" ? installHook : installHook.handler;
-            const result = await runWithLogContext({ invocation: installBody.invocation }, async () => {
-              return await runWithConfig(installRequestConfig, async () => {
-                return await installHandler(installContext);
-              });
-            });
-            return createResponse(
-              200,
-              { env: result.env ?? {}, redirect: result.redirect },
-              headers
-            );
-          } catch (err) {
-            if (err instanceof InstallError) {
-              return createResponse(
-                400,
-                {
-                  error: {
-                    code: err.code,
-                    message: err.message,
-                    field: err.field
-                  }
-                },
-                headers
-              );
-            }
-            return createResponse(
-              500,
-              {
-                error: {
-                  code: -32603,
-                  message: err instanceof Error ? err.message : String(err ?? "")
-                }
-              },
-              headers
-            );
-          }
+          const result = await handleInstall(installBody, config.hooks);
+          return createResponse(result.status, result.body, headers);
         }
         if (path === "/uninstall" && method === "POST") {
-          if (!config.hooks?.uninstall) {
-            return createResponse(404, { error: "Uninstall handler not configured" }, headers);
-          }
           let uninstallBody;
           try {
             uninstallBody = event.body ? JSON.parse(event.body) : {};
@@ -1756,137 +1684,24 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
               headers
             );
           }
-          if (!uninstallBody.context?.appInstallationId || !uninstallBody.context?.workplace || !uninstallBody.context?.app) {
-            return createResponse(
-              400,
-              {
-                error: {
-                  code: -32602,
-                  message: "Missing context (appInstallationId, workplace and app required)"
-                }
-              },
-              headers
-            );
-          }
-          const uninstallContext = {
-            env: uninstallBody.env ?? {},
-            workplace: uninstallBody.context.workplace,
-            appInstallationId: uninstallBody.context.appInstallationId,
-            app: uninstallBody.context.app,
-            invocation: uninstallBody.invocation,
-            log: createContextLogger()
-          };
-          const uninstallRequestConfig = {
-            baseUrl: uninstallBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
-            apiToken: uninstallBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
-          };
-          try {
-            const uninstallHook = config.hooks.uninstall;
-            const uninstallHandlerFn = typeof uninstallHook === "function" ? uninstallHook : uninstallHook.handler;
-            const result = await runWithLogContext({ invocation: uninstallBody.invocation }, async () => {
-              return await runWithConfig(uninstallRequestConfig, async () => {
-                return await uninstallHandlerFn(uninstallContext);
-              });
-            });
-            return createResponse(
-              200,
-              { cleanedWebhookIds: result.cleanedWebhookIds ?? [] },
-              headers
-            );
-          } catch (err) {
-            return createResponse(
-              500,
-              {
-                error: {
-                  code: -32603,
-                  message: err instanceof Error ? err.message : String(err ?? "")
-                }
-              },
-              headers
-            );
-          }
+          const result = await handleUninstall(uninstallBody, config.hooks);
+          return createResponse(result.status, result.body, headers);
         }
         if (path === "/provision" && method === "POST") {
-          console.log("[serverless] /provision endpoint called");
-          if (!config.hooks?.provision) {
-            console.log("[serverless] No provision handler configured");
-            return createResponse(404, { error: "Provision handler not configured" }, headers);
-          }
           let provisionBody;
           try {
             provisionBody = event.body ? JSON.parse(event.body) : {};
-            console.log("[serverless] Provision body parsed:", {
-              hasEnv: !!provisionBody.env,
-              hasContext: !!provisionBody.context,
-              appId: provisionBody.context?.app?.id,
-              versionId: provisionBody.context?.app?.versionId
-            });
           } catch {
-            console.log("[serverless] Failed to parse provision body");
             return createResponse(
               400,
               { error: { code: -32700, message: "Parse error" } },
               headers
             );
           }
-          if (!provisionBody.context?.app) {
-            console.log("[serverless] Missing app context in provision body");
-            return createResponse(
-              400,
-              { error: { code: -32602, message: "Missing context (app required)" } },
-              headers
-            );
-          }
-          const mergedEnv = {};
-          for (const [key, value] of Object.entries(process.env)) {
-            if (value !== void 0) {
-              mergedEnv[key] = value;
-            }
-          }
-          Object.assign(mergedEnv, provisionBody.env ?? {});
-          const provisionContext = {
-            env: mergedEnv,
-            app: provisionBody.context.app,
-            invocation: provisionBody.invocation,
-            log: createContextLogger()
-          };
-          const provisionRequestConfig = {
-            baseUrl: mergedEnv.SKEDYUL_API_URL ?? "",
-            apiToken: mergedEnv.SKEDYUL_API_TOKEN ?? ""
-          };
-          console.log("[serverless] Calling provision handler...");
-          try {
-            const provisionHook = config.hooks.provision;
-            const provisionHandler = typeof provisionHook === "function" ? provisionHook : provisionHook.handler;
-            const result = await runWithLogContext({ invocation: provisionBody.invocation }, async () => {
-              return await runWithConfig(provisionRequestConfig, async () => {
-                return await provisionHandler(provisionContext);
-              });
-            });
-            console.log("[serverless] Provision handler completed successfully");
-            return createResponse(200, result, headers);
-          } catch (err) {
-            console.error("[serverless] Provision handler failed:", err instanceof Error ? err.message : String(err));
-            return createResponse(
-              500,
-              {
-                error: {
-                  code: -32603,
-                  message: err instanceof Error ? err.message : String(err ?? "")
-                }
-              },
-              headers
-            );
-          }
+          const result = await handleProvision(provisionBody, config.hooks);
+          return createResponse(result.status, result.body, headers);
         }
         if (path === "/oauth_callback" && method === "POST") {
-          if (!config.hooks?.oauth_callback) {
-            return createResponse(
-              404,
-              { error: "OAuth callback handler not configured" },
-              headers
-            );
-          }
           let parsedBody;
           try {
             parsedBody = event.body ? JSON.parse(event.body) : {};
@@ -1898,70 +1713,14 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
               headers
             );
           }
-          const envelope = parseHandlerEnvelope(parsedBody);
-          if (!envelope) {
-            console.error("[OAuth Callback] Failed to parse envelope. Body:", JSON.stringify(parsedBody, null, 2));
-            return createResponse(
-              400,
-              { error: { code: -32602, message: "Missing envelope format: expected { env, request }" } },
-              headers
-            );
-          }
-          const invocation = parsedBody.invocation;
-          const oauthRequest = buildRequestFromRaw(envelope.request);
-          const oauthCallbackRequestConfig = buildRequestScopedConfig(envelope.env);
-          const oauthCallbackContext = {
-            request: oauthRequest,
-            invocation,
-            log: createContextLogger()
-          };
-          try {
-            const oauthCallbackHook = config.hooks.oauth_callback;
-            const oauthCallbackHandler = typeof oauthCallbackHook === "function" ? oauthCallbackHook : oauthCallbackHook.handler;
-            const result = await runWithLogContext({ invocation }, async () => {
-              return await runWithConfig(oauthCallbackRequestConfig, async () => {
-                return await oauthCallbackHandler(oauthCallbackContext);
-              });
-            });
-            return createResponse(
-              200,
-              {
-                appInstallationId: result.appInstallationId,
-                env: result.env ?? {}
-              },
-              headers
-            );
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err ?? "Unknown error");
-            return createResponse(
-              500,
-              {
-                error: {
-                  code: -32603,
-                  message: errorMessage
-                }
-              },
-              headers
-            );
-          }
+          const result = await handleOAuthCallback(parsedBody, config.hooks);
+          return createResponse(result.status, result.body, headers);
         }
         if (path === "/health" && method === "GET") {
           return createResponse(200, state.getHealthStatus(), headers);
         }
         if (path === "/config" && method === "GET") {
-          let appConfig = config.appConfig;
-          if (!appConfig && config.appConfigLoader) {
-            const loaded = await config.appConfigLoader();
-            appConfig = loaded.default;
-          }
-          if (!appConfig) {
-            appConfig = createMinimalConfig(
-              config.metadata.name,
-              config.metadata.version
-            );
-          }
-          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
-          return createResponse(200, serializedConfig, headers);
+          return createResponse(200, serializeConfig(config), headers);
         }
         if (path === "/mcp" && method === "POST") {
           let body;
@@ -2179,9 +1938,11 @@ 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, registry, webhookRegistry) {
+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);
@@ -2193,7 +1954,7 @@ function createSkedyulServer(config, registry, webhookRegistry) {
   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;
+  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()");
@@ -2206,8 +1967,8 @@ function createSkedyulServer(config, registry, webhookRegistry) {
   console.log("[createSkedyulServer] Step 4 done");
   console.log("[createSkedyulServer] Step 5: new McpServer()");
   const mcpServer = new import_mcp.McpServer({
-    name: config.metadata.name,
-    version: config.metadata.version
+    name: config.name,
+    version: config.version ?? "0.0.0"
   });
   console.log("[createSkedyulServer] Step 5 done");
   const dedicatedShutdown = () => {
@@ -2335,13 +2096,11 @@ function createSkedyulServer(config, registry, webhookRegistry) {
       tools,
       callTool,
       state,
-      mcpServer,
-      registry,
-      webhookRegistry
+      mcpServer
     );
   }
   console.log("[createSkedyulServer] Creating serverless instance");
-  const serverlessInstance = createServerlessInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry);
+  const serverlessInstance = createServerlessInstance(config, tools, callTool, state, mcpServer);
   console.log("[createSkedyulServer] Serverless instance created successfully");
   return serverlessInstance;
 }
@@ -2350,32 +2109,10 @@ var server = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  buildRequestFromRaw,
-  buildRequestScopedConfig,
-  buildToolMetadata,
-  createCallToolHandler,
-  createDedicatedServerInstance,
-  createRequestState,
-  createResponse,
-  createServerlessInstance,
   createSkedyulServer,
-  getDefaultHeaders,
   getJsonSchemaFromToolSchema,
-  getListeningPort,
   getZodSchema,
-  handleCoreMethod,
   isToolSchemaWithJson,
-  mergeRuntimeEnv,
-  normalizeBilling,
-  padEnd,
-  parseHandlerEnvelope,
-  parseJSONBody,
-  parseJsonRecord,
-  parseNumberEnv,
-  printStartupLog,
-  readRawRequestBody,
-  sendHTML,
-  sendJSON,
   server,
   toJsonSchema
 });