skedyul 0.1.22 → 0.1.24

package/dist/core/client.d.ts

@@ -33,13 +33,34 @@ export declare const workplace: {
     list(args?: ListArgs): Promise<Workplace[]>;
     get(id: string): Promise<Workplace>;
 };
+export interface CreateMessageAttachment {
+    fileId: string;
+    name: string;
+    mimeType: string;
+    size: number;
+}
+export interface CreateMessageType {
+    id?: string | null;
+    remoteId?: string | null;
+    message: string;
+    title?: string | null;
+    contentRaw?: string | null;
+    newChat?: boolean;
+    attachments?: CreateMessageAttachment[];
+}
+export interface ReceiveMessageContact {
+    id?: string;
+    identifierValue?: string;
+}
 export interface ReceiveMessageInput {
     /** Communication channel ID */
     communicationChannelId: string;
     /** Sender's identifier (e.g., phone number, email) */
     from: string;
-    /** Message content */
-    message: string;
+    /** Message payload */
+    message: CreateMessageType;
+    /** Optional contact metadata to associate the message */
+    contact?: ReceiveMessageContact;
     /** Optional remote/external message ID (e.g., Twilio MessageSid) */
     remoteId?: string;
 }

package/dist/core/client.js

@@ -119,6 +119,7 @@ exports.communicationChannel = {
             communicationChannelId: input.communicationChannelId,
             from: input.from,
             message: input.message,
+            contact: input.contact,
             ...(input.remoteId ? { remoteId: input.remoteId } : {}),
         }));
         return payload;

package/dist/server.d.ts

@@ -1,5 +1,5 @@
-import type { SkedyulServerConfig, SkedyulServerInstance, ToolRegistry } from './types';
-export declare function createSkedyulServer(config: SkedyulServerConfig, registry: ToolRegistry): SkedyulServerInstance;
+import type { SkedyulServerConfig, SkedyulServerInstance, ToolRegistry, WebhookRegistry } from './types';
+export declare function createSkedyulServer(config: SkedyulServerConfig, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): SkedyulServerInstance;
 export declare const server: {
     create: typeof createSkedyulServer;
 };

package/dist/server.js

@@ -401,7 +401,7 @@ function getListeningPort(config) {
     }
     return config.defaultPort ?? 3000;
 }
-function createSkedyulServer(config, registry) {
+function createSkedyulServer(config, registry, webhookRegistry) {
     mergeRuntimeEnv();
     if (config.coreApi?.service) {
         service_1.coreApiService.register(config.coreApi.service);
@@ -476,11 +476,11 @@ function createSkedyulServer(config, registry) {
         });
     }
     if (config.computeLayer === 'dedicated') {
-        return createDedicatedServerInstance(config, tools, callTool, state, mcpServer);
+        return createDedicatedServerInstance(config, tools, callTool, state, mcpServer, webhookRegistry);
     }
-    return createServerlessInstance(config, tools, callTool, state, mcpServer, registry);
+    return createServerlessInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry);
 }
-function createDedicatedServerInstance(config, tools, callTool, state, mcpServer) {
+function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, webhookRegistry) {
     const port = getListeningPort(config);
     const httpServer = http_1.default.createServer(async (req, res) => {
         function sendCoreResult(result) {
@@ -493,6 +493,90 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
                 sendJSON(res, 200, state.getHealthStatus());
                 return;
             }
+            // Handle webhook requests: /webhooks/{handle}
+            if (pathname.startsWith('/webhooks/') && webhookRegistry) {
+                const handle = pathname.slice('/webhooks/'.length);
+                const webhookDef = webhookRegistry[handle];
+                if (!webhookDef) {
+                    sendJSON(res, 404, { error: `Webhook handler '${handle}' not found` });
+                    return;
+                }
+                // Check if HTTP method is allowed
+                const allowedMethods = webhookDef.methods ?? ['POST'];
+                if (!allowedMethods.includes(req.method)) {
+                    sendJSON(res, 405, { error: `Method ${req.method} not allowed` });
+                    return;
+                }
+                // Read raw request body
+                let rawBody;
+                try {
+                    rawBody = await readRawRequestBody(req);
+                }
+                catch {
+                    sendJSON(res, 400, { error: 'Failed to read request body' });
+                    return;
+                }
+                // Parse body based on content type
+                let parsedBody;
+                const contentType = req.headers['content-type'] ?? '';
+                if (contentType.includes('application/json')) {
+                    try {
+                        parsedBody = rawBody ? JSON.parse(rawBody) : {};
+                    }
+                    catch {
+                        parsedBody = rawBody;
+                    }
+                }
+                else {
+                    parsedBody = rawBody;
+                }
+                // Build WebhookRequest
+                const 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') : undefined,
+                };
+                // Build WebhookContext
+                const webhookContext = {
+                    env: process.env,
+                };
+                // Invoke the handler
+                let webhookResponse;
+                try {
+                    webhookResponse = await webhookDef.handler(webhookRequest, webhookContext);
+                }
+                catch (err) {
+                    console.error(`Webhook handler '${handle}' error:`, err);
+                    sendJSON(res, 500, { error: 'Webhook handler error' });
+                    return;
+                }
+                // Send response
+                const status = webhookResponse.status ?? 200;
+                const responseHeaders = {
+                    ...webhookResponse.headers,
+                };
+                // Default to JSON content type if not specified
+                if (!responseHeaders['Content-Type'] && !responseHeaders['content-type']) {
+                    responseHeaders['Content-Type'] = 'application/json';
+                }
+                res.writeHead(status, responseHeaders);
+                if (webhookResponse.body !== undefined) {
+                    if (typeof webhookResponse.body === 'string') {
+                        res.end(webhookResponse.body);
+                    }
+                    else {
+                        res.end(JSON.stringify(webhookResponse.body));
+                    }
+                }
+                else {
+                    res.end();
+                }
+                return;
+            }
             if (pathname === '/estimate' && req.method === 'POST') {
                 let estimateBody;
                 try {
@@ -657,7 +741,7 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
         getHealthStatus: () => state.getHealthStatus(),
     };
 }
-function createServerlessInstance(config, tools, callTool, state, mcpServer, registry) {
+function createServerlessInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
     const headers = getDefaultHeaders(config.cors);
     return {
         async handler(event) {
@@ -667,6 +751,81 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
                 if (method === 'OPTIONS') {
                     return 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 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 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;
+                    }
+                    // Build URL
+                    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}`;
+                    // Build WebhookRequest
+                    const webhookRequest = {
+                        method,
+                        url: webhookUrl,
+                        path,
+                        headers: event.headers,
+                        query: event.queryStringParameters ?? {},
+                        body: parsedBody,
+                        rawBody: rawBody ? Buffer.from(rawBody, 'utf-8') : undefined,
+                    };
+                    // Build WebhookContext
+                    const webhookContext = {
+                        env: process.env,
+                    };
+                    // Invoke the handler
+                    let webhookResponse;
+                    try {
+                        webhookResponse = await webhookDef.handler(webhookRequest, webhookContext);
+                    }
+                    catch (err) {
+                        console.error(`Webhook handler '${handle}' error:`, err);
+                        return createResponse(500, { error: 'Webhook handler error' }, headers);
+                    }
+                    // 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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skedyul",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",