skedyul 1.2.21 → 1.2.24

package/dist/server/dedicated.d.ts

@@ -5,4 +5,4 @@ import type { RequestState } from './types';
 /**
  * Creates a dedicated (long-running HTTP) server instance
  */
-export declare function createDedicatedServerInstance(config: RuntimeSkedyulConfig, tools: ToolMetadata[], callTool: (nameRaw: unknown, argsRaw: unknown) => Promise<ToolCallResponse>, state: RequestState, mcpServer: McpServer): 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/serverless.d.ts

@@ -5,4 +5,4 @@ import type { RequestState } from './types';
 /**
  * Creates a serverless (Lambda-style) server instance
  */
-export declare function createServerlessInstance(config: RuntimeSkedyulConfig, tools: ToolMetadata[], callTool: (nameRaw: unknown, argsRaw: unknown) => Promise<ToolCallResponse>, state: RequestState, mcpServer: McpServer): SkedyulServerInstance;
+export declare function createServerlessInstance(config: RuntimeSkedyulConfig, tools: ToolMetadata[], callTool: (toolNameInput: unknown, toolArgsInput: unknown) => Promise<ToolCallResponse>, state: RequestState, mcpServer: McpServer): SkedyulServerInstance;

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.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, type RuntimeSkedyulConfig, 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';