skedyul 0.3.0 → 0.3.2

package/dist/server/startup-logger.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padEnd = padEnd;
+exports.printStartupLog = printStartupLog;
+const utils_1 = require("./utils");
+/**
+ * Pad a string to the right with spaces
+ */
+function padEnd(str, length) {
+    if (str.length >= length) {
+        return str.slice(0, length);
+    }
+    return str + ' '.repeat(length - str.length);
+}
+/**
+ * Prints a styled startup log showing server configuration
+ */
+function printStartupLog(config, tools, webhookRegistry, port) {
+    // Skip startup log during tests
+    if (process.env.NODE_ENV === 'test') {
+        return;
+    }
+    const webhookCount = webhookRegistry ? Object.keys(webhookRegistry).length : 0;
+    const webhookNames = webhookRegistry ? Object.keys(webhookRegistry) : [];
+    const maxRequests = config.maxRequests ??
+        (0, utils_1.parseNumberEnv)(process.env.MCP_MAX_REQUESTS) ??
+        null;
+    const ttlExtendSeconds = config.ttlExtendSeconds ??
+        (0, utils_1.parseNumberEnv)(process.env.MCP_TTL_EXTEND) ??
+        3600;
+    const executableId = process.env.SKEDYUL_EXECUTABLE_ID || 'local';
+    const divider = '═'.repeat(70);
+    const thinDivider = '─'.repeat(70);
+    // eslint-disable-next-line no-console
+    console.log('');
+    // eslint-disable-next-line no-console
+    console.log(`╔${divider}╗`);
+    // eslint-disable-next-line no-console
+    console.log(`║  🚀 Skedyul MCP Server Starting                                      ║`);
+    // eslint-disable-next-line no-console
+    console.log(`╠${divider}╣`);
+    // eslint-disable-next-line no-console
+    console.log(`║                                                                      ║`);
+    // eslint-disable-next-line no-console
+    console.log(`║  📦 Server:       ${padEnd(config.metadata.name, 49)}║`);
+    // eslint-disable-next-line no-console
+    console.log(`║  🏷️  Version:      ${padEnd(config.metadata.version, 49)}║`);
+    // eslint-disable-next-line no-console
+    console.log(`║  ⚡ Compute:      ${padEnd(config.computeLayer, 49)}║`);
+    if (port) {
+        // eslint-disable-next-line no-console
+        console.log(`║  🌐 Port:         ${padEnd(String(port), 49)}║`);
+    }
+    // eslint-disable-next-line no-console
+    console.log(`║  🔑 Executable:   ${padEnd(executableId, 49)}║`);
+    // eslint-disable-next-line no-console
+    console.log(`║                                                                      ║`);
+    // eslint-disable-next-line no-console
+    console.log(`╟${thinDivider}╢`);
+    // eslint-disable-next-line no-console
+    console.log(`║                                                                      ║`);
+    // eslint-disable-next-line no-console
+    console.log(`║  🔧 Tools (${tools.length}):                                                       ║`);
+    // List tools (max 10, then show "and X more...")
+    const maxToolsToShow = 10;
+    const toolsToShow = tools.slice(0, maxToolsToShow);
+    for (const tool of toolsToShow) {
+        // eslint-disable-next-line no-console
+        console.log(`║     • ${padEnd(tool.name, 61)}║`);
+    }
+    if (tools.length > maxToolsToShow) {
+        // eslint-disable-next-line no-console
+        console.log(`║     ... and ${tools.length - maxToolsToShow} more                                              ║`);
+    }
+    if (webhookCount > 0) {
+        // eslint-disable-next-line no-console
+        console.log(`║                                                                      ║`);
+        // eslint-disable-next-line no-console
+        console.log(`║  🪝 Webhooks (${webhookCount}):                                                     ║`);
+        const maxWebhooksToShow = 5;
+        const webhooksToShow = webhookNames.slice(0, maxWebhooksToShow);
+        for (const name of webhooksToShow) {
+            // eslint-disable-next-line no-console
+            console.log(`║     • /webhooks/${padEnd(name, 51)}║`);
+        }
+        if (webhookCount > maxWebhooksToShow) {
+            // eslint-disable-next-line no-console
+            console.log(`║     ... and ${webhookCount - maxWebhooksToShow} more                                              ║`);
+        }
+    }
+    // eslint-disable-next-line no-console
+    console.log(`║                                                                      ║`);
+    // eslint-disable-next-line no-console
+    console.log(`╟${thinDivider}╢`);
+    // eslint-disable-next-line no-console
+    console.log(`║                                                                      ║`);
+    // eslint-disable-next-line no-console
+    console.log(`║  ⚙️  Configuration:                                                   ║`);
+    // eslint-disable-next-line no-console
+    console.log(`║     Max Requests:    ${padEnd(maxRequests !== null ? String(maxRequests) : 'unlimited', 46)}║`);
+    // eslint-disable-next-line no-console
+    console.log(`║     TTL Extend:      ${padEnd(`${ttlExtendSeconds}s`, 46)}║`);
+    // eslint-disable-next-line no-console
+    console.log(`║                                                                      ║`);
+    // eslint-disable-next-line no-console
+    console.log(`╟${thinDivider}╢`);
+    // eslint-disable-next-line no-console
+    console.log(`║  ✅ Ready at ${padEnd(new Date().toISOString(), 55)}║`);
+    // eslint-disable-next-line no-console
+    console.log(`╚${divider}╝`);
+    // eslint-disable-next-line no-console
+    console.log('');
+}

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

@@ -0,0 +1,14 @@
+import type { ToolCallResponse, ToolMetadata, ToolRegistry } from '../types';
+import type { RequestState } from './types';
+/**
+ * Builds tool metadata array from a tool registry
+ */
+export declare function buildToolMetadata(registry: ToolRegistry): ToolMetadata[];
+/**
+ * Creates a request state tracker for managing request counts and health status
+ */
+export declare function createRequestState(maxRequests: number | null, ttlExtendSeconds: number, runtimeLabel: string, toolNames: string[]): RequestState;
+/**
+ * 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>;

package/dist/server/tool-handler.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildToolMetadata = buildToolMetadata;
+exports.createRequestState = createRequestState;
+exports.createCallToolHandler = createCallToolHandler;
+const utils_1 = require("./utils");
+const client_1 = require("../core/client");
+const errors_1 = require("../errors");
+/**
+ * Builds tool metadata array from a tool registry
+ */
+function buildToolMetadata(registry) {
+    return Object.values(registry).map((tool) => {
+        const timeout = typeof tool.timeout === 'number' && tool.timeout > 0 ? tool.timeout : 10000;
+        return {
+            name: tool.name,
+            displayName: tool.label || tool.name,
+            description: tool.description,
+            inputSchema: (0, utils_1.getJsonSchemaFromToolSchema)(tool.inputSchema),
+            outputSchema: (0, utils_1.getJsonSchemaFromToolSchema)(tool.outputSchema),
+            timeout, // Default to 10 seconds
+        };
+    });
+}
+/**
+ * Creates a request state tracker for managing request counts and health status
+ */
+function createRequestState(maxRequests, ttlExtendSeconds, runtimeLabel, toolNames) {
+    let requestCount = 0;
+    let lastRequestTime = Date.now();
+    return {
+        incrementRequestCount() {
+            requestCount += 1;
+            lastRequestTime = Date.now();
+        },
+        shouldShutdown() {
+            return maxRequests !== null && requestCount >= maxRequests;
+        },
+        getHealthStatus() {
+            return {
+                status: 'running',
+                requests: requestCount,
+                maxRequests,
+                requestsRemaining: maxRequests !== null ? Math.max(0, maxRequests - requestCount) : null,
+                lastRequestTime,
+                ttlExtendSeconds,
+                runtime: runtimeLabel,
+                tools: [...toolNames],
+            };
+        },
+    };
+}
+/**
+ * Creates a tool call handler function for executing tools from the registry
+ */
+function createCallToolHandler(registry, state, onMaxRequests) {
+    return async function callTool(nameRaw, argsRaw) {
+        const toolName = String(nameRaw);
+        const tool = registry[toolName];
+        if (!tool) {
+            throw new Error(`Tool "${toolName}" not found in registry`);
+        }
+        if (!tool.handler || typeof tool.handler !== 'function') {
+            throw new Error(`Tool "${toolName}" handler is not a function`);
+        }
+        const fn = tool.handler;
+        const args = (argsRaw ?? {});
+        const estimateMode = args.estimate === true;
+        if (!estimateMode) {
+            state.incrementRequestCount();
+            if (state.shouldShutdown()) {
+                onMaxRequests?.();
+            }
+        }
+        const requestEnv = args.env ?? {};
+        const originalEnv = { ...process.env };
+        Object.assign(process.env, requestEnv);
+        try {
+            // Get tool inputs (clean, no context)
+            const inputs = (args.inputs ?? {});
+            // Get context from args.context (separate from inputs)
+            const rawContext = (args.context ?? {});
+            // Extract app info (required for all contexts)
+            const app = rawContext.app;
+            // Determine trigger type from context
+            const trigger = rawContext.trigger || 'agent';
+            // Build execution context based on trigger type
+            let executionContext;
+            if (trigger === 'provision') {
+                // Provision context - no installation, no workplace
+                executionContext = {
+                    trigger: 'provision',
+                    app,
+                    env: process.env,
+                    mode: estimateMode ? 'estimate' : 'execute',
+                };
+            }
+            else {
+                // Runtime context - has installation, workplace, request
+                const workplace = rawContext.workplace;
+                const request = rawContext.request;
+                const appInstallationId = rawContext.appInstallationId;
+                const envVars = process.env;
+                const modeValue = estimateMode ? 'estimate' : 'execute';
+                if (trigger === 'field_change') {
+                    const field = rawContext.field;
+                    executionContext = { trigger: 'field_change', app, appInstallationId, workplace, request, env: envVars, mode: modeValue, field };
+                }
+                else if (trigger === 'page_action') {
+                    const page = rawContext.page;
+                    executionContext = { trigger: 'page_action', app, appInstallationId, workplace, request, env: envVars, mode: modeValue, page };
+                }
+                else if (trigger === 'form_submit') {
+                    const form = rawContext.form;
+                    executionContext = { trigger: 'form_submit', app, appInstallationId, workplace, request, env: envVars, mode: modeValue, form };
+                }
+                else if (trigger === 'workflow') {
+                    executionContext = { trigger: 'workflow', app, appInstallationId, workplace, request, env: envVars, mode: modeValue };
+                }
+                else if (trigger === 'page_context') {
+                    // Page context trigger - similar to agent but for page context resolution
+                    executionContext = { trigger: 'agent', app, appInstallationId, workplace, request, env: envVars, mode: modeValue };
+                }
+                else {
+                    // Default to agent
+                    executionContext = { trigger: 'agent', app, appInstallationId, workplace, request, env: envVars, mode: modeValue };
+                }
+            }
+            // Build request-scoped config from env passed in MCP call
+            const requestConfig = {
+                baseUrl: requestEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? '',
+                apiToken: requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? '',
+            };
+            // Call handler with two arguments: (input, context)
+            // Wrap in runWithConfig for request-scoped SDK configuration
+            const functionResult = await (0, client_1.runWithConfig)(requestConfig, async () => {
+                return await fn(inputs, executionContext);
+            });
+            const billing = (0, utils_1.normalizeBilling)(functionResult.billing);
+            return {
+                output: functionResult.output,
+                billing,
+                meta: functionResult.meta ?? {
+                    success: true,
+                    message: 'OK',
+                    toolName,
+                },
+                effect: functionResult.effect,
+            };
+        }
+        catch (error) {
+            // Check if it's an AppAuthInvalidError
+            if (error instanceof errors_1.AppAuthInvalidError) {
+                return {
+                    output: null,
+                    billing: { credits: 0 },
+                    meta: {
+                        success: false,
+                        message: error.message,
+                        toolName,
+                    },
+                    error: {
+                        code: error.code,
+                        message: error.message,
+                    },
+                    // Note: redirect URL will be added by workflow after detecting APP_AUTH_INVALID
+                };
+            }
+            // Generic error handling for other errors
+            const errorMessage = error instanceof Error ? error.message : String(error ?? '');
+            return {
+                output: null,
+                billing: { credits: 0 },
+                meta: {
+                    success: false,
+                    message: errorMessage,
+                    toolName,
+                },
+                error: {
+                    code: 'TOOL_EXECUTION_ERROR',
+                    message: errorMessage,
+                },
+            };
+        }
+        finally {
+            process.env = originalEnv;
+        }
+    };
+}

package/dist/server/types.d.ts

@@ -0,0 +1,22 @@
+import type { HealthStatus } from '../types';
+/**
+ * Arguments passed to tool call handlers
+ */
+export type ToolCallArgs = {
+    env?: Record<string, string | undefined>;
+    inputs?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    estimate?: boolean;
+};
+/**
+ * Interface for tracking request state and health status
+ */
+export interface RequestState {
+    incrementRequestCount(): void;
+    shouldShutdown(): boolean;
+    getHealthStatus(): HealthStatus;
+}
+/**
+ * Supported core API methods
+ */
+export type CoreMethod = 'createCommunicationChannel' | 'updateCommunicationChannel' | 'deleteCommunicationChannel' | 'getCommunicationChannel' | 'getCommunicationChannels' | 'communicationChannel.list' | 'communicationChannel.get' | 'workplace.list' | 'workplace.get' | 'sendMessage';

package/dist/server/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,12 @@
+/**
+ * Parses a JSON string into a Record, returning empty object on failure
+ */
+export declare function parseJsonRecord(value?: string): Record<string, string>;
+/**
+ * Parses a string environment variable as a number
+ */
+export declare function parseNumberEnv(value?: string): number | null;
+/**
+ * Merges baked-in environment variables with runtime environment variables
+ */
+export declare function mergeRuntimeEnv(): void;

package/dist/server/utils/env.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonRecord = parseJsonRecord;
+exports.parseNumberEnv = parseNumberEnv;
+exports.mergeRuntimeEnv = mergeRuntimeEnv;
+/**
+ * Parses a JSON string into a Record, returning empty object on failure
+ */
+function parseJsonRecord(value) {
+    if (!value) {
+        return {};
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Parses a string environment variable as a number
+ */
+function parseNumberEnv(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+/**
+ * Merges baked-in environment variables with runtime environment variables
+ */
+function mergeRuntimeEnv() {
+    const bakedEnv = parseJsonRecord(process.env.MCP_ENV_JSON);
+    const runtimeEnv = parseJsonRecord(process.env.MCP_ENV);
+    const merged = { ...bakedEnv, ...runtimeEnv };
+    Object.assign(process.env, merged);
+}

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

@@ -0,0 +1,30 @@
+import http, { IncomingMessage } from 'http';
+import type { APIGatewayProxyResult, CorsOptions, SkedyulServerConfig } from '../../types';
+/**
+ * Reads the raw request body from an IncomingMessage
+ */
+export declare function readRawRequestBody(req: IncomingMessage): Promise<string>;
+/**
+ * Parses JSON body from an IncomingMessage
+ */
+export declare function parseJSONBody(req: IncomingMessage): Promise<unknown>;
+/**
+ * Sends a JSON response
+ */
+export declare function sendJSON(res: http.ServerResponse, statusCode: number, data: unknown): void;
+/**
+ * Sends an HTML response
+ */
+export declare function sendHTML(res: http.ServerResponse, statusCode: number, html: string): void;
+/**
+ * Gets default CORS headers
+ */
+export declare function getDefaultHeaders(options?: CorsOptions): Record<string, string>;
+/**
+ * Creates an API Gateway proxy response
+ */
+export declare function createResponse(statusCode: number, body: unknown, headers: Record<string, string>): APIGatewayProxyResult;
+/**
+ * Gets the port to listen on from config or environment
+ */
+export declare function getListeningPort(config: SkedyulServerConfig): number;

package/dist/server/utils/http.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRawRequestBody = readRawRequestBody;
+exports.parseJSONBody = parseJSONBody;
+exports.sendJSON = sendJSON;
+exports.sendHTML = sendHTML;
+exports.getDefaultHeaders = getDefaultHeaders;
+exports.createResponse = createResponse;
+exports.getListeningPort = getListeningPort;
+/**
+ * Reads the raw request body from an IncomingMessage
+ */
+function readRawRequestBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            resolve(body);
+        });
+        req.on('error', reject);
+    });
+}
+/**
+ * Parses JSON body from an IncomingMessage
+ */
+async function parseJSONBody(req) {
+    const rawBody = await readRawRequestBody(req);
+    try {
+        return rawBody ? JSON.parse(rawBody) : {};
+    }
+    catch (err) {
+        throw err;
+    }
+}
+/**
+ * Sends a JSON response
+ */
+function sendJSON(res, statusCode, data) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+}
+/**
+ * Sends an HTML response
+ */
+function sendHTML(res, statusCode, html) {
+    res.writeHead(statusCode, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(html);
+}
+/**
+ * Gets default CORS headers
+ */
+function getDefaultHeaders(options) {
+    return {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': options?.allowOrigin ?? '*',
+        'Access-Control-Allow-Methods': options?.allowMethods ?? 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': options?.allowHeaders ?? 'Content-Type',
+    };
+}
+/**
+ * Creates an API Gateway proxy response
+ */
+function createResponse(statusCode, body, headers) {
+    return {
+        statusCode,
+        headers,
+        body: JSON.stringify(body),
+    };
+}
+/**
+ * Gets the port to listen on from config or environment
+ */
+function getListeningPort(config) {
+    const envPort = Number.parseInt(process.env.PORT ?? '', 10);
+    if (!Number.isNaN(envPort)) {
+        return envPort;
+    }
+    return config.defaultPort ?? 3000;
+}

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

@@ -0,0 +1,3 @@
+export { normalizeBilling, toJsonSchema, isToolSchemaWithJson, getZodSchema, getJsonSchemaFromToolSchema, } from './schema';
+export { parseJsonRecord, parseNumberEnv, mergeRuntimeEnv, } from './env';
+export { readRawRequestBody, parseJSONBody, sendJSON, sendHTML, getDefaultHeaders, createResponse, getListeningPort, } from './http';

package/dist/server/utils/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getListeningPort = exports.createResponse = exports.getDefaultHeaders = exports.sendHTML = exports.sendJSON = exports.parseJSONBody = exports.readRawRequestBody = exports.mergeRuntimeEnv = exports.parseNumberEnv = exports.parseJsonRecord = exports.getJsonSchemaFromToolSchema = exports.getZodSchema = exports.isToolSchemaWithJson = exports.toJsonSchema = exports.normalizeBilling = void 0;
+// Schema utilities
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "normalizeBilling", { enumerable: true, get: function () { return schema_1.normalizeBilling; } });
+Object.defineProperty(exports, "toJsonSchema", { enumerable: true, get: function () { return schema_1.toJsonSchema; } });
+Object.defineProperty(exports, "isToolSchemaWithJson", { enumerable: true, get: function () { return schema_1.isToolSchemaWithJson; } });
+Object.defineProperty(exports, "getZodSchema", { enumerable: true, get: function () { return schema_1.getZodSchema; } });
+Object.defineProperty(exports, "getJsonSchemaFromToolSchema", { enumerable: true, get: function () { return schema_1.getJsonSchemaFromToolSchema; } });
+// Environment utilities
+var env_1 = require("./env");
+Object.defineProperty(exports, "parseJsonRecord", { enumerable: true, get: function () { return env_1.parseJsonRecord; } });
+Object.defineProperty(exports, "parseNumberEnv", { enumerable: true, get: function () { return env_1.parseNumberEnv; } });
+Object.defineProperty(exports, "mergeRuntimeEnv", { enumerable: true, get: function () { return env_1.mergeRuntimeEnv; } });
+// HTTP utilities
+var http_1 = require("./http");
+Object.defineProperty(exports, "readRawRequestBody", { enumerable: true, get: function () { return http_1.readRawRequestBody; } });
+Object.defineProperty(exports, "parseJSONBody", { enumerable: true, get: function () { return http_1.parseJSONBody; } });
+Object.defineProperty(exports, "sendJSON", { enumerable: true, get: function () { return http_1.sendJSON; } });
+Object.defineProperty(exports, "sendHTML", { enumerable: true, get: function () { return http_1.sendHTML; } });
+Object.defineProperty(exports, "getDefaultHeaders", { enumerable: true, get: function () { return http_1.getDefaultHeaders; } });
+Object.defineProperty(exports, "createResponse", { enumerable: true, get: function () { return http_1.createResponse; } });
+Object.defineProperty(exports, "getListeningPort", { enumerable: true, get: function () { return http_1.getListeningPort; } });

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

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import type { BillingInfo, ToolSchema, ToolSchemaWithJson } from '../../types';
+/**
+ * Normalizes billing info to ensure credits field exists
+ */
+export declare function normalizeBilling(billing?: BillingInfo): BillingInfo;
+/**
+ * Converts a Zod schema to JSON Schema format
+ */
+export declare function toJsonSchema(schema?: z.ZodTypeAny): Record<string, unknown> | undefined;
+/**
+ * Type guard to check if a schema is a ToolSchemaWithJson
+ */
+export declare function isToolSchemaWithJson(schema: ToolSchema | undefined): schema is ToolSchemaWithJson;
+/**
+ * Extracts the Zod schema from a ToolSchema
+ */
+export declare function getZodSchema(schema?: ToolSchema): z.ZodTypeAny | undefined;
+/**
+ * Gets JSON schema from a ToolSchema, either from explicit jsonSchema or by converting Zod
+ */
+export declare function getJsonSchemaFromToolSchema(schema?: ToolSchema): Record<string, unknown> | undefined;

package/dist/server/utils/schema.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBilling = normalizeBilling;
+exports.toJsonSchema = toJsonSchema;
+exports.isToolSchemaWithJson = isToolSchemaWithJson;
+exports.getZodSchema = getZodSchema;
+exports.getJsonSchemaFromToolSchema = getJsonSchemaFromToolSchema;
+const z = __importStar(require("zod"));
+/**
+ * Normalizes billing info to ensure credits field exists
+ */
+function normalizeBilling(billing) {
+    if (!billing || typeof billing.credits !== 'number') {
+        return { credits: 0 };
+    }
+    return billing;
+}
+/**
+ * Converts a Zod schema to JSON Schema format
+ */
+function toJsonSchema(schema) {
+    if (!schema)
+        return undefined;
+    try {
+        // Zod v4 has native JSON Schema support via z.toJSONSchema()
+        return z.toJSONSchema(schema, {
+            unrepresentable: 'any', // Handle z.date(), z.bigint() etc gracefully
+        });
+    }
+    catch (err) {
+        console.error('[toJsonSchema] Failed to convert schema:', err);
+        return undefined;
+    }
+}
+/**
+ * Type guard to check if a schema is a ToolSchemaWithJson
+ */
+function isToolSchemaWithJson(schema) {
+    return Boolean(schema &&
+        typeof schema === 'object' &&
+        'zod' in schema &&
+        schema.zod instanceof z.ZodType);
+}
+/**
+ * Extracts the Zod schema from a ToolSchema
+ */
+function getZodSchema(schema) {
+    if (!schema)
+        return undefined;
+    if (schema instanceof z.ZodType) {
+        return schema;
+    }
+    if (isToolSchemaWithJson(schema)) {
+        return schema.zod;
+    }
+    return undefined;
+}
+/**
+ * Gets JSON schema from a ToolSchema, either from explicit jsonSchema or by converting Zod
+ */
+function getJsonSchemaFromToolSchema(schema) {
+    if (!schema)
+        return undefined;
+    if (isToolSchemaWithJson(schema) && schema.jsonSchema) {
+        return schema.jsonSchema;
+    }
+    const zodSchema = getZodSchema(schema);
+    return toJsonSchema(zodSchema);
+}