skedyul 1.2.17 → 1.2.19

package/dist/cli/index.js

@@ -2951,6 +2951,64 @@ function printStartupLog(config, tools, webhookRegistry, port) {
   console.log("");
 }
 
+// src/config/resolve.ts
+async function resolveDynamicImport(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value instanceof Promise) {
+    const resolved = await value;
+    if (resolved && typeof resolved === "object" && "default" in resolved) {
+      return resolved.default;
+    }
+    return resolved;
+  }
+  return value;
+}
+function serializeTools(registry) {
+  return Object.entries(registry).map(([key, tool]) => ({
+    name: tool.name || key,
+    displayName: tool.label,
+    description: tool.description,
+    timeout: tool.timeout,
+    retries: tool.retries
+  }));
+}
+function serializeWebhooks(registry) {
+  return Object.values(registry).map((webhook) => ({
+    name: webhook.name,
+    description: webhook.description,
+    methods: webhook.methods ?? ["POST"],
+    type: webhook.type ?? "WEBHOOK"
+  }));
+}
+async function resolveConfig(config, registry, webhookRegistry) {
+  const provision = await resolveDynamicImport(
+    config.provision
+  );
+  const install = await resolveDynamicImport(
+    config.install
+  );
+  const tools = serializeTools(registry);
+  const webhooks = webhookRegistry ? serializeWebhooks(webhookRegistry) : [];
+  return {
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    computeLayer: config.computeLayer,
+    tools,
+    webhooks,
+    provision,
+    agents: config.agents
+  };
+}
+function createMinimalConfig(name, version) {
+  return {
+    name,
+    version
+  };
+}
+
 // src/server/dedicated.ts
 function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
   const port = getListeningPort(config);
@@ -2970,23 +3028,19 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           return;
         }
         if (pathname === "/config" && req.method === "GET") {
-          sendJSON(res, 200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          });
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          sendJSON(res, 200, serializedConfig);
           return;
         }
         if (pathname.startsWith("/webhooks/") && webhookRegistry) {
@@ -4077,23 +4131,19 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
           return createResponse(200, state.getHealthStatus(), headers);
         }
         if (path14 === "/config" && method === "GET") {
-          return createResponse(200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          }, headers);
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          return createResponse(200, serializedConfig, headers);
         }
         if (path14 === "/mcp" && method === "POST") {
           let body;

package/dist/config/index.d.ts

@@ -13,4 +13,5 @@ export type { InstallConfig, ProvisionConfig, BuildConfig, SkedyulConfig, Serial
 export { defineConfig } from './app-config';
 export { defineModel, defineChannel, definePage, defineWorkflow, defineAgent, defineEnv, defineNavigation, } from './define';
 export { CONFIG_FILE_NAMES, loadConfig, validateConfig } from './loader';
+export { resolveConfig, createMinimalConfig } from './resolve';
 export { getAllEnvKeys, getRequiredInstallEnvKeys } from './utils';

package/dist/config/resolve.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Config resolution utilities.
+ *
+ * This module provides functions to resolve dynamic imports in SkedyulConfig
+ * and convert it to a serializable format for the /config endpoint.
+ */
+import type { SkedyulConfig, SerializableSkedyulConfig } from './app-config';
+import type { ToolRegistry, WebhookRegistry } from '../types';
+/**
+ * Resolves all dynamic imports in a SkedyulConfig and returns a serializable version.
+ *
+ * This function:
+ * 1. Resolves dynamic imports for tools, webhooks, provision, and install
+ * 2. Serializes tool and webhook registries to metadata arrays
+ * 3. Returns a plain object suitable for JSON serialization
+ *
+ * @param config - The original SkedyulConfig (may contain dynamic imports)
+ * @param registry - The resolved tool registry (already loaded by mcp_server.ts)
+ * @param webhookRegistry - The resolved webhook registry (if any)
+ * @returns A fully resolved and serializable config
+ */
+export declare function resolveConfig(config: SkedyulConfig, registry: ToolRegistry, webhookRegistry?: WebhookRegistry): Promise<SerializableSkedyulConfig>;
+/**
+ * Creates a minimal SkedyulConfig from server metadata.
+ * Used as a fallback when appConfig is not provided.
+ */
+export declare function createMinimalConfig(name: string, version?: string): SkedyulConfig;

package/dist/dedicated/server.js

@@ -769,6 +769,64 @@ function printStartupLog(config, tools, webhookRegistry, port) {
   console.log("");
 }
 
+// src/config/resolve.ts
+async function resolveDynamicImport(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value instanceof Promise) {
+    const resolved = await value;
+    if (resolved && typeof resolved === "object" && "default" in resolved) {
+      return resolved.default;
+    }
+    return resolved;
+  }
+  return value;
+}
+function serializeTools(registry) {
+  return Object.entries(registry).map(([key, tool]) => ({
+    name: tool.name || key,
+    displayName: tool.label,
+    description: tool.description,
+    timeout: tool.timeout,
+    retries: tool.retries
+  }));
+}
+function serializeWebhooks(registry) {
+  return Object.values(registry).map((webhook) => ({
+    name: webhook.name,
+    description: webhook.description,
+    methods: webhook.methods ?? ["POST"],
+    type: webhook.type ?? "WEBHOOK"
+  }));
+}
+async function resolveConfig(config, registry, webhookRegistry) {
+  const provision = await resolveDynamicImport(
+    config.provision
+  );
+  const install = await resolveDynamicImport(
+    config.install
+  );
+  const tools = serializeTools(registry);
+  const webhooks = webhookRegistry ? serializeWebhooks(webhookRegistry) : [];
+  return {
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    computeLayer: config.computeLayer,
+    tools,
+    webhooks,
+    provision,
+    agents: config.agents
+  };
+}
+function createMinimalConfig(name, version) {
+  return {
+    name,
+    version
+  };
+}
+
 // src/server/dedicated.ts
 function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
   const port = getListeningPort(config);
@@ -788,23 +846,19 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           return;
         }
         if (pathname === "/config" && req.method === "GET") {
-          sendJSON(res, 200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          });
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          sendJSON(res, 200, serializedConfig);
           return;
         }
         if (pathname.startsWith("/webhooks/") && webhookRegistry) {
@@ -1895,23 +1949,19 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
           return createResponse(200, state.getHealthStatus(), headers);
         }
         if (path === "/config" && method === "GET") {
-          return createResponse(200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          }, headers);
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          return createResponse(200, serializedConfig, headers);
         }
         if (path === "/mcp" && method === "POST") {
           let body;

package/dist/esm/index.mjs

@@ -2455,6 +2455,64 @@ function printStartupLog(config, tools, webhookRegistry, port) {
   console.log("");
 }
 
+// src/config/resolve.ts
+async function resolveDynamicImport(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value instanceof Promise) {
+    const resolved = await value;
+    if (resolved && typeof resolved === "object" && "default" in resolved) {
+      return resolved.default;
+    }
+    return resolved;
+  }
+  return value;
+}
+function serializeTools(registry) {
+  return Object.entries(registry).map(([key, tool]) => ({
+    name: tool.name || key,
+    displayName: tool.label,
+    description: tool.description,
+    timeout: tool.timeout,
+    retries: tool.retries
+  }));
+}
+function serializeWebhooks(registry) {
+  return Object.values(registry).map((webhook2) => ({
+    name: webhook2.name,
+    description: webhook2.description,
+    methods: webhook2.methods ?? ["POST"],
+    type: webhook2.type ?? "WEBHOOK"
+  }));
+}
+async function resolveConfig(config, registry, webhookRegistry) {
+  const provision = await resolveDynamicImport(
+    config.provision
+  );
+  const install = await resolveDynamicImport(
+    config.install
+  );
+  const tools = serializeTools(registry);
+  const webhooks = webhookRegistry ? serializeWebhooks(webhookRegistry) : [];
+  return {
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    computeLayer: config.computeLayer,
+    tools,
+    webhooks,
+    provision,
+    agents: config.agents
+  };
+}
+function createMinimalConfig(name, version) {
+  return {
+    name,
+    version
+  };
+}
+
 // src/server/dedicated.ts
 function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
   const port = getListeningPort(config);
@@ -2474,23 +2532,19 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           return;
         }
         if (pathname === "/config" && req.method === "GET") {
-          sendJSON(res, 200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          });
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          sendJSON(res, 200, serializedConfig);
           return;
         }
         if (pathname.startsWith("/webhooks/") && webhookRegistry) {
@@ -3581,23 +3635,19 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
           return createResponse(200, state.getHealthStatus(), headers);
         }
         if (path2 === "/config" && method === "GET") {
-          return createResponse(200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          }, headers);
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          return createResponse(200, serializedConfig, headers);
         }
         if (path2 === "/mcp" && method === "POST") {
           let body;
@@ -4298,6 +4348,7 @@ export {
   communicationChannel,
   configure,
   createContextLogger,
+  createMinimalConfig,
   createServerHookContext,
   createToolCallContext,
   createWebhookContext,
@@ -4324,6 +4375,7 @@ export {
   isWorkflowDependency,
   loadConfig,
   report,
+  resolveConfig,
   resource,
   runWithConfig,
   safeParseConfig,

package/dist/index.d.ts

@@ -15,5 +15,5 @@ declare const _default: {
     z: typeof z;
 };
 export default _default;
-export { defineConfig, defineModel, defineChannel, definePage, defineWorkflow, defineAgent, defineEnv, defineNavigation, loadConfig, validateConfig, CONFIG_FILE_NAMES, getAllEnvKeys, getRequiredInstallEnvKeys, } from './config';
+export { defineConfig, defineModel, defineChannel, definePage, defineWorkflow, defineAgent, defineEnv, defineNavigation, loadConfig, validateConfig, resolveConfig, createMinimalConfig, CONFIG_FILE_NAMES, getAllEnvKeys, getRequiredInstallEnvKeys, } from './config';
 export type { SkedyulConfig, SerializableSkedyulConfig, InstallConfig, ProvisionConfig, BaseDefinition, Scope, FieldOwner, Visibility, ComputeLayer, StructuredFilter, FilterOperator, FilterCondition, FieldOption, EnvVariable, EnvSchema, FieldType, Cardinality, OnDelete, InlineFieldDefinition, FieldVisibility, FieldDefinition, ModelDefinition, RelationshipLink, RelationshipDefinition, CapabilityType, ChannelCapability, ChannelFieldPermissions, ChannelField, ChannelDefinition, WorkflowActionInput, WorkflowAction, WorkflowDefinition, AgentDefinition, NavigationItem, NavigationSection, NavigationSidebar, BreadcrumbItem, NavigationBreadcrumb, NavigationConfig, ContextMode, ContextItemModel, ContextItemTool, ContextItem, ContextDefinition, FormStyleProps, ButtonVariant, ButtonSize, ButtonProps, RelationshipExtension, FormHeader, ActionDefinition, ModalFormDefinition, InputComponent, TextareaComponent, SelectComponent, ComboboxComponent, CheckboxComponent, DatePickerComponent, TimePickerComponent, StatusIndicator, FieldSettingComponent, ImageSettingComponent, FileSettingComponent, ListItemTemplate, ListComponent, EmptyFormComponent, AlertComponent, FormComponent, FormLayoutColumn, FormLayoutRow, FormLayoutConfig, FormProps, CardHeader, CardBlock, ListBlock, ModelMapperBlock, BlockDefinition, PageType, PageDefinition, HttpMethod, WebhookRequest, WebhookHandlerContext, WebhookHandlerResponse, WebhookHandlerFn, WebhookHandlerDefinition, Webhooks, WebhookHandlerMetadata, ModelDependency, ChannelDependency, WorkflowDependency, ResourceDependency, } from './config';

package/dist/index.js

@@ -136,6 +136,7 @@ __export(index_exports, {
   communicationChannel: () => communicationChannel,
   configure: () => configure,
   createContextLogger: () => createContextLogger,
+  createMinimalConfig: () => createMinimalConfig,
   createServerHookContext: () => createServerHookContext,
   createToolCallContext: () => createToolCallContext,
   createWebhookContext: () => createWebhookContext,
@@ -162,6 +163,7 @@ __export(index_exports, {
   isWorkflowDependency: () => isWorkflowDependency,
   loadConfig: () => loadConfig,
   report: () => report,
+  resolveConfig: () => resolveConfig,
   resource: () => resource,
   runWithConfig: () => runWithConfig,
   safeParseConfig: () => safeParseConfig,
@@ -2621,6 +2623,64 @@ function printStartupLog(config, tools, webhookRegistry, port) {
   console.log("");
 }
 
+// src/config/resolve.ts
+async function resolveDynamicImport(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value instanceof Promise) {
+    const resolved = await value;
+    if (resolved && typeof resolved === "object" && "default" in resolved) {
+      return resolved.default;
+    }
+    return resolved;
+  }
+  return value;
+}
+function serializeTools(registry) {
+  return Object.entries(registry).map(([key, tool]) => ({
+    name: tool.name || key,
+    displayName: tool.label,
+    description: tool.description,
+    timeout: tool.timeout,
+    retries: tool.retries
+  }));
+}
+function serializeWebhooks(registry) {
+  return Object.values(registry).map((webhook2) => ({
+    name: webhook2.name,
+    description: webhook2.description,
+    methods: webhook2.methods ?? ["POST"],
+    type: webhook2.type ?? "WEBHOOK"
+  }));
+}
+async function resolveConfig(config, registry, webhookRegistry) {
+  const provision = await resolveDynamicImport(
+    config.provision
+  );
+  const install = await resolveDynamicImport(
+    config.install
+  );
+  const tools = serializeTools(registry);
+  const webhooks = webhookRegistry ? serializeWebhooks(webhookRegistry) : [];
+  return {
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    computeLayer: config.computeLayer,
+    tools,
+    webhooks,
+    provision,
+    agents: config.agents
+  };
+}
+function createMinimalConfig(name, version) {
+  return {
+    name,
+    version
+  };
+}
+
 // src/server/dedicated.ts
 function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
   const port = getListeningPort(config);
@@ -2640,23 +2700,19 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           return;
         }
         if (pathname === "/config" && req.method === "GET") {
-          sendJSON(res, 200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          });
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          sendJSON(res, 200, serializedConfig);
           return;
         }
         if (pathname.startsWith("/webhooks/") && webhookRegistry) {
@@ -3747,23 +3803,19 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
           return createResponse(200, state.getHealthStatus(), headers);
         }
         if (path2 === "/config" && method === "GET") {
-          return createResponse(200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          }, headers);
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          return createResponse(200, serializedConfig, headers);
         }
         if (path2 === "/mcp" && method === "POST") {
           let body;
@@ -4465,6 +4517,7 @@ var index_default = { z: import_v44.z };
   communicationChannel,
   configure,
   createContextLogger,
+  createMinimalConfig,
   createServerHookContext,
   createToolCallContext,
   createWebhookContext,
@@ -4490,6 +4543,7 @@ var index_default = { z: import_v44.z };
   isWorkflowDependency,
   loadConfig,
   report,
+  resolveConfig,
   resource,
   runWithConfig,
   safeParseConfig,

package/dist/server.js

@@ -769,6 +769,64 @@ function printStartupLog(config, tools, webhookRegistry, port) {
   console.log("");
 }
 
+// src/config/resolve.ts
+async function resolveDynamicImport(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value instanceof Promise) {
+    const resolved = await value;
+    if (resolved && typeof resolved === "object" && "default" in resolved) {
+      return resolved.default;
+    }
+    return resolved;
+  }
+  return value;
+}
+function serializeTools(registry) {
+  return Object.entries(registry).map(([key, tool]) => ({
+    name: tool.name || key,
+    displayName: tool.label,
+    description: tool.description,
+    timeout: tool.timeout,
+    retries: tool.retries
+  }));
+}
+function serializeWebhooks(registry) {
+  return Object.values(registry).map((webhook) => ({
+    name: webhook.name,
+    description: webhook.description,
+    methods: webhook.methods ?? ["POST"],
+    type: webhook.type ?? "WEBHOOK"
+  }));
+}
+async function resolveConfig(config, registry, webhookRegistry) {
+  const provision = await resolveDynamicImport(
+    config.provision
+  );
+  const install = await resolveDynamicImport(
+    config.install
+  );
+  const tools = serializeTools(registry);
+  const webhooks = webhookRegistry ? serializeWebhooks(webhookRegistry) : [];
+  return {
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    computeLayer: config.computeLayer,
+    tools,
+    webhooks,
+    provision,
+    agents: config.agents
+  };
+}
+function createMinimalConfig(name, version) {
+  return {
+    name,
+    version
+  };
+}
+
 // src/server/dedicated.ts
 function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
   const port = getListeningPort(config);
@@ -788,23 +846,19 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           return;
         }
         if (pathname === "/config" && req.method === "GET") {
-          sendJSON(res, 200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          });
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          sendJSON(res, 200, serializedConfig);
           return;
         }
         if (pathname.startsWith("/webhooks/") && webhookRegistry) {
@@ -1895,23 +1949,19 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
           return createResponse(200, state.getHealthStatus(), headers);
         }
         if (path === "/config" && method === "GET") {
-          return createResponse(200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          }, headers);
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          return createResponse(200, serializedConfig, headers);
         }
         if (path === "/mcp" && method === "POST") {
           let body;

package/dist/serverless/server.mjs

@@ -708,6 +708,64 @@ function printStartupLog(config, tools, webhookRegistry, port) {
   console.log("");
 }
 
+// src/config/resolve.ts
+async function resolveDynamicImport(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value instanceof Promise) {
+    const resolved = await value;
+    if (resolved && typeof resolved === "object" && "default" in resolved) {
+      return resolved.default;
+    }
+    return resolved;
+  }
+  return value;
+}
+function serializeTools(registry) {
+  return Object.entries(registry).map(([key, tool]) => ({
+    name: tool.name || key,
+    displayName: tool.label,
+    description: tool.description,
+    timeout: tool.timeout,
+    retries: tool.retries
+  }));
+}
+function serializeWebhooks(registry) {
+  return Object.values(registry).map((webhook) => ({
+    name: webhook.name,
+    description: webhook.description,
+    methods: webhook.methods ?? ["POST"],
+    type: webhook.type ?? "WEBHOOK"
+  }));
+}
+async function resolveConfig(config, registry, webhookRegistry) {
+  const provision = await resolveDynamicImport(
+    config.provision
+  );
+  const install = await resolveDynamicImport(
+    config.install
+  );
+  const tools = serializeTools(registry);
+  const webhooks = webhookRegistry ? serializeWebhooks(webhookRegistry) : [];
+  return {
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    computeLayer: config.computeLayer,
+    tools,
+    webhooks,
+    provision,
+    agents: config.agents
+  };
+}
+function createMinimalConfig(name, version) {
+  return {
+    name,
+    version
+  };
+}
+
 // src/server/dedicated.ts
 function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
   const port = getListeningPort(config);
@@ -727,23 +785,19 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
           return;
         }
         if (pathname === "/config" && req.method === "GET") {
-          sendJSON(res, 200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          });
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          sendJSON(res, 200, serializedConfig);
           return;
         }
         if (pathname.startsWith("/webhooks/") && webhookRegistry) {
@@ -1834,23 +1888,19 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer, reg
           return createResponse(200, state.getHealthStatus(), headers);
         }
         if (path === "/config" && method === "GET") {
-          return createResponse(200, {
-            name: config.metadata.name,
-            version: config.metadata.version,
-            computeLayer: config.computeLayer,
-            tools: Object.entries(registry).map(([key, tool]) => ({
-              name: tool.name || key,
-              description: tool.description,
-              timeout: tool.timeout,
-              retries: tool.retries,
-              triggers: tool.triggers
-            })),
-            webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
-              name: w.name,
-              description: w.description,
-              methods: w.methods
-            })) : []
-          }, headers);
+          let appConfig = config.appConfig;
+          if (!appConfig && config.appConfigLoader) {
+            const loaded = await config.appConfigLoader();
+            appConfig = loaded.default;
+          }
+          if (!appConfig) {
+            appConfig = createMinimalConfig(
+              config.metadata.name,
+              config.metadata.version
+            );
+          }
+          const serializedConfig = await resolveConfig(appConfig, registry, webhookRegistry);
+          return createResponse(200, serializedConfig, headers);
         }
         if (path === "/mcp" && method === "POST") {
           let body;

package/dist/types/server.d.ts

@@ -2,6 +2,7 @@ import type { CoreApiConfig } from '../core/types';
 import type { ServerHooks } from './handlers';
 import type { APIGatewayProxyEvent, APIGatewayProxyResult } from './aws';
 import type { ComputeLayer } from '../config/types/compute';
+import type { SkedyulConfig } from '../config/app-config';
 export interface HealthStatus {
     status: 'running';
     requests: number;
@@ -32,6 +33,16 @@ export interface SkedyulServerConfig {
     coreApi?: CoreApiConfig;
     /** Lifecycle hooks for install and provision handlers */
     hooks?: ServerHooks;
+    /** Original app config from skedyul.config.ts for /config endpoint serialization */
+    appConfig?: SkedyulConfig;
+    /**
+     * Lazy loader for app config - use this instead of appConfig to avoid bundling
+     * provision/install configs at build time. The loader is called only when the
+     * /config endpoint is accessed.
+     */
+    appConfigLoader?: () => Promise<{
+        default: SkedyulConfig;
+    }>;
 }
 export interface DedicatedServerInstance {
     listen(port?: number): Promise<void>;

package/package.json

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