skedyul 1.1.9 → 1.2.1

package/dist/esm/index.mjs

@@ -0,0 +1,4255 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { z as z6 } from "zod/v4";
+
+// src/types/invocation.ts
+function createToolCallContext(params) {
+  return {
+    invocationId: params.invocationId,
+    invocationType: "tool_call",
+    toolCallId: params.toolCallId,
+    toolHandle: params.toolHandle,
+    appInstallationId: params.appInstallationId,
+    workflowId: params.workflowId,
+    workflowVersionId: params.workflowVersionId,
+    workflowRunId: params.workflowRunId
+  };
+}
+function createServerHookContext(params) {
+  return {
+    invocationId: params.invocationId,
+    invocationType: "server_hook",
+    serverHookHandle: params.serverHookHandle,
+    appInstallationId: params.appInstallationId
+  };
+}
+function createWebhookContext(params) {
+  return {
+    invocationId: params.invocationId,
+    invocationType: "webhook",
+    appInstallationId: params.appInstallationId
+  };
+}
+function createWorkflowStepContext(params) {
+  return {
+    invocationId: params.invocationId,
+    invocationType: "workflow_step",
+    workflowId: params.workflowId,
+    workflowVersionId: params.workflowVersionId,
+    workflowRunId: params.workflowRunId,
+    workflowStepId: params.workflowStepId
+  };
+}
+
+// src/types/tool-context.ts
+function isProvisionContext(ctx) {
+  return ctx.trigger === "provision";
+}
+function isRuntimeContext(ctx) {
+  return ctx.trigger !== "provision";
+}
+
+// src/types/tool.ts
+import { z } from "zod/v4";
+var ToolResponseMetaSchema = z.object({
+  /** Whether the tool execution succeeded */
+  success: z.boolean(),
+  /** Human-readable message describing the result or error */
+  message: z.string(),
+  /** Name of the tool that was executed */
+  toolName: z.string()
+});
+
+// src/types/webhook.ts
+function isRuntimeWebhookContext(ctx) {
+  return "appInstallationId" in ctx && ctx.appInstallationId !== void 0;
+}
+
+// src/schemas.ts
+import { z as z2 } from "zod/v4";
+var EnvVisibilitySchema = z2.enum(["visible", "encrypted"]);
+var EnvVariableDefinitionSchema = z2.object({
+  label: z2.string(),
+  required: z2.boolean().optional(),
+  visibility: EnvVisibilitySchema.optional(),
+  default: z2.string().optional(),
+  description: z2.string().optional(),
+  placeholder: z2.string().optional()
+});
+var EnvSchemaSchema = z2.record(z2.string(), EnvVariableDefinitionSchema);
+var ComputeLayerTypeSchema = z2.enum(["serverless", "dedicated"]);
+var FieldOwnerSchema = z2.enum(["APP", "SHARED"]);
+var PrimitiveSchema = z2.union([z2.string(), z2.number(), z2.boolean()]);
+var PrimitiveOrArraySchema = z2.union([PrimitiveSchema, z2.array(PrimitiveSchema)]);
+var FilterOperatorSchema = z2.enum([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "contains",
+  "notContains",
+  "not_contains",
+  "startsWith",
+  "starts_with",
+  "endsWith",
+  "ends_with",
+  "isEmpty",
+  "isNotEmpty"
+]);
+var FilterConditionSchema = z2.record(
+  FilterOperatorSchema,
+  PrimitiveOrArraySchema
+);
+var StructuredFilterSchema = z2.record(
+  z2.string(),
+  FilterConditionSchema
+);
+var ModelDependencySchema = z2.object({
+  model: z2.string(),
+  fields: z2.array(z2.string()).optional(),
+  where: StructuredFilterSchema.optional()
+});
+var ChannelDependencySchema = z2.object({
+  channel: z2.string()
+});
+var WorkflowDependencySchema = z2.object({
+  workflow: z2.string()
+});
+var ResourceDependencySchema = z2.union([
+  ModelDependencySchema,
+  ChannelDependencySchema,
+  WorkflowDependencySchema
+]);
+var FieldDataTypeSchema = z2.enum([
+  "LONG_STRING",
+  "STRING",
+  "NUMBER",
+  "BOOLEAN",
+  "DATE",
+  "DATE_TIME",
+  "TIME",
+  "FILE",
+  "IMAGE",
+  "RELATION",
+  "OBJECT"
+]);
+var FieldOptionSchema = z2.object({
+  label: z2.string(),
+  value: z2.string(),
+  color: z2.string().optional()
+});
+var InlineFieldDefinitionSchema = z2.object({
+  limitChoices: z2.number().optional(),
+  options: z2.array(FieldOptionSchema).optional(),
+  minLength: z2.number().optional(),
+  maxLength: z2.number().optional(),
+  min: z2.number().optional(),
+  max: z2.number().optional(),
+  relatedModel: z2.string().optional(),
+  pattern: z2.string().optional()
+});
+var AppFieldVisibilitySchema = z2.object({
+  data: z2.boolean().optional(),
+  list: z2.boolean().optional(),
+  filters: z2.boolean().optional()
+});
+var ModelFieldDefinitionSchema = z2.object({
+  handle: z2.string(),
+  label: z2.string(),
+  type: FieldDataTypeSchema.optional(),
+  definition: z2.union([InlineFieldDefinitionSchema, z2.string()]).optional(),
+  required: z2.boolean().optional(),
+  unique: z2.boolean().optional(),
+  system: z2.boolean().optional(),
+  isList: z2.boolean().optional(),
+  defaultValue: z2.object({ value: z2.unknown() }).optional(),
+  description: z2.string().optional(),
+  visibility: AppFieldVisibilitySchema.optional(),
+  owner: FieldOwnerSchema.optional()
+});
+var ModelDefinitionSchema = z2.object({
+  handle: z2.string(),
+  name: z2.string(),
+  namePlural: z2.string().optional(),
+  labelTemplate: z2.string().optional(),
+  description: z2.string().optional(),
+  fields: z2.array(ModelFieldDefinitionSchema),
+  requires: z2.array(ResourceDependencySchema).optional(),
+  addDefaultPages: z2.boolean().optional(),
+  addNavigation: z2.boolean().optional()
+});
+var RelationshipCardinalitySchema = z2.enum([
+  "ONE_TO_ONE",
+  "ONE_TO_MANY"
+]);
+var OnDeleteBehaviorSchema = z2.enum(["NONE", "CASCADE", "RESTRICT"]);
+var RelationshipLinkSchema = z2.object({
+  model: z2.string(),
+  field: z2.string(),
+  label: z2.string()
+});
+var RelationshipDefinitionSchema = z2.object({
+  source: RelationshipLinkSchema,
+  target: RelationshipLinkSchema,
+  cardinality: RelationshipCardinalitySchema,
+  onDelete: OnDeleteBehaviorSchema.default("NONE")
+});
+var ChannelCapabilityTypeSchema = z2.enum([
+  "messaging",
+  // Text-based: SMS, WhatsApp, Messenger, DMs
+  "voice",
+  // Audio calls: Phone, WhatsApp Voice, etc.
+  "video"
+  // Video calls (future)
+]);
+var ChannelCapabilitySchema = z2.object({
+  label: z2.string(),
+  // Display name: "SMS", "WhatsApp Messages"
+  icon: z2.string().optional(),
+  // Lucide icon name
+  receive: z2.string().optional(),
+  // Inbound webhook handler
+  send: z2.string().optional()
+  // Outbound tool handle
+});
+var ChannelFieldDefinitionSchema = z2.object({
+  handle: z2.string(),
+  label: z2.string(),
+  /** Field definition reference or inline definition */
+  definition: z2.union([InlineFieldDefinitionSchema, z2.string()]).optional(),
+  /** Marks this field as the identifier field for the channel */
+  identifier: z2.boolean().optional(),
+  /** Whether this field is required */
+  required: z2.boolean().optional(),
+  /** Default value when creating a new field */
+  defaultValue: z2.object({ value: z2.unknown() }).passthrough().optional(),
+  /** Visibility settings for the field */
+  visibility: z2.object({
+    data: z2.boolean().optional(),
+    list: z2.boolean().optional(),
+    filters: z2.boolean().optional()
+  }).passthrough().optional(),
+  /** Permission settings for the field */
+  permissions: z2.object({
+    read: z2.boolean().optional(),
+    write: z2.boolean().optional()
+  }).passthrough().optional()
+}).passthrough();
+var ChannelDefinitionSchema = z2.object({
+  handle: z2.string(),
+  label: z2.string(),
+  icon: z2.string().optional(),
+  /** Array of field definitions for this channel. One field must have identifier: true. */
+  fields: z2.array(ChannelFieldDefinitionSchema),
+  // Capabilities keyed by standard type (messaging, voice, video) - all optional
+  capabilities: z2.object({
+    messaging: ChannelCapabilitySchema.optional(),
+    voice: ChannelCapabilitySchema.optional(),
+    video: ChannelCapabilitySchema.optional()
+  })
+});
+var WorkflowActionInputSchema = z2.object({
+  key: z2.string(),
+  label: z2.string(),
+  fieldRef: z2.object({
+    fieldHandle: z2.string(),
+    entityHandle: z2.string()
+  }).optional(),
+  template: z2.string().optional()
+});
+var WorkflowActionSchema = z2.object({
+  label: z2.string(),
+  handle: z2.string(),
+  batch: z2.boolean().optional(),
+  entityHandle: z2.string().optional(),
+  inputs: z2.array(WorkflowActionInputSchema).optional()
+});
+var WorkflowDefinitionSchema = z2.object({
+  path: z2.string(),
+  label: z2.string().optional(),
+  handle: z2.string().optional(),
+  requires: z2.array(ResourceDependencySchema).optional(),
+  actions: z2.array(WorkflowActionSchema)
+});
+var PageTypeSchema = z2.enum(["INSTANCE", "LIST"]);
+var PageBlockTypeSchema = z2.enum(["form", "spreadsheet", "kanban", "calendar", "link", "list", "card"]);
+var PageFieldTypeSchema = z2.enum(["STRING", "FILE", "NUMBER", "DATE", "BOOLEAN", "SELECT", "FORM", "RELATIONSHIP"]);
+var PageFieldSourceSchema = z2.object({
+  model: z2.string(),
+  field: z2.string()
+});
+var PageFormHeaderSchema = z2.object({
+  title: z2.string(),
+  description: z2.string().optional()
+});
+var PageActionDefinitionSchema = z2.object({
+  handle: z2.string(),
+  label: z2.string(),
+  handler: z2.string(),
+  icon: z2.string().optional(),
+  variant: z2.enum(["primary", "secondary", "destructive"]).optional(),
+  isDisabled: z2.union([z2.boolean(), z2.string()]).optional(),
+  isHidden: z2.union([z2.boolean(), z2.string()]).optional()
+});
+var FormV2StylePropsSchema = z2.object({
+  id: z2.string(),
+  row: z2.number(),
+  col: z2.number(),
+  className: z2.string().optional(),
+  hidden: z2.boolean().optional()
+});
+var FieldSettingButtonPropsSchema = z2.object({
+  label: z2.string(),
+  variant: z2.enum(["default", "destructive", "outline", "secondary", "ghost", "link"]).optional(),
+  size: z2.enum(["default", "sm", "lg", "icon"]).optional(),
+  isLoading: z2.boolean().optional(),
+  /** Can be boolean or Liquid template string that resolves to boolean */
+  isDisabled: z2.union([z2.boolean(), z2.string()]).optional(),
+  leftIcon: z2.string().optional()
+});
+var RelationshipExtensionSchema = z2.object({
+  model: z2.string()
+});
+var FormLayoutColumnDefinitionSchema = z2.object({
+  field: z2.string(),
+  colSpan: z2.number(),
+  dataType: z2.string().optional(),
+  subQuery: z2.unknown().optional()
+});
+var FormLayoutRowDefinitionSchema = z2.object({
+  columns: z2.array(FormLayoutColumnDefinitionSchema)
+});
+var FormLayoutConfigDefinitionSchema = z2.object({
+  type: z2.literal("form"),
+  rows: z2.array(FormLayoutRowDefinitionSchema)
+});
+var InputComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("Input"),
+  props: z2.object({
+    label: z2.string().optional(),
+    placeholder: z2.string().optional(),
+    helpText: z2.string().optional(),
+    type: z2.enum(["text", "number", "email", "password", "tel", "url", "hidden"]).optional(),
+    required: z2.boolean().optional(),
+    disabled: z2.boolean().optional(),
+    value: z2.union([z2.string(), z2.number()]).optional()
+  })
+});
+var TextareaComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("Textarea"),
+  props: z2.object({
+    label: z2.string().optional(),
+    placeholder: z2.string().optional(),
+    helpText: z2.string().optional(),
+    required: z2.boolean().optional(),
+    disabled: z2.boolean().optional(),
+    value: z2.string().optional()
+  })
+});
+var SelectComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("Select"),
+  props: z2.object({
+    label: z2.string().optional(),
+    placeholder: z2.string().optional(),
+    helpText: z2.string().optional(),
+    /** Static items array (will be populated by iterable if using dynamic items) */
+    items: z2.union([z2.array(z2.object({ value: z2.string(), label: z2.string() })), z2.string()]).optional(),
+    value: z2.string().optional(),
+    isDisabled: z2.boolean().optional(),
+    required: z2.boolean().optional()
+  }),
+  relationship: RelationshipExtensionSchema.optional(),
+  /** For dynamic items using iterable pattern (e.g., 'system.models') */
+  iterable: z2.string().optional(),
+  /** Template for each item in the iterable */
+  itemTemplate: z2.object({
+    value: z2.string(),
+    label: z2.string()
+  }).optional()
+});
+var ComboboxComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("Combobox"),
+  props: z2.object({
+    label: z2.string().optional(),
+    placeholder: z2.string().optional(),
+    helpText: z2.string().optional(),
+    items: z2.array(z2.object({ value: z2.string(), label: z2.string() })).optional(),
+    value: z2.string().optional()
+  }),
+  relationship: RelationshipExtensionSchema.optional()
+});
+var CheckboxComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("Checkbox"),
+  props: z2.object({
+    label: z2.string().optional(),
+    helpText: z2.string().optional(),
+    checked: z2.boolean().optional(),
+    disabled: z2.boolean().optional()
+  })
+});
+var DatePickerComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("DatePicker"),
+  props: z2.object({
+    label: z2.string().optional(),
+    helpText: z2.string().optional(),
+    value: z2.union([z2.string(), z2.date()]).optional(),
+    disabled: z2.boolean().optional()
+  })
+});
+var TimePickerComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("TimePicker"),
+  props: z2.object({
+    label: z2.string().optional(),
+    helpText: z2.string().optional(),
+    value: z2.string().optional(),
+    disabled: z2.boolean().optional()
+  })
+});
+var ImageSettingComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("ImageSetting"),
+  props: z2.object({
+    label: z2.string().optional(),
+    description: z2.string().optional(),
+    helpText: z2.string().optional(),
+    accept: z2.string().optional()
+  })
+});
+var FileSettingComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("FileSetting"),
+  props: z2.object({
+    label: z2.string().optional(),
+    description: z2.string().optional(),
+    helpText: z2.string().optional(),
+    accept: z2.string().optional(),
+    required: z2.boolean().optional(),
+    button: z2.object({
+      label: z2.string().optional(),
+      variant: z2.enum(["default", "outline", "ghost", "link"]).optional(),
+      size: z2.enum(["sm", "md", "lg"]).optional()
+    }).optional()
+  })
+});
+var ListItemTemplateSchema = z2.object({
+  component: z2.string(),
+  span: z2.number().optional(),
+  mdSpan: z2.number().optional(),
+  lgSpan: z2.number().optional(),
+  props: z2.record(z2.string(), z2.unknown())
+});
+var ListComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("List"),
+  props: z2.object({
+    title: z2.string().optional(),
+    items: z2.array(z2.object({
+      id: z2.string(),
+      label: z2.string(),
+      description: z2.string().optional()
+    })).optional(),
+    emptyMessage: z2.string().optional()
+  }),
+  model: z2.string().optional(),
+  labelField: z2.string().optional(),
+  descriptionField: z2.string().optional(),
+  icon: z2.string().optional(),
+  /** Context variable name to iterate over (e.g., 'phone_numbers') */
+  iterable: z2.string().optional(),
+  /** Template for each item - use {{ item.xyz }} for field values */
+  itemTemplate: ListItemTemplateSchema.optional()
+});
+var EmptyFormComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("EmptyForm"),
+  props: z2.object({
+    title: z2.string().optional(),
+    description: z2.string().optional(),
+    icon: z2.string().optional()
+  })
+});
+var AlertComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("Alert"),
+  props: z2.object({
+    title: z2.string(),
+    description: z2.string(),
+    icon: z2.string().optional(),
+    variant: z2.enum(["default", "destructive"]).optional()
+  })
+});
+var ModalFormDefinitionSchema = z2.object({
+  header: PageFormHeaderSchema,
+  handler: z2.string(),
+  /** Named dialog template to use instead of inline fields */
+  template: z2.string().optional(),
+  /** Template-specific params to pass to the dialog */
+  templateParams: z2.record(z2.string(), z2.unknown()).optional(),
+  /** Inline field definitions (used when template is not specified) */
+  fields: z2.lazy(() => z2.array(FormV2ComponentDefinitionSchema)).optional(),
+  layout: FormLayoutConfigDefinitionSchema.optional(),
+  actions: z2.array(PageActionDefinitionSchema).optional()
+});
+var FieldSettingComponentDefinitionSchema = FormV2StylePropsSchema.extend({
+  component: z2.literal("FieldSetting"),
+  props: z2.object({
+    label: z2.string(),
+    description: z2.string().optional(),
+    helpText: z2.string().optional(),
+    mode: z2.enum(["field", "setting"]).optional(),
+    /** Status indicator - can be literal or Liquid template */
+    status: z2.string().optional(),
+    /** Text to display alongside status badge - can be Liquid template */
+    statusText: z2.string().optional(),
+    button: FieldSettingButtonPropsSchema
+  }),
+  modalForm: ModalFormDefinitionSchema.optional()
+});
+var FormV2ComponentDefinitionSchema = z2.discriminatedUnion("component", [
+  InputComponentDefinitionSchema,
+  TextareaComponentDefinitionSchema,
+  SelectComponentDefinitionSchema,
+  ComboboxComponentDefinitionSchema,
+  CheckboxComponentDefinitionSchema,
+  DatePickerComponentDefinitionSchema,
+  TimePickerComponentDefinitionSchema,
+  FieldSettingComponentDefinitionSchema,
+  ImageSettingComponentDefinitionSchema,
+  FileSettingComponentDefinitionSchema,
+  ListComponentDefinitionSchema,
+  EmptyFormComponentDefinitionSchema,
+  AlertComponentDefinitionSchema
+]);
+var FormV2PropsDefinitionSchema = z2.object({
+  formVersion: z2.literal("v2"),
+  id: z2.string().optional(),
+  fields: z2.array(FormV2ComponentDefinitionSchema),
+  layout: FormLayoutConfigDefinitionSchema,
+  /** Optional actions that trigger MCP tool calls */
+  actions: z2.array(PageActionDefinitionSchema).optional()
+});
+var CardBlockHeaderSchema = z2.object({
+  title: z2.string(),
+  description: z2.string().optional(),
+  descriptionHref: z2.string().optional()
+});
+var CardBlockDefinitionSchema = z2.object({
+  type: z2.literal("card"),
+  restructurable: z2.boolean().optional(),
+  header: CardBlockHeaderSchema.optional(),
+  form: FormV2PropsDefinitionSchema,
+  actions: z2.array(PageActionDefinitionSchema).optional(),
+  secondaryActions: z2.array(PageActionDefinitionSchema).optional(),
+  primaryActions: z2.array(PageActionDefinitionSchema).optional()
+});
+var PageFieldDefinitionBaseSchema = z2.object({
+  handle: z2.string(),
+  type: PageFieldTypeSchema,
+  label: z2.string(),
+  description: z2.string().optional(),
+  required: z2.boolean().optional(),
+  handler: z2.string().optional(),
+  source: PageFieldSourceSchema.optional(),
+  options: z2.array(z2.object({ value: z2.string(), label: z2.string() })).optional(),
+  accept: z2.string().optional(),
+  model: z2.string().optional()
+});
+var PageFieldDefinitionSchema = PageFieldDefinitionBaseSchema.extend({
+  header: PageFormHeaderSchema.optional(),
+  fields: z2.lazy(() => z2.array(PageFieldDefinitionSchema)).optional(),
+  actions: z2.lazy(() => z2.array(PageActionDefinitionSchema)).optional()
+});
+var LegacyFormBlockDefinitionSchema = z2.object({
+  type: z2.enum(["form", "spreadsheet", "kanban", "calendar", "link"]),
+  title: z2.string().optional(),
+  fields: z2.array(PageFieldDefinitionSchema).optional(),
+  readonly: z2.boolean().optional()
+});
+var ListBlockDefinitionSchema = z2.object({
+  type: z2.literal("list"),
+  title: z2.string().optional(),
+  model: z2.string(),
+  labelField: z2.string().optional(),
+  descriptionField: z2.string().optional(),
+  icon: z2.string().optional(),
+  emptyMessage: z2.string().optional()
+});
+var ModelMapperBlockDefinitionSchema = z2.object({
+  type: z2.literal("model_mapper"),
+  /** The SHARED model handle from install config (e.g., "client", "patient") */
+  model: z2.string()
+});
+var PageBlockDefinitionSchema = z2.union([
+  CardBlockDefinitionSchema,
+  LegacyFormBlockDefinitionSchema,
+  ListBlockDefinitionSchema,
+  ModelMapperBlockDefinitionSchema
+]);
+var PageContextModeSchema = z2.enum(["first", "many", "count"]);
+var PageContextFiltersSchema = z2.record(
+  z2.string(),
+  z2.record(
+    z2.string(),
+    z2.union([PrimitiveSchema, z2.array(PrimitiveSchema), z2.string()])
+  )
+);
+var PageContextItemDefinitionSchema = z2.object({
+  /** Model handle to fetch data from */
+  model: z2.string(),
+  /** Fetch mode: 'first' returns single object, 'many' returns array, 'count' returns number */
+  mode: PageContextModeSchema,
+  /**
+   * Optional filters. Supports:
+   * - Simple key-value with Liquid templates: { id: '{{ path_params.id }}' }
+   * - StructuredFilter format: { status: { eq: 'APPROVED' } }
+   */
+  filters: PageContextFiltersSchema.optional(),
+  /** Optional limit for 'many' mode */
+  limit: z2.number().optional()
+});
+var PageContextToolItemDefinitionSchema = z2.object({
+  /** Tool name to invoke for fetching context data */
+  tool: z2.string()
+});
+var PageContextDefinitionSchema = z2.record(
+  z2.string(),
+  z2.union([PageContextItemDefinitionSchema, PageContextToolItemDefinitionSchema])
+);
+var PageInstanceFilterSchema = z2.object({
+  model: z2.string(),
+  where: z2.record(z2.string(), z2.unknown()).optional()
+});
+var NavigationItemSchema = z2.object({
+  /** Display label (supports Liquid templates) */
+  label: z2.string(),
+  /** URL href (supports Liquid templates with path_params and context) */
+  href: z2.string(),
+  /** Optional icon name */
+  icon: z2.string().optional()
+});
+var NavigationSectionSchema = z2.object({
+  /** Section title (supports Liquid templates) */
+  title: z2.string().optional(),
+  /** Navigation items in this section */
+  items: z2.array(NavigationItemSchema)
+});
+var NavigationSidebarSchema = z2.object({
+  /** Sections to display in the sidebar */
+  sections: z2.array(NavigationSectionSchema)
+});
+var BreadcrumbItemSchema = z2.object({
+  /** Display label (supports Liquid templates) */
+  label: z2.string(),
+  /** Optional href - if not provided, item is not clickable */
+  href: z2.string().optional()
+});
+var NavigationBreadcrumbSchema = z2.object({
+  /** Breadcrumb items from left to right */
+  items: z2.array(BreadcrumbItemSchema)
+});
+var NavigationConfigSchema = z2.object({
+  /** Sidebar navigation */
+  sidebar: NavigationSidebarSchema.optional(),
+  /** Breadcrumb navigation */
+  breadcrumb: NavigationBreadcrumbSchema.optional()
+});
+var PageDefinitionSchema = z2.object({
+  type: PageTypeSchema,
+  title: z2.string(),
+  /** URL path for this page (e.g., '/phone-numbers' or '/phone-numbers/[id]' for dynamic segments) */
+  path: z2.string(),
+  /** When true, this page is the default landing page for the app installation */
+  default: z2.boolean().optional(),
+  /**
+   * Navigation configuration:
+   * - true/false: show/hide in auto-generated navigation
+   * - string: Liquid template that evaluates to true/false
+   * - NavigationConfigSchema: full navigation override for this page (replaces base navigation)
+   */
+  navigation: z2.union([z2.boolean(), z2.string(), NavigationConfigSchema]).optional().default(true),
+  blocks: z2.array(PageBlockDefinitionSchema),
+  actions: z2.array(PageActionDefinitionSchema).optional(),
+  /** Context data to load for Liquid templates. appInstallationId filtering is automatic. */
+  context: PageContextDefinitionSchema.optional(),
+  /** @deprecated Use context instead */
+  filter: PageInstanceFilterSchema.optional()
+});
+var WebhookHttpMethodSchema = z2.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]);
+var WebhookTypeSchema = z2.enum(["WEBHOOK", "CALLBACK"]);
+var WebhookHandlerDefinitionSchema = z2.object({
+  description: z2.string().optional(),
+  methods: z2.array(WebhookHttpMethodSchema).optional(),
+  /** Invocation type: WEBHOOK (fire-and-forget) or CALLBACK (waits for response). Defaults to WEBHOOK. */
+  type: WebhookTypeSchema.optional(),
+  handler: z2.unknown()
+});
+var WebhooksSchema = z2.record(z2.string(), WebhookHandlerDefinitionSchema);
+var AgentDefinitionSchema = z2.object({
+  /** Unique identifier within the app (used for upserts) */
+  handle: z2.string().regex(/^[a-z0-9_-]+$/, "Handle must be lowercase alphanumeric with dashes/underscores"),
+  /** Display name */
+  name: z2.string().min(1),
+  /** Description of what the agent does */
+  description: z2.string(),
+  /** System prompt (static, no templating) */
+  system: z2.string(),
+  /** Tool names to bind (can be empty for orchestrator agents) */
+  tools: z2.array(z2.string()),
+  /** Optional LLM model override */
+  llmModelId: z2.string().optional(),
+  /** Parent agent that can call this agent ('composer' or another agent handle) */
+  parentAgent: z2.string().optional()
+});
+var InstallConfigSchema = z2.object({
+  env: EnvSchemaSchema.optional(),
+  /** SHARED model definitions (mapped to user's existing data during installation) */
+  models: z2.array(ModelDefinitionSchema).optional(),
+  /** Relationship definitions between SHARED models */
+  relationships: z2.array(RelationshipDefinitionSchema).optional()
+});
+var ProvisionConfigSchema = z2.object({
+  env: EnvSchemaSchema.optional(),
+  /** INTERNAL model definitions (app-owned, not visible to users) */
+  models: z2.array(ModelDefinitionSchema).optional(),
+  /** Relationship definitions between INTERNAL models */
+  relationships: z2.array(RelationshipDefinitionSchema).optional(),
+  channels: z2.array(ChannelDefinitionSchema).optional(),
+  workflows: z2.array(WorkflowDefinitionSchema).optional(),
+  /** Base navigation configuration for all pages (can be overridden per page) */
+  navigation: NavigationConfigSchema.optional(),
+  pages: z2.array(PageDefinitionSchema).optional()
+});
+var SkedyulConfigSchema = z2.object({
+  name: z2.string(),
+  version: z2.string().optional(),
+  description: z2.string().optional(),
+  computeLayer: ComputeLayerTypeSchema.optional(),
+  tools: z2.unknown().optional(),
+  webhooks: z2.unknown().optional(),
+  provision: z2.union([ProvisionConfigSchema, z2.unknown()]).optional(),
+  agents: z2.array(AgentDefinitionSchema).optional()
+});
+function safeParseConfig(data) {
+  const result = SkedyulConfigSchema.safeParse(data);
+  return result.success ? result.data : null;
+}
+var MessageSendChannelSchema = z2.object({
+  id: z2.string(),
+  handle: z2.string(),
+  identifierValue: z2.string()
+});
+var MessageSendSubscriptionSchema = z2.object({
+  id: z2.string(),
+  identifierValue: z2.string()
+});
+var MessageSendContactSchema = z2.object({
+  id: z2.string(),
+  name: z2.string().optional()
+});
+var MessageSendMessageSchema = z2.object({
+  id: z2.string(),
+  content: z2.string(),
+  contentRaw: z2.string().optional(),
+  title: z2.string().optional()
+});
+var MessageSendInputSchema = z2.object({
+  channel: MessageSendChannelSchema,
+  subscription: MessageSendSubscriptionSchema,
+  contact: MessageSendContactSchema,
+  message: MessageSendMessageSchema
+});
+var MessageSendOutputSchema = z2.object({
+  status: z2.enum(["sent", "queued", "failed"]),
+  remoteId: z2.string().optional()
+});
+function isModelDependency(dep) {
+  return "model" in dep;
+}
+function isChannelDependency(dep) {
+  return "channel" in dep;
+}
+function isWorkflowDependency(dep) {
+  return "workflow" in dep;
+}
+
+// src/server/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z5 from "zod";
+
+// src/core/service.ts
+var CoreApiService = class {
+  register(service) {
+    this.service = service;
+  }
+  getService() {
+    return this.service;
+  }
+  setWebhookHandler(handler) {
+    this.webhookHandler = handler;
+  }
+  async dispatchWebhook(request) {
+    if (!this.webhookHandler) {
+      return { status: 404 };
+    }
+    return this.webhookHandler(request);
+  }
+  async callCreateChannel(channel) {
+    return this.service?.createCommunicationChannel(channel);
+  }
+  async callUpdateChannel(channel) {
+    return this.service?.updateCommunicationChannel(channel);
+  }
+  async callDeleteChannel(id) {
+    return this.service?.deleteCommunicationChannel(id);
+  }
+  async callGetChannel(id) {
+    return this.service?.getCommunicationChannel(id);
+  }
+  async callListChannels() {
+    return this.service?.getCommunicationChannels();
+  }
+  async callGetWorkplace(id) {
+    return this.service?.getWorkplace(id);
+  }
+  async callListWorkplaces() {
+    return this.service?.listWorkplaces();
+  }
+  async callSendMessage(args) {
+    return this.service?.sendMessage(args);
+  }
+};
+var coreApiService = new CoreApiService();
+
+// src/server/utils/schema.ts
+import * as z3 from "zod";
+function normalizeBilling(billing) {
+  if (!billing || typeof billing.credits !== "number") {
+    return { credits: 0 };
+  }
+  return billing;
+}
+function toJsonSchema(schema) {
+  if (!schema) return void 0;
+  try {
+    return z3.toJSONSchema(schema, {
+      unrepresentable: "any"
+      // Handle z.date(), z.bigint() etc gracefully
+    });
+  } catch (err) {
+    console.error("[toJsonSchema] Failed to convert schema:", err);
+    return void 0;
+  }
+}
+function isToolSchemaWithJson(schema) {
+  return Boolean(
+    schema && typeof schema === "object" && "zod" in schema && schema.zod instanceof z3.ZodType
+  );
+}
+function getZodSchema(schema) {
+  if (!schema) return void 0;
+  if (schema instanceof z3.ZodType) {
+    return schema;
+  }
+  if (isToolSchemaWithJson(schema)) {
+    return schema.zod;
+  }
+  return void 0;
+}
+function getJsonSchemaFromToolSchema(schema) {
+  if (!schema) return void 0;
+  if (isToolSchemaWithJson(schema) && schema.jsonSchema) {
+    return schema.jsonSchema;
+  }
+  const zodSchema = getZodSchema(schema);
+  return toJsonSchema(zodSchema);
+}
+
+// src/server/utils/env.ts
+function parseJsonRecord(value) {
+  if (!value) {
+    return {};
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}
+function parseNumberEnv(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+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);
+}
+
+// src/server/utils/http.ts
+function readRawRequestBody(req) {
+  return new Promise((resolve2, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      resolve2(body);
+    });
+    req.on("error", reject);
+  });
+}
+async function parseJSONBody(req) {
+  const rawBody = await readRawRequestBody(req);
+  try {
+    return rawBody ? JSON.parse(rawBody) : {};
+  } catch (err) {
+    throw err;
+  }
+}
+function sendJSON(res, statusCode, data) {
+  res.writeHead(statusCode, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+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"
+  };
+}
+function createResponse(statusCode, body, headers) {
+  return {
+    statusCode,
+    headers,
+    body: JSON.stringify(body)
+  };
+}
+function getListeningPort(config) {
+  const envPort = Number.parseInt(process.env.PORT ?? "", 10);
+  if (!Number.isNaN(envPort)) {
+    return envPort;
+  }
+  return config.defaultPort ?? 3e3;
+}
+
+// src/core/client.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { z as z4 } from "zod/v4";
+var requestConfigStorage = new AsyncLocalStorage();
+var globalConfig = {
+  baseUrl: process.env.SKEDYUL_API_URL ?? process.env.SKEDYUL_NODE_URL ?? "",
+  apiToken: process.env.SKEDYUL_API_TOKEN ?? ""
+};
+function runWithConfig(config, fn) {
+  return requestConfigStorage.run(config, fn);
+}
+function getEffectiveConfig() {
+  const requestConfig = requestConfigStorage.getStore();
+  if (requestConfig?.baseUrl && requestConfig?.apiToken) {
+    return requestConfig;
+  }
+  return globalConfig;
+}
+function configure(options) {
+  globalConfig = {
+    ...globalConfig,
+    ...options
+  };
+}
+function getConfig() {
+  return getEffectiveConfig();
+}
+async function callCore(method, params) {
+  const effectiveConfig = getEffectiveConfig();
+  const { baseUrl, apiToken } = effectiveConfig;
+  if (!baseUrl) {
+    throw new Error(
+      "Skedyul client not configured: missing baseUrl. Set SKEDYUL_API_URL environment variable or call configure()."
+    );
+  }
+  if (!apiToken) {
+    throw new Error(
+      "Skedyul client not configured: missing apiToken. Set SKEDYUL_API_TOKEN environment variable or call configure()."
+    );
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiToken}`
+  };
+  const fetchUrl = `${baseUrl}/api/core`;
+  const response = await fetch(fetchUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ method, params })
+  });
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json")) {
+    const text = await response.text();
+    console.error(`[skedyul-node] Core API error: ${response.status} - ${text.slice(0, 200)}`);
+    throw new Error(`Core API returned non-JSON response (${response.status}): ${text.slice(0, 100)}`);
+  }
+  const payload = await response.json();
+  if (!payload.success) {
+    const message = payload.errors?.map((e) => e.field ? `${e.field}: ${e.message}` : e.message).join("; ") || "Unknown error";
+    throw new Error(message);
+  }
+  if (!response.ok) {
+    throw new Error(`Core API error (${response.status})`);
+  }
+  return {
+    data: payload.data,
+    errors: payload.errors ?? [],
+    pagination: payload.pagination
+  };
+}
+var workplace = {
+  async list(args) {
+    const { data } = await callCore("workplace.list", {
+      ...args?.filter ? { filter: args.filter } : {},
+      ...args?.limit ? { limit: args.limit } : {}
+    });
+    return data;
+  },
+  async get(id) {
+    const { data } = await callCore("workplace.get", { id });
+    return data;
+  }
+};
+var communicationChannel = {
+  /**
+   * Create a communication channel for an app installation.
+   *
+   * Creates a channel with the given handle from provision.config.ts.
+   * Optionally links a SHARED model to the user's model in a single operation.
+   *
+   * **Requires sk_wkp_ token** - channels are scoped to app installations.
+   *
+   * @param handle - Channel handle from provision.config.ts (e.g., "phone", "email")
+   * @param params - Channel creation parameters
+   *
+   * @example
+   * ```ts
+   * // Create a phone channel and link the contact model
+   * const channel = await communicationChannel.create("phone", {
+   *   name: "Sales Line",
+   *   identifierValue: "+61400000000",
+   *   link: {
+   *     handle: "contact",        // SHARED model from provision config
+   *     targetModelId: modelId,   // User's selected model
+   *   },
+   * });
+   * ```
+   */
+  async create(handle, params) {
+    const { data } = await callCore("communicationChannel.create", {
+      handle,
+      ...params
+    });
+    return data;
+  },
+  /**
+   * List communication channels with optional filters.
+   *
+   * @example
+   * ```ts
+   * // Find channel by phone number
+   * const channels = await communicationChannel.list({
+   *   filter: { identifierValue: '+1234567890' },
+   *   limit: 1,
+   * });
+   * ```
+   */
+  async list(args) {
+    const { data } = await callCore("communicationChannel.list", {
+      ...args?.filter ? { filter: args.filter } : {},
+      ...args?.limit ? { limit: args.limit } : {}
+    });
+    return data;
+  },
+  async get(id) {
+    const { data } = await callCore("communicationChannel.get", { id });
+    return data;
+  },
+  /**
+   * Receive an inbound message on a communication channel.
+   *
+   * This is typically called from webhook handlers to process incoming messages
+   * (e.g., SMS from Twilio, emails, WhatsApp messages).
+   *
+   * @example
+   * ```ts
+   * // In a webhook handler
+   * const result = await communicationChannel.receiveMessage({
+   *   communicationChannelId: channel.id,
+   *   from: '+1234567890',
+   *   message: 'Hello!',
+   *   remoteId: 'twilio-message-sid-123',
+   * });
+   * ```
+   */
+  async receiveMessage(input) {
+    const { data } = await callCore("communicationChannel.receiveMessage", {
+      communicationChannelId: input.communicationChannelId,
+      from: input.from,
+      message: input.message,
+      contact: input.contact,
+      ...input.remoteId ? { remoteId: input.remoteId } : {}
+    });
+    return data;
+  },
+  /**
+   * Update a communication channel's properties.
+   *
+   * @param channelId - The ID of the channel to update
+   * @param params - The properties to update (e.g., name)
+   *
+   * @example
+   * ```ts
+   * const channel = await communicationChannel.update('channel-id-123', {
+   *   name: 'New Channel Name',
+   * })
+   * ```
+   */
+  async update(channelId, params) {
+    const { data } = await callCore("communicationChannel.update", {
+      communicationChannelId: channelId,
+      ...params
+    });
+    return data;
+  },
+  /**
+   * Remove a communication channel and its associated resources.
+   *
+   * Deletes the channel and cascades:
+   * - EnvVariables scoped to this channel
+   * - AppFields scoped to this channel
+   * - AppResourceInstances scoped to this channel
+   * - CommunicationChannelSubscriptions (Prisma cascade)
+   *
+   * ChatMessages are preserved with subscriptionId set to null.
+   *
+   * @example
+   * ```ts
+   * const { success } = await communicationChannel.remove('channel-id-123')
+   * ```
+   */
+  async remove(channelId) {
+    const { data } = await callCore("communicationChannel.remove", {
+      communicationChannelId: channelId
+    });
+    return data;
+  }
+};
+var instance = {
+  /**
+   * List instances of an internal model.
+   *
+   * The API token determines the context:
+   * - sk_wkp_ tokens: scoped to the token's app installation
+   * - sk_app_ tokens: searches across ALL installations for the app
+   *
+   * @example
+   * ```ts
+   * // List with filters
+   * const { data, pagination } = await instance.list('compliance_record', {
+   *   filter: { status: 'pending' },
+   *   page: 1,
+   *   limit: 10,
+   * })
+   *
+   * // Cross-installation search (with sk_app_ token)
+   * const { data } = await instance.list('phone_number', {
+   *   filter: { phone: '+1234567890' },
+   * })
+   * ```
+   */
+  async list(modelHandle, args) {
+    const { data, pagination } = await callCore("instance.list", {
+      modelHandle,
+      ...args?.page !== void 0 ? { page: args.page } : {},
+      ...args?.limit !== void 0 ? { limit: args.limit } : {},
+      ...args?.filter ? { filter: args.filter } : {}
+    });
+    return {
+      data,
+      pagination: pagination ?? { page: 1, total: 0, hasMore: false, limit: args?.limit ?? 50 }
+    };
+  },
+  /**
+   * Get a single instance by ID.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @example
+   * ```ts
+   * const record = await instance.get('phone_number', 'ins_abc123')
+   * ```
+   */
+  async get(modelHandle, id) {
+    const { data } = await callCore("instance.get", {
+      modelHandle,
+      id
+    });
+    return data;
+  },
+  /**
+   * Create a new instance of an internal model.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @example
+   * ```ts
+   * const newRecord = await instance.create('compliance_record', {
+   *   status: 'pending',
+   *   document_url: 'https://...',
+   * })
+   * ```
+   */
+  async create(modelHandle, data) {
+    const { data: instance2 } = await callCore("instance.create", {
+      modelHandle,
+      data
+    });
+    return instance2;
+  },
+  /**
+   * Update an existing instance.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @example
+   * ```ts
+   * const updated = await instance.update('compliance_record', 'ins_abc123', {
+   *   status: 'approved',
+   *   bundle_sid: 'BU123456',
+   * })
+   * ```
+   */
+  async update(modelHandle, id, data) {
+    const { data: instance2 } = await callCore("instance.update", {
+      modelHandle,
+      id,
+      data
+    });
+    return instance2;
+  },
+  /**
+   * Delete an existing instance.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @example
+   * ```ts
+   * const { deleted } = await instance.delete('phone_number', 'ins_abc123')
+   * ```
+   */
+  async delete(modelHandle, id) {
+    const { data } = await callCore("instance.delete", {
+      modelHandle,
+      id
+    });
+    return data;
+  },
+  /**
+   * Delete multiple instances of an internal model in a single batch operation.
+   *
+   * This is more efficient than calling delete() multiple times as it reduces
+   * API overhead and executes all deletes in a single transaction.
+   *
+   * Supports two modes:
+   * - **By IDs**: Delete specific instances by their IDs
+   * - **By Filter**: Delete instances matching a StructuredFilter
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @param modelHandle - The model handle from provision config
+   * @param options - Either { ids: string[] } or { filter: StructuredFilter }
+   * @returns Object containing deleted instance IDs and any errors that occurred
+   *
+   * @example
+   * ```ts
+   * // Delete by IDs
+   * const { deleted, errors } = await instance.deleteMany('panel_result', {
+   *   ids: ['ins_abc123', 'ins_def456'],
+   * })
+   *
+   * // Delete by filter
+   * const { deleted, errors } = await instance.deleteMany('panel_result', {
+   *   filter: { status: { eq: 'pending' } },
+   * })
+   *
+   * if (errors.length > 0) {
+   *   console.log('Some items failed:', errors)
+   * }
+   * console.log('Deleted:', deleted.length, 'instances')
+   * ```
+   */
+  async deleteMany(modelHandle, options) {
+    const { data } = await callCore("instance.deleteMany", {
+      modelHandle,
+      ...options
+    });
+    return data;
+  },
+  /**
+   * Create multiple instances of an internal model in a single batch operation.
+   *
+   * This is more efficient than calling create() multiple times as it reduces
+   * API overhead and executes all creates in a single transaction.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @param modelHandle - The model handle from provision config
+   * @param items - Array of data objects to create as instances
+   * @returns Object containing created instances and any errors that occurred
+   *
+   * @example
+   * ```ts
+   * const { created, errors } = await instance.createMany('panel_result', [
+   *   { test_name: 'Glucose', value_string: '5.2', unit: 'mmol/L' },
+   *   { test_name: 'Creatinine', value_string: '80', unit: 'umol/L' },
+   * ])
+   *
+   * if (errors.length > 0) {
+   *   console.log('Some items failed:', errors)
+   * }
+   * console.log('Created:', created.length, 'instances')
+   * ```
+   */
+  async createMany(modelHandle, items) {
+    const { data } = await callCore("instance.createMany", {
+      modelHandle,
+      items
+    });
+    return data;
+  },
+  /**
+   * Update multiple instances of an internal model in a single batch operation.
+   *
+   * This is more efficient than calling update() multiple times as it reduces
+   * API overhead and executes all updates in a single transaction.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @param modelHandle - The model handle from provision config
+   * @param items - Array of objects containing id and data to update
+   * @returns Object containing updated instances and any errors that occurred
+   *
+   * @example
+   * ```ts
+   * const { updated, errors } = await instance.updateMany('panel_result', [
+   *   { id: 'ins_abc123', data: { value_string: '5.5' } },
+   *   { id: 'ins_def456', data: { value_string: '85' } },
+   * ])
+   *
+   * if (errors.length > 0) {
+   *   console.log('Some items failed:', errors)
+   * }
+   * console.log('Updated:', updated.length, 'instances')
+   * ```
+   */
+  async updateMany(modelHandle, items) {
+    const { data } = await callCore("instance.updateMany", {
+      modelHandle,
+      items
+    });
+    return data;
+  },
+  /**
+   * Upsert multiple instances of an internal model in a single batch operation.
+   *
+   * Creates instances if they don't exist, updates them if they do (based on matchField).
+   * This is more efficient than calling upsert() multiple times as it reduces
+   * API overhead and executes all upserts in a single transaction.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @param modelHandle - The model handle from provision config
+   * @param items - Array of data objects to upsert as instances
+   * @param matchField - The field handle to match existing instances (e.g., 'vetnostics_id')
+   * @returns Object containing upserted instances with mode and any errors that occurred
+   *
+   * @example
+   * ```ts
+   * const { results, errors } = await instance.upsertMany('panel_result', [
+   *   { vetnostics_id: '25-54966975/622/glucose', test_name: 'Glucose', value_string: '5.2' },
+   *   { vetnostics_id: '25-54966975/622/creatinine', test_name: 'Creatinine', value_string: '80' },
+   * ], 'vetnostics_id')
+   *
+   * if (errors.length > 0) {
+   *   console.log('Some items failed:', errors)
+   * }
+   * const created = results.filter(r => r.mode === 'created')
+   * const updated = results.filter(r => r.mode === 'updated')
+   * console.log('Created:', created.length, 'Updated:', updated.length)
+   * ```
+   */
+  async upsertMany(modelHandle, items, matchField) {
+    const { data } = await callCore("instance.upsertMany", {
+      modelHandle,
+      items,
+      matchField
+    });
+    return data;
+  },
+  /**
+   * Check if a model is configured (linked) for the current app installation.
+   *
+   * This is useful for best-effort sync scenarios where you want to check
+   * which models are available before attempting to create instances.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @param modelHandle - The model handle from provision config
+   * @returns true if the model is configured and has a valid targetId, false otherwise
+   *
+   * @example
+   * ```ts
+   * // Check if models are configured before syncing
+   * const isTestOrderConfigured = await instance.isConfigured('test_order')
+   * const isTestReportConfigured = await instance.isConfigured('test_report')
+   *
+   * if (isTestOrderConfigured) {
+   *   await instance.create('test_order', orderData)
+   * }
+   * ```
+   */
+  async isConfigured(modelHandle) {
+    const { data } = await callCore("instance.isConfigured", {
+      modelHandle
+    });
+    return data.configured;
+  },
+  /**
+   * Check which models from a list are configured for the current app installation.
+   *
+   * This is more efficient than calling isConfigured() multiple times as it
+   * makes a single API call to check all models at once.
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @param modelHandles - Array of model handles from provision config
+   * @returns Map of model handle to configuration status
+   *
+   * @example
+   * ```ts
+   * // Check multiple models at once
+   * const configStatus = await instance.getConfiguredModels([
+   *   'test_order',
+   *   'test_report',
+   *   'panel_result',
+   *   'culture_result',
+   * ])
+   *
+   * if (configStatus.get('test_order')) {
+   *   // test_order is configured
+   * }
+   * ```
+   */
+  async getConfiguredModels(modelHandles) {
+    const { data } = await callCore("instance.getConfiguredModels", {
+      modelHandles
+    });
+    return new Map(Object.entries(data));
+  }
+};
+var token = {
+  /**
+   * Exchange an sk_app_ token for an installation-scoped sk_wkp_ JWT.
+   *
+   * **Requires sk_app_ token** - only works with app-level tokens.
+   * Used after identifying the target installation (e.g., via instance.search).
+   *
+   * The returned JWT is short-lived (1 hour) and scoped to the specific installation.
+   *
+   * @example
+   * ```ts
+   * // After finding the installation via instance.search
+   * const { token: scopedToken } = await token.exchange(appInstallationId)
+   *
+   * // Use the scoped token for subsequent operations
+   * runWithConfig({ apiToken: scopedToken, baseUrl: config.baseUrl }, async () => {
+   *   const channels = await communicationChannel.list({ filter: { identifierValue: phoneNumber } })
+   *   // ...
+   * })
+   * ```
+   */
+  async exchange(appInstallationId) {
+    const { data } = await callCore("token.exchange", {
+      appInstallationId
+    });
+    return data;
+  }
+};
+var file = {
+  /**
+   * Get file metadata by ID.
+   *
+   * Returns file information including name, mimeType, and size.
+   * Files are validated to ensure they belong to the requesting app installation.
+   *
+   * @example
+   * ```ts
+   * // Get file info
+   * const fileInfo = await file.get('fl_abc123')
+   * console.log(fileInfo.name) // 'document.pdf'
+   * console.log(fileInfo.mimeType) // 'application/pdf'
+   * console.log(fileInfo.size) // 12345
+   * ```
+   */
+  async get(fileId) {
+    const { data } = await callCore("file.get", {
+      fileId
+    });
+    return data;
+  },
+  /**
+   * Get a temporary download URL for an app-scoped file.
+   *
+   * Files are validated to ensure they belong to the requesting app installation.
+   * The returned URL expires in 1 hour.
+   *
+   * @example
+   * ```ts
+   * // Get a download URL for a file
+   * const { url, expiresAt } = await file.getUrl('fl_abc123')
+   *
+   * // Use the URL to download or pass to external services
+   * const response = await fetch(url)
+   * ```
+   */
+  async getUrl(fileId) {
+    const { data } = await callCore("file.getUrl", {
+      fileId
+    });
+    return data;
+  },
+  /**
+   * Upload file content and create a File record.
+   *
+   * Files are scoped to the app installation and stored privately.
+   * Use file.getUrl() to generate a temporary download URL when needed.
+   *
+   * @example
+   * ```ts
+   * // Upload a file from a Buffer
+   * const buffer = await downloadFromExternalUrl(url)
+   * const { id } = await file.upload({
+   *   content: buffer,
+   *   name: 'document.pdf',
+   *   mimeType: 'application/pdf',
+   * })
+   *
+   * // Upload with a path prefix for organization
+   * const { id } = await file.upload({
+   *   content: imageBuffer,
+   *   name: 'photo.jpg',
+   *   mimeType: 'image/jpeg',
+   *   path: 'attachments',
+   * })
+   * ```
+   */
+  async upload(params) {
+    const content = typeof params.content === "string" ? params.content : params.content.toString("base64");
+    const { data } = await callCore("file.upload", {
+      content,
+      name: params.name,
+      mimeType: params.mimeType,
+      ...params.path ? { path: params.path } : {}
+    });
+    return data;
+  }
+};
+var webhook = {
+  /**
+   * Create a webhook registration for a handler.
+   *
+   * Creates a unique URL that external services can call.
+   * When called, the request is routed to the handler defined in webhooks config.
+   *
+   * **Requires sk_wkp_ token** - registrations are scoped to the app installation.
+   *
+   * @param name - Handler name from webhooks config
+   * @param context - Optional metadata passed to the handler when webhook fires
+   * @param options - Optional configuration (e.g., expiration)
+   *
+   * @example
+   * ```ts
+   * // Create a webhook for Twilio compliance callbacks
+   * const { url, id } = await webhook.create('compliance_status', {
+   *   bundleSid: bundle.sid,
+   *   complianceRecordId: record.id,
+   * })
+   *
+   * // Pass the URL to Twilio
+   * await twilioClient.bundles(bundle.sid).update({
+   *   statusCallback: url,
+   * })
+   * ```
+   */
+  async create(name, context, options) {
+    const { data } = await callCore("webhook.create", {
+      name,
+      ...context ? { context } : {},
+      ...options?.expiresIn ? { expiresIn: options.expiresIn } : {}
+    });
+    return data;
+  },
+  /**
+   * Delete a webhook registration by ID.
+   *
+   * @param id - Registration ID (whkr_xxx format)
+   * @returns Whether the registration was deleted (false if not found)
+   *
+   * @example
+   * ```ts
+   * const { deleted } = await webhook.delete('whkr_abc123')
+   * ```
+   */
+  async delete(id) {
+    const { data } = await callCore("webhook.delete", {
+      id
+    });
+    return data;
+  },
+  /**
+   * Delete webhook registrations by handler name.
+   *
+   * Useful for cleaning up all webhooks of a certain type,
+   * or filtering by context values.
+   *
+   * @param name - Handler name from webhooks config
+   * @param options - Optional filter by context values
+   * @returns Number of registrations deleted
+   *
+   * @example
+   * ```ts
+   * // Delete all receive_sms webhooks for this installation
+   * const { count } = await webhook.deleteByName('receive_sms')
+   *
+   * // Delete only webhooks for a specific channel
+   * const { count } = await webhook.deleteByName('receive_sms', {
+   *   filter: { communicationChannelId: channel.id },
+   * })
+   * ```
+   */
+  async deleteByName(name, options) {
+    const { data } = await callCore("webhook.deleteByName", {
+      name,
+      ...options?.filter ? { filter: options.filter } : {}
+    });
+    return data;
+  },
+  /**
+   * List webhook registrations for this installation.
+   *
+   * @param options - Optional filter by handler name
+   * @returns Array of webhook registrations
+   *
+   * @example
+   * ```ts
+   * // List all webhooks
+   * const { webhooks } = await webhook.list()
+   *
+   * // List only receive_sms webhooks
+   * const { webhooks } = await webhook.list({ name: 'receive_sms' })
+   * ```
+   */
+  async list(options) {
+    const { data } = await callCore("webhook.list", {
+      ...options?.name ? { name: options.name } : {}
+    });
+    return { webhooks: data };
+  }
+};
+var resource = {
+  /**
+   * Link a SHARED app resource (model) to a user's resource.
+   *
+   * Creates an AppResourceInstance hierarchy for MODEL types.
+   * This establishes the connection between an app's SHARED model
+   * (e.g., 'contact') and a user's actual workplace model (e.g., 'Clients').
+   *
+   * The API token determines the context (app installation is embedded in sk_wkp_ tokens).
+   *
+   * @param params - Link parameters
+   *
+   * @example
+   * ```ts
+   * // Link the SHARED 'contact' model to user's 'Clients' model
+   * const { instanceId } = await resource.link({
+   *   handle: 'contact',           // SHARED model handle from provision config
+   *   targetModelId: modelId,      // User's selected model ID
+   *   channelId: channel.id,       // Optional: scope to communication channel
+   * })
+   * ```
+   */
+  async link(params) {
+    const { data } = await callCore("resource.link", {
+      ...params
+    });
+    return data;
+  }
+};
+function zodSchemaToJsonSchema(schema) {
+  return z4.toJSONSchema(schema);
+}
+var ai = {
+  /**
+   * Generate a structured object using AI.
+   *
+   * The AI will generate an object that conforms to the provided Zod schema.
+   * Supports both simple text prompts and multimodal messages with files/images.
+   *
+   * @example
+   * ```ts
+   * // Simple text prompt
+   * const result = await ai.generateObject({
+   *   system: 'Extract patient information from the text.',
+   *   prompt: 'Patient: Max, Species: Canine, DOB: 2020-01-15',
+   *   schema: z.object({
+   *     patientName: z.string(),
+   *     species: z.string(),
+   *     dateOfBirth: z.string().nullable(),
+   *   }),
+   * })
+   *
+   * // With files array (simple multimodal)
+   * const result = await ai.generateObject({
+   *   model: 'openai/gpt-4o',
+   *   system: 'Parse the lab report and extract test results.',
+   *   prompt: 'Extract all test results from this report.',
+   *   files: ['fl_abc123'],
+   *   schema: TestResultsSchema,
+   * })
+   *
+   * // With messages (advanced multimodal)
+   * const result = await ai.generateObject({
+   *   model: 'openai/gpt-4o',
+   *   system: 'Parse the lab report and extract test results.',
+   *   schema: TestResultsSchema,
+   *   messages: [
+   *     {
+   *       role: 'user',
+   *       content: [
+   *         { type: 'text', text: 'Extract all test results from this report.' },
+   *         { type: 'file', fileId: 'fl_abc123' },
+   *       ],
+   *     },
+   *   ],
+   * })
+   * ```
+   */
+  async generateObject(options) {
+    if (!options.prompt && !options.messages) {
+      throw new Error("Either prompt or messages must be provided");
+    }
+    const jsonSchema = zodSchemaToJsonSchema(options.schema);
+    const { data } = await callCore("ai.generateObject", {
+      ...options.model ? { model: options.model } : {},
+      system: options.system,
+      ...options.prompt ? { prompt: options.prompt } : {},
+      schema: jsonSchema,
+      ...options.files && options.files.length > 0 ? { files: options.files } : {},
+      ...options.messages ? { messages: options.messages } : {},
+      ...options.maxTokens !== void 0 ? { maxTokens: options.maxTokens } : {},
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+    });
+    return data;
+  }
+};
+var report = {
+  /**
+   * Generate a report from a template.
+   *
+   * By default, returns a URL to view the report. Set `mode: 'html'` to get
+   * the rendered HTML content directly.
+   *
+   * **Requires sk_wkp_ token** - reports are scoped to workplaces.
+   *
+   * @example
+   * ```ts
+   * // Get report URL (default)
+   * const { url } = await report.generate({
+   *   templateHandle: 'lab-results',
+   *   arguments: { patient_id: 'ins_abc123' },
+   * })
+   * console.log(url) // https://app.skedyul.com/crux/reports/lab-results/generate?patient_id=ins_abc123
+   *
+   * // Get HTML content
+   * const { html } = await report.generate({
+   *   templateHandle: 'lab-results',
+   *   arguments: { patient_id: 'ins_abc123' },
+   *   mode: 'html',
+   * })
+   * // Use html for email, PDF generation, etc.
+   * ```
+   */
+  async generate(params) {
+    const { data } = await callCore("report.generate", {
+      templateHandle: params.templateHandle,
+      ...params.arguments ? { arguments: params.arguments } : {},
+      ...params.mode ? { mode: params.mode } : {}
+    });
+    return data;
+  },
+  /**
+   * Define (create or update) a report from a YAML template.
+   *
+   * If a report with the same handle already exists, it will be updated
+   * and the version number incremented.
+   *
+   * **Requires sk_wkp_ token** - reports are scoped to workplaces.
+   *
+   * @example
+   * ```ts
+   * const { definitionId, handle, version } = await report.define({
+   *   yaml: `
+   *     handle: patient-summary
+   *     name: Patient Summary
+   *     sections:
+   *       - type: header
+   *         title: "{{ patient.name }}"
+   *   `,
+   * })
+   * console.log(`Created report ${handle} v${version}`)
+   * ```
+   */
+  async define(params) {
+    const { data } = await callCore("report.define", {
+      yaml: params.yaml
+    });
+    return data;
+  },
+  /**
+   * List report definitions in the workplace.
+   *
+   * **Requires sk_wkp_ token** - reports are scoped to workplaces.
+   *
+   * @example
+   * ```ts
+   * const { data, pagination } = await report.list({ page: 1, limit: 10 })
+   * for (const def of data) {
+   *   console.log(`${def.handle}: ${def.name} (v${def.version})`)
+   * }
+   * ```
+   */
+  async list(params) {
+    const { data, pagination } = await callCore("report.list", {
+      ...params?.page !== void 0 ? { page: params.page } : {},
+      ...params?.limit !== void 0 ? { limit: params.limit } : {}
+    });
+    return {
+      data,
+      pagination: pagination ?? { page: 1, total: 0, hasMore: false, limit: params?.limit ?? 50 }
+    };
+  },
+  /**
+   * Get a report definition by handle.
+   *
+   * **Requires sk_wkp_ token** - reports are scoped to workplaces.
+   *
+   * @example
+   * ```ts
+   * const definition = await report.get('lab-results')
+   * if (definition) {
+   *   console.log(definition.templateYaml)
+   * }
+   * ```
+   */
+  async get(handle) {
+    const { data } = await callCore("report.get", {
+      handle
+    });
+    return data;
+  }
+};
+
+// src/errors.ts
+var InstallError = class extends Error {
+  // Optional: which field caused the error
+  constructor(message, code, field) {
+    super(message);
+    this.name = "InstallError";
+    this.code = code;
+    this.field = field;
+  }
+};
+var MissingRequiredFieldError = class extends InstallError {
+  constructor(fieldName, message) {
+    super(
+      message ?? `${fieldName} is required`,
+      "MISSING_REQUIRED_FIELD",
+      fieldName
+    );
+    this.name = "MissingRequiredFieldError";
+  }
+};
+var AuthenticationError = class extends InstallError {
+  constructor(message) {
+    super(message ?? "Authentication failed", "AUTHENTICATION_FAILED");
+    this.name = "AuthenticationError";
+  }
+};
+var InvalidConfigurationError = class extends InstallError {
+  constructor(fieldName, message) {
+    super(
+      message ?? "Invalid configuration",
+      "INVALID_CONFIGURATION",
+      fieldName
+    );
+    this.name = "InvalidConfigurationError";
+  }
+};
+var ConnectionError = class extends InstallError {
+  constructor(message) {
+    super(
+      message ?? "Connection failed",
+      "CONNECTION_FAILED"
+    );
+    this.name = "ConnectionError";
+  }
+};
+var AppAuthInvalidError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "APP_AUTH_INVALID";
+    this.name = "AppAuthInvalidError";
+  }
+};
+
+// src/server/context-logger.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var logContextStorage = new AsyncLocalStorage2();
+function runWithLogContext(context, fn) {
+  return logContextStorage.run(context, fn);
+}
+function getLogContext() {
+  return logContextStorage.getStore();
+}
+function safeStringify(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message}${value.stack ? `
+${value.stack}` : ""}`;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatLogWithContext(args) {
+  const context = getLogContext();
+  if (!context?.invocation) {
+    return args;
+  }
+  const contextPrefix = {
+    invocationType: context.invocation.invocationType,
+    ...context.invocation.toolHandle && { toolHandle: context.invocation.toolHandle },
+    ...context.invocation.serverHookHandle && { serverHookHandle: context.invocation.serverHookHandle },
+    ...context.invocation.appInstallationId && { appInstallationId: context.invocation.appInstallationId },
+    ...context.invocation.toolCallId && { toolCallId: context.invocation.toolCallId },
+    ...context.invocation.workflowId && { workflowId: context.invocation.workflowId },
+    ...context.invocation.workflowRunId && { workflowRunId: context.invocation.workflowRunId }
+  };
+  const prefix = `[${JSON.stringify(contextPrefix)}]`;
+  const messageParts = args.map((arg) => {
+    if (typeof arg === "string") return arg;
+    return safeStringify(arg);
+  });
+  return [`${prefix} ${messageParts.join(" ")}`];
+}
+var originalConsole = {
+  log: console.log.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console),
+  debug: console.debug.bind(console)
+};
+function installContextLogger() {
+  console.log = (...args) => {
+    originalConsole.log(...formatLogWithContext(args));
+  };
+  console.info = (...args) => {
+    originalConsole.info(...formatLogWithContext(args));
+  };
+  console.warn = (...args) => {
+    originalConsole.warn(...formatLogWithContext(args));
+  };
+  console.error = (...args) => {
+    originalConsole.error(...formatLogWithContext(args));
+  };
+  console.debug = (...args) => {
+    originalConsole.debug(...formatLogWithContext(args));
+  };
+}
+
+// src/server/logger.ts
+function createContextLogger() {
+  const log = ((msg, ...args) => {
+    console.log(msg, ...args);
+  });
+  log.info = (msg, ...args) => {
+    console.info(msg, ...args);
+  };
+  log.warn = (msg, ...args) => {
+    console.warn(msg, ...args);
+  };
+  log.error = (msg, ...args) => {
+    console.error(msg, ...args);
+  };
+  log.debug = (msg, ...args) => {
+    console.debug(msg, ...args);
+  };
+  return log;
+}
+
+// src/server/tool-handler.ts
+function buildToolMetadata(registry) {
+  return Object.values(registry).map((tool) => {
+    const timeout = typeof tool.timeout === "number" && tool.timeout > 0 ? tool.timeout : 1e4;
+    const retries = typeof tool.retries === "number" && tool.retries >= 1 ? tool.retries : 1;
+    return {
+      name: tool.name,
+      displayName: tool.label || tool.name,
+      description: tool.description,
+      inputSchema: getJsonSchemaFromToolSchema(tool.inputSchema),
+      outputSchema: getJsonSchemaFromToolSchema(tool.outputSchema),
+      timeout,
+      retries
+    };
+  });
+}
+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]
+      };
+    }
+  };
+}
+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);
+    const invocation = args.invocation;
+    try {
+      const inputs = args.inputs ?? {};
+      const rawContext = args.context ?? {};
+      const app = rawContext.app;
+      const trigger = rawContext.trigger || "agent";
+      let executionContext;
+      const log = createContextLogger();
+      if (trigger === "provision") {
+        executionContext = {
+          trigger: "provision",
+          app,
+          env: process.env,
+          mode: estimateMode ? "estimate" : "execute",
+          invocation,
+          log
+        };
+      } else {
+        const workplace2 = 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: workplace2, request, env: envVars, mode: modeValue, field, invocation, log };
+        } else if (trigger === "page_action") {
+          const page = rawContext.page;
+          executionContext = { trigger: "page_action", app, appInstallationId, workplace: workplace2, request, env: envVars, mode: modeValue, page, invocation, log };
+        } else if (trigger === "form_submit") {
+          const form = rawContext.form;
+          executionContext = { trigger: "form_submit", app, appInstallationId, workplace: workplace2, request, env: envVars, mode: modeValue, form, invocation, log };
+        } else if (trigger === "workflow") {
+          executionContext = { trigger: "workflow", app, appInstallationId, workplace: workplace2, request, env: envVars, mode: modeValue, invocation, log };
+        } else if (trigger === "page_context") {
+          executionContext = { trigger: "agent", app, appInstallationId, workplace: workplace2, request, env: envVars, mode: modeValue, invocation, log };
+        } else {
+          executionContext = { trigger: "agent", app, appInstallationId, workplace: workplace2, request, env: envVars, mode: modeValue, invocation, log };
+        }
+      }
+      const requestConfig = {
+        baseUrl: requestEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+        apiToken: requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+      };
+      const functionResult = await runWithLogContext({ invocation }, async () => {
+        return await runWithConfig(requestConfig, async () => {
+          return await fn(inputs, executionContext);
+        });
+      });
+      const billing = normalizeBilling(functionResult.billing);
+      return {
+        output: functionResult.output,
+        billing,
+        meta: functionResult.meta ?? {
+          success: true,
+          message: "OK",
+          toolName
+        },
+        effect: functionResult.effect
+      };
+    } catch (error) {
+      if (error instanceof 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
+        };
+      }
+      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;
+    }
+  };
+}
+
+// src/server/dedicated.ts
+import http from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/server/core-api-handler.ts
+async function handleCoreMethod(method, params) {
+  const service = coreApiService.getService();
+  if (!service) {
+    return {
+      status: 404,
+      payload: { error: "Core API service not configured" }
+    };
+  }
+  if (method === "createCommunicationChannel") {
+    if (!params?.channel) {
+      return { status: 400, payload: { error: "channel is required" } };
+    }
+    const channel = params.channel;
+    const result = await coreApiService.callCreateChannel(channel);
+    if (!result) {
+      return {
+        status: 500,
+        payload: { error: "Core API service did not respond" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "updateCommunicationChannel") {
+    if (!params?.channel) {
+      return { status: 400, payload: { error: "channel is required" } };
+    }
+    const channel = params.channel;
+    const result = await coreApiService.callUpdateChannel(channel);
+    if (!result) {
+      return {
+        status: 500,
+        payload: { error: "Core API service did not respond" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "deleteCommunicationChannel") {
+    if (!params?.id || typeof params.id !== "string") {
+      return { status: 400, payload: { error: "id is required" } };
+    }
+    const result = await coreApiService.callDeleteChannel(params.id);
+    if (!result) {
+      return {
+        status: 500,
+        payload: { error: "Core API service did not respond" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "getCommunicationChannel") {
+    if (!params?.id || typeof params.id !== "string") {
+      return { status: 400, payload: { error: "id is required" } };
+    }
+    const result = await coreApiService.callGetChannel(params.id);
+    if (!result) {
+      return {
+        status: 404,
+        payload: { error: "Channel not found" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "getCommunicationChannels") {
+    const result = await coreApiService.callListChannels();
+    if (!result) {
+      return {
+        status: 500,
+        payload: { error: "Core API service did not respond" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "communicationChannel.list") {
+    const result = await coreApiService.callListChannels();
+    if (!result) {
+      return {
+        status: 500,
+        payload: { error: "Core API service did not respond" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "communicationChannel.get") {
+    if (!params?.id || typeof params.id !== "string") {
+      return { status: 400, payload: { error: "id is required" } };
+    }
+    const result = await coreApiService.callGetChannel(params.id);
+    if (!result) {
+      return {
+        status: 404,
+        payload: { error: "Channel not found" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "workplace.list") {
+    const result = await coreApiService.callListWorkplaces();
+    if (!result) {
+      return {
+        status: 500,
+        payload: { error: "Core API service did not respond" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "workplace.get") {
+    if (!params?.id || typeof params.id !== "string") {
+      return { status: 400, payload: { error: "id is required" } };
+    }
+    const result = await coreApiService.callGetWorkplace(params.id);
+    if (!result) {
+      return {
+        status: 404,
+        payload: { error: "Workplace not found" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  if (method === "sendMessage") {
+    if (!params?.message || !params?.communicationChannel) {
+      return { status: 400, payload: { error: "message and communicationChannel are required" } };
+    }
+    const msg = params.message;
+    const channel = params.communicationChannel;
+    const result = await coreApiService.callSendMessage({
+      message: msg,
+      communicationChannel: channel
+    });
+    if (!result) {
+      return {
+        status: 500,
+        payload: { error: "Core API service did not respond" }
+      };
+    }
+    return { status: 200, payload: result };
+  }
+  return {
+    status: 400,
+    payload: { error: "Unknown core method" }
+  };
+}
+
+// src/server/handler-helpers.ts
+function parseHandlerEnvelope(parsedBody) {
+  if (typeof parsedBody !== "object" || parsedBody === null || Array.isArray(parsedBody) || !("env" in parsedBody) || !("request" in parsedBody)) {
+    return null;
+  }
+  const envelope = parsedBody;
+  if (typeof envelope.env !== "object" || envelope.env === null || Array.isArray(envelope.env)) {
+    return null;
+  }
+  if (typeof envelope.request !== "object" || envelope.request === null || Array.isArray(envelope.request)) {
+    return null;
+  }
+  return {
+    env: envelope.env,
+    request: envelope.request,
+    context: envelope.context
+  };
+}
+function buildRequestFromRaw(raw) {
+  let parsedBody = raw.body;
+  const contentType = raw.headers["content-type"] ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      parsedBody = raw.body ? JSON.parse(raw.body) : {};
+    } catch {
+      parsedBody = raw.body;
+    }
+  }
+  return {
+    method: raw.method,
+    url: raw.url,
+    path: raw.path,
+    headers: raw.headers,
+    query: raw.query,
+    body: parsedBody,
+    rawBody: raw.body ? Buffer.from(raw.body, "utf-8") : void 0
+  };
+}
+function buildRequestScopedConfig(env) {
+  return {
+    baseUrl: env.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+    apiToken: env.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+  };
+}
+
+// src/server/startup-logger.ts
+function padEnd(str, length) {
+  if (str.length >= length) {
+    return str.slice(0, length);
+  }
+  return str + " ".repeat(length - str.length);
+}
+function printStartupLog(config, tools, webhookRegistry, port) {
+  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 ?? parseNumberEnv(process.env.MCP_MAX_REQUESTS) ?? null;
+  const ttlExtendSeconds = config.ttlExtendSeconds ?? parseNumberEnv(process.env.MCP_TTL_EXTEND) ?? 3600;
+  const executableId = process.env.SKEDYUL_EXECUTABLE_ID || "local";
+  const divider = "\u2550".repeat(70);
+  const thinDivider = "\u2500".repeat(70);
+  console.log("");
+  console.log(`\u2554${divider}\u2557`);
+  console.log(`\u2551  \u{1F680} Skedyul MCP Server Starting                                      \u2551`);
+  console.log(`\u2560${divider}\u2563`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u2551  \u{1F4E6} Server:       ${padEnd(config.metadata.name, 49)}\u2551`);
+  console.log(`\u2551  \u{1F3F7}\uFE0F  Version:      ${padEnd(config.metadata.version, 49)}\u2551`);
+  console.log(`\u2551  \u26A1 Compute:      ${padEnd(config.computeLayer, 49)}\u2551`);
+  if (port) {
+    console.log(`\u2551  \u{1F310} Port:         ${padEnd(String(port), 49)}\u2551`);
+  }
+  console.log(`\u2551  \u{1F511} Executable:   ${padEnd(executableId, 49)}\u2551`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u255F${thinDivider}\u2562`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u2551  \u{1F527} Tools (${tools.length}):                                                       \u2551`);
+  const maxToolsToShow = 10;
+  const toolsToShow = tools.slice(0, maxToolsToShow);
+  for (const tool of toolsToShow) {
+    console.log(`\u2551     \u2022 ${padEnd(tool.name, 61)}\u2551`);
+  }
+  if (tools.length > maxToolsToShow) {
+    console.log(`\u2551     ... and ${tools.length - maxToolsToShow} more                                              \u2551`);
+  }
+  if (webhookCount > 0) {
+    console.log(`\u2551                                                                      \u2551`);
+    console.log(`\u2551  \u{1FA9D} Webhooks (${webhookCount}):                                                     \u2551`);
+    const maxWebhooksToShow = 5;
+    const webhooksToShow = webhookNames.slice(0, maxWebhooksToShow);
+    for (const name of webhooksToShow) {
+      console.log(`\u2551     \u2022 /webhooks/${padEnd(name, 51)}\u2551`);
+    }
+    if (webhookCount > maxWebhooksToShow) {
+      console.log(`\u2551     ... and ${webhookCount - maxWebhooksToShow} more                                              \u2551`);
+    }
+  }
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u255F${thinDivider}\u2562`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u2551  \u2699\uFE0F  Configuration:                                                   \u2551`);
+  console.log(`\u2551     Max Requests:    ${padEnd(maxRequests !== null ? String(maxRequests) : "unlimited", 46)}\u2551`);
+  console.log(`\u2551     TTL Extend:      ${padEnd(`${ttlExtendSeconds}s`, 46)}\u2551`);
+  console.log(`\u2551                                                                      \u2551`);
+  console.log(`\u255F${thinDivider}\u2562`);
+  console.log(`\u2551  \u2705 Ready at ${padEnd((/* @__PURE__ */ new Date()).toISOString(), 55)}\u2551`);
+  console.log(`\u255A${divider}\u255D`);
+  console.log("");
+}
+
+// src/server/dedicated.ts
+function createDedicatedServerInstance(config, tools, callTool, state, mcpServer, webhookRegistry) {
+  const port = getListeningPort(config);
+  const httpServer = http.createServer(
+    async (req, res) => {
+      function sendCoreResult(result) {
+        sendJSON(res, result.status, result.payload);
+      }
+      try {
+        const url = new URL(
+          req.url || "/",
+          `http://${req.headers.host || "localhost"}`
+        );
+        const pathname = url.pathname;
+        if (pathname === "/health" && req.method === "GET") {
+          sendJSON(res, 200, state.getHealthStatus());
+          return;
+        }
+        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;
+          }
+          const allowedMethods = webhookDef.methods ?? ["POST"];
+          if (!allowedMethods.includes(req.method)) {
+            sendJSON(res, 405, { error: `Method ${req.method} not allowed` });
+            return;
+          }
+          let rawBody;
+          try {
+            rawBody = await readRawRequestBody(req);
+          } catch {
+            sendJSON(res, 400, { error: "Failed to read request body" });
+            return;
+          }
+          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;
+          }
+          const envelope = parseHandlerEnvelope(parsedBody);
+          let webhookRequest;
+          let webhookContext;
+          let requestEnv = {};
+          let invocation;
+          if (envelope && "context" in envelope && envelope.context) {
+            const context = envelope.context;
+            requestEnv = envelope.env;
+            invocation = parsedBody.invocation;
+            webhookRequest = buildRequestFromRaw(envelope.request);
+            const envVars = { ...process.env, ...envelope.env };
+            const app = context.app;
+            if (context.appInstallationId && context.workplace) {
+              webhookContext = {
+                env: envVars,
+                app,
+                appInstallationId: context.appInstallationId,
+                workplace: context.workplace,
+                registration: context.registration ?? {},
+                invocation,
+                log: createContextLogger()
+              };
+            } else {
+              webhookContext = {
+                env: envVars,
+                app,
+                invocation,
+                log: createContextLogger()
+              };
+            }
+          } else {
+            const appId = req.headers["x-skedyul-app-id"];
+            const appVersionId = req.headers["x-skedyul-app-version-id"];
+            if (!appId || !appVersionId) {
+              throw new Error("Missing app info in webhook request (x-skedyul-app-id and x-skedyul-app-version-id headers required)");
+            }
+            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") : void 0
+            };
+            webhookContext = {
+              env: process.env,
+              app: { id: appId, versionId: appVersionId },
+              log: createContextLogger()
+            };
+          }
+          const originalEnv = { ...process.env };
+          Object.assign(process.env, requestEnv);
+          const requestConfig = buildRequestScopedConfig(requestEnv);
+          let webhookResponse;
+          try {
+            webhookResponse = await runWithLogContext({ invocation }, async () => {
+              return await runWithConfig(requestConfig, async () => {
+                return await webhookDef.handler(webhookRequest, webhookContext);
+              });
+            });
+          } catch (err) {
+            console.error(`Webhook handler '${handle}' error:`, err);
+            sendJSON(res, 500, { error: "Webhook handler error" });
+            return;
+          } finally {
+            process.env = originalEnv;
+          }
+          const status = webhookResponse.status ?? 200;
+          const responseHeaders = {
+            ...webhookResponse.headers
+          };
+          if (!responseHeaders["Content-Type"] && !responseHeaders["content-type"]) {
+            responseHeaders["Content-Type"] = "application/json";
+          }
+          res.writeHead(status, responseHeaders);
+          if (webhookResponse.body !== void 0) {
+            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 {
+            estimateBody = await parseJSONBody(req);
+          } catch {
+            sendJSON(res, 400, {
+              error: {
+                code: -32700,
+                message: "Parse error"
+              }
+            });
+            return;
+          }
+          try {
+            const estimateResponse = await callTool(estimateBody.name, {
+              inputs: estimateBody.inputs,
+              estimate: true
+            });
+            sendJSON(res, 200, {
+              billing: estimateResponse.billing ?? { credits: 0 }
+            });
+          } catch (err) {
+            sendJSON(res, 500, {
+              error: {
+                code: -32603,
+                message: err instanceof Error ? err.message : String(err ?? "")
+              }
+            });
+          }
+          return;
+        }
+        if (pathname === "/oauth_callback" && req.method === "POST") {
+          if (!config.hooks?.oauth_callback) {
+            sendJSON(res, 404, { error: "OAuth callback handler not configured" });
+            return;
+          }
+          let parsedBody;
+          try {
+            parsedBody = await parseJSONBody(req);
+          } catch (err) {
+            console.error("[OAuth Callback] Failed to parse JSON body:", err);
+            sendJSON(res, 400, {
+              error: { code: -32700, message: "Parse error" }
+            });
+            return;
+          }
+          const envelope = parseHandlerEnvelope(parsedBody);
+          if (!envelope) {
+            console.error("[OAuth Callback] Failed to parse envelope. Body:", JSON.stringify(parsedBody, null, 2));
+            sendJSON(res, 400, {
+              error: { code: -32602, message: "Missing envelope format: expected { env, request }" }
+            });
+            return;
+          }
+          const invocation = parsedBody.invocation;
+          const oauthRequest = buildRequestFromRaw(envelope.request);
+          const oauthCallbackRequestConfig = buildRequestScopedConfig(envelope.env);
+          const oauthCallbackContext = {
+            request: oauthRequest,
+            invocation,
+            log: createContextLogger()
+          };
+          try {
+            const oauthCallbackHook = config.hooks.oauth_callback;
+            const oauthCallbackHandler = typeof oauthCallbackHook === "function" ? oauthCallbackHook : oauthCallbackHook.handler;
+            const result = await runWithLogContext({ invocation }, async () => {
+              return await runWithConfig(oauthCallbackRequestConfig, async () => {
+                return await oauthCallbackHandler(oauthCallbackContext);
+              });
+            });
+            sendJSON(res, 200, {
+              appInstallationId: result.appInstallationId,
+              env: result.env ?? {}
+            });
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err ?? "Unknown error");
+            sendJSON(res, 500, {
+              error: {
+                code: -32603,
+                message: errorMessage
+              }
+            });
+          }
+          return;
+        }
+        if (pathname === "/install" && req.method === "POST") {
+          if (!config.hooks?.install) {
+            sendJSON(res, 404, { error: "Install handler not configured" });
+            return;
+          }
+          let installBody;
+          try {
+            installBody = await parseJSONBody(req);
+          } catch {
+            sendJSON(res, 400, {
+              error: { code: -32700, message: "Parse error" }
+            });
+            return;
+          }
+          if (!installBody.context?.appInstallationId || !installBody.context?.workplace) {
+            sendJSON(res, 400, {
+              error: { code: -32602, message: "Missing context (appInstallationId and workplace required)" }
+            });
+            return;
+          }
+          const installContext = {
+            env: installBody.env ?? {},
+            workplace: installBody.context.workplace,
+            appInstallationId: installBody.context.appInstallationId,
+            app: installBody.context.app,
+            invocation: installBody.invocation,
+            log: createContextLogger()
+          };
+          const installRequestConfig = {
+            baseUrl: installBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+            apiToken: installBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+          };
+          try {
+            const installHook = config.hooks.install;
+            const installHandler = typeof installHook === "function" ? installHook : installHook.handler;
+            const result = await runWithLogContext({ invocation: installBody.invocation }, async () => {
+              return await runWithConfig(installRequestConfig, async () => {
+                return await installHandler(installContext);
+              });
+            });
+            sendJSON(res, 200, {
+              env: result.env ?? {},
+              redirect: result.redirect
+            });
+          } catch (err) {
+            if (err instanceof InstallError) {
+              sendJSON(res, 400, {
+                error: {
+                  code: err.code,
+                  message: err.message,
+                  field: err.field
+                }
+              });
+            } else {
+              sendJSON(res, 500, {
+                error: {
+                  code: -32603,
+                  message: err instanceof Error ? err.message : String(err ?? "")
+                }
+              });
+            }
+          }
+          return;
+        }
+        if (pathname === "/uninstall" && req.method === "POST") {
+          if (!config.hooks?.uninstall) {
+            sendJSON(res, 404, { error: "Uninstall handler not configured" });
+            return;
+          }
+          let uninstallBody;
+          try {
+            uninstallBody = await parseJSONBody(req);
+          } catch {
+            sendJSON(res, 400, {
+              error: { code: -32700, message: "Parse error" }
+            });
+            return;
+          }
+          if (!uninstallBody.context?.appInstallationId || !uninstallBody.context?.workplace || !uninstallBody.context?.app) {
+            sendJSON(res, 400, {
+              error: {
+                code: -32602,
+                message: "Missing context (appInstallationId, workplace and app required)"
+              }
+            });
+            return;
+          }
+          const uninstallContext = {
+            env: uninstallBody.env ?? {},
+            workplace: uninstallBody.context.workplace,
+            appInstallationId: uninstallBody.context.appInstallationId,
+            app: uninstallBody.context.app,
+            invocation: uninstallBody.invocation,
+            log: createContextLogger()
+          };
+          const uninstallRequestConfig = {
+            baseUrl: uninstallBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+            apiToken: uninstallBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+          };
+          try {
+            const uninstallHook = config.hooks.uninstall;
+            const uninstallHandlerFn = typeof uninstallHook === "function" ? uninstallHook : uninstallHook.handler;
+            const result = await runWithLogContext({ invocation: uninstallBody.invocation }, async () => {
+              return await runWithConfig(uninstallRequestConfig, async () => {
+                return await uninstallHandlerFn(uninstallContext);
+              });
+            });
+            sendJSON(res, 200, {
+              cleanedWebhookIds: result.cleanedWebhookIds ?? []
+            });
+          } catch (err) {
+            sendJSON(res, 500, {
+              error: {
+                code: -32603,
+                message: err instanceof Error ? err.message : String(err ?? "")
+              }
+            });
+          }
+          return;
+        }
+        if (pathname === "/provision" && req.method === "POST") {
+          if (!config.hooks?.provision) {
+            sendJSON(res, 404, { error: "Provision handler not configured" });
+            return;
+          }
+          let provisionBody;
+          try {
+            provisionBody = await parseJSONBody(req);
+          } catch {
+            sendJSON(res, 400, {
+              error: { code: -32700, message: "Parse error" }
+            });
+            return;
+          }
+          if (!provisionBody.context?.app) {
+            sendJSON(res, 400, {
+              error: { code: -32602, message: "Missing context (app required)" }
+            });
+            return;
+          }
+          const mergedEnv = {};
+          for (const [key, value] of Object.entries(process.env)) {
+            if (value !== void 0) {
+              mergedEnv[key] = value;
+            }
+          }
+          Object.assign(mergedEnv, provisionBody.env ?? {});
+          const provisionContext = {
+            env: mergedEnv,
+            app: provisionBody.context.app,
+            invocation: provisionBody.invocation,
+            log: createContextLogger()
+          };
+          const provisionRequestConfig = {
+            baseUrl: mergedEnv.SKEDYUL_API_URL ?? "",
+            apiToken: mergedEnv.SKEDYUL_API_TOKEN ?? ""
+          };
+          try {
+            const provisionHook = config.hooks.provision;
+            const provisionHandler = typeof provisionHook === "function" ? provisionHook : provisionHook.handler;
+            const result = await runWithLogContext({ invocation: provisionBody.invocation }, async () => {
+              return await runWithConfig(provisionRequestConfig, async () => {
+                return await provisionHandler(provisionContext);
+              });
+            });
+            sendJSON(res, 200, result);
+          } catch (err) {
+            sendJSON(res, 500, {
+              error: {
+                code: -32603,
+                message: err instanceof Error ? err.message : String(err ?? "")
+              }
+            });
+          }
+          return;
+        }
+        if (pathname === "/core" && req.method === "POST") {
+          let coreBody;
+          try {
+            coreBody = await parseJSONBody(req);
+          } catch {
+            sendJSON(res, 400, {
+              error: {
+                code: -32700,
+                message: "Parse error"
+              }
+            });
+            return;
+          }
+          if (!coreBody?.method) {
+            sendJSON(res, 400, {
+              error: {
+                code: -32602,
+                message: "Missing method"
+              }
+            });
+            return;
+          }
+          const method = coreBody.method;
+          const result = await handleCoreMethod(method, coreBody.params);
+          sendCoreResult(result);
+          return;
+        }
+        if (pathname === "/core/webhook" && req.method === "POST") {
+          let rawWebhookBody;
+          try {
+            rawWebhookBody = await readRawRequestBody(req);
+          } catch {
+            sendJSON(res, 400, { status: "parse-error" });
+            return;
+          }
+          let webhookBody;
+          try {
+            webhookBody = rawWebhookBody ? JSON.parse(rawWebhookBody) : {};
+          } catch {
+            sendJSON(res, 400, { status: "parse-error" });
+            return;
+          }
+          const normalizedHeaders = Object.fromEntries(
+            Object.entries(req.headers).map(([key, value]) => [
+              key,
+              typeof value === "string" ? value : value?.[0] ?? ""
+            ])
+          );
+          const coreWebhookRequest = {
+            method: req.method ?? "POST",
+            headers: normalizedHeaders,
+            body: webhookBody,
+            query: Object.fromEntries(url.searchParams.entries()),
+            url: url.toString(),
+            path: url.pathname,
+            rawBody: rawWebhookBody ? Buffer.from(rawWebhookBody, "utf-8") : void 0
+          };
+          const webhookResponse = await coreApiService.dispatchWebhook(
+            coreWebhookRequest
+          );
+          res.writeHead(webhookResponse.status, {
+            "Content-Type": "application/json"
+          });
+          res.end(JSON.stringify(webhookResponse.body ?? {}));
+          return;
+        }
+        if (pathname === "/mcp" && req.method === "POST") {
+          try {
+            const body = await parseJSONBody(req);
+            if (body?.method === "tools/list") {
+              sendJSON(res, 200, {
+                jsonrpc: "2.0",
+                id: body.id ?? null,
+                result: { tools }
+              });
+              return;
+            }
+            if (body?.method === "webhooks/list") {
+              const webhooks = webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
+                name: w.name,
+                description: w.description,
+                methods: w.methods ?? ["POST"],
+                type: w.type ?? "WEBHOOK"
+              })) : [];
+              sendJSON(res, 200, {
+                jsonrpc: "2.0",
+                id: body.id ?? null,
+                result: { webhooks }
+              });
+              return;
+            }
+            const transport = new StreamableHTTPServerTransport({
+              sessionIdGenerator: void 0,
+              enableJsonResponse: true
+            });
+            res.on("close", () => {
+              transport.close();
+            });
+            await mcpServer.connect(transport);
+            await transport.handleRequest(req, res, body);
+          } catch (err) {
+            sendJSON(res, 500, {
+              jsonrpc: "2.0",
+              id: null,
+              error: {
+                code: -32603,
+                message: err instanceof Error ? err.message : String(err ?? "")
+              }
+            });
+          }
+          return;
+        }
+        sendJSON(res, 404, {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32601,
+            message: "Not Found"
+          }
+        });
+      } catch (err) {
+        sendJSON(res, 500, {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32603,
+            message: err instanceof Error ? err.message : String(err ?? "")
+          }
+        });
+      }
+    }
+  );
+  return {
+    async listen(listenPort) {
+      const finalPort = listenPort ?? port;
+      return new Promise((resolve2, reject) => {
+        httpServer.listen(finalPort, () => {
+          printStartupLog(config, tools, webhookRegistry, finalPort);
+          resolve2();
+        });
+        httpServer.once("error", reject);
+      });
+    },
+    getHealthStatus: () => state.getHealthStatus()
+  };
+}
+
+// src/server/serverless.ts
+function createServerlessInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry) {
+  const headers = getDefaultHeaders(config.cors);
+  let hasLoggedStartup = false;
+  return {
+    async handler(event) {
+      if (!hasLoggedStartup) {
+        printStartupLog(config, tools, webhookRegistry);
+        hasLoggedStartup = true;
+      }
+      try {
+        const path2 = event.path || event.rawPath || "/";
+        const method = event.httpMethod || event.requestContext?.http?.method || "POST";
+        if (method === "OPTIONS") {
+          return createResponse(200, { message: "OK" }, headers);
+        }
+        if (path2.startsWith("/webhooks/") && webhookRegistry) {
+          const handle = path2.slice("/webhooks/".length);
+          const webhookDef = webhookRegistry[handle];
+          if (!webhookDef) {
+            return createResponse(404, { error: `Webhook handler '${handle}' not found` }, headers);
+          }
+          const allowedMethods = webhookDef.methods ?? ["POST"];
+          if (!allowedMethods.includes(method)) {
+            return createResponse(405, { error: `Method ${method} not allowed` }, headers);
+          }
+          const rawBody = event.body ?? "";
+          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;
+          }
+          const isEnvelope = typeof parsedBody === "object" && parsedBody !== null && "env" in parsedBody && "request" in parsedBody && "context" in parsedBody;
+          let webhookRequest;
+          let webhookContext;
+          let requestEnv = {};
+          let invocation;
+          if (isEnvelope) {
+            const envelope = parsedBody;
+            requestEnv = envelope.env ?? {};
+            invocation = envelope.invocation;
+            let originalParsedBody = envelope.request.body;
+            const originalContentType = envelope.request.headers["content-type"] ?? "";
+            if (originalContentType.includes("application/json")) {
+              try {
+                originalParsedBody = envelope.request.body ? JSON.parse(envelope.request.body) : {};
+              } catch {
+              }
+            }
+            webhookRequest = {
+              method: envelope.request.method,
+              url: envelope.request.url,
+              path: envelope.request.path,
+              headers: envelope.request.headers,
+              query: envelope.request.query,
+              body: originalParsedBody,
+              rawBody: envelope.request.body ? Buffer.from(envelope.request.body, "utf-8") : void 0
+            };
+            const envVars = { ...process.env, ...requestEnv };
+            const app = envelope.context.app;
+            if (envelope.context.appInstallationId && envelope.context.workplace) {
+              webhookContext = {
+                env: envVars,
+                app,
+                appInstallationId: envelope.context.appInstallationId,
+                workplace: envelope.context.workplace,
+                registration: envelope.context.registration ?? {},
+                invocation,
+                log: createContextLogger()
+              };
+            } else {
+              webhookContext = {
+                env: envVars,
+                app,
+                invocation,
+                log: createContextLogger()
+              };
+            }
+          } else {
+            const appId = event.headers?.["x-skedyul-app-id"] ?? event.headers?.["X-Skedyul-App-Id"];
+            const appVersionId = event.headers?.["x-skedyul-app-version-id"] ?? event.headers?.["X-Skedyul-App-Version-Id"];
+            if (!appId || !appVersionId) {
+              throw new Error("Missing app info in webhook request (x-skedyul-app-id and x-skedyul-app-version-id headers required)");
+            }
+            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}${path2}${queryString}`;
+            webhookRequest = {
+              method,
+              url: webhookUrl,
+              path: path2,
+              headers: event.headers,
+              query: event.queryStringParameters ?? {},
+              body: parsedBody,
+              rawBody: rawBody ? Buffer.from(rawBody, "utf-8") : void 0
+            };
+            webhookContext = {
+              env: process.env,
+              app: { id: appId, versionId: appVersionId },
+              log: createContextLogger()
+            };
+          }
+          const originalEnv = { ...process.env };
+          Object.assign(process.env, requestEnv);
+          const requestConfig = {
+            baseUrl: requestEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+            apiToken: requestEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+          };
+          let webhookResponse;
+          try {
+            webhookResponse = await runWithLogContext({ invocation }, async () => {
+              return await runWithConfig(requestConfig, async () => {
+                return await webhookDef.handler(webhookRequest, webhookContext);
+              });
+            });
+          } catch (err) {
+            console.error(`Webhook handler '${handle}' error:`, err);
+            return createResponse(500, { error: "Webhook handler error" }, headers);
+          } finally {
+            process.env = originalEnv;
+          }
+          const responseHeaders = {
+            ...headers,
+            ...webhookResponse.headers
+          };
+          const status = webhookResponse.status ?? 200;
+          const body = webhookResponse.body;
+          return {
+            statusCode: status,
+            headers: responseHeaders,
+            body: body !== void 0 ? typeof body === "string" ? body : JSON.stringify(body) : ""
+          };
+        }
+        if (path2 === "/core" && method === "POST") {
+          let coreBody;
+          try {
+            coreBody = event.body ? JSON.parse(event.body) : {};
+          } catch {
+            return createResponse(
+              400,
+              {
+                error: {
+                  code: -32700,
+                  message: "Parse error"
+                }
+              },
+              headers
+            );
+          }
+          if (!coreBody?.method) {
+            return createResponse(
+              400,
+              {
+                error: {
+                  code: -32602,
+                  message: "Missing method"
+                }
+              },
+              headers
+            );
+          }
+          const coreMethod = coreBody.method;
+          const result = await handleCoreMethod(coreMethod, coreBody.params);
+          return createResponse(result.status, result.payload, headers);
+        }
+        if (path2 === "/core/webhook" && method === "POST") {
+          const rawWebhookBody = event.body ?? "";
+          let webhookBody;
+          try {
+            webhookBody = rawWebhookBody ? JSON.parse(rawWebhookBody) : {};
+          } catch {
+            return createResponse(
+              400,
+              { status: "parse-error" },
+              headers
+            );
+          }
+          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 webhookUrl = `${protocol}://${host}${path2}`;
+          const coreWebhookRequest = {
+            method,
+            headers: event.headers ?? {},
+            body: webhookBody,
+            query: event.queryStringParameters ?? {},
+            url: webhookUrl,
+            path: path2,
+            rawBody: rawWebhookBody ? Buffer.from(rawWebhookBody, "utf-8") : void 0
+          };
+          const webhookResponse = await coreApiService.dispatchWebhook(
+            coreWebhookRequest
+          );
+          return createResponse(
+            webhookResponse.status,
+            webhookResponse.body ?? {},
+            headers
+          );
+        }
+        if (path2 === "/estimate" && method === "POST") {
+          let estimateBody;
+          try {
+            estimateBody = event.body ? JSON.parse(event.body) : {};
+          } catch {
+            return createResponse(
+              400,
+              {
+                error: {
+                  code: -32700,
+                  message: "Parse error"
+                }
+              },
+              headers
+            );
+          }
+          try {
+            const toolName = estimateBody.name;
+            const toolArgs = estimateBody.inputs ?? {};
+            let toolKey = null;
+            let tool = null;
+            for (const [key, t] of Object.entries(registry)) {
+              if (t.name === toolName || key === toolName) {
+                toolKey = key;
+                tool = t;
+                break;
+              }
+            }
+            if (!tool || !toolKey) {
+              return createResponse(
+                400,
+                {
+                  error: {
+                    code: -32602,
+                    message: `Tool "${toolName}" not found`
+                  }
+                },
+                headers
+              );
+            }
+            const inputSchema = getZodSchema(tool.inputSchema);
+            const validatedArgs = inputSchema ? inputSchema.parse(toolArgs) : toolArgs;
+            const estimateResponse = await callTool(toolKey, {
+              inputs: validatedArgs,
+              estimate: true
+            });
+            return createResponse(
+              200,
+              {
+                billing: estimateResponse.billing ?? { credits: 0 }
+              },
+              headers
+            );
+          } catch (err) {
+            return createResponse(
+              500,
+              {
+                error: {
+                  code: -32603,
+                  message: err instanceof Error ? err.message : String(err ?? "")
+                }
+              },
+              headers
+            );
+          }
+        }
+        if (path2 === "/install" && method === "POST") {
+          if (!config.hooks?.install) {
+            return createResponse(404, { error: "Install handler not configured" }, headers);
+          }
+          let installBody;
+          try {
+            installBody = event.body ? JSON.parse(event.body) : {};
+          } catch {
+            return createResponse(
+              400,
+              { error: { code: -32700, message: "Parse error" } },
+              headers
+            );
+          }
+          if (!installBody.context?.appInstallationId || !installBody.context?.workplace) {
+            return createResponse(
+              400,
+              { error: { code: -32602, message: "Missing context (appInstallationId and workplace required)" } },
+              headers
+            );
+          }
+          const installContext = {
+            env: installBody.env ?? {},
+            workplace: installBody.context.workplace,
+            appInstallationId: installBody.context.appInstallationId,
+            app: installBody.context.app,
+            invocation: installBody.invocation,
+            log: createContextLogger()
+          };
+          const installRequestConfig = {
+            baseUrl: installBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+            apiToken: installBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+          };
+          try {
+            const installHook = config.hooks.install;
+            const installHandler = typeof installHook === "function" ? installHook : installHook.handler;
+            const result = await runWithLogContext({ invocation: installBody.invocation }, async () => {
+              return await runWithConfig(installRequestConfig, async () => {
+                return await installHandler(installContext);
+              });
+            });
+            return createResponse(
+              200,
+              { env: result.env ?? {}, redirect: result.redirect },
+              headers
+            );
+          } catch (err) {
+            if (err instanceof InstallError) {
+              return createResponse(
+                400,
+                {
+                  error: {
+                    code: err.code,
+                    message: err.message,
+                    field: err.field
+                  }
+                },
+                headers
+              );
+            }
+            return createResponse(
+              500,
+              {
+                error: {
+                  code: -32603,
+                  message: err instanceof Error ? err.message : String(err ?? "")
+                }
+              },
+              headers
+            );
+          }
+        }
+        if (path2 === "/uninstall" && method === "POST") {
+          if (!config.hooks?.uninstall) {
+            return createResponse(404, { error: "Uninstall handler not configured" }, headers);
+          }
+          let uninstallBody;
+          try {
+            uninstallBody = event.body ? JSON.parse(event.body) : {};
+          } catch {
+            return createResponse(
+              400,
+              { error: { code: -32700, message: "Parse error" } },
+              headers
+            );
+          }
+          if (!uninstallBody.context?.appInstallationId || !uninstallBody.context?.workplace || !uninstallBody.context?.app) {
+            return createResponse(
+              400,
+              {
+                error: {
+                  code: -32602,
+                  message: "Missing context (appInstallationId, workplace and app required)"
+                }
+              },
+              headers
+            );
+          }
+          const uninstallContext = {
+            env: uninstallBody.env ?? {},
+            workplace: uninstallBody.context.workplace,
+            appInstallationId: uninstallBody.context.appInstallationId,
+            app: uninstallBody.context.app,
+            invocation: uninstallBody.invocation,
+            log: createContextLogger()
+          };
+          const uninstallRequestConfig = {
+            baseUrl: uninstallBody.env?.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+            apiToken: uninstallBody.env?.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+          };
+          try {
+            const uninstallHook = config.hooks.uninstall;
+            const uninstallHandlerFn = typeof uninstallHook === "function" ? uninstallHook : uninstallHook.handler;
+            const result = await runWithLogContext({ invocation: uninstallBody.invocation }, async () => {
+              return await runWithConfig(uninstallRequestConfig, async () => {
+                return await uninstallHandlerFn(uninstallContext);
+              });
+            });
+            return createResponse(
+              200,
+              { cleanedWebhookIds: result.cleanedWebhookIds ?? [] },
+              headers
+            );
+          } catch (err) {
+            return createResponse(
+              500,
+              {
+                error: {
+                  code: -32603,
+                  message: err instanceof Error ? err.message : String(err ?? "")
+                }
+              },
+              headers
+            );
+          }
+        }
+        if (path2 === "/provision" && method === "POST") {
+          console.log("[serverless] /provision endpoint called");
+          if (!config.hooks?.provision) {
+            console.log("[serverless] No provision handler configured");
+            return createResponse(404, { error: "Provision handler not configured" }, headers);
+          }
+          let provisionBody;
+          try {
+            provisionBody = event.body ? JSON.parse(event.body) : {};
+            console.log("[serverless] Provision body parsed:", {
+              hasEnv: !!provisionBody.env,
+              hasContext: !!provisionBody.context,
+              appId: provisionBody.context?.app?.id,
+              versionId: provisionBody.context?.app?.versionId
+            });
+          } catch {
+            console.log("[serverless] Failed to parse provision body");
+            return createResponse(
+              400,
+              { error: { code: -32700, message: "Parse error" } },
+              headers
+            );
+          }
+          if (!provisionBody.context?.app) {
+            console.log("[serverless] Missing app context in provision body");
+            return createResponse(
+              400,
+              { error: { code: -32602, message: "Missing context (app required)" } },
+              headers
+            );
+          }
+          const mergedEnv = {};
+          for (const [key, value] of Object.entries(process.env)) {
+            if (value !== void 0) {
+              mergedEnv[key] = value;
+            }
+          }
+          Object.assign(mergedEnv, provisionBody.env ?? {});
+          const provisionContext = {
+            env: mergedEnv,
+            app: provisionBody.context.app,
+            invocation: provisionBody.invocation,
+            log: createContextLogger()
+          };
+          const provisionRequestConfig = {
+            baseUrl: mergedEnv.SKEDYUL_API_URL ?? "",
+            apiToken: mergedEnv.SKEDYUL_API_TOKEN ?? ""
+          };
+          console.log("[serverless] Calling provision handler...");
+          try {
+            const provisionHook = config.hooks.provision;
+            const provisionHandler = typeof provisionHook === "function" ? provisionHook : provisionHook.handler;
+            const result = await runWithLogContext({ invocation: provisionBody.invocation }, async () => {
+              return await runWithConfig(provisionRequestConfig, async () => {
+                return await provisionHandler(provisionContext);
+              });
+            });
+            console.log("[serverless] Provision handler completed successfully");
+            return createResponse(200, result, headers);
+          } catch (err) {
+            console.error("[serverless] Provision handler failed:", err instanceof Error ? err.message : String(err));
+            return createResponse(
+              500,
+              {
+                error: {
+                  code: -32603,
+                  message: err instanceof Error ? err.message : String(err ?? "")
+                }
+              },
+              headers
+            );
+          }
+        }
+        if (path2 === "/oauth_callback" && method === "POST") {
+          if (!config.hooks?.oauth_callback) {
+            return createResponse(
+              404,
+              { error: "OAuth callback handler not configured" },
+              headers
+            );
+          }
+          let parsedBody;
+          try {
+            parsedBody = event.body ? JSON.parse(event.body) : {};
+          } catch (err) {
+            console.error("[OAuth Callback] Failed to parse JSON body:", err);
+            return createResponse(
+              400,
+              { error: { code: -32700, message: "Parse error" } },
+              headers
+            );
+          }
+          const envelope = parseHandlerEnvelope(parsedBody);
+          if (!envelope) {
+            console.error("[OAuth Callback] Failed to parse envelope. Body:", JSON.stringify(parsedBody, null, 2));
+            return createResponse(
+              400,
+              { error: { code: -32602, message: "Missing envelope format: expected { env, request }" } },
+              headers
+            );
+          }
+          const invocation = parsedBody.invocation;
+          const oauthRequest = buildRequestFromRaw(envelope.request);
+          const oauthCallbackRequestConfig = buildRequestScopedConfig(envelope.env);
+          const oauthCallbackContext = {
+            request: oauthRequest,
+            invocation,
+            log: createContextLogger()
+          };
+          try {
+            const oauthCallbackHook = config.hooks.oauth_callback;
+            const oauthCallbackHandler = typeof oauthCallbackHook === "function" ? oauthCallbackHook : oauthCallbackHook.handler;
+            const result = await runWithLogContext({ invocation }, async () => {
+              return await runWithConfig(oauthCallbackRequestConfig, async () => {
+                return await oauthCallbackHandler(oauthCallbackContext);
+              });
+            });
+            return createResponse(
+              200,
+              {
+                appInstallationId: result.appInstallationId,
+                env: result.env ?? {}
+              },
+              headers
+            );
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err ?? "Unknown error");
+            return createResponse(
+              500,
+              {
+                error: {
+                  code: -32603,
+                  message: errorMessage
+                }
+              },
+              headers
+            );
+          }
+        }
+        if (path2 === "/health" && method === "GET") {
+          return createResponse(200, state.getHealthStatus(), headers);
+        }
+        if (path2 === "/mcp" && method === "POST") {
+          let body;
+          try {
+            body = event.body ? JSON.parse(event.body) : {};
+          } catch {
+            return createResponse(
+              400,
+              {
+                jsonrpc: "2.0",
+                id: null,
+                error: {
+                  code: -32700,
+                  message: "Parse error"
+                }
+              },
+              headers
+            );
+          }
+          try {
+            const { jsonrpc, id, method: rpcMethod, params } = body;
+            if (jsonrpc !== "2.0") {
+              return createResponse(
+                400,
+                {
+                  jsonrpc: "2.0",
+                  id,
+                  error: {
+                    code: -32600,
+                    message: "Invalid Request"
+                  }
+                },
+                headers
+              );
+            }
+            let result;
+            if (rpcMethod === "tools/list") {
+              result = { tools };
+            } else if (rpcMethod === "tools/call") {
+              const toolName = params?.name;
+              const rawArgs = params?.arguments ?? {};
+              const hasSkedyulFormat = "inputs" in rawArgs || "env" in rawArgs || "context" in rawArgs || "invocation" in rawArgs;
+              const toolInputs = hasSkedyulFormat ? rawArgs.inputs ?? {} : rawArgs;
+              const toolContext = hasSkedyulFormat ? rawArgs.context : void 0;
+              const toolEnv = hasSkedyulFormat ? rawArgs.env : void 0;
+              const toolInvocation = hasSkedyulFormat ? rawArgs.invocation : void 0;
+              let toolKey = null;
+              let tool = null;
+              for (const [key, t] of Object.entries(registry)) {
+                if (t.name === toolName || key === toolName) {
+                  toolKey = key;
+                  tool = t;
+                  break;
+                }
+              }
+              if (!tool || !toolKey) {
+                return createResponse(
+                  200,
+                  {
+                    jsonrpc: "2.0",
+                    id,
+                    error: {
+                      code: -32602,
+                      message: `Tool "${toolName}" not found`
+                    }
+                  },
+                  headers
+                );
+              }
+              try {
+                const inputSchema = getZodSchema(tool.inputSchema);
+                const outputSchema = getZodSchema(tool.outputSchema);
+                const hasOutputSchema = Boolean(outputSchema);
+                const validatedInputs = inputSchema ? inputSchema.parse(toolInputs) : toolInputs;
+                const toolResult = await callTool(toolKey, {
+                  inputs: validatedInputs,
+                  context: toolContext,
+                  env: toolEnv,
+                  invocation: toolInvocation
+                });
+                if (toolResult.error) {
+                  const errorOutput = { error: toolResult.error };
+                  result = {
+                    content: [{ type: "text", text: JSON.stringify(errorOutput) }],
+                    // Don't provide structuredContent for error responses when tool has outputSchema
+                    // because the error response won't match the success schema and MCP SDK validates it
+                    structuredContent: hasOutputSchema ? void 0 : errorOutput,
+                    isError: true,
+                    billing: toolResult.billing
+                  };
+                } else {
+                  const outputData = toolResult.output;
+                  let structuredContent;
+                  if (outputData) {
+                    structuredContent = { ...outputData, __effect: toolResult.effect };
+                  } else if (toolResult.effect) {
+                    structuredContent = { __effect: toolResult.effect };
+                  } else if (hasOutputSchema) {
+                    structuredContent = {};
+                  }
+                  result = {
+                    content: [{ type: "text", text: JSON.stringify(toolResult.output) }],
+                    structuredContent,
+                    billing: toolResult.billing
+                  };
+                }
+              } catch (validationError) {
+                return createResponse(
+                  200,
+                  {
+                    jsonrpc: "2.0",
+                    id,
+                    error: {
+                      code: -32602,
+                      message: validationError instanceof Error ? validationError.message : "Invalid arguments"
+                    }
+                  },
+                  headers
+                );
+              }
+            } else if (rpcMethod === "webhooks/list") {
+              const webhooks = webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
+                name: w.name,
+                description: w.description,
+                methods: w.methods ?? ["POST"],
+                type: w.type ?? "WEBHOOK"
+              })) : [];
+              result = { webhooks };
+            } else {
+              return createResponse(
+                200,
+                {
+                  jsonrpc: "2.0",
+                  id,
+                  error: {
+                    code: -32601,
+                    message: `Method not found: ${rpcMethod}`
+                  }
+                },
+                headers
+              );
+            }
+            return createResponse(
+              200,
+              {
+                jsonrpc: "2.0",
+                id,
+                result
+              },
+              headers
+            );
+          } catch (err) {
+            return createResponse(
+              500,
+              {
+                jsonrpc: "2.0",
+                id: body?.id ?? null,
+                error: {
+                  code: -32603,
+                  message: err instanceof Error ? err.message : String(err ?? "")
+                }
+              },
+              headers
+            );
+          }
+        }
+        return createResponse(
+          404,
+          {
+            jsonrpc: "2.0",
+            id: null,
+            error: {
+              code: -32601,
+              message: "Not Found"
+            }
+          },
+          headers
+        );
+      } catch (err) {
+        return createResponse(
+          500,
+          {
+            jsonrpc: "2.0",
+            id: null,
+            error: {
+              code: -32603,
+              message: err instanceof Error ? err.message : String(err ?? "")
+            }
+          },
+          headers
+        );
+      }
+    },
+    getHealthStatus: () => state.getHealthStatus()
+  };
+}
+
+// src/server/index.ts
+console.log("[skedyul-node/server] Module loading - imports done");
+console.log("[skedyul-node/server] All imports complete");
+console.log("[skedyul-node/server] Installing context logger...");
+installContextLogger();
+console.log("[skedyul-node/server] Context logger installed");
+function createSkedyulServer(config, registry, webhookRegistry) {
+  console.log("[createSkedyulServer] Step 1: mergeRuntimeEnv()");
+  mergeRuntimeEnv();
+  console.log("[createSkedyulServer] Step 2: coreApi setup");
+  if (config.coreApi?.service) {
+    coreApiService.register(config.coreApi.service);
+    if (config.coreApi.webhookHandler) {
+      coreApiService.setWebhookHandler(config.coreApi.webhookHandler);
+    }
+  }
+  console.log("[createSkedyulServer] Step 3: buildToolMetadata()");
+  const tools = buildToolMetadata(registry);
+  console.log("[createSkedyulServer] Step 3 done, tools:", tools.length);
+  const toolNames = Object.values(registry).map((tool) => tool.name);
+  const runtimeLabel = config.computeLayer;
+  const maxRequests = config.maxRequests ?? parseNumberEnv(process.env.MCP_MAX_REQUESTS) ?? null;
+  const ttlExtendSeconds = config.ttlExtendSeconds ?? parseNumberEnv(process.env.MCP_TTL_EXTEND) ?? 3600;
+  console.log("[createSkedyulServer] Step 4: createRequestState()");
+  const state = createRequestState(
+    maxRequests,
+    ttlExtendSeconds,
+    runtimeLabel,
+    toolNames
+  );
+  console.log("[createSkedyulServer] Step 4 done");
+  console.log("[createSkedyulServer] Step 5: new McpServer()");
+  const mcpServer = new McpServer({
+    name: config.metadata.name,
+    version: config.metadata.version
+  });
+  console.log("[createSkedyulServer] Step 5 done");
+  const dedicatedShutdown = () => {
+    console.log("Max requests reached, shutting down...");
+    setTimeout(() => process.exit(0), 1e3);
+  };
+  console.log("[createSkedyulServer] Step 6: createCallToolHandler()");
+  const callTool = createCallToolHandler(
+    registry,
+    state,
+    config.computeLayer === "dedicated" ? dedicatedShutdown : void 0
+  );
+  console.log("[createSkedyulServer] Step 6 done");
+  console.log("[createSkedyulServer] Step 7: Registering tools...");
+  for (const [toolKey, tool] of Object.entries(registry)) {
+    console.log(`[createSkedyulServer] Registering tool: ${toolKey}`);
+    const toolName = tool.name || toolKey;
+    const toolDisplayName = tool.label || toolName;
+    console.log(`[createSkedyulServer] Getting input schema for ${toolKey}`);
+    const inputZodSchema = getZodSchema(tool.inputSchema);
+    console.log(`[createSkedyulServer] Getting output schema for ${toolKey}`);
+    const outputZodSchema = getZodSchema(tool.outputSchema);
+    console.log(`[createSkedyulServer] Creating wrapped schema for ${toolKey}`);
+    const wrappedInputSchema = z5.object({
+      inputs: inputZodSchema ?? z5.record(z5.string(), z5.unknown()).optional(),
+      env: z5.record(z5.string(), z5.string()).optional()
+    }).passthrough();
+    console.log(`[createSkedyulServer] Calling mcpServer.registerTool for ${toolKey}`);
+    mcpServer.registerTool(
+      toolName,
+      {
+        title: toolDisplayName,
+        description: tool.description,
+        inputSchema: wrappedInputSchema
+        // Don't pass outputSchema to MCP SDK - it validates structuredContent against it
+        // which fails for error responses. We handle output formatting ourselves.
+        // outputSchema: outputZodSchema,
+      },
+      async (args) => {
+        const rawArgs = args;
+        const toolInputs = rawArgs.inputs ?? {};
+        const toolContext = rawArgs.context;
+        const toolEnv = rawArgs.env;
+        const toolInvocation = rawArgs.invocation;
+        let validatedInputs = toolInputs;
+        if (inputZodSchema) {
+          try {
+            validatedInputs = inputZodSchema.parse(toolInputs);
+          } catch (error) {
+            console.error(
+              `[registerTool] Input validation failed for tool ${toolName}:`,
+              error
+            );
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    error: `Input validation failed: ${error instanceof Error ? error.message : String(error)}`
+                  })
+                }
+              ],
+              structuredContent: {
+                error: `Input validation failed: ${error instanceof Error ? error.message : String(error)}`
+              },
+              isError: true,
+              billing: { credits: 0 }
+            };
+          }
+        }
+        const result = await callTool(toolKey, {
+          inputs: validatedInputs,
+          context: toolContext,
+          env: toolEnv,
+          invocation: toolInvocation
+        });
+        const hasOutputSchema = Boolean(outputZodSchema);
+        if (result.error) {
+          const errorOutput = { error: result.error };
+          return {
+            content: [{ type: "text", text: JSON.stringify(errorOutput) }],
+            // Don't provide structuredContent for error responses when tool has outputSchema
+            // because the error response won't match the success schema and MCP SDK validates it
+            structuredContent: hasOutputSchema ? void 0 : errorOutput,
+            isError: true,
+            billing: result.billing
+          };
+        }
+        const outputData = result.output;
+        let structuredContent;
+        if (outputData) {
+          structuredContent = { ...outputData, __effect: result.effect };
+        } else if (result.effect) {
+          structuredContent = { __effect: result.effect };
+        } else if (hasOutputSchema) {
+          structuredContent = {};
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.output) }],
+          structuredContent,
+          billing: result.billing
+        };
+      }
+    );
+    console.log(`[createSkedyulServer] Tool ${toolKey} registered successfully`);
+  }
+  console.log("[createSkedyulServer] Step 7 done - all tools registered");
+  console.log("[createSkedyulServer] Step 8: Creating server instance");
+  if (config.computeLayer === "dedicated") {
+    console.log("[createSkedyulServer] Creating dedicated instance");
+    return createDedicatedServerInstance(
+      config,
+      tools,
+      callTool,
+      state,
+      mcpServer,
+      webhookRegistry
+    );
+  }
+  console.log("[createSkedyulServer] Creating serverless instance");
+  const serverlessInstance = createServerlessInstance(config, tools, callTool, state, mcpServer, registry, webhookRegistry);
+  console.log("[createSkedyulServer] Serverless instance created successfully");
+  return serverlessInstance;
+}
+var server = {
+  create: createSkedyulServer
+};
+
+// src/dockerfile.ts
+var DEFAULT_DOCKERFILE = `# =============================================================================
+# BUILDER STAGE - Common build for all targets
+# =============================================================================
+FROM public.ecr.aws/docker/library/node:22-alpine AS builder
+
+ARG COMPUTE_LAYER=serverless
+ARG BUILD_EXTERNAL=""
+WORKDIR /app
+
+# Install pnpm
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+# Copy package files (lockfile is optional)
+COPY package.json tsconfig.json skedyul.config.ts ./
+COPY src ./src
+
+# Copy tsup.config.ts if it exists, otherwise generate based on COMPUTE_LAYER
+# BUILD_EXTERNAL is a comma-separated list of additional externals (e.g., "twilio,stripe")
+COPY tsup.config.t[s] ./
+RUN if [ ! -f tsup.config.ts ]; then \\
+      BASE_EXT="skedyul,zod"; \\
+      if [ "$COMPUTE_LAYER" = "serverless" ]; then \\
+        BASE_EXT="skedyul,skedyul/serverless,zod"; \\
+        FORMAT="esm"; \\
+      else \\
+        BASE_EXT="skedyul,skedyul/dedicated,zod"; \\
+        FORMAT="cjs"; \\
+      fi; \\
+      if [ -n "$BUILD_EXTERNAL" ]; then \\
+        ALL_EXT="$BASE_EXT,$BUILD_EXTERNAL"; \\
+      else \\
+        ALL_EXT="$BASE_EXT"; \\
+      fi; \\
+      EXT_ARRAY=$(echo "$ALL_EXT" | sed 's/,/","/g'); \\
+      printf 'import{defineConfig}from"tsup";export default defineConfig({entry:["src/server/mcp_server.ts"],format:["%s"],target:"node22",outDir:"dist/server",clean:true,splitting:false,dts:false,external:["%s"]})' "$FORMAT" "$EXT_ARRAY" > tsup.config.ts; \\
+    fi
+
+# Install dependencies (including dev deps for build), compile, smoke test, then prune
+# Note: Using --no-frozen-lockfile since lockfile may not exist
+# skedyul build reads computeLayer from skedyul.config.ts
+# Smoke test runs before pruning since skedyul CLI is a dev dependency
+RUN pnpm install --no-frozen-lockfile && \\
+    pnpm run build && \\
+    skedyul smoke-test && \\
+    pnpm prune --prod && \\
+    pnpm store prune && \\
+    rm -rf /tmp/* /var/cache/apk/* ~/.npm
+
+# =============================================================================
+# DEDICATED STAGE - For local Docker and ECS deployments (HTTP server)
+# =============================================================================
+FROM public.ecr.aws/docker/library/node:22-alpine AS dedicated
+
+WORKDIR /app
+
+# Copy built artifacts
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package.json ./package.json
+
+# Allow overriding the baked-in MCP env at runtime
+ARG MCP_ENV_JSON="{}"
+ENV MCP_ENV_JSON=\${MCP_ENV_JSON}
+
+# Expose the HTTP port
+EXPOSE 3000
+
+# Run as HTTP server (dedicated mode auto-detected by absence of AWS_LAMBDA_FUNCTION_NAME)
+CMD ["node", "dist/server/mcp_server.js"]
+
+# =============================================================================
+# SERVERLESS STAGE - For AWS Lambda deployments
+# =============================================================================
+FROM public.ecr.aws/lambda/nodejs:22 AS serverless
+
+WORKDIR \${LAMBDA_TASK_ROOT}
+
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package.json ./package.json
+
+# Allow overriding the baked-in MCP env at runtime
+ARG MCP_ENV_JSON="{}"
+ENV MCP_ENV_JSON=\${MCP_ENV_JSON}
+
+# Lambda handler format
+CMD ["dist/server/mcp_server.handler"]
+
+# =============================================================================
+# DEFAULT - Use dedicated for local development, override with --target for production
+# =============================================================================
+FROM dedicated
+`;
+
+// src/config/app-config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/config/define.ts
+function defineModel(model) {
+  return model;
+}
+function defineChannel(channel) {
+  return channel;
+}
+function definePage(page) {
+  return page;
+}
+function defineWorkflow(workflow) {
+  return workflow;
+}
+function defineAgent(agent) {
+  return agent;
+}
+function defineEnv(env) {
+  return env;
+}
+function defineNavigation(navigation) {
+  return navigation;
+}
+
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var CONFIG_FILE_NAMES = [
+  "skedyul.config.ts",
+  "skedyul.config.js",
+  "skedyul.config.mjs",
+  "skedyul.config.cjs"
+];
+async function transpileTypeScript(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const configDir = path.dirname(path.resolve(filePath));
+  let transpiled = content.replace(/import\s+type\s+\{[^}]+\}\s+from\s+['"][^'"]+['"]\s*;?\n?/g, "").replace(/import\s+\{\s*defineConfig\s*\}\s+from\s+['"]skedyul['"]\s*;?\n?/g, "").replace(/:\s*SkedyulConfig/g, "").replace(/export\s+default\s+/, "module.exports = ").replace(/defineConfig\s*\(\s*\{/, "{").replace(/\}\s*\)\s*;?\s*$/, "}");
+  transpiled = transpiled.replace(
+    /import\s+(\w+)\s+from\s+['"](\.[^'"]+)['"]/g,
+    (match, varName, relativePath) => {
+      const absolutePath = path.resolve(configDir, relativePath);
+      return `const ${varName} = require('${absolutePath.replace(/\\/g, "/")}')`;
+    }
+  );
+  transpiled = transpiled.replace(/import\s*\(\s*['"][^'"]+['"]\s*\)/g, "null");
+  return transpiled;
+}
+async function loadConfig(configPath) {
+  const absolutePath = path.resolve(configPath);
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+  const isTypeScript = absolutePath.endsWith(".ts");
+  try {
+    let moduleToLoad = absolutePath;
+    if (isTypeScript) {
+      const transpiled = await transpileTypeScript(absolutePath);
+      const tempDir = os.tmpdir();
+      const tempFile = path.join(tempDir, `skedyul-config-${Date.now()}.js`);
+      fs.writeFileSync(tempFile, transpiled);
+      moduleToLoad = tempFile;
+      try {
+        const module2 = __require(moduleToLoad);
+        const config2 = module2.default || module2;
+        if (!config2 || typeof config2 !== "object") {
+          throw new Error("Config file must export a configuration object");
+        }
+        if (!config2.name || typeof config2.name !== "string") {
+          throw new Error('Config must have a "name" property');
+        }
+        return config2;
+      } finally {
+        try {
+          fs.unlinkSync(tempFile);
+        } catch {
+        }
+      }
+    }
+    const module = await import(moduleToLoad);
+    const config = module.default || module;
+    if (!config || typeof config !== "object") {
+      throw new Error("Config file must export a configuration object");
+    }
+    if (!config.name || typeof config.name !== "string") {
+      throw new Error('Config must have a "name" property');
+    }
+    return config;
+  } catch (error) {
+    throw new Error(
+      `Failed to load config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!config.name) {
+    errors.push("Missing required field: name");
+  }
+  if (config.computeLayer && !["serverless", "dedicated"].includes(config.computeLayer)) {
+    errors.push(`Invalid computeLayer: ${config.computeLayer}. Must be 'serverless' or 'dedicated'`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/config/utils.ts
+function getAllEnvKeys(config) {
+  const provision = config.provision && "env" in config.provision ? config.provision : void 0;
+  const globalKeys = provision?.env ? Object.keys(provision.env) : [];
+  return {
+    global: globalKeys,
+    install: []
+  };
+}
+function getRequiredInstallEnvKeys(config) {
+  const provision = config.provision && "env" in config.provision ? config.provision : void 0;
+  if (!provision?.env) return [];
+  return Object.entries(provision.env).filter(([, def]) => def.required).map(([key]) => key);
+}
+
+// src/index.ts
+var src_default = { z: z6 };
+export {
+  AgentDefinitionSchema,
+  AlertComponentDefinitionSchema,
+  AppAuthInvalidError,
+  AppFieldVisibilitySchema,
+  AuthenticationError,
+  BreadcrumbItemSchema,
+  CONFIG_FILE_NAMES,
+  CardBlockDefinitionSchema,
+  CardBlockHeaderSchema,
+  ChannelCapabilitySchema,
+  ChannelCapabilityTypeSchema,
+  ChannelDefinitionSchema,
+  ChannelDependencySchema,
+  ChannelFieldDefinitionSchema,
+  CheckboxComponentDefinitionSchema,
+  ComboboxComponentDefinitionSchema,
+  ComputeLayerTypeSchema,
+  ConnectionError,
+  DEFAULT_DOCKERFILE,
+  DatePickerComponentDefinitionSchema,
+  EmptyFormComponentDefinitionSchema,
+  EnvSchemaSchema,
+  EnvVariableDefinitionSchema,
+  EnvVisibilitySchema,
+  FieldDataTypeSchema,
+  FieldOptionSchema,
+  FieldOwnerSchema,
+  FieldSettingButtonPropsSchema,
+  FieldSettingComponentDefinitionSchema,
+  FileSettingComponentDefinitionSchema,
+  FilterConditionSchema,
+  FilterOperatorSchema,
+  FormLayoutColumnDefinitionSchema,
+  FormLayoutConfigDefinitionSchema,
+  FormLayoutRowDefinitionSchema,
+  FormV2ComponentDefinitionSchema,
+  FormV2PropsDefinitionSchema,
+  FormV2StylePropsSchema,
+  ImageSettingComponentDefinitionSchema,
+  InlineFieldDefinitionSchema,
+  InputComponentDefinitionSchema,
+  InstallConfigSchema,
+  InstallError,
+  InvalidConfigurationError,
+  LegacyFormBlockDefinitionSchema,
+  ListBlockDefinitionSchema,
+  ListComponentDefinitionSchema,
+  ListItemTemplateSchema,
+  MessageSendChannelSchema,
+  MessageSendContactSchema,
+  MessageSendInputSchema,
+  MessageSendMessageSchema,
+  MessageSendOutputSchema,
+  MessageSendSubscriptionSchema,
+  MissingRequiredFieldError,
+  ModalFormDefinitionSchema,
+  ModelDefinitionSchema,
+  ModelDependencySchema,
+  ModelFieldDefinitionSchema,
+  ModelMapperBlockDefinitionSchema,
+  NavigationBreadcrumbSchema,
+  NavigationConfigSchema,
+  NavigationItemSchema,
+  NavigationSectionSchema,
+  NavigationSidebarSchema,
+  OnDeleteBehaviorSchema,
+  PageActionDefinitionSchema,
+  PageBlockDefinitionSchema,
+  PageBlockTypeSchema,
+  PageContextDefinitionSchema,
+  PageContextFiltersSchema,
+  PageContextItemDefinitionSchema,
+  PageContextModeSchema,
+  PageContextToolItemDefinitionSchema,
+  PageDefinitionSchema,
+  PageFieldDefinitionSchema,
+  PageFieldSourceSchema,
+  PageFieldTypeSchema,
+  PageFormHeaderSchema,
+  PageInstanceFilterSchema,
+  PageTypeSchema,
+  ProvisionConfigSchema,
+  RelationshipCardinalitySchema,
+  RelationshipDefinitionSchema,
+  RelationshipExtensionSchema,
+  RelationshipLinkSchema,
+  ResourceDependencySchema,
+  SelectComponentDefinitionSchema,
+  SkedyulConfigSchema,
+  StructuredFilterSchema,
+  TextareaComponentDefinitionSchema,
+  TimePickerComponentDefinitionSchema,
+  ToolResponseMetaSchema,
+  WebhookHandlerDefinitionSchema,
+  WebhookHttpMethodSchema,
+  WebhookTypeSchema,
+  WebhooksSchema,
+  WorkflowActionInputSchema,
+  WorkflowActionSchema,
+  WorkflowDefinitionSchema,
+  WorkflowDependencySchema,
+  ai,
+  communicationChannel,
+  configure,
+  createContextLogger,
+  createServerHookContext,
+  createToolCallContext,
+  createWebhookContext,
+  createWorkflowStepContext,
+  src_default as default,
+  defineAgent,
+  defineChannel,
+  defineConfig,
+  defineEnv,
+  defineModel,
+  defineNavigation,
+  definePage,
+  defineWorkflow,
+  file,
+  getAllEnvKeys,
+  getConfig,
+  getRequiredInstallEnvKeys,
+  instance,
+  isChannelDependency,
+  isModelDependency,
+  isProvisionContext,
+  isRuntimeContext,
+  isRuntimeWebhookContext,
+  isWorkflowDependency,
+  loadConfig,
+  report,
+  resource,
+  runWithConfig,
+  safeParseConfig,
+  server,
+  token,
+  validateConfig,
+  webhook,
+  workplace,
+  z6 as z
+};