terse-types 0.0.1 → 0.0.3

package/dist/Configs.js

@@ -23,6 +23,7 @@ export var ConfigType;
     ConfigType["WORKOS_OUTPUT"] = "workos_output";
     ConfigType["ATTIO_OUTPUT"] = "attio_output";
     ConfigType["SNOWFLAKE_OUTPUT"] = "snowflake_output";
+    ConfigType["WEBHOOK_INPUT"] = "webhook_input";
 })(ConfigType || (ConfigType = {}));
 export const configTypeEnum = z.enum(ConfigType);
 // Metadata objects - using const objects instead of classes
@@ -194,6 +195,14 @@ export const SnowflakeOutputConfigMetadata = {
     isInput: false,
     isOutput: true
 };
+export const WebhookInputConfigMetadata = {
+    configType: ConfigType.WEBHOOK_INPUT,
+    name: "Webhook",
+    description: "Trigger via an external HTTP request to a generated URL",
+    integrationType: IntegrationType.WEBHOOK,
+    isInput: true,
+    isOutput: false
+};
 export const CONFIG_DETAILS = {
     [ConfigType.GMAIL]: GmailConfigMetadata,
     [ConfigType.GMAIL_OUTPUT]: GmailOutputConfigMetadata,
@@ -215,7 +224,8 @@ export const CONFIG_DETAILS = {
     [ConfigType.WORKOS_INPUT]: WorkOSInputConfigMetadata,
     [ConfigType.WORKOS_OUTPUT]: WorkOSOutputConfigMetadata,
     [ConfigType.ATTIO_OUTPUT]: AttioOutputConfigMetadata,
-    [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfigMetadata
+    [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfigMetadata,
+    [ConfigType.WEBHOOK_INPUT]: WebhookInputConfigMetadata
 };
 // MARK: Event Types — specific events within each integration trigger
 export var SlackEventType;
@@ -283,11 +293,11 @@ class BaseConfigInstance {
 export const GmailConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.GMAIL),
     configType: z.literal(ConfigType.GMAIL),
-    eventTypes: z.array(z.enum(GmailEventType)).optional()
+    eventTypes: z.array(z.enum(GmailEventType)).nullable()
 });
 export class GmailConfig extends BaseConfigInstance {
     eventTypes;
-    constructor(integrationId, eventTypes) {
+    constructor(integrationId, eventTypes = null) {
         super(integrationId, IntegrationType.GMAIL, ConfigType.GMAIL);
         this.eventTypes = eventTypes;
     }
@@ -304,14 +314,14 @@ export const FigmaConfigSchema = ConfigInstanceSchema.extend({
     fileKey: z.string(),
     fileName: z.string(),
     teamId: z.string(),
-    eventTypes: z.array(z.enum(FigmaEventType)).optional()
+    eventTypes: z.array(z.enum(FigmaEventType)).nullable()
 });
 export class FigmaConfig extends BaseConfigInstance {
     fileKey;
     fileName;
     teamId;
     eventTypes;
-    constructor(integrationId, fileKey, fileName, teamId, eventTypes) {
+    constructor(integrationId, fileKey, fileName, teamId, eventTypes = null) {
         super(integrationId, IntegrationType.FIGMA, ConfigType.FIGMA);
         this.fileKey = fileKey;
         this.fileName = fileName;
@@ -335,11 +345,11 @@ export class FigmaConfig extends BaseConfigInstance {
 export const SlackConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.SLACK),
     configType: z.literal(ConfigType.SLACK),
-    channelId: z.string().optional(),
-    channelName: z.string().optional(),
+    channelId: z.string().nullable(),
+    channelName: z.string().nullable(),
     listenToUserDms: z.boolean().default(false),
-    userIds: z.array(z.string()).optional(),
-    eventTypes: z.array(z.enum(SlackEventType)).optional()
+    userIds: z.array(z.string()).nullable(),
+    eventTypes: z.array(z.enum(SlackEventType)).nullable()
 });
 export class SlackConfig extends BaseConfigInstance {
     channelId;
@@ -347,7 +357,7 @@ export class SlackConfig extends BaseConfigInstance {
     listenToUserDms;
     userIds;
     eventTypes;
-    constructor(integrationId, channelId, channelName, listenToUserDms = false, userIds, eventTypes) {
+    constructor(integrationId, channelId = null, channelName = null, listenToUserDms = false, userIds = null, eventTypes = null) {
         super(integrationId, IntegrationType.SLACK, ConfigType.SLACK);
         this.channelId = channelId;
         this.channelName = channelName;
@@ -379,10 +389,10 @@ export class SlackConfig extends BaseConfigInstance {
 export const SlackOutputConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.SLACK),
     configType: z.literal(ConfigType.SLACK_OUTPUT),
-    channelId: z.string().optional(),
-    channelName: z.string().optional(),
-    userIds: z.array(z.string()).optional(),
-    userNames: z.array(z.string()).optional(),
+    channelId: z.string().nullable(),
+    channelName: z.string().nullable(),
+    userIds: z.array(z.string()).nullable(),
+    userNames: z.array(z.string()).nullable(),
     listenToUserDms: z.boolean().default(false)
 });
 export class SlackOutputConfig extends BaseConfigInstance {
@@ -391,7 +401,7 @@ export class SlackOutputConfig extends BaseConfigInstance {
     userIds;
     userNames;
     listenToUserDms;
-    constructor(integrationId, channelId, channelName, userIds, userNames, listenToUserDms = false) {
+    constructor(integrationId, channelId = null, channelName = null, userIds = null, userNames = null, listenToUserDms = false) {
         super(integrationId, IntegrationType.SLACK, ConfigType.SLACK_OUTPUT);
         this.channelId = channelId;
         this.channelName = channelName;
@@ -489,15 +499,15 @@ export class NotionConfig extends BaseConfigInstance {
 export const LinearInputConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.LINEAR),
     configType: z.literal(ConfigType.LINEAR_INPUT),
-    projectId: z.string().optional(),
-    projectName: z.string().optional(),
-    eventTypes: z.array(z.enum(LinearEventType)).optional()
+    projectId: z.string().nullable(),
+    projectName: z.string().nullable(),
+    eventTypes: z.array(z.enum(LinearEventType)).nullable()
 });
 export class LinearInputConfig extends BaseConfigInstance {
     projectId;
     projectName;
     eventTypes;
-    constructor(integrationId, projectId, projectName, eventTypes) {
+    constructor(integrationId, projectId = null, projectName = null, eventTypes = null) {
         super(integrationId, IntegrationType.LINEAR, ConfigType.LINEAR_INPUT);
         this.projectId = projectId;
         this.projectName = projectName;
@@ -520,17 +530,17 @@ export class LinearInputConfig extends BaseConfigInstance {
 export const LinearOutputConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.LINEAR),
     configType: z.literal(ConfigType.LINEAR_OUTPUT),
-    teamId: z.string().optional(),
-    teamName: z.string().optional(),
-    projectId: z.string().optional(),
-    projectName: z.string().optional()
+    teamId: z.string().nullable(),
+    teamName: z.string().nullable(),
+    projectId: z.string().nullable(),
+    projectName: z.string().nullable()
 });
 export class LinearOutputConfig extends BaseConfigInstance {
     teamId;
     teamName;
     projectId;
     projectName;
-    constructor(integrationId, teamId, teamName, projectId, projectName) {
+    constructor(integrationId, teamId = null, teamName = null, projectId = null, projectName = null) {
         super(integrationId, IntegrationType.LINEAR, ConfigType.LINEAR_OUTPUT);
         this.teamId = teamId;
         this.teamName = teamName;
@@ -560,13 +570,13 @@ export class LinearOutputConfig extends BaseConfigInstance {
 export const GitHubConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.GITHUB),
     configType: z.literal(ConfigType.GITHUB),
-    repositoryIds: z.array(z.number()),
-    eventTypes: z.array(z.enum(GitHubEventType)).optional()
+    repositoryIds: z.array(z.number().int()),
+    eventTypes: z.array(z.enum(GitHubEventType)).nullable()
 });
 export class GitHubConfig extends BaseConfigInstance {
     repositoryIds;
     eventTypes;
-    constructor(integrationId, repositoryIds, eventTypes) {
+    constructor(integrationId, repositoryIds, eventTypes = null) {
         super(integrationId, IntegrationType.GITHUB, ConfigType.GITHUB);
         this.repositoryIds = repositoryIds;
         this.eventTypes = eventTypes;
@@ -585,15 +595,15 @@ export class GitHubConfig extends BaseConfigInstance {
 export const JiraConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.ATLASSIAN),
     configType: z.literal(ConfigType.JIRA),
-    projectKey: z.string().optional(),
-    projectId: z.string().optional(),
-    eventTypes: z.array(z.enum(JiraEventType)).optional()
+    projectKey: z.string().nullable(),
+    projectId: z.string().nullable(),
+    eventTypes: z.array(z.enum(JiraEventType)).nullable()
 });
 export class JiraConfig extends BaseConfigInstance {
     projectKey;
     projectId;
     eventTypes;
-    constructor(integrationId, projectKey, projectId, eventTypes) {
+    constructor(integrationId, projectKey = null, projectId = null, eventTypes = null) {
         super(integrationId, IntegrationType.ATLASSIAN, ConfigType.JIRA);
         this.projectKey = projectKey;
         this.projectId = projectId;
@@ -658,12 +668,12 @@ export const PosthogConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.POSTHOG),
     configType: z.literal(ConfigType.POSTHOG),
     projectId: z.string(),
-    projectName: z.string().optional()
+    projectName: z.string().nullable()
 });
 export class PosthogConfig extends BaseConfigInstance {
     projectId;
     projectName;
-    constructor(integrationId, projectId, projectName) {
+    constructor(integrationId, projectId, projectName = null) {
         super(integrationId, IntegrationType.POSTHOG, ConfigType.POSTHOG);
         this.projectId = projectId;
         this.projectName = projectName;
@@ -808,11 +818,11 @@ export class WorkOSOutputConfig extends BaseConfigInstance {
 export const AttioOutputConfigSchema = ConfigInstanceSchema.extend({
     integrationType: z.literal(IntegrationType.ATTIO),
     configType: z.literal(ConfigType.ATTIO_OUTPUT),
-    objectSlug: z.string().optional()
+    objectSlug: z.string().nullable()
 });
 export class AttioOutputConfig extends BaseConfigInstance {
     objectSlug;
-    constructor(integrationId, objectSlug) {
+    constructor(integrationId, objectSlug = null) {
         super(integrationId, IntegrationType.ATTIO, ConfigType.ATTIO_OUTPUT);
         this.objectSlug = objectSlug;
     }
@@ -843,6 +853,248 @@ export class SnowflakeOutputConfig extends BaseConfigInstance {
         return parts.join("\n");
     }
 }
+export const WebhookInputConfigSchema = ConfigInstanceSchema.extend({
+    integrationId: z.literal("system"),
+    integrationType: z.literal(IntegrationType.WEBHOOK),
+    configType: z.literal(ConfigType.WEBHOOK_INPUT)
+});
+export class WebhookInputConfig extends BaseConfigInstance {
+    constructor() {
+        super("system", IntegrationType.WEBHOOK, ConfigType.WEBHOOK_INPUT);
+    }
+    isComplete() {
+        return true;
+    }
+    formatForAgent() {
+        return "Type: Webhook Trigger";
+    }
+}
+export const configDataSchema = z.union([
+    GmailConfigSchema,
+    FigmaConfigSchema,
+    SlackConfigSchema,
+    SlackOutputConfigSchema,
+    GmailOutputConfigSchema,
+    GmailDraftOutputConfigSchema,
+    NotionConfigSchema,
+    LinearInputConfigSchema,
+    LinearOutputConfigSchema,
+    GitHubConfigSchema,
+    JiraConfigSchema,
+    ConfluenceConfigSchema,
+    PosthogConfigSchema,
+    DatadogConfigSchema,
+    TimeTriggerConfigSchema,
+    LaunchDarklyConfigSchema,
+    TerseConfigSchema,
+    WorkOSInputConfigSchema,
+    WorkOSOutputConfigSchema,
+    AttioOutputConfigSchema,
+    SnowflakeOutputConfigSchema,
+    WebhookInputConfigSchema
+]);
+export function isConfigComplete(config) {
+    if (!config) {
+        return false;
+    }
+    switch (config.configType) {
+        case ConfigType.GMAIL:
+        case ConfigType.GMAIL_OUTPUT:
+        case ConfigType.GMAIL_DRAFT_OUTPUT:
+        case ConfigType.LINEAR_INPUT:
+        case ConfigType.JIRA:
+        case ConfigType.CONFLUENCE:
+        case ConfigType.TERSE:
+        case ConfigType.WEBHOOK_INPUT:
+            return true;
+        case ConfigType.FIGMA:
+            return !!(config.fileKey && config.teamId);
+        case ConfigType.SLACK:
+            return !!(config.channelId || config.listenToUserDms);
+        case ConfigType.SLACK_OUTPUT:
+            return !!(config.channelId || (config.userIds?.length ?? 0) > 0 || config.listenToUserDms);
+        case ConfigType.NOTION:
+            return (config.databaseIds?.length ?? 0) > 0 || (config.pageIds?.length ?? 0) > 0;
+        case ConfigType.LINEAR_OUTPUT:
+        case ConfigType.DATADOG:
+        case ConfigType.WORKOS_OUTPUT:
+        case ConfigType.SNOWFLAKE_OUTPUT:
+            return !!config.integrationId;
+        case ConfigType.GITHUB:
+            return (config.repositoryIds?.length ?? 0) > 0;
+        case ConfigType.POSTHOG:
+            return !!config.projectId;
+        case ConfigType.TIME_TRIGGER:
+            return !!config.cronExpression;
+        case ConfigType.LAUNCHDARKLY:
+            return !!(config.projectKey && config.environmentKeys.length > 0);
+        case ConfigType.WORKOS_INPUT:
+            return config.eventTypes.length > 0;
+        case ConfigType.ATTIO_OUTPUT:
+            return !!config.objectSlug;
+        default:
+            const _exhaustive = config;
+            return _exhaustive;
+    }
+}
+export function formatConfigForAgent(config) {
+    switch (config.configType) {
+        case ConfigType.GMAIL:
+            return `Type: Gmail\nIntegration ID: ${config.integrationId}`;
+        case ConfigType.FIGMA: {
+            const parts = [`Type: Figma`, `Integration ID: ${config.integrationId}`];
+            if (config.fileName)
+                parts.push(`File: ${config.fileName}`);
+            if (config.fileKey)
+                parts.push(`File Key: ${config.fileKey}`);
+            return parts.join("\n");
+        }
+        case ConfigType.SLACK: {
+            const parts = [`Type: Slack`, `Integration ID: ${config.integrationId}`];
+            if (config.channelName) {
+                parts.push(`Channel: ${config.channelName}`);
+            }
+            else if (config.channelId) {
+                parts.push(`Channel ID: ${config.channelId}`);
+            }
+            if (config.listenToUserDms)
+                parts.push(`Listening to user DMs: Yes`);
+            if (config.userIds)
+                parts.push(`Users: ${config.userIds.join(", ")}`);
+            return parts.join("\n");
+        }
+        case ConfigType.SLACK_OUTPUT: {
+            const parts = [`Type: Slack Output`, `Integration ID: ${config.integrationId}`];
+            if (config.channelId)
+                parts.push(`Channel ID: ${config.channelId}`);
+            if (config.listenToUserDms)
+                parts.push(`Listen to user DMs: Yes`);
+            if (config.userIds?.length)
+                parts.push(`DM user IDs: ${config.userIds.join(", ")}`);
+            return parts.join("\n");
+        }
+        case ConfigType.GMAIL_OUTPUT:
+            return `Type: Gmail Output\nIntegration ID: ${config.integrationId}`;
+        case ConfigType.GMAIL_DRAFT_OUTPUT:
+            return `Type: Gmail Draft Output\nIntegration ID: ${config.integrationId}`;
+        case ConfigType.NOTION: {
+            const parts = [`Type: Notion`, `Integration ID: ${config.integrationId}`];
+            const dbIds = config.databaseIds ?? [];
+            const dbNames = config.databaseNames ?? [];
+            if (dbIds.length > 0) {
+                parts.push(`Databases: ${dbIds.map((id, i) => dbNames[i] || id).join(", ")}`);
+            }
+            const pageIds = config.pageIds ?? [];
+            const pageNames = config.pageNames ?? [];
+            if (pageIds.length > 0) {
+                parts.push(`Pages: ${pageIds.map((id, i) => pageNames[i] || id).join(", ")}`);
+            }
+            return parts.join("\n");
+        }
+        case ConfigType.LINEAR_INPUT: {
+            const parts = [`Type: Linear`, `Integration ID: ${config.integrationId}`];
+            if (config.projectName) {
+                parts.push(`Project: ${config.projectName}`);
+            }
+            else if (config.projectId) {
+                parts.push(`Project ID: ${config.projectId}`);
+            }
+            return parts.join("\n");
+        }
+        case ConfigType.LINEAR_OUTPUT: {
+            const parts = [`Type: Linear`, `Integration ID: ${config.integrationId}`];
+            if (config.teamName) {
+                parts.push(`Team: ${config.teamName}`);
+            }
+            else if (config.teamId) {
+                parts.push(`Team ID: ${config.teamId}`);
+            }
+            if (config.projectName) {
+                parts.push(`Project: ${config.projectName}`);
+            }
+            else if (config.projectId) {
+                parts.push(`Project ID: ${config.projectId}`);
+            }
+            return parts.join("\n");
+        }
+        case ConfigType.GITHUB: {
+            const parts = [`Type: GitHub`, `Integration ID: ${config.integrationId}`];
+            if (config.repositoryIds.length > 0)
+                parts.push(`Repositories: ${config.repositoryIds.join(", ")}`);
+            return parts.join("\n");
+        }
+        case ConfigType.JIRA: {
+            const parts = [`Type: Jira`, `Integration ID: ${config.integrationId}`];
+            if (config.projectKey) {
+                parts.push(`Project Key: ${config.projectKey}`);
+            }
+            else if (config.projectId) {
+                parts.push(`Project ID: ${config.projectId}`);
+            }
+            return parts.join("\n");
+        }
+        case ConfigType.CONFLUENCE: {
+            const parts = [`Type: Confluence`, `Integration ID: ${config.integrationId}`];
+            if (config.spaceName)
+                parts.push(`Space: ${config.spaceName}`);
+            if (config.pageName) {
+                parts.push(`Page: ${config.pageName}`);
+            }
+            else if (config.pageId) {
+                parts.push(`Page ID: ${config.pageId}`);
+            }
+            return parts.join("\n");
+        }
+        case ConfigType.POSTHOG: {
+            const parts = [`Type: Posthog`, `Integration ID: ${config.integrationId}`];
+            if (config.projectId)
+                parts.push(`Project ID: ${config.projectId}`);
+            if (config.projectName)
+                parts.push(`Project: ${config.projectName}`);
+            return parts.join("\n");
+        }
+        case ConfigType.DATADOG: {
+            const parts = [`Type: Datadog`, `Integration ID: ${config.integrationId}`];
+            if (config.defaultIndexes?.length)
+                parts.push(`Default indexes: ${config.defaultIndexes.join(", ")}`);
+            return parts.join("\n");
+        }
+        case ConfigType.TIME_TRIGGER: {
+            const parts = [`Type: Time Trigger`];
+            if (config.cronExpression)
+                parts.push(`Schedule (UTC): ${config.cronExpression}`);
+            return parts.join("\n");
+        }
+        case ConfigType.LAUNCHDARKLY: {
+            const parts = [`Type: LaunchDarkly`, `Integration ID: ${config.integrationId}`];
+            if (config.projectKey)
+                parts.push(`Project Key: ${config.projectKey}`);
+            if (config.environmentKeys.length > 0)
+                parts.push(`Environments: ${config.environmentKeys.join(", ")}`);
+            return parts.join("\n");
+        }
+        case ConfigType.TERSE:
+            return "Type: Terse Skills";
+        case ConfigType.WORKOS_INPUT:
+            return `Type: WorkOS Events\nListening for: ${config.eventTypes.join(", ")}`;
+        case ConfigType.WORKOS_OUTPUT:
+            return `Type: WorkOS Skill\nIntegration ID: ${config.integrationId}`;
+        case ConfigType.ATTIO_OUTPUT: {
+            const parts = [`Type: Attio Output`, `Integration ID: ${config.integrationId}`];
+            if (config.objectSlug)
+                parts.push(`Object: ${config.objectSlug}`);
+            return parts.join("\n");
+        }
+        case ConfigType.SNOWFLAKE_OUTPUT:
+            return `Type: Snowflake Output\nIntegration ID: ${config.integrationId}`;
+        case ConfigType.WEBHOOK_INPUT:
+            return "Type: Webhook Trigger";
+        default: {
+            const _exhaustive = config;
+            return _exhaustive;
+        }
+    }
+}
 export const CONFIG_METADATA = {
     [ConfigType.GMAIL]: GmailConfig,
     [ConfigType.GMAIL_OUTPUT]: GmailOutputConfig,
@@ -864,5 +1116,6 @@ export const CONFIG_METADATA = {
     [ConfigType.WORKOS_INPUT]: WorkOSInputConfig,
     [ConfigType.WORKOS_OUTPUT]: WorkOSOutputConfig,
     [ConfigType.ATTIO_OUTPUT]: AttioOutputConfig,
-    [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfig
+    [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfig,
+    [ConfigType.WEBHOOK_INPUT]: WebhookInputConfig
 };

package/dist/Integrations.d.ts

@@ -14,7 +14,8 @@ export declare enum IntegrationType {
     LAUNCHDARKLY = "launchdarkly",
     WORKOS = "workos",
     ATTIO = "attio",
-    SNOWFLAKE = "snowflake"
+    SNOWFLAKE = "snowflake",
+    WEBHOOK = "webhook"
 }
 export declare const integrationTypeEnum: z.ZodEnum<typeof IntegrationType>;
 export interface IntegrationDetails {
@@ -129,6 +130,13 @@ export declare const SnowflakeIntegrationMetadata: {
     readonly isInput: false;
     readonly isOutput: true;
 };
+export declare const WebhookIntegrationMetadata: {
+    readonly type: IntegrationType.WEBHOOK;
+    readonly name: "Webhook";
+    readonly description: "Trigger via an external HTTP request to a generated URL";
+    readonly isInput: true;
+    readonly isOutput: false;
+};
 export type IntegrationMetadataMap = Record<IntegrationType, IntegrationDetails>;
 export declare const INTEGRATION_METADATA: IntegrationMetadataMap;
 export declare const IntegrationInstanceSchema: z.ZodObject<{
@@ -157,6 +165,7 @@ export type IntegrationInstallationOptions = EnsureExhaustiveInstallationOptions
     [IntegrationType.WORKOS]: NoInstallationOptions;
     [IntegrationType.ATTIO]: NoInstallationOptions;
     [IntegrationType.SNOWFLAKE]: NoInstallationOptions;
+    [IntegrationType.WEBHOOK]: NoInstallationOptions;
 }>;
 export type InstallationOptionsFor<T extends IntegrationType> = IntegrationInstallationOptions[T];
 export declare const SlackIntegrationSchema: z.ZodObject<{

package/dist/Integrations.js

@@ -17,6 +17,7 @@ export var IntegrationType;
     IntegrationType["WORKOS"] = "workos";
     IntegrationType["ATTIO"] = "attio";
     IntegrationType["SNOWFLAKE"] = "snowflake";
+    IntegrationType["WEBHOOK"] = "webhook";
 })(IntegrationType || (IntegrationType = {}));
 export const integrationTypeEnum = z.enum(IntegrationType);
 // Metadata objects - using const objects instead of classes
@@ -125,6 +126,13 @@ export const SnowflakeIntegrationMetadata = {
     isInput: false,
     isOutput: true
 };
+export const WebhookIntegrationMetadata = {
+    type: IntegrationType.WEBHOOK,
+    name: "Webhook",
+    description: "Trigger via an external HTTP request to a generated URL",
+    isInput: true,
+    isOutput: false
+};
 export const INTEGRATION_METADATA = {
     [IntegrationType.GMAIL]: GmailIntegrationMetadata,
     [IntegrationType.NOTION]: NotionIntegrationMetadata,
@@ -140,7 +148,8 @@ export const INTEGRATION_METADATA = {
     [IntegrationType.LAUNCHDARKLY]: LaunchDarklyIntegrationMetadata,
     [IntegrationType.WORKOS]: WorkOSIntegrationMetadata,
     [IntegrationType.ATTIO]: AttioIntegrationMetadata,
-    [IntegrationType.SNOWFLAKE]: SnowflakeIntegrationMetadata
+    [IntegrationType.SNOWFLAKE]: SnowflakeIntegrationMetadata,
+    [IntegrationType.WEBHOOK]: WebhookIntegrationMetadata
 };
 // MARK: Integration Details
 export const IntegrationInstanceSchema = z.object({
@@ -173,7 +182,7 @@ export const AtlassianIntegrationSchema = IntegrationInstanceSchema.extend({
     projectName: z.string().optional()
 });
 export const GithubIntegrationSchema = IntegrationInstanceSchema.extend({
-    installation_id: z.number(),
+    installation_id: z.number().int(),
     account_name: z.string().optional()
 });
 export const LinearIntegrationSchema = IntegrationInstanceSchema.extend({