terse-types 0.0.18 → 0.0.20

package/dist/TriggerEvents.js

@@ -0,0 +1,437 @@
+import { z } from "zod";
+import { GitHubEventType, WorkOSEventType, gitHubEventTypeSchema, gmailEventTypeSchema, linearEventTypeSchema, slackEventTypeSchema, workOSEventTypeSchema } from "./Configs.js";
+import { IntegrationType, integrationTypeEnum } from "./Integrations.js";
+import { SlackChannelType } from "./SlackTypes.js";
+import { debugTrigger as debugTriggerWithPresenter, formatTriggerForAgent as formatTriggerForAgentWithPresenter } from "./TriggerPresenters.js";
+const providerTriggerTypeSchema = z.union([slackEventTypeSchema, gitHubEventTypeSchema, linearEventTypeSchema, gmailEventTypeSchema, workOSEventTypeSchema]);
+const TriggerHeaderSchema = z.object({
+    integrationType: integrationTypeEnum,
+    eventType: providerTriggerTypeSchema
+});
+const slackTriggerBaseSchema = TriggerHeaderSchema.extend({
+    integrationType: z.literal(IntegrationType.SLACK),
+    eventType: slackEventTypeSchema,
+    channelId: z.string(),
+    channelName: z.string().nullable(),
+    userId: z.string(),
+    userName: z.string().nullable(),
+    text: z.string(),
+    timestamp: z.string(),
+    // Keep both names during migration; `threadTs` is the target shared field.
+    threadTs: z.string().nullable().optional(),
+    threadTimestamp: z.string().nullable(),
+    teamId: z.string(),
+    permalink: z.string().nullable(),
+    channelType: z.enum(SlackChannelType).nullable(),
+    blocks: z.array(z.unknown()).nullable(),
+    attachments: z.array(z.unknown()).nullable(),
+    files: z.array(z.unknown()).nullable()
+});
+export const slackMessageTriggerSchema = slackTriggerBaseSchema.extend({
+    eventType: z.literal("message")
+});
+export const slackAppMentionTriggerSchema = slackTriggerBaseSchema.extend({
+    eventType: z.literal("app_mention")
+});
+export const slackReactionAddedTriggerSchema = slackTriggerBaseSchema.extend({
+    eventType: z.literal("reaction_added"),
+    reaction: z.string(),
+    itemType: z.string().nullable(),
+    itemUserId: z.string().nullable(),
+    itemChannelId: z.string().nullable(),
+    itemTimestamp: z.string().nullable()
+});
+export const slackTriggerSchema = z.discriminatedUnion("eventType", [slackMessageTriggerSchema, slackAppMentionTriggerSchema, slackReactionAddedTriggerSchema]);
+// Github Event Data
+export const fileDiffSchema = z.object({
+    filename: z.string(),
+    diff: z.string()
+});
+export const commitSchema = z.object({
+    sha: z.string(),
+    // Keep both names during migration; `message` is the target shared field.
+    message: z.string().optional(),
+    name: z.string(),
+    fileDiffs: z.array(fileDiffSchema)
+});
+export const pullRequestUserSchema = z.object({
+    login: z.string(),
+    email: z.string().optional()
+});
+export const pullRequestRefSchema = z.object({
+    ref: z.string(),
+    sha: z.string()
+});
+export const pullRequestSchema = z.object({
+    id: z.string(),
+    number: z.number(),
+    title: z.string(),
+    body: z.string().optional(),
+    state: z.enum(["open", "closed"]),
+    merged: z.boolean(),
+    head: pullRequestRefSchema,
+    base: pullRequestRefSchema,
+    // Keep both names during migration; `author` is the target shared field.
+    user: pullRequestUserSchema,
+    author: pullRequestUserSchema.optional(),
+    url: z.string().optional()
+});
+export const githubRepositorySchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    owner: z.string(),
+    defaultBranch: z.string()
+});
+export const senderSchema = z.object({
+    login: z.string(),
+    email: z.string().optional()
+});
+const GithubTriggerBaseSchema = z.object({
+    integrationType: z.literal(IntegrationType.GITHUB),
+    username: z.string(),
+    installationId: z.number(),
+    repositoryName: z.string(),
+    repository: githubRepositorySchema,
+    sender: senderSchema
+});
+export const GithubPushTriggerSchema = GithubTriggerBaseSchema.extend({
+    eventType: z.literal(GitHubEventType.PUSH),
+    branch: z.string(),
+    commits: z.array(commitSchema),
+    pullRequest: z.undefined().optional()
+});
+const GithubPRTriggerBaseSchema = GithubTriggerBaseSchema.extend({
+    pullRequest: pullRequestSchema,
+    branch: z.string().optional(),
+    commits: z.array(commitSchema)
+});
+export const GithubPROpenedTriggerSchema = GithubPRTriggerBaseSchema.extend({
+    eventType: z.literal(GitHubEventType.PR_OPENED)
+});
+export const GithubPRSynchronizedTriggerSchema = GithubPRTriggerBaseSchema.extend({
+    eventType: z.literal(GitHubEventType.PR_SYNCHRONIZE)
+});
+export const GithubPRClosedTriggerSchema = GithubPRTriggerBaseSchema.extend({
+    eventType: z.literal(GitHubEventType.PR_CLOSED)
+});
+export const GithubPRMergedTriggerSchema = GithubPRTriggerBaseSchema.extend({
+    eventType: z.literal(GitHubEventType.PR_MERGED)
+});
+export const GithubPRTriggerSchema = z.discriminatedUnion("eventType", [GithubPROpenedTriggerSchema, GithubPRSynchronizedTriggerSchema, GithubPRClosedTriggerSchema, GithubPRMergedTriggerSchema]);
+export const GithubTriggerSchema = z.discriminatedUnion("eventType", [
+    GithubPushTriggerSchema,
+    GithubPROpenedTriggerSchema,
+    GithubPRSynchronizedTriggerSchema,
+    GithubPRClosedTriggerSchema,
+    GithubPRMergedTriggerSchema
+]);
+export const GmailParsedAttachmentSchema = z.object({
+    attachmentId: z.string(),
+    filename: z.string(),
+    mimeType: z.string(),
+    contentId: z.string().optional(),
+    isInline: z.boolean()
+});
+const gmailMessagePayloadSchema = z.object({
+    id: z.string(),
+    threadId: z.string(),
+    subject: z.string(),
+    from: z.string(),
+    to: z.string(),
+    date: z.string(),
+    internalDate: z.string(),
+    messageId: z.string(),
+    body: z.string(),
+    snippet: z.string(),
+    labelIds: z.array(z.string()),
+    attachments: z.array(GmailParsedAttachmentSchema).optional()
+});
+export const LinearWebhookActionSchema = z.enum(["create", "update", "remove"]);
+export const LinearWebhookTypeSchema = z.union([z.literal("Issue"), z.literal("Comment"), z.literal("Project"), z.string()]);
+export const LinearWebhookActorSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string(),
+    url: z.string(),
+    type: z.string()
+});
+export const LinearWebhookStateSchema = z.object({
+    id: z.string(),
+    color: z.string(),
+    name: z.string(),
+    type: z.string()
+});
+export const LinearWebhookTeamSchema = z.object({
+    id: z.string(),
+    key: z.string(),
+    name: z.string()
+});
+export const LinearWebhookAssigneeSchema = z.object({
+    id: z.string(),
+    name: z.string()
+});
+export const LinearWebhookDataSchema = z.object({
+    id: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    number: z.number(),
+    title: z.string(),
+    priority: z.number(),
+    sortOrder: z.number(),
+    prioritySortOrder: z.number(),
+    slaType: z.string(),
+    addedToTeamAt: z.string(),
+    trashed: z.boolean(),
+    labelIds: z.array(z.string()),
+    teamId: z.string(),
+    previousIdentifiers: z.array(z.string()),
+    stateId: z.string(),
+    reactionData: z.array(z.any()),
+    priorityLabel: z.string(),
+    botActor: z.string().optional(),
+    identifier: z.string(),
+    url: z.string(),
+    subscriberIds: z.array(z.string()),
+    state: LinearWebhookStateSchema,
+    team: LinearWebhookTeamSchema,
+    labels: z.array(z.any()),
+    description: z.string().optional(),
+    descriptionData: z.string().optional(),
+    assignee: LinearWebhookAssigneeSchema.optional()
+});
+export const LinearWebhookCommentDataSchema = z
+    .object({
+    id: z.string(),
+    body: z.string().optional(),
+    issueId: z.string().optional()
+})
+    .passthrough();
+export const linearWebhookPayloadSchema = z.object({
+    action: LinearWebhookActionSchema,
+    actor: LinearWebhookActorSchema,
+    createdAt: z.string(),
+    data: LinearWebhookDataSchema,
+    type: LinearWebhookTypeSchema,
+    url: z.string().optional(),
+    organizationId: z.string(),
+    webhookTimestamp: z.number(),
+    webhookId: z.string()
+});
+export const WorkOSWebhookDataSchema = z.record(z.string(), z.any());
+export const workOSWebhookPayloadSchema = z.object({
+    id: z.string(),
+    event: z.string(),
+    data: WorkOSWebhookDataSchema,
+    created_at: z.string()
+});
+// MARK: Canonical Trigger Events
+export const webhookTriggerTypeSchema = z.literal("webhook");
+export const cronTriggerTypeSchema = z.literal("cron");
+export const manualSampleTriggerTypeSchema = z.literal("manual_sample");
+export const TriggerTypeSchema = z.union([
+    slackEventTypeSchema,
+    gitHubEventTypeSchema,
+    linearEventTypeSchema,
+    gmailEventTypeSchema,
+    workOSEventTypeSchema,
+    webhookTriggerTypeSchema,
+    cronTriggerTypeSchema,
+    manualSampleTriggerTypeSchema
+]);
+export const baseTriggerSchema = z.object({
+    integrationType: integrationTypeEnum,
+    eventType: TriggerTypeSchema
+});
+export const gmailTriggerSchema = baseTriggerSchema
+    .extend({
+    integrationType: z.literal(IntegrationType.GMAIL),
+    eventType: gmailEventTypeSchema
+})
+    .merge(gmailMessagePayloadSchema);
+const linearTriggerBaseSchema = z.object({
+    integrationType: z.literal(IntegrationType.LINEAR),
+    action: LinearWebhookActionSchema,
+    actor: LinearWebhookActorSchema,
+    createdAt: z.string(),
+    url: z.string().optional(),
+    organizationId: z.string(),
+    webhookTimestamp: z.number(),
+    webhookId: z.string()
+});
+export const linearIssueCreatedTriggerSchema = linearTriggerBaseSchema.extend({
+    eventType: z.literal("issue.created"),
+    action: z.literal("create"),
+    type: z.literal("Issue"),
+    data: LinearWebhookDataSchema
+});
+export const linearIssueUpdatedTriggerSchema = linearTriggerBaseSchema.extend({
+    eventType: z.literal("issue.updated"),
+    action: z.literal("update"),
+    type: z.literal("Issue"),
+    data: LinearWebhookDataSchema
+});
+export const linearCommentCreatedTriggerSchema = linearTriggerBaseSchema.extend({
+    eventType: z.literal("comment.created"),
+    action: z.literal("create"),
+    type: z.literal("Comment"),
+    data: LinearWebhookCommentDataSchema
+});
+export const linearTriggerSchema = z.discriminatedUnion("eventType", [linearIssueCreatedTriggerSchema, linearIssueUpdatedTriggerSchema, linearCommentCreatedTriggerSchema]);
+export const workOSTriggerUserSchema = z.object({
+    id: z.string(),
+    email: z.string(),
+    firstName: z.string().optional(),
+    lastName: z.string().optional(),
+    emailVerified: z.boolean(),
+    profilePictureUrl: z.string().optional()
+});
+export const workOSTriggerMembershipSchema = z.object({
+    id: z.string(),
+    userId: z.string(),
+    organizationId: z.string(),
+    role: z.object({
+        slug: z.string()
+    }),
+    status: z.string()
+});
+export const workOSTriggerInvitationSchema = z.object({
+    id: z.string(),
+    email: z.string(),
+    organizationId: z.string(),
+    inviterEmail: z.string().optional(),
+    state: z.string(),
+    acceptedAt: z.string().optional()
+});
+export const workOSTriggerOrganizationSchema = z.object({
+    id: z.string(),
+    name: z.string()
+});
+const workOSTriggerBaseSchema = baseTriggerSchema.extend({
+    integrationType: z.literal(IntegrationType.WORKOS),
+    eventType: workOSEventTypeSchema,
+    eventId: z.string(),
+    createdAt: z.string()
+});
+export const workOSUserCreatedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.USER_CREATED),
+    user: workOSTriggerUserSchema
+});
+export const workOSUserUpdatedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.USER_UPDATED),
+    user: workOSTriggerUserSchema
+});
+export const workOSUserDeletedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.USER_DELETED),
+    user: workOSTriggerUserSchema
+});
+export const workOSUserTriggerSchema = z.discriminatedUnion("eventType", [workOSUserCreatedTriggerSchema, workOSUserUpdatedTriggerSchema, workOSUserDeletedTriggerSchema]);
+export const workOSOrganizationMembershipCreatedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.ORGANIZATION_MEMBERSHIP_CREATED),
+    membership: workOSTriggerMembershipSchema
+});
+export const workOSOrganizationMembershipUpdatedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.ORGANIZATION_MEMBERSHIP_UPDATED),
+    membership: workOSTriggerMembershipSchema
+});
+export const workOSOrganizationMembershipDeletedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.ORGANIZATION_MEMBERSHIP_DELETED),
+    membership: workOSTriggerMembershipSchema
+});
+export const workOSMembershipTriggerSchema = z.discriminatedUnion("eventType", [
+    workOSOrganizationMembershipCreatedTriggerSchema,
+    workOSOrganizationMembershipUpdatedTriggerSchema,
+    workOSOrganizationMembershipDeletedTriggerSchema
+]);
+export const workOSInvitationCreatedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.INVITATION_CREATED),
+    invitation: workOSTriggerInvitationSchema,
+    user: workOSTriggerUserSchema.optional()
+});
+export const workOSInvitationAcceptedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.INVITATION_ACCEPTED),
+    invitation: workOSTriggerInvitationSchema,
+    user: workOSTriggerUserSchema.optional()
+});
+export const workOSInvitationResentTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.INVITATION_RESENT),
+    invitation: workOSTriggerInvitationSchema,
+    user: workOSTriggerUserSchema.optional()
+});
+export const workOSInvitationRevokedTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.INVITATION_REVOKED),
+    invitation: workOSTriggerInvitationSchema,
+    user: workOSTriggerUserSchema.optional()
+});
+export const workOSInvitationTriggerSchema = z.discriminatedUnion("eventType", [
+    workOSInvitationCreatedTriggerSchema,
+    workOSInvitationAcceptedTriggerSchema,
+    workOSInvitationResentTriggerSchema,
+    workOSInvitationRevokedTriggerSchema
+]);
+export const workOSOrganizationTriggerSchema = workOSTriggerBaseSchema.extend({
+    eventType: z.literal(WorkOSEventType.ORGANIZATION_CREATED),
+    organization: workOSTriggerOrganizationSchema
+});
+export const workOSTriggerSchema = z.discriminatedUnion("eventType", [
+    workOSUserCreatedTriggerSchema,
+    workOSUserUpdatedTriggerSchema,
+    workOSUserDeletedTriggerSchema,
+    workOSOrganizationMembershipCreatedTriggerSchema,
+    workOSOrganizationMembershipUpdatedTriggerSchema,
+    workOSOrganizationMembershipDeletedTriggerSchema,
+    workOSInvitationCreatedTriggerSchema,
+    workOSInvitationAcceptedTriggerSchema,
+    workOSInvitationResentTriggerSchema,
+    workOSInvitationRevokedTriggerSchema,
+    workOSOrganizationTriggerSchema
+]);
+export const webhookTriggerSchema = baseTriggerSchema.extend({
+    integrationType: z.literal(IntegrationType.WEBHOOK),
+    eventType: webhookTriggerTypeSchema,
+    body: z.record(z.string(), z.unknown()),
+    headers: z.record(z.string(), z.string()),
+    method: z.string()
+});
+export const cronTriggerSchema = baseTriggerSchema.extend({
+    integrationType: z.literal(IntegrationType.CRON_JOB),
+    eventType: cronTriggerTypeSchema,
+    inputId: z.string(),
+    isManualTrigger: z.boolean().optional(),
+    manualContext: z.string().optional()
+});
+export const manualSampleTriggerSchema = baseTriggerSchema.extend({
+    eventType: manualSampleTriggerTypeSchema
+});
+export const TriggerSchema = z.union([
+    slackTriggerSchema,
+    GithubTriggerSchema,
+    gmailTriggerSchema,
+    linearTriggerSchema,
+    workOSTriggerSchema,
+    webhookTriggerSchema,
+    cronTriggerSchema,
+    manualSampleTriggerSchema
+]);
+export function parseTrigger(value) {
+    return TriggerSchema.parse(value);
+}
+export function createManualTrigger(params = {}) {
+    return parseTrigger({
+        integrationType: params.integrationType ?? IntegrationType.TERSE,
+        eventType: "manual_sample"
+    });
+}
+export function formatTriggerForAgent(event) {
+    return formatTriggerForAgentWithPresenter(event);
+}
+export function debugTrigger(event) {
+    return debugTriggerWithPresenter(event);
+}
+export const TriggerArraySchema = z.array(TriggerSchema);
+export const serializedEventSchema = z.object({
+    integrationType: integrationTypeEnum,
+    eventType: TriggerTypeSchema,
+    formattedContent: z.string(),
+    debugLog: z.string(),
+    data: TriggerSchema
+});

package/dist/TriggerPresenters.d.ts

@@ -1,3 +1,8 @@
 import type { Trigger } from "./Triggers.js";
+export interface TriggerDisplay {
+    title: string;
+    subtitle: string;
+}
 export declare function formatTriggerForAgent(event: Trigger): string;
 export declare function debugTrigger(event: Trigger): string;
+export declare function displayTrigger(event: Trigger): TriggerDisplay;

package/dist/TriggerPresenters.js

@@ -2,22 +2,32 @@ import { IntegrationType } from "./Integrations.js";
 const TriggerPresenters = {
     manual_sample: {
         formatForAgent: (event) => `Manual sample event for ${event.integrationType}.`,
-        debug: (event) => `${event.integrationType} ${event.eventType}`
+        debug: (event) => `${event.integrationType} ${event.eventType}`,
+        display: (event) => ({
+            title: `Manual ${event.integrationType} sample`,
+            subtitle: event.eventType
+        })
     },
     [IntegrationType.GITHUB]: {
         formatForAgent: formatGithubTrigger,
-        debug: (event) => `GitHub Event: ${event.eventType} - ${event.repository.owner}/${event.repository.name} - ${event.sender.login}`
+        debug: (event) => `GitHub Event: ${event.eventType} - ${event.repository.owner}/${event.repository.name} - ${event.sender.login}`,
+        display: formatGithubDisplay
     },
     [IntegrationType.SLACK]: {
         formatForAgent: formatSlackTrigger,
         debug: (event) => {
             const isDM = event.channelType === "im";
             return `Slack Event: ${event.eventType} - ${isDM ? "DM" : event.channelName || event.channelId} - ${event.userName || event.userId}`;
-        }
+        },
+        display: formatSlackDisplay
     },
     [IntegrationType.GMAIL]: {
         formatForAgent: formatGmailTrigger,
-        debug: (event) => `Gmail Event: ${event.subject} message ID: ${event.messageId}`
+        debug: (event) => `Gmail Event: ${event.subject} message ID: ${event.messageId}`,
+        display: (event) => ({
+            title: event.subject || "(no subject)",
+            subtitle: `from ${event.from}`
+        })
     },
     [IntegrationType.LINEAR]: {
         formatForAgent: formatLinearTrigger,
@@ -26,23 +36,39 @@ const TriggerPresenters = {
                 return `Linear ${event.type} Event: ${event.data.identifier} - ${event.data.title} (${event.action})`;
             }
             return `Linear ${event.type} Event: Comment on issue ${event.data.issueId || "Unknown"} (${event.action})`;
+        },
+        display: (event) => {
+            if (event.type === "Issue") {
+                return {
+                    title: `${event.data.identifier} ${event.data.title}`,
+                    subtitle: `${event.data.team?.name || "Linear"} · ${event.action} issue`
+                };
+            }
+            return {
+                title: `Comment on ${event.data.issueId || "Unknown issue"}`,
+                subtitle: `${event.actor.name} · ${event.action} comment`
+            };
         }
     },
     [IntegrationType.WORKOS]: {
         formatForAgent: formatWorkOSTrigger,
-        debug: (event) => `WorkOS ${event.eventType}`
+        debug: (event) => `WorkOS ${event.eventType}`,
+        display: formatWorkOSDisplay
     },
     [IntegrationType.WEBHOOK]: {
         formatForAgent: formatWebhookTrigger,
-        debug: (event) => `Webhook Trigger (${event.method})`
+        debug: (event) => `Webhook Trigger (${event.method})`,
+        display: formatWebhookDisplay
     },
     [IntegrationType.CRON_JOB]: {
         formatForAgent: formatCronTrigger,
-        debug: (event) => (event.isManualTrigger ? "Manual Trigger" : "Scheduled Event")
+        debug: (event) => (event.isManualTrigger ? "Manual Trigger" : "Scheduled Event"),
+        display: formatCronDisplay
     },
     [IntegrationType.WEBMONITOR]: {
         formatForAgent: formatWebMonitorTrigger,
-        debug: (event) => `${event.query.slice(0, 80)}${event.query.length > 80 ? "…" : ""}`
+        debug: (event) => `${event.query.slice(0, 80)}${event.query.length > 80 ? "…" : ""}`,
+        display: formatWebMonitorDisplay
     }
 };
 function dispatchPresenter(event, method) {
@@ -77,6 +103,12 @@ export function debugTrigger(event) {
     }
     return dispatchPresenter(event, "debug");
 }
+export function displayTrigger(event) {
+    if (event.eventType === "manual_sample") {
+        return TriggerPresenters.manual_sample.display(event);
+    }
+    return dispatchPresenter(event, "display");
+}
 function formatGithubTrigger(event) {
     const indentMultiline = (text) => text
         .split("\n")
@@ -174,6 +206,122 @@ function formatSlackTrigger(event) {
         : ""}
         `;
 }
+function formatSlackDisplay(event) {
+    const channelLabel = event.channelType === "im" ? "DM" : event.channelName || event.channelId;
+    const actorLabel = event.userName || event.userId;
+    if (event.eventType === "reaction_added") {
+        return {
+            title: `:${event.reaction || "reaction"}: reaction`,
+            subtitle: `${channelLabel} by ${actorLabel}`
+        };
+    }
+    const messageText = event.text?.trim();
+    return {
+        title: messageText && messageText.length > 0 ? truncateForDisplay(messageText, 80) : "(no message text)",
+        subtitle: `${channelLabel} by ${actorLabel}`
+    };
+}
+function truncateForDisplay(value, maxLength) {
+    return value.length > maxLength ? `${value.slice(0, maxLength - 1)}…` : value;
+}
+function formatGithubDisplay(event) {
+    if (event.pullRequest) {
+        return {
+            title: `#${event.pullRequest.number} ${truncateForDisplay(event.pullRequest.title, 80)}`,
+            subtitle: `${event.repository.owner}/${event.repository.name} · ${event.eventType} by ${event.sender.login}`
+        };
+    }
+    if (event.commits.length > 0) {
+        const latestCommit = event.commits[event.commits.length - 1];
+        const commitMessage = latestCommit.message || latestCommit.name || latestCommit.sha.slice(0, 7);
+        return {
+            title: truncateForDisplay(commitMessage, 80),
+            subtitle: `${event.repository.owner}/${event.repository.name} · ${event.commits.length} commit${event.commits.length === 1 ? "" : "s"} on ${event.branch || "branch"}`
+        };
+    }
+    return {
+        title: `${event.repository.owner}/${event.repository.name}`,
+        subtitle: `${event.eventType} by ${event.sender.login}`
+    };
+}
+function formatWorkOSDisplay(event) {
+    if ("user" in event && event.user) {
+        return {
+            title: event.user.email,
+            subtitle: humanizeWorkOSEventType(event.eventType)
+        };
+    }
+    if ("organization" in event && event.organization) {
+        return {
+            title: event.organization.name,
+            subtitle: humanizeWorkOSEventType(event.eventType)
+        };
+    }
+    if ("invitation" in event && event.invitation) {
+        return {
+            title: event.invitation.email,
+            subtitle: humanizeWorkOSEventType(event.eventType)
+        };
+    }
+    if ("membership" in event && event.membership) {
+        return {
+            title: event.membership.role.slug,
+            subtitle: humanizeWorkOSEventType(event.eventType)
+        };
+    }
+    return {
+        title: "WorkOS event",
+        subtitle: humanizeWorkOSEventType(event.eventType)
+    };
+}
+function humanizeWorkOSEventType(eventType) {
+    return eventType.replaceAll(".", " ");
+}
+function formatWebhookDisplay(event) {
+    const bodyPreview = summarizeUnknown(event.body);
+    return {
+        title: bodyPreview || "Webhook trigger",
+        subtitle: event.method
+    };
+}
+function formatCronDisplay(event) {
+    return {
+        title: event.isManualTrigger ? "Manual trigger" : "Scheduled event",
+        subtitle: event.manualContext ? truncateForDisplay(event.manualContext, 80) : event.inputId
+    };
+}
+function formatWebMonitorDisplay(event) {
+    const sourceLabel = firstHost(event.sourceUrls);
+    const outputPreview = typeof event.payload === "string" ? event.payload : typeof event.rawPayload === "string" ? event.rawPayload : "";
+    return {
+        title: sourceLabel ? `Change detected on ${sourceLabel}` : "Web monitor match",
+        subtitle: truncateForDisplay(outputPreview || event.query, 100)
+    };
+}
+function firstHost(urls) {
+    const first = urls[0];
+    if (!first)
+        return null;
+    try {
+        return new URL(first).host;
+    }
+    catch {
+        return first;
+    }
+}
+function summarizeUnknown(value) {
+    if (typeof value === "string") {
+        return truncateForDisplay(value.trim() || "Webhook trigger", 80);
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const preferred = [record.title, record.subject, record.name, record.action, record.type, record.event].find(v => typeof v === "string" && v.trim().length > 0);
+        if (typeof preferred === "string") {
+            return truncateForDisplay(preferred, 80);
+        }
+    }
+    return "Webhook trigger";
+}
 function formatGmailTrigger(event) {
     const attachmentInfo = event.attachments?.map(attachment => `- ${attachment.filename} ${attachment.isInline ? "Inline" : "Attachment"} (${attachment.mimeType})`).join("\n") || "No attachments";
     return `

package/dist/Triggers.d.ts

@@ -2820,6 +2820,7 @@ export declare function createManualTrigger(params?: {
 }): Trigger;
 export declare function formatTriggerForAgent(event: Trigger): string;
 export declare function debugTrigger(event: Trigger): string;
+export declare function displayTrigger(event: Trigger): SerializedEventDisplay;
 export declare const TriggerArraySchema: z.ZodArray<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
     integrationType: z.ZodLiteral<IntegrationType.SLACK>;
     channelId: z.ZodString;
@@ -3496,6 +3497,11 @@ export declare const TriggerArraySchema: z.ZodArray<z.ZodUnion<readonly [z.ZodDi
     integrationType: z.ZodEnum<typeof IntegrationType>;
     eventType: z.ZodLiteral<"manual_sample">;
 }, z.core.$strip>]>>;
+export declare const serializedEventDisplaySchema: z.ZodObject<{
+    title: z.ZodString;
+    subtitle: z.ZodString;
+}, z.core.$strip>;
+export type SerializedEventDisplay = z.infer<typeof serializedEventDisplaySchema>;
 export declare const serializedEventSchema: z.ZodObject<{
     integrationType: z.ZodEnum<typeof IntegrationType>;
     eventType: z.ZodUnion<readonly [z.ZodEnum<{
@@ -3529,6 +3535,10 @@ export declare const serializedEventSchema: z.ZodObject<{
     }>, z.ZodLiteral<"webhook">, z.ZodLiteral<"cron">, z.ZodLiteral<"webmonitor">, z.ZodLiteral<"manual_sample">]>;
     formattedContent: z.ZodString;
     debugLog: z.ZodString;
+    display: z.ZodOptional<z.ZodObject<{
+        title: z.ZodString;
+        subtitle: z.ZodString;
+    }, z.core.$strip>>;
     data: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
         integrationType: z.ZodLiteral<IntegrationType.SLACK>;
         channelId: z.ZodString;