skedyul 0.3.0 → 0.3.2

package/dist/server/serverless.js

@@ -0,0 +1,629 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerlessInstance = createServerlessInstance;
+const service_1 = require("../core/service");
+const client_1 = require("../core/client");
+const errors_1 = require("../errors");
+const core_api_handler_1 = require("./core-api-handler");
+const handler_helpers_1 = require("./handler-helpers");
+const startup_logger_1 = require("./startup-logger");
+const utils_1 = require("./utils");
+/**
+ * Creates a serverless (Lambda-style) server instance
+ */
+function createServerlessInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
+    const headers = (0, utils_1.getDefaultHeaders)(config.cors);
+    // Print startup log once on cold start
+    let hasLoggedStartup = false;
+    return {
+        async handler(event) {
+            // Log startup info on first invocation (cold start)
+            if (!hasLoggedStartup) {
+                (0, startup_logger_1.printStartupLog)(config, tools, webhookRegistry);
+                hasLoggedStartup = true;
+            }
+            try {
+                const path = event.path;
+                const method = event.httpMethod;
+                if (method === 'OPTIONS') {
+                    return (0, utils_1.createResponse)(200, { message: 'OK' }, headers);
+                }
+                // Handle webhook requests: /webhooks/{handle}
+                if (path.startsWith('/webhooks/') && webhookRegistry) {
+                    const handle = path.slice('/webhooks/'.length);
+                    const webhookDef = webhookRegistry[handle];
+                    if (!webhookDef) {
+                        return (0, utils_1.createResponse)(404, { error: `Webhook handler '${handle}' not found` }, headers);
+                    }
+                    // Check if HTTP method is allowed
+                    const allowedMethods = webhookDef.methods ?? ['POST'];
+                    if (!allowedMethods.includes(method)) {
+                        return (0, utils_1.createResponse)(405, { error: `Method ${method} not allowed` }, headers);
+                    }
+                    // Get raw body
+                    const rawBody = event.body ?? '';
+                    // Parse body based on content type
+                    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;
+                    }
+                    // Check if this is an envelope format from the platform
+                    // Envelope format: { env: {...}, request: {...}, context: {...} }
+                    const isEnvelope = (typeof parsedBody === 'object' &&
+                        parsedBody !== null &&
+                        'env' in parsedBody &&
+                        'request' in parsedBody &&
+                        'context' in parsedBody);
+                    let webhookRequest;
+                    let webhookContext;
+                    let requestEnv = {};
+                    if (isEnvelope) {
+                        // Platform envelope format - extract env, request, and context
+                        const envelope = parsedBody;
+                        requestEnv = envelope.env ?? {};
+                        // Parse the original request body
+                        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 {
+                                // Keep as string if JSON parsing fails
+                            }
+                        }
+                        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') : undefined,
+                        };
+                        const envVars = { ...process.env, ...requestEnv };
+                        const app = envelope.context.app;
+                        // Build webhook context based on whether we have installation context
+                        if (envelope.context.appInstallationId && envelope.context.workplace) {
+                            // Runtime webhook context
+                            webhookContext = {
+                                env: envVars,
+                                app,
+                                appInstallationId: envelope.context.appInstallationId,
+                                workplace: envelope.context.workplace,
+                                registration: envelope.context.registration ?? {},
+                            };
+                        }
+                        else {
+                            // Provision webhook context
+                            webhookContext = {
+                                env: envVars,
+                                app,
+                            };
+                        }
+                    }
+                    else {
+                        // Direct request format (legacy or direct calls) - requires app info from headers or fail
+                        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') : undefined,
+                        };
+                        // Direct calls are provision-level (no installation context)
+                        webhookContext = {
+                            env: process.env,
+                            app: { id: appId, versionId: appVersionId },
+                        };
+                    }
+                    // Temporarily inject env into process.env for skedyul client to use
+                    // (same pattern as tool handler)
+                    const originalEnv = { ...process.env };
+                    Object.assign(process.env, requestEnv);
+                    // Build request-scoped config for the skedyul client
+                    // This uses AsyncLocalStorage to override the global config (same pattern as tools)
+                    const requestConfig = {
+                        baseUrl: requestEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? '',
+                        apiToken: requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? '',
+                    };
+                    // Invoke the handler with request-scoped config
+                    let webhookResponse;
+                    try {
+                        webhookResponse = await (0, client_1.runWithConfig)(requestConfig, async () => {
+                            return await webhookDef.handler(webhookRequest, webhookContext);
+                        });
+                    }
+                    catch (err) {
+                        console.error(`Webhook handler '${handle}' error:`, err);
+                        return (0, utils_1.createResponse)(500, { error: 'Webhook handler error' }, headers);
+                    }
+                    finally {
+                        // Restore original env
+                        process.env = originalEnv;
+                    }
+                    // Build response headers
+                    const responseHeaders = {
+                        ...headers,
+                        ...webhookResponse.headers,
+                    };
+                    const status = webhookResponse.status ?? 200;
+                    const body = webhookResponse.body;
+                    return {
+                        statusCode: status,
+                        headers: responseHeaders,
+                        body: body !== undefined
+                            ? (typeof body === 'string' ? body : JSON.stringify(body))
+                            : '',
+                    };
+                }
+                if (path === '/core' && method === 'POST') {
+                    let coreBody;
+                    try {
+                        coreBody = event.body ? JSON.parse(event.body) : {};
+                    }
+                    catch {
+                        return (0, utils_1.createResponse)(400, {
+                            error: {
+                                code: -32700,
+                                message: 'Parse error',
+                            },
+                        }, headers);
+                    }
+                    if (!coreBody?.method) {
+                        return (0, utils_1.createResponse)(400, {
+                            error: {
+                                code: -32602,
+                                message: 'Missing method',
+                            },
+                        }, headers);
+                    }
+                    const coreMethod = coreBody.method;
+                    const result = await (0, core_api_handler_1.handleCoreMethod)(coreMethod, coreBody.params);
+                    return (0, utils_1.createResponse)(result.status, result.payload, headers);
+                }
+                if (path === '/core/webhook' && method === 'POST') {
+                    const rawWebhookBody = event.body ?? '';
+                    let webhookBody;
+                    try {
+                        webhookBody = rawWebhookBody ? JSON.parse(rawWebhookBody) : {};
+                    }
+                    catch {
+                        return (0, utils_1.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}${event.path}`;
+                    const coreWebhookRequest = {
+                        method,
+                        headers: (event.headers ?? {}),
+                        body: webhookBody,
+                        query: event.queryStringParameters ?? {},
+                        url: webhookUrl,
+                        path: event.path,
+                        rawBody: rawWebhookBody
+                            ? Buffer.from(rawWebhookBody, 'utf-8')
+                            : undefined,
+                    };
+                    const webhookResponse = await service_1.coreApiService.dispatchWebhook(coreWebhookRequest);
+                    return (0, utils_1.createResponse)(webhookResponse.status, webhookResponse.body ?? {}, headers);
+                }
+                if (path === '/estimate' && method === 'POST') {
+                    let estimateBody;
+                    try {
+                        estimateBody = event.body ? JSON.parse(event.body) : {};
+                    }
+                    catch {
+                        return (0, utils_1.createResponse)(400, {
+                            error: {
+                                code: -32700,
+                                message: 'Parse error',
+                            },
+                        }, headers);
+                    }
+                    try {
+                        const toolName = estimateBody.name;
+                        const toolArgs = estimateBody.inputs ?? {};
+                        // Find tool by name
+                        let toolKey = null;
+                        let tool = null;
+                        for (const [key, t] of Object.entries(registry)) {
+                            if (t.name === toolName || key === toolName) {
+                                toolKey = key;
+                                tool = t;
+                                break;
+                            }
+                        }
+                        if (!tool || !toolKey) {
+                            return (0, utils_1.createResponse)(400, {
+                                error: {
+                                    code: -32602,
+                                    message: `Tool "${toolName}" not found`,
+                                },
+                            }, headers);
+                        }
+                        const inputSchema = (0, utils_1.getZodSchema)(tool.inputSchema);
+                        // Validate arguments against Zod schema
+                        const validatedArgs = inputSchema ? inputSchema.parse(toolArgs) : toolArgs;
+                        const estimateResponse = await callTool(toolKey, {
+                            inputs: validatedArgs,
+                            estimate: true,
+                        });
+                        return (0, utils_1.createResponse)(200, {
+                            billing: estimateResponse.billing ?? { credits: 0 },
+                        }, headers);
+                    }
+                    catch (err) {
+                        return (0, utils_1.createResponse)(500, {
+                            error: {
+                                code: -32603,
+                                message: err instanceof Error ? err.message : String(err ?? ''),
+                            },
+                        }, headers);
+                    }
+                }
+                // Handle /install endpoint for install handlers
+                if (path === '/install' && method === 'POST') {
+                    if (!config.hooks?.install) {
+                        return (0, utils_1.createResponse)(404, { error: 'Install handler not configured' }, headers);
+                    }
+                    let installBody;
+                    try {
+                        installBody = event.body ? JSON.parse(event.body) : {};
+                    }
+                    catch {
+                        return (0, utils_1.createResponse)(400, { error: { code: -32700, message: 'Parse error' } }, headers);
+                    }
+                    if (!installBody.context?.appInstallationId || !installBody.context?.workplace) {
+                        return (0, utils_1.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,
+                    };
+                    // Build request-scoped config for SDK access
+                    // Use env from request body (contains generated token from workflow)
+                    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 (0, client_1.runWithConfig)(installRequestConfig, async () => {
+                            return await installHandler(installContext);
+                        });
+                        return (0, utils_1.createResponse)(200, { env: result.env ?? {}, redirect: result.redirect }, headers);
+                    }
+                    catch (err) {
+                        // Check for typed install errors
+                        if (err instanceof errors_1.InstallError) {
+                            return (0, utils_1.createResponse)(400, {
+                                error: {
+                                    code: err.code,
+                                    message: err.message,
+                                    field: err.field,
+                                },
+                            }, headers);
+                        }
+                        return (0, utils_1.createResponse)(500, {
+                            error: {
+                                code: -32603,
+                                message: err instanceof Error ? err.message : String(err ?? ''),
+                            },
+                        }, headers);
+                    }
+                }
+                // Handle /uninstall endpoint for uninstall handlers
+                if (path === '/uninstall' && method === 'POST') {
+                    if (!config.hooks?.uninstall) {
+                        return (0, utils_1.createResponse)(404, { error: 'Uninstall handler not configured' }, headers);
+                    }
+                    let uninstallBody;
+                    try {
+                        uninstallBody = event.body ? JSON.parse(event.body) : {};
+                    }
+                    catch {
+                        return (0, utils_1.createResponse)(400, { error: { code: -32700, message: 'Parse error' } }, headers);
+                    }
+                    if (!uninstallBody.context?.appInstallationId ||
+                        !uninstallBody.context?.workplace ||
+                        !uninstallBody.context?.app) {
+                        return (0, utils_1.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,
+                    };
+                    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 (0, client_1.runWithConfig)(uninstallRequestConfig, async () => {
+                            return await uninstallHandlerFn(uninstallContext);
+                        });
+                        return (0, utils_1.createResponse)(200, { cleanedWebhookIds: result.cleanedWebhookIds ?? [] }, headers);
+                    }
+                    catch (err) {
+                        return (0, utils_1.createResponse)(500, {
+                            error: {
+                                code: -32603,
+                                message: err instanceof Error ? err.message : String(err ?? ''),
+                            },
+                        }, headers);
+                    }
+                }
+                // Handle /oauth_callback endpoint for OAuth callbacks (called by platform route)
+                if (path === '/oauth_callback' && method === 'POST') {
+                    if (!config.hooks?.oauth_callback) {
+                        return (0, utils_1.createResponse)(404, { error: 'OAuth callback handler not configured' }, headers);
+                    }
+                    let parsedBody;
+                    try {
+                        parsedBody = event.body ? JSON.parse(event.body) : {};
+                    }
+                    catch (err) {
+                        console.error('[OAuth Callback] Failed to parse JSON body:', err);
+                        return (0, utils_1.createResponse)(400, { error: { code: -32700, message: 'Parse error' } }, headers);
+                    }
+                    // Parse envelope using shared helper
+                    const envelope = (0, handler_helpers_1.parseHandlerEnvelope)(parsedBody);
+                    if (!envelope) {
+                        console.error('[OAuth Callback] Failed to parse envelope. Body:', JSON.stringify(parsedBody, null, 2));
+                        return (0, utils_1.createResponse)(400, { error: { code: -32602, message: 'Missing envelope format: expected { env, request }' } }, headers);
+                    }
+                    // Convert raw request to rich request using shared helper
+                    const oauthRequest = (0, handler_helpers_1.buildRequestFromRaw)(envelope.request);
+                    // Build request-scoped config using shared helper
+                    const oauthCallbackRequestConfig = (0, handler_helpers_1.buildRequestScopedConfig)(envelope.env);
+                    const oauthCallbackContext = {
+                        request: oauthRequest,
+                    };
+                    try {
+                        const oauthCallbackHook = config.hooks.oauth_callback;
+                        const oauthCallbackHandler = typeof oauthCallbackHook === 'function'
+                            ? oauthCallbackHook
+                            : oauthCallbackHook.handler;
+                        const result = await (0, client_1.runWithConfig)(oauthCallbackRequestConfig, async () => {
+                            return await oauthCallbackHandler(oauthCallbackContext);
+                        });
+                        return (0, utils_1.createResponse)(200, {
+                            appInstallationId: result.appInstallationId,
+                            env: result.env ?? {},
+                        }, headers);
+                    }
+                    catch (err) {
+                        const errorMessage = err instanceof Error ? err.message : String(err ?? 'Unknown error');
+                        return (0, utils_1.createResponse)(500, {
+                            error: {
+                                code: -32603,
+                                message: errorMessage,
+                            },
+                        }, headers);
+                    }
+                }
+                if (path === '/health' && method === 'GET') {
+                    return (0, utils_1.createResponse)(200, state.getHealthStatus(), headers);
+                }
+                if (path === '/mcp' && method === 'POST') {
+                    let body;
+                    try {
+                        body = event.body ? JSON.parse(event.body) : {};
+                    }
+                    catch {
+                        return (0, utils_1.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 (0, utils_1.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;
+                            // Support both formats:
+                            // 1. Skedyul format: { inputs: {...}, context: {...}, env: {...} }
+                            // 2. Standard MCP format: { ...directArgs }
+                            const rawArgs = (params?.arguments ?? {});
+                            const hasSkedyulFormat = 'inputs' in rawArgs || 'env' in rawArgs || 'context' in rawArgs;
+                            const toolInputs = hasSkedyulFormat ? (rawArgs.inputs ?? {}) : rawArgs;
+                            const toolContext = hasSkedyulFormat ? rawArgs.context : undefined;
+                            const toolEnv = hasSkedyulFormat ? rawArgs.env : undefined;
+                            // Find tool by name (check both registry key and tool.name)
+                            let toolKey = null;
+                            let tool = null;
+                            for (const [key, t] of Object.entries(registry)) {
+                                if (t.name === toolName || key === toolName) {
+                                    toolKey = key;
+                                    tool = t;
+                                    break;
+                                }
+                            }
+                            if (!tool || !toolKey) {
+                                return (0, utils_1.createResponse)(200, {
+                                    jsonrpc: '2.0',
+                                    id,
+                                    error: {
+                                        code: -32602,
+                                        message: `Tool "${toolName}" not found`,
+                                    },
+                                }, headers);
+                            }
+                            try {
+                                const inputSchema = (0, utils_1.getZodSchema)(tool.inputSchema);
+                                const outputSchema = (0, utils_1.getZodSchema)(tool.outputSchema);
+                                const hasOutputSchema = Boolean(outputSchema);
+                                const validatedInputs = inputSchema
+                                    ? inputSchema.parse(toolInputs)
+                                    : toolInputs;
+                                const toolResult = await callTool(toolKey, {
+                                    inputs: validatedInputs,
+                                    context: toolContext,
+                                    env: toolEnv,
+                                });
+                                // Transform internal format to MCP protocol format
+                                // Note: effect is embedded in structuredContent as __effect
+                                // for consistency with dedicated mode (MCP SDK strips custom fields)
+                                if (toolResult.error) {
+                                    const errorOutput = { error: toolResult.error };
+                                    result = {
+                                        content: [{ type: 'text', text: JSON.stringify(errorOutput) }],
+                                        structuredContent: errorOutput,
+                                        isError: true,
+                                        billing: toolResult.billing,
+                                    };
+                                }
+                                else {
+                                    const outputData = toolResult.output;
+                                    const structuredContent = outputData
+                                        ? { ...outputData, __effect: toolResult.effect }
+                                        : toolResult.effect
+                                            ? { __effect: toolResult.effect }
+                                            : undefined;
+                                    result = {
+                                        content: [{ type: 'text', text: JSON.stringify(toolResult.output) }],
+                                        structuredContent,
+                                        billing: toolResult.billing,
+                                    };
+                                }
+                            }
+                            catch (validationError) {
+                                return (0, utils_1.createResponse)(200, {
+                                    jsonrpc: '2.0',
+                                    id,
+                                    error: {
+                                        code: -32602,
+                                        message: validationError instanceof Error
+                                            ? validationError.message
+                                            : 'Invalid arguments',
+                                    },
+                                }, headers);
+                            }
+                        }
+                        else if (rpcMethod === 'webhooks/list') {
+                            // Return registered webhooks with their metadata
+                            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 (0, utils_1.createResponse)(200, {
+                                jsonrpc: '2.0',
+                                id,
+                                error: {
+                                    code: -32601,
+                                    message: `Method not found: ${rpcMethod}`,
+                                },
+                            }, headers);
+                        }
+                        return (0, utils_1.createResponse)(200, {
+                            jsonrpc: '2.0',
+                            id,
+                            result,
+                        }, headers);
+                    }
+                    catch (err) {
+                        return (0, utils_1.createResponse)(500, {
+                            jsonrpc: '2.0',
+                            id: body?.id ?? null,
+                            error: {
+                                code: -32603,
+                                message: err instanceof Error ? err.message : String(err ?? ''),
+                            },
+                        }, headers);
+                    }
+                }
+                return (0, utils_1.createResponse)(404, {
+                    jsonrpc: '2.0',
+                    id: null,
+                    error: {
+                        code: -32601,
+                        message: 'Not Found',
+                    },
+                }, headers);
+            }
+            catch (err) {
+                return (0, utils_1.createResponse)(500, {
+                    jsonrpc: '2.0',
+                    id: null,
+                    error: {
+                        code: -32603,
+                        message: err instanceof Error ? err.message : String(err ?? ''),
+                    },
+                }, headers);
+            }
+        },
+        getHealthStatus: () => state.getHealthStatus(),
+    };
+}

package/dist/server/startup-logger.d.ts

@@ -0,0 +1,9 @@
+import type { SkedyulServerConfig, ToolMetadata, WebhookRegistry } from '../types';
+/**
+ * Pad a string to the right with spaces
+ */
+export declare function padEnd(str: string, length: number): string;
+/**
+ * Prints a styled startup log showing server configuration
+ */
+export declare function printStartupLog(config: SkedyulServerConfig, tools: ToolMetadata[], webhookRegistry?: WebhookRegistry, port?: number): void;