terse-types 0.0.1

package/dist/Configs.js

@@ -0,0 +1,868 @@
+import * as z from "zod";
+import { IntegrationType, integrationTypeEnum } from "./Integrations.js";
+export var ConfigType;
+(function (ConfigType) {
+    ConfigType["GMAIL"] = "gmail";
+    ConfigType["GMAIL_OUTPUT"] = "gmail_output";
+    ConfigType["GMAIL_DRAFT_OUTPUT"] = "gmail_draft_output";
+    ConfigType["FIGMA"] = "figma";
+    ConfigType["SLACK"] = "slack";
+    ConfigType["SLACK_OUTPUT"] = "slack_output";
+    ConfigType["NOTION"] = "notion";
+    ConfigType["LINEAR_INPUT"] = "linear_input";
+    ConfigType["LINEAR_OUTPUT"] = "linear_output";
+    ConfigType["GITHUB"] = "github";
+    ConfigType["JIRA"] = "jira";
+    ConfigType["CONFLUENCE"] = "confluence";
+    ConfigType["POSTHOG"] = "POSTHOG";
+    ConfigType["DATADOG"] = "DATADOG";
+    ConfigType["TIME_TRIGGER"] = "time_trigger";
+    ConfigType["LAUNCHDARKLY"] = "launchdarkly";
+    ConfigType["TERSE"] = "terse";
+    ConfigType["WORKOS_INPUT"] = "workos_input";
+    ConfigType["WORKOS_OUTPUT"] = "workos_output";
+    ConfigType["ATTIO_OUTPUT"] = "attio_output";
+    ConfigType["SNOWFLAKE_OUTPUT"] = "snowflake_output";
+})(ConfigType || (ConfigType = {}));
+export const configTypeEnum = z.enum(ConfigType);
+// Metadata objects - using const objects instead of classes
+export const GmailConfigMetadata = {
+    configType: ConfigType.GMAIL,
+    name: "Gmail",
+    description: "Monitor incoming emails",
+    integrationType: IntegrationType.GMAIL,
+    isInput: true,
+    isOutput: false
+};
+export const FigmaConfigMetadata = {
+    configType: ConfigType.FIGMA,
+    name: "Figma",
+    description: "Monitor design changes in Figma files",
+    integrationType: IntegrationType.FIGMA,
+    isInput: true,
+    isOutput: false
+};
+export const SlackConfigMetadata = {
+    configType: ConfigType.SLACK,
+    name: "Slack",
+    description: "Monitor messages in Slack channels or DMs",
+    integrationType: IntegrationType.SLACK,
+    isInput: true,
+    isOutput: false
+};
+export const SlackOutputConfigMetadata = {
+    configType: ConfigType.SLACK_OUTPUT,
+    name: "Slack",
+    description: "Send messages to Slack channels, group DMs, or direct messages",
+    integrationType: IntegrationType.SLACK,
+    isInput: false,
+    isOutput: true
+};
+export const GmailOutputConfigMetadata = {
+    configType: ConfigType.GMAIL_OUTPUT,
+    name: "Gmail",
+    description: "Send emails via Gmail",
+    integrationType: IntegrationType.GMAIL,
+    isInput: false,
+    isOutput: true
+};
+export const GmailDraftOutputConfigMetadata = {
+    configType: ConfigType.GMAIL_DRAFT_OUTPUT,
+    name: "Gmail Draft",
+    description: "Create draft emails in Gmail",
+    integrationType: IntegrationType.GMAIL,
+    isInput: false,
+    isOutput: true
+};
+export const NotionConfigMetadata = {
+    configType: ConfigType.NOTION,
+    name: "Notion",
+    description: "Update and monitor Notion pages and databases",
+    integrationType: IntegrationType.NOTION,
+    isInput: false,
+    isOutput: true
+};
+export const LinearInputConfigMetadata = {
+    configType: ConfigType.LINEAR_INPUT,
+    name: "Linear",
+    description: "Monitor Linear issues",
+    integrationType: IntegrationType.LINEAR,
+    isInput: true,
+    isOutput: false
+};
+export const LinearOutputConfigMetadata = {
+    configType: ConfigType.LINEAR_OUTPUT,
+    name: "Linear",
+    description: "Update Linear issues",
+    integrationType: IntegrationType.LINEAR,
+    isInput: false,
+    isOutput: true
+};
+export const GitHubConfigMetadata = {
+    configType: ConfigType.GITHUB,
+    name: "GitHub",
+    description: "Monitor and read Github repositories",
+    integrationType: IntegrationType.GITHUB,
+    isInput: true,
+    isOutput: true
+};
+export const JiraConfigMetadata = {
+    configType: ConfigType.JIRA,
+    name: "Jira",
+    description: "Monitor and update Jira issues",
+    integrationType: IntegrationType.ATLASSIAN,
+    isInput: true,
+    isOutput: true
+};
+export const ConfluenceConfigMetadata = {
+    configType: ConfigType.CONFLUENCE,
+    name: "Confluence",
+    description: "Update Confluence pages",
+    integrationType: IntegrationType.ATLASSIAN,
+    isInput: false,
+    isOutput: true
+};
+export const PosthogConfigMetadata = {
+    configType: ConfigType.POSTHOG,
+    name: "Posthog",
+    description: "Track user events",
+    integrationType: IntegrationType.POSTHOG,
+    isInput: false,
+    isOutput: true
+};
+export const DatadogConfigMetadata = {
+    configType: ConfigType.DATADOG,
+    name: "Datadog",
+    description: "Search logs in Datadog",
+    integrationType: IntegrationType.DATADOG,
+    isInput: false,
+    isOutput: true
+};
+export const TimeTriggerConfigMetadata = {
+    configType: ConfigType.TIME_TRIGGER,
+    name: "Time Trigger",
+    description: "Run on a schedule (daily, weekly, etc.)",
+    integrationType: IntegrationType.CRON_JOB,
+    isInput: true,
+    isOutput: false
+};
+export const LaunchDarklyConfigMetadata = {
+    configType: ConfigType.LAUNCHDARKLY,
+    name: "LaunchDarkly",
+    description: "Query feature flags",
+    integrationType: IntegrationType.LAUNCHDARKLY,
+    isInput: false,
+    isOutput: true
+};
+export const TerseConfigMetadata = {
+    configType: ConfigType.TERSE,
+    name: "Terse Skills",
+    description: "Built-in capabilities like web search (always available to agents)",
+    integrationType: IntegrationType.TERSE,
+    isInput: false,
+    isOutput: true
+};
+export const WorkOSInputConfigMetadata = {
+    configType: ConfigType.WORKOS_INPUT,
+    name: "WorkOS",
+    description: "Trigger on user signup, deletion, or membership changes in your app",
+    integrationType: IntegrationType.WORKOS,
+    isInput: true,
+    isOutput: false
+};
+export const WorkOSOutputConfigMetadata = {
+    configType: ConfigType.WORKOS_OUTPUT,
+    name: "WorkOS",
+    description: "Fetch and search users from your WorkOS account",
+    integrationType: IntegrationType.WORKOS,
+    isInput: false,
+    isOutput: true
+};
+export const AttioOutputConfigMetadata = {
+    configType: ConfigType.ATTIO_OUTPUT,
+    name: "Attio",
+    description: "Add and update contacts in Attio",
+    integrationType: IntegrationType.ATTIO,
+    isInput: false,
+    isOutput: true
+};
+export const SnowflakeOutputConfigMetadata = {
+    configType: ConfigType.SNOWFLAKE_OUTPUT,
+    name: "Snowflake",
+    description: "Run read-only queries against Snowflake data warehouses",
+    integrationType: IntegrationType.SNOWFLAKE,
+    isInput: false,
+    isOutput: true
+};
+export const CONFIG_DETAILS = {
+    [ConfigType.GMAIL]: GmailConfigMetadata,
+    [ConfigType.GMAIL_OUTPUT]: GmailOutputConfigMetadata,
+    [ConfigType.GMAIL_DRAFT_OUTPUT]: GmailDraftOutputConfigMetadata,
+    [ConfigType.FIGMA]: FigmaConfigMetadata,
+    [ConfigType.SLACK]: SlackConfigMetadata,
+    [ConfigType.SLACK_OUTPUT]: SlackOutputConfigMetadata,
+    [ConfigType.NOTION]: NotionConfigMetadata,
+    [ConfigType.LINEAR_INPUT]: LinearInputConfigMetadata,
+    [ConfigType.LINEAR_OUTPUT]: LinearOutputConfigMetadata,
+    [ConfigType.GITHUB]: GitHubConfigMetadata,
+    [ConfigType.JIRA]: JiraConfigMetadata,
+    [ConfigType.CONFLUENCE]: ConfluenceConfigMetadata,
+    [ConfigType.POSTHOG]: PosthogConfigMetadata,
+    [ConfigType.DATADOG]: DatadogConfigMetadata,
+    [ConfigType.TIME_TRIGGER]: TimeTriggerConfigMetadata,
+    [ConfigType.LAUNCHDARKLY]: LaunchDarklyConfigMetadata,
+    [ConfigType.TERSE]: TerseConfigMetadata,
+    [ConfigType.WORKOS_INPUT]: WorkOSInputConfigMetadata,
+    [ConfigType.WORKOS_OUTPUT]: WorkOSOutputConfigMetadata,
+    [ConfigType.ATTIO_OUTPUT]: AttioOutputConfigMetadata,
+    [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfigMetadata
+};
+// MARK: Event Types — specific events within each integration trigger
+export var SlackEventType;
+(function (SlackEventType) {
+    SlackEventType["MESSAGE"] = "message";
+    SlackEventType["APP_MENTION"] = "app_mention";
+    SlackEventType["REACTION_ADDED"] = "reaction_added";
+})(SlackEventType || (SlackEventType = {}));
+export var GitHubEventType;
+(function (GitHubEventType) {
+    GitHubEventType["PUSH"] = "push";
+    GitHubEventType["PR_OPENED"] = "pull_request.opened";
+    GitHubEventType["PR_MERGED"] = "pull_request.merged";
+    GitHubEventType["PR_CLOSED"] = "pull_request.closed";
+    GitHubEventType["PR_SYNCHRONIZE"] = "pull_request.synchronize";
+})(GitHubEventType || (GitHubEventType = {}));
+export var LinearEventType;
+(function (LinearEventType) {
+    LinearEventType["ISSUE_CREATED"] = "issue.created";
+    LinearEventType["ISSUE_UPDATED"] = "issue.updated";
+    LinearEventType["COMMENT_CREATED"] = "comment.created";
+})(LinearEventType || (LinearEventType = {}));
+export var JiraEventType;
+(function (JiraEventType) {
+    JiraEventType["ISSUE_CREATED"] = "issue.created";
+    JiraEventType["ISSUE_UPDATED"] = "issue.updated";
+})(JiraEventType || (JiraEventType = {}));
+export var FigmaEventType;
+(function (FigmaEventType) {
+    FigmaEventType["FILE_COMMENT"] = "file_comment";
+})(FigmaEventType || (FigmaEventType = {}));
+export var GmailEventType;
+(function (GmailEventType) {
+    GmailEventType["EMAIL_RECEIVED"] = "email.received";
+})(GmailEventType || (GmailEventType = {}));
+export var WorkOSEventType;
+(function (WorkOSEventType) {
+    WorkOSEventType["USER_CREATED"] = "user.created";
+    WorkOSEventType["USER_UPDATED"] = "user.updated";
+    WorkOSEventType["USER_DELETED"] = "user.deleted";
+    WorkOSEventType["ORGANIZATION_CREATED"] = "organization.created";
+    WorkOSEventType["ORGANIZATION_MEMBERSHIP_CREATED"] = "organization_membership.created";
+    WorkOSEventType["ORGANIZATION_MEMBERSHIP_UPDATED"] = "organization_membership.updated";
+    WorkOSEventType["ORGANIZATION_MEMBERSHIP_DELETED"] = "organization_membership.deleted";
+    WorkOSEventType["INVITATION_CREATED"] = "invitation.created";
+    WorkOSEventType["INVITATION_ACCEPTED"] = "invitation.accepted";
+    WorkOSEventType["INVITATION_RESENT"] = "invitation.resent";
+    WorkOSEventType["INVITATION_REVOKED"] = "invitation.revoked";
+})(WorkOSEventType || (WorkOSEventType = {}));
+export const ConfigInstanceSchema = z.object({
+    integrationId: z.string(),
+    integrationType: integrationTypeEnum,
+    configType: configTypeEnum
+});
+class BaseConfigInstance {
+    integrationId;
+    integrationType;
+    configType;
+    constructor(integrationId, integrationType, configType) {
+        this.integrationId = integrationId;
+        this.integrationType = integrationType;
+        this.configType = configType;
+    }
+}
+export const GmailConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.GMAIL),
+    configType: z.literal(ConfigType.GMAIL),
+    eventTypes: z.array(z.enum(GmailEventType)).optional()
+});
+export class GmailConfig extends BaseConfigInstance {
+    eventTypes;
+    constructor(integrationId, eventTypes) {
+        super(integrationId, IntegrationType.GMAIL, ConfigType.GMAIL);
+        this.eventTypes = eventTypes;
+    }
+    isComplete() {
+        return true;
+    }
+    formatForAgent() {
+        return `Type: Gmail\nIntegration ID: ${this.integrationId}`;
+    }
+}
+export const FigmaConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.FIGMA),
+    configType: z.literal(ConfigType.FIGMA),
+    fileKey: z.string(),
+    fileName: z.string(),
+    teamId: z.string(),
+    eventTypes: z.array(z.enum(FigmaEventType)).optional()
+});
+export class FigmaConfig extends BaseConfigInstance {
+    fileKey;
+    fileName;
+    teamId;
+    eventTypes;
+    constructor(integrationId, fileKey, fileName, teamId, eventTypes) {
+        super(integrationId, IntegrationType.FIGMA, ConfigType.FIGMA);
+        this.fileKey = fileKey;
+        this.fileName = fileName;
+        this.teamId = teamId;
+        this.eventTypes = eventTypes;
+    }
+    isComplete() {
+        return !!(this.fileKey && this.teamId);
+    }
+    formatForAgent() {
+        const parts = [`Type: Figma`, `Integration ID: ${this.integrationId}`];
+        if (this.fileName) {
+            parts.push(`File: ${this.fileName}`);
+        }
+        if (this.fileKey) {
+            parts.push(`File Key: ${this.fileKey}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const SlackConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.SLACK),
+    configType: z.literal(ConfigType.SLACK),
+    channelId: z.string().optional(),
+    channelName: z.string().optional(),
+    listenToUserDms: z.boolean().default(false),
+    userIds: z.array(z.string()).optional(),
+    eventTypes: z.array(z.enum(SlackEventType)).optional()
+});
+export class SlackConfig extends BaseConfigInstance {
+    channelId;
+    channelName;
+    listenToUserDms;
+    userIds;
+    eventTypes;
+    constructor(integrationId, channelId, channelName, listenToUserDms = false, userIds, eventTypes) {
+        super(integrationId, IntegrationType.SLACK, ConfigType.SLACK);
+        this.channelId = channelId;
+        this.channelName = channelName;
+        this.listenToUserDms = listenToUserDms;
+        this.userIds = userIds;
+        this.eventTypes = eventTypes;
+    }
+    isComplete() {
+        // Slack is complete if either channelId is set OR listenToUserDms is true
+        return !!(this.channelId || this.listenToUserDms);
+    }
+    formatForAgent() {
+        const parts = [`Type: Slack`, `Integration ID: ${this.integrationId}`];
+        if (this.channelName) {
+            parts.push(`Channel: ${this.channelName}`);
+        }
+        else if (this.channelId) {
+            parts.push(`Channel ID: ${this.channelId}`);
+        }
+        if (this.listenToUserDms) {
+            parts.push(`Listening to user DMs: Yes`);
+        }
+        if (this.userIds) {
+            parts.push(`Users: ${this.userIds.join(", ")}`);
+        }
+        return parts.join("\n");
+    }
+}
+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(),
+    listenToUserDms: z.boolean().default(false)
+});
+export class SlackOutputConfig extends BaseConfigInstance {
+    channelId;
+    channelName;
+    userIds;
+    userNames;
+    listenToUserDms;
+    constructor(integrationId, channelId, channelName, userIds, userNames, listenToUserDms = false) {
+        super(integrationId, IntegrationType.SLACK, ConfigType.SLACK_OUTPUT);
+        this.channelId = channelId;
+        this.channelName = channelName;
+        this.userIds = userIds;
+        this.userNames = userNames;
+        this.listenToUserDms = listenToUserDms;
+    }
+    isComplete() {
+        // Slack output is complete if a channel is set, DM users are set, or "listen to user DMs" is enabled.
+        return !!(this.channelId || (this.userIds?.length ?? 0) > 0 || this.listenToUserDms);
+    }
+    formatForAgent() {
+        const parts = [`Type: Slack Output`, `Integration ID: ${this.integrationId}`];
+        if (this.channelId) {
+            parts.push(`Channel ID: ${this.channelId}`);
+        }
+        if (this.listenToUserDms) {
+            parts.push(`Listen to user DMs: Yes`);
+        }
+        if (this.userIds?.length) {
+            parts.push(`DM user IDs: ${this.userIds.join(", ")}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const GmailOutputConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.GMAIL),
+    configType: z.literal(ConfigType.GMAIL_OUTPUT)
+});
+export class GmailOutputConfig extends BaseConfigInstance {
+    constructor(integrationId) {
+        super(integrationId, IntegrationType.GMAIL, ConfigType.GMAIL_OUTPUT);
+    }
+    isComplete() {
+        // Gmail output only requires integrationId
+        return true;
+    }
+    formatForAgent() {
+        return `Type: Gmail Output\nIntegration ID: ${this.integrationId}`;
+    }
+}
+export const GmailDraftOutputConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.GMAIL),
+    configType: z.literal(ConfigType.GMAIL_DRAFT_OUTPUT)
+});
+export class GmailDraftOutputConfig extends BaseConfigInstance {
+    constructor(integrationId) {
+        super(integrationId, IntegrationType.GMAIL, ConfigType.GMAIL_DRAFT_OUTPUT);
+    }
+    isComplete() {
+        return true;
+    }
+    formatForAgent() {
+        return `Type: Gmail Draft Output\nIntegration ID: ${this.integrationId}`;
+    }
+}
+export const NotionConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.NOTION),
+    configType: z.literal(ConfigType.NOTION),
+    databaseIds: z.array(z.string()).default([]),
+    databaseNames: z.array(z.string()).default([]),
+    pageIds: z.array(z.string()).default([]),
+    pageNames: z.array(z.string()).default([])
+});
+export class NotionConfig extends BaseConfigInstance {
+    databaseIds;
+    databaseNames;
+    pageIds;
+    pageNames;
+    constructor(integrationId, databaseIds = [], databaseNames = [], pageIds = [], pageNames = []) {
+        super(integrationId, IntegrationType.NOTION, ConfigType.NOTION);
+        this.databaseIds = databaseIds;
+        this.databaseNames = databaseNames;
+        this.pageIds = pageIds;
+        this.pageNames = pageNames;
+    }
+    isComplete() {
+        return (this.databaseIds?.length ?? 0) > 0 || (this.pageIds?.length ?? 0) > 0;
+    }
+    formatForAgent() {
+        const parts = [`Type: Notion`, `Integration ID: ${this.integrationId}`];
+        const dbIds = this.databaseIds ?? [];
+        const dbNames = this.databaseNames ?? [];
+        if (dbIds.length > 0) {
+            parts.push(`Databases: ${dbIds.map((id, i) => dbNames[i] || id).join(", ")}`);
+        }
+        const pageIds = this.pageIds ?? [];
+        const pageNames = this.pageNames ?? [];
+        if (pageIds.length > 0) {
+            parts.push(`Pages: ${pageIds.map((id, i) => pageNames[i] || id).join(", ")}`);
+        }
+        return parts.join("\n");
+    }
+}
+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()
+});
+export class LinearInputConfig extends BaseConfigInstance {
+    projectId;
+    projectName;
+    eventTypes;
+    constructor(integrationId, projectId, projectName, eventTypes) {
+        super(integrationId, IntegrationType.LINEAR, ConfigType.LINEAR_INPUT);
+        this.projectId = projectId;
+        this.projectName = projectName;
+        this.eventTypes = eventTypes;
+    }
+    isComplete() {
+        return true;
+    }
+    formatForAgent() {
+        const parts = [`Type: Linear`, `Integration ID: ${this.integrationId}`];
+        if (this.projectName) {
+            parts.push(`Project: ${this.projectName}`);
+        }
+        else if (this.projectId) {
+            parts.push(`Project ID: ${this.projectId}`);
+        }
+        return parts.join("\n");
+    }
+}
+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()
+});
+export class LinearOutputConfig extends BaseConfigInstance {
+    teamId;
+    teamName;
+    projectId;
+    projectName;
+    constructor(integrationId, teamId, teamName, projectId, projectName) {
+        super(integrationId, IntegrationType.LINEAR, ConfigType.LINEAR_OUTPUT);
+        this.teamId = teamId;
+        this.teamName = teamName;
+        this.projectId = projectId;
+        this.projectName = projectName;
+    }
+    isComplete() {
+        return !!this.integrationId;
+    }
+    formatForAgent() {
+        const parts = [`Type: Linear`, `Integration ID: ${this.integrationId}`];
+        if (this.teamName) {
+            parts.push(`Team: ${this.teamName}`);
+        }
+        else if (this.teamId) {
+            parts.push(`Team ID: ${this.teamId}`);
+        }
+        if (this.projectName) {
+            parts.push(`Project: ${this.projectName}`);
+        }
+        else if (this.projectId) {
+            parts.push(`Project ID: ${this.projectId}`);
+        }
+        return parts.join("\n");
+    }
+}
+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()
+});
+export class GitHubConfig extends BaseConfigInstance {
+    repositoryIds;
+    eventTypes;
+    constructor(integrationId, repositoryIds, eventTypes) {
+        super(integrationId, IntegrationType.GITHUB, ConfigType.GITHUB);
+        this.repositoryIds = repositoryIds;
+        this.eventTypes = eventTypes;
+    }
+    isComplete() {
+        return (this.repositoryIds?.length ?? 0) > 0;
+    }
+    formatForAgent() {
+        const parts = [`Type: GitHub`, `Integration ID: ${this.integrationId}`];
+        if (this.repositoryIds.length > 0) {
+            parts.push(`Repositories: ${this.repositoryIds.join(", ")}`);
+        }
+        return parts.join("\n");
+    }
+}
+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()
+});
+export class JiraConfig extends BaseConfigInstance {
+    projectKey;
+    projectId;
+    eventTypes;
+    constructor(integrationId, projectKey, projectId, eventTypes) {
+        super(integrationId, IntegrationType.ATLASSIAN, ConfigType.JIRA);
+        this.projectKey = projectKey;
+        this.projectId = projectId;
+        this.eventTypes = eventTypes;
+    }
+    isComplete() {
+        // Jira only requires integrationId (base check handled in isInputComplete)
+        return true;
+    }
+    formatForAgent() {
+        const parts = [`Type: Jira`, `Integration ID: ${this.integrationId}`];
+        if (this.projectKey) {
+            parts.push(`Project Key: ${this.projectKey}`);
+        }
+        else if (this.projectId) {
+            parts.push(`Project ID: ${this.projectId}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const ConfluenceConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.ATLASSIAN),
+    configType: z.literal(ConfigType.CONFLUENCE),
+    spaceName: z.string(),
+    spaceId: z.string(),
+    pageId: z.string(),
+    pageName: z.string()
+});
+export class ConfluenceConfig extends BaseConfigInstance {
+    spaceName;
+    spaceId;
+    pageId;
+    pageName;
+    constructor(integrationId, spaceName, spaceId, pageId, // Page ID (required for outputs - specific page to write to)
+    pageName // Page display name (for UI, optional)
+    ) {
+        super(integrationId, IntegrationType.ATLASSIAN, ConfigType.CONFLUENCE);
+        this.spaceName = spaceName;
+        this.spaceId = spaceId;
+        this.pageId = pageId;
+        this.pageName = pageName;
+    }
+    isComplete() {
+        // Confluence only requires integrationId (base check handled in isInputComplete)
+        return true;
+    }
+    formatForAgent() {
+        const parts = [`Type: Confluence`, `Integration ID: ${this.integrationId}`];
+        if (this.spaceName) {
+            parts.push(`Space: ${this.spaceName}`);
+        }
+        if (this.pageName) {
+            parts.push(`Page: ${this.pageName}`);
+        }
+        else if (this.pageId) {
+            parts.push(`Page ID: ${this.pageId}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const PosthogConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.POSTHOG),
+    configType: z.literal(ConfigType.POSTHOG),
+    projectId: z.string(),
+    projectName: z.string().optional()
+});
+export class PosthogConfig extends BaseConfigInstance {
+    projectId;
+    projectName;
+    constructor(integrationId, projectId, projectName) {
+        super(integrationId, IntegrationType.POSTHOG, ConfigType.POSTHOG);
+        this.projectId = projectId;
+        this.projectName = projectName;
+    }
+    isComplete() {
+        return !!this.projectId;
+    }
+    formatForAgent() {
+        const parts = [`Type: Posthog`, `Integration ID: ${this.integrationId}`];
+        if (this.projectId) {
+            parts.push(`Project ID: ${this.projectId}`);
+        }
+        if (this.projectName) {
+            parts.push(`Project: ${this.projectName}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const DatadogConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.DATADOG),
+    configType: z.literal(ConfigType.DATADOG),
+    defaultIndexes: z.array(z.string()).default(["main"])
+});
+export class DatadogConfig extends BaseConfigInstance {
+    defaultIndexes;
+    constructor(integrationId, defaultIndexes = ["main"]) {
+        super(integrationId, IntegrationType.DATADOG, ConfigType.DATADOG);
+        this.defaultIndexes = defaultIndexes;
+    }
+    isComplete() {
+        return !!this.integrationId;
+    }
+    formatForAgent() {
+        const parts = [`Type: Datadog`, `Integration ID: ${this.integrationId}`];
+        if (this.defaultIndexes && this.defaultIndexes.length > 0) {
+            parts.push(`Default indexes: ${this.defaultIndexes.join(", ")}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const TimeTriggerConfigSchema = ConfigInstanceSchema.extend({
+    integrationId: z.literal("system"),
+    integrationType: z.literal(IntegrationType.CRON_JOB),
+    configType: z.literal(ConfigType.TIME_TRIGGER),
+    cronExpression: z.string()
+});
+export class TimeTriggerConfig extends BaseConfigInstance {
+    cronExpression;
+    constructor(cronExpression) {
+        super("system", IntegrationType.CRON_JOB, ConfigType.TIME_TRIGGER);
+        this.cronExpression = cronExpression;
+    }
+    isComplete() {
+        return !!this.cronExpression;
+    }
+    formatForAgent() {
+        const parts = [`Type: Time Trigger`];
+        if (this.cronExpression) {
+            parts.push(`Schedule (UTC): ${this.cronExpression}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const LaunchDarklyConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.LAUNCHDARKLY),
+    configType: z.literal(ConfigType.LAUNCHDARKLY),
+    projectKey: z.string(),
+    environmentKeys: z.array(z.string())
+});
+export class LaunchDarklyConfig extends BaseConfigInstance {
+    projectKey;
+    environmentKeys;
+    constructor(integrationId, projectKey, environmentKeys // ["production", "staging"]
+    ) {
+        super(integrationId, IntegrationType.LAUNCHDARKLY, ConfigType.LAUNCHDARKLY);
+        this.projectKey = projectKey;
+        this.environmentKeys = environmentKeys;
+    }
+    isComplete() {
+        return !!(this.projectKey && this.environmentKeys.length > 0);
+    }
+    formatForAgent() {
+        const parts = [`Type: LaunchDarkly`, `Integration ID: ${this.integrationId}`];
+        if (this.projectKey) {
+            parts.push(`Project Key: ${this.projectKey}`);
+        }
+        if (this.environmentKeys.length > 0) {
+            parts.push(`Environments: ${this.environmentKeys.join(", ")}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const TerseConfigSchema = ConfigInstanceSchema.extend({
+    integrationId: z.literal("system"),
+    integrationType: z.literal(IntegrationType.TERSE),
+    configType: z.literal(ConfigType.TERSE)
+});
+export class TerseConfig extends BaseConfigInstance {
+    constructor() {
+        super("system", IntegrationType.TERSE, ConfigType.TERSE);
+    }
+    isComplete() {
+        return true;
+    }
+    formatForAgent() {
+        return "Type: Terse Skills";
+    }
+}
+export const WorkOSInputConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.WORKOS),
+    configType: z.literal(ConfigType.WORKOS_INPUT),
+    eventTypes: z.array(z.enum(WorkOSEventType)).default([])
+});
+export class WorkOSInputConfig extends BaseConfigInstance {
+    eventTypes;
+    constructor(integrationId, eventTypes = []) {
+        super(integrationId, IntegrationType.WORKOS, ConfigType.WORKOS_INPUT);
+        this.eventTypes = eventTypes;
+    }
+    isComplete() {
+        return this.eventTypes.length > 0;
+    }
+    formatForAgent() {
+        return `Type: WorkOS Events\nListening for: ${this.eventTypes.join(", ")}`;
+    }
+}
+export const WorkOSOutputConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.WORKOS),
+    configType: z.literal(ConfigType.WORKOS_OUTPUT)
+});
+export class WorkOSOutputConfig extends BaseConfigInstance {
+    constructor(integrationId) {
+        super(integrationId, IntegrationType.WORKOS, ConfigType.WORKOS_OUTPUT);
+    }
+    isComplete() {
+        return !!this.integrationId;
+    }
+    formatForAgent() {
+        return `Type: WorkOS Skill\nIntegration ID: ${this.integrationId}`;
+    }
+}
+export const AttioOutputConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.ATTIO),
+    configType: z.literal(ConfigType.ATTIO_OUTPUT),
+    objectSlug: z.string().optional()
+});
+export class AttioOutputConfig extends BaseConfigInstance {
+    objectSlug;
+    constructor(integrationId, objectSlug) {
+        super(integrationId, IntegrationType.ATTIO, ConfigType.ATTIO_OUTPUT);
+        this.objectSlug = objectSlug;
+    }
+    isComplete() {
+        return !!this.objectSlug;
+    }
+    formatForAgent() {
+        const parts = [`Type: Attio Output`, `Integration ID: ${this.integrationId}`];
+        if (this.objectSlug) {
+            parts.push(`Object: ${this.objectSlug}`);
+        }
+        return parts.join("\n");
+    }
+}
+export const SnowflakeOutputConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.SNOWFLAKE),
+    configType: z.literal(ConfigType.SNOWFLAKE_OUTPUT)
+});
+export class SnowflakeOutputConfig extends BaseConfigInstance {
+    constructor(integrationId) {
+        super(integrationId, IntegrationType.SNOWFLAKE, ConfigType.SNOWFLAKE_OUTPUT);
+    }
+    isComplete() {
+        return !!this.integrationId;
+    }
+    formatForAgent() {
+        const parts = [`Type: Snowflake Output`, `Integration ID: ${this.integrationId}`];
+        return parts.join("\n");
+    }
+}
+export const CONFIG_METADATA = {
+    [ConfigType.GMAIL]: GmailConfig,
+    [ConfigType.GMAIL_OUTPUT]: GmailOutputConfig,
+    [ConfigType.GMAIL_DRAFT_OUTPUT]: GmailDraftOutputConfig,
+    [ConfigType.FIGMA]: FigmaConfig,
+    [ConfigType.SLACK]: SlackConfig,
+    [ConfigType.SLACK_OUTPUT]: SlackOutputConfig,
+    [ConfigType.NOTION]: NotionConfig,
+    [ConfigType.LINEAR_INPUT]: LinearInputConfig,
+    [ConfigType.LINEAR_OUTPUT]: LinearOutputConfig,
+    [ConfigType.GITHUB]: GitHubConfig,
+    [ConfigType.JIRA]: JiraConfig,
+    [ConfigType.CONFLUENCE]: ConfluenceConfig,
+    [ConfigType.POSTHOG]: PosthogConfig,
+    [ConfigType.DATADOG]: DatadogConfig,
+    [ConfigType.TIME_TRIGGER]: TimeTriggerConfig,
+    [ConfigType.LAUNCHDARKLY]: LaunchDarklyConfig,
+    [ConfigType.TERSE]: TerseConfig,
+    [ConfigType.WORKOS_INPUT]: WorkOSInputConfig,
+    [ConfigType.WORKOS_OUTPUT]: WorkOSOutputConfig,
+    [ConfigType.ATTIO_OUTPUT]: AttioOutputConfig,
+    [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfig
+};