skedyul 1.2.19 → 1.2.23

package/dist/server/config-serializer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Config serialization utilities for the /config endpoint.
+ */
+import type { SkedyulConfig, SerializableSkedyulConfig } from '../config/app-config';
+/**
+ * Serializes a SkedyulConfig into a SerializableSkedyulConfig.
+ * Used by both serverless and dedicated servers for the /config endpoint.
+ *
+ * Note: provision and agents are included if they are direct objects (not promises).
+ * Promise-based configs from skedyul.config.ts are resolved at build time, not runtime.
+ */
+export declare function serializeConfig(config: SkedyulConfig): SerializableSkedyulConfig;

package/dist/server/dedicated.d.ts

@@ -1,7 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { SkedyulServerConfig, SkedyulServerInstance, ToolCallResponse, ToolMetadata, ToolRegistry, WebhookRegistry } from '../types';
+import type { SkedyulServerInstance, ToolCallResponse, ToolMetadata } from '../types';
+import type { RuntimeSkedyulConfig } from './index';
 import type { RequestState } from './types';
 /**
  * Creates a dedicated (long-running HTTP) server instance
  */
-export declare function createDedicatedServerInstance(config: SkedyulServerConfig, tools: ToolMetadata[], callTool: (nameRaw: unknown, argsRaw: unknown) => Promise<ToolCallResponse>, state: RequestState, mcpServer: McpServer, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): SkedyulServerInstance;
+export declare function createDedicatedServerInstance(config: RuntimeSkedyulConfig, tools: ToolMetadata[], callTool: (toolNameInput: unknown, toolArgsInput: unknown) => Promise<ToolCallResponse>, state: RequestState, mcpServer: McpServer): SkedyulServerInstance;

package/dist/server/handlers/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared handlers for serverless and dedicated servers.
+ *
+ * These handlers contain the core business logic that is identical
+ * between serverless (Lambda) and dedicated (HTTP) server modes.
+ */
+export * from './types';
+export { handleInstall } from './install-handler';
+export { handleUninstall } from './uninstall-handler';
+export { handleProvision } from './provision-handler';
+export { handleOAuthCallback } from './oauth-callback-handler';
+export { parseWebhookRequest, executeWebhookHandler, isMethodAllowed, type ParsedWebhookData, } from './webhook-handler';

package/dist/server/handlers/install-handler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Install handler - shared implementation for serverless and dedicated servers.
+ */
+import type { ServerHooks } from '../../types';
+import type { HandlerResult, InstallRequestBody } from './types';
+/**
+ * Handle install request.
+ */
+export declare function handleInstall(body: InstallRequestBody, hooks: ServerHooks | undefined): Promise<HandlerResult>;

package/dist/server/handlers/oauth-callback-handler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OAuth callback handler - shared implementation for serverless and dedicated servers.
+ */
+import type { ServerHooks } from '../../types';
+import type { HandlerResult } from './types';
+/**
+ * Handle OAuth callback request.
+ */
+export declare function handleOAuthCallback(parsedBody: unknown, hooks: ServerHooks | undefined): Promise<HandlerResult>;

package/dist/server/handlers/provision-handler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Provision handler - shared implementation for serverless and dedicated servers.
+ */
+import type { ServerHooks } from '../../types';
+import type { HandlerResult, ProvisionRequestBody } from './types';
+/**
+ * Handle provision request.
+ */
+export declare function handleProvision(body: ProvisionRequestBody, hooks: ServerHooks | undefined): Promise<HandlerResult>;

package/dist/server/handlers/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Shared types for handler implementations.
+ * These types abstract over serverless vs dedicated server differences.
+ */
+import type { InvocationContext } from '../../types';
+/**
+ * Generic handler result that can be converted to either serverless or HTTP response.
+ */
+export interface HandlerResult {
+    status: number;
+    body: unknown;
+    headers?: Record<string, string>;
+}
+/**
+ * Common envelope format from the platform.
+ */
+export interface HandlerEnvelope {
+    env: Record<string, string>;
+    request: RawRequest;
+    context?: EnvelopeContext;
+    invocation?: InvocationContext;
+}
+/**
+ * Raw request from envelope.
+ */
+export interface RawRequest {
+    method: string;
+    url: string;
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    body: string;
+}
+/**
+ * Context from envelope.
+ */
+export interface EnvelopeContext {
+    app: {
+        id: string;
+        versionId: string;
+    };
+    appInstallationId?: string | null;
+    workplace?: {
+        id: string;
+        subdomain: string;
+    } | null;
+    registration?: Record<string, unknown> | null;
+}
+/**
+ * Install request body format.
+ */
+export interface InstallRequestBody {
+    env?: Record<string, string>;
+    invocation?: InvocationContext;
+    context?: {
+        app: {
+            id: string;
+            versionId: string;
+            handle: string;
+            versionHandle: string;
+        };
+        appInstallationId: string;
+        workplace: {
+            id: string;
+            subdomain: string;
+        };
+    };
+}
+/**
+ * Uninstall request body format.
+ */
+export interface UninstallRequestBody {
+    env?: Record<string, string>;
+    invocation?: InvocationContext;
+    context?: {
+        app: {
+            id: string;
+            versionId: string;
+            handle: string;
+            versionHandle: string;
+        };
+        appInstallationId: string;
+        workplace: {
+            id: string;
+            subdomain: string;
+        };
+    };
+}
+/**
+ * Provision request body format.
+ */
+export interface ProvisionRequestBody {
+    env?: Record<string, string>;
+    invocation?: InvocationContext;
+    context?: {
+        app: {
+            id: string;
+            versionId: string;
+        };
+    };
+}

package/dist/server/handlers/uninstall-handler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Uninstall handler - shared implementation for serverless and dedicated servers.
+ */
+import type { ServerHooks } from '../../types';
+import type { HandlerResult, UninstallRequestBody } from './types';
+/**
+ * Handle uninstall request.
+ */
+export declare function handleUninstall(body: UninstallRequestBody, hooks: ServerHooks | undefined): Promise<HandlerResult>;

package/dist/server/handlers/webhook-handler.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Webhook handler - shared implementation for serverless and dedicated servers.
+ */
+import type { WebhookContext, WebhookRequest, InvocationContext, WebhookRegistry } from '../../types';
+import type { HandlerResult } from './types';
+/**
+ * Parsed webhook request data.
+ */
+export interface ParsedWebhookData {
+    webhookRequest: WebhookRequest;
+    webhookContext: WebhookContext;
+    requestEnv: Record<string, string>;
+    invocation?: InvocationContext;
+}
+/**
+ * Parse webhook request from envelope or direct format.
+ */
+export declare function parseWebhookRequest(parsedBody: unknown, method: string, url: string, path: string, headers: Record<string, string | string[] | undefined>, query: Record<string, string>, rawBody: string, appIdHeader?: string, appVersionIdHeader?: string): ParsedWebhookData | {
+    error: string;
+};
+/**
+ * Execute webhook handler with proper context.
+ */
+export declare function executeWebhookHandler(handle: string, webhookRegistry: WebhookRegistry, data: ParsedWebhookData): Promise<HandlerResult>;
+/**
+ * Check if HTTP method is allowed for webhook.
+ */
+export declare function isMethodAllowed(webhookRegistry: WebhookRegistry, handle: string, method: string): boolean;

package/dist/server/index.d.ts

@@ -1,4 +1,5 @@
-import type { DedicatedServerInstance, ServerlessServerInstance, SkedyulServerConfig, SkedyulServerInstance, ToolRegistry, WebhookRegistry } from '../types';
+import type { DedicatedServerInstance, ServerlessServerInstance, SkedyulServerInstance, ToolRegistry, WebhookRegistry } from '../types';
+import type { SkedyulConfig } from '../config/app-config';
 export type { RequestState, CoreMethod, ToolCallArgs } from './types';
 export { normalizeBilling, toJsonSchema, isToolSchemaWithJson, getZodSchema, getJsonSchemaFromToolSchema, parseJsonRecord, parseNumberEnv, mergeRuntimeEnv, readRawRequestBody, parseJSONBody, sendJSON, sendHTML, getDefaultHeaders, createResponse, getListeningPort, } from './utils';
 export { handleCoreMethod } from './core-api-handler';
@@ -8,13 +9,21 @@ export { printStartupLog, padEnd } from './startup-logger';
 export { createDedicatedServerInstance } from './dedicated';
 export { createServerlessInstance } from './serverless';
 export { runWithLogContext, getLogContext, installContextLogger, uninstallContextLogger } from './context-logger';
-export declare function createSkedyulServer(config: SkedyulServerConfig & {
+/**
+ * Runtime config type - SkedyulConfig with resolved registries (not promises).
+ * This is what server.create() expects at runtime.
+ */
+export type RuntimeSkedyulConfig = Omit<SkedyulConfig, 'tools' | 'webhooks'> & {
+    tools: ToolRegistry;
+    webhooks?: WebhookRegistry;
+};
+export declare function createSkedyulServer(config: RuntimeSkedyulConfig & {
     computeLayer: 'dedicated';
-}, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): DedicatedServerInstance;
-export declare function createSkedyulServer(config: SkedyulServerConfig & {
+}): DedicatedServerInstance;
+export declare function createSkedyulServer(config: RuntimeSkedyulConfig & {
     computeLayer: 'serverless';
-}, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): ServerlessServerInstance;
-export declare function createSkedyulServer(config: SkedyulServerConfig, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): SkedyulServerInstance;
+}): ServerlessServerInstance;
+export declare function createSkedyulServer(config: RuntimeSkedyulConfig): SkedyulServerInstance;
 export declare const server: {
     create: typeof createSkedyulServer;
 };

package/dist/server/serverless.d.ts

@@ -1,7 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { SkedyulServerConfig, SkedyulServerInstance, ToolCallResponse, ToolMetadata, ToolRegistry, WebhookRegistry } from '../types';
+import type { SkedyulServerInstance, ToolCallResponse, ToolMetadata } from '../types';
+import type { RuntimeSkedyulConfig } from './index';
 import type { RequestState } from './types';
 /**
  * Creates a serverless (Lambda-style) server instance
  */
-export declare function createServerlessInstance(config: SkedyulServerConfig, tools: ToolMetadata[], callTool: (nameRaw: unknown, argsRaw: unknown) => Promise<ToolCallResponse>, state: RequestState, mcpServer: McpServer, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): SkedyulServerInstance;
+export declare function createServerlessInstance(config: RuntimeSkedyulConfig, tools: ToolMetadata[], callTool: (toolNameInput: unknown, toolArgsInput: unknown) => Promise<ToolCallResponse>, state: RequestState, mcpServer: McpServer): SkedyulServerInstance;

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

@@ -1,4 +1,5 @@
-import type { SkedyulServerConfig, ToolMetadata, WebhookRegistry } from '../types';
+import type { ToolMetadata } from '../types';
+import type { SkedyulConfig } from '../config/app-config';
 /**
  * Pad a string to the right with spaces
  */
@@ -6,4 +7,4 @@ 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;
+export declare function printStartupLog(config: SkedyulConfig, tools: ToolMetadata[], port?: number): void;

package/dist/server/tool-handler.d.ts

@@ -11,4 +11,4 @@ export declare function createRequestState(maxRequests: number | null, ttlExtend
 /**
  * Creates a tool call handler function for executing tools from the registry
  */
-export declare function createCallToolHandler<T extends ToolRegistry>(registry: T, state: RequestState, onMaxRequests?: () => void): (nameRaw: unknown, argsRaw: unknown) => Promise<ToolCallResponse>;
+export declare function createCallToolHandler<T extends ToolRegistry>(registry: T, state: RequestState, onMaxRequests?: () => void): (toolNameInput: unknown, toolArgsInput: unknown) => Promise<ToolCallResponse>;

package/dist/server/utils/http.d.ts

@@ -1,5 +1,6 @@
 import http, { IncomingMessage } from 'http';
-import type { APIGatewayProxyResult, CorsOptions, SkedyulServerConfig } from '../../types';
+import type { APIGatewayProxyResult } from '../../types';
+import type { CorsOptions, SkedyulConfig } from '../../config/app-config';
 /**
  * Reads the raw request body from an IncomingMessage
  */
@@ -27,4 +28,4 @@ export declare function createResponse(statusCode: number, body: unknown, header
 /**
  * Gets the port to listen on from config or environment
  */
-export declare function getListeningPort(config: SkedyulServerConfig): number;
+export declare function getListeningPort(config: SkedyulConfig): number;

package/dist/server.d.ts

@@ -4,4 +4,4 @@
  * This file maintains backward compatibility while the actual implementation
  * has been split into smaller, focused modules in the server/ folder.
  */
-export { createSkedyulServer, server, type RequestState, type CoreMethod, type ToolCallArgs, normalizeBilling, toJsonSchema, isToolSchemaWithJson, getZodSchema, getJsonSchemaFromToolSchema, parseJsonRecord, parseNumberEnv, mergeRuntimeEnv, readRawRequestBody, parseJSONBody, sendJSON, sendHTML, getDefaultHeaders, createResponse, getListeningPort, handleCoreMethod, buildToolMetadata, createRequestState, createCallToolHandler, parseHandlerEnvelope, buildRequestFromRaw, buildRequestScopedConfig, printStartupLog, padEnd, createDedicatedServerInstance, createServerlessInstance, } from './server/index';
+export { createSkedyulServer, server, type RuntimeSkedyulConfig, toJsonSchema, isToolSchemaWithJson, getZodSchema, getJsonSchemaFromToolSchema, } from './server/index';