terse-types 0.0.76 → 0.1.0

package/dist/ApiRouteBuilder.d.ts

@@ -94,6 +94,10 @@ export declare const ApiRoutes: {
         INTEGRATIONS: string;
         CAMPAIGNS: string;
     };
+    RESEND: {
+        INTEGRATIONS: string;
+        TEMPLATES: string;
+    };
     AGENTS: {
         LIST: string;
         RECENT: string;

package/dist/ApiRoutes.json

@@ -94,6 +94,10 @@
         "INTEGRATIONS": "/heyreach/integrations",
         "CAMPAIGNS": "/heyreach/campaigns"
     },
+    "RESEND": {
+        "INTEGRATIONS": "/resend/integrations",
+        "TEMPLATES": "/resend/templates"
+    },
     "AGENTS": {
         "LIST": "/agents",
         "RECENT": "/agents/recent",

package/dist/Configs.d.ts

@@ -24,7 +24,8 @@ export declare enum ConfigType {
     SNOWFLAKE_OUTPUT = "snowflake_output",
     WEBHOOK_INPUT = "webhook_input",
     WEBMONITOR = "webmonitor",
-    HEY_REACH_INPUT = "hey_reach_input"
+    HEY_REACH_INPUT = "hey_reach_input",
+    RESEND_OUTPUT = "resend_output"
 }
 export declare const configTypeEnum: z.ZodEnum<typeof ConfigType>;
 export declare const frequencyUnitSchema: z.ZodEnum<{
@@ -233,6 +234,14 @@ export declare const HeyReachInputConfigMetadata: {
     readonly isInput: true;
     readonly isOutput: false;
 };
+export declare const ResendOutputConfigMetadata: {
+    readonly configType: ConfigType.RESEND_OUTPUT;
+    readonly name: "Resend";
+    readonly description: "Send transactional email using published Resend templates";
+    readonly integrationType: IntegrationType.RESEND;
+    readonly isInput: false;
+    readonly isOutput: true;
+};
 export type ConfigDetailsMap = Record<ConfigType, ConfigDetails>;
 export declare const CONFIG_DETAILS: ConfigDetailsMap;
 export declare const SlackEventType: {
@@ -939,6 +948,18 @@ export declare class SnowflakeOutputConfig extends BaseConfigInstance<Integratio
     isComplete(): boolean;
     formatForAgent(): string;
 }
+export declare const ResendOutputConfigSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.RESEND>;
+    configType: z.ZodLiteral<ConfigType.RESEND_OUTPUT>;
+}, z.core.$strip>;
+export type ResendOutputConfigData = z.infer<typeof ResendOutputConfigSchema>;
+export type ResendOutputConfigInstance = ResendOutputConfigData & ConfigBehavior;
+export declare class ResendOutputConfig extends BaseConfigInstance<IntegrationType.RESEND, ConfigType.RESEND_OUTPUT> implements ResendOutputConfigInstance {
+    constructor(integrationId: string);
+    isComplete(): boolean;
+    formatForAgent(): string;
+}
 export declare const WebhookInputConfigSchema: z.ZodObject<{
     integrationId: z.ZodLiteral<"system">;
     integrationType: z.ZodLiteral<IntegrationType.WEBHOOK>;
@@ -1237,6 +1258,10 @@ export declare const configDataSchema: z.ZodUnion<readonly [z.ZodObject<{
         readonly LEAD_TAG_UPDATED: "LEAD_TAG_UPDATED";
     }>;
     campaignIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.RESEND>;
+    configType: z.ZodLiteral<ConfigType.RESEND_OUTPUT>;
 }, z.core.$strip>]>;
 export type ConfigData = z.infer<typeof configDataSchema>;
 /** Configs that can serve as triggers (event sources). */
@@ -1485,6 +1510,10 @@ export declare const skillConfigDataSchema: z.ZodUnion<readonly [z.ZodObject<{
     integrationId: z.ZodString;
     integrationType: z.ZodLiteral<IntegrationType.SNOWFLAKE>;
     configType: z.ZodLiteral<ConfigType.SNOWFLAKE_OUTPUT>;
+}, z.core.$strip>, z.ZodObject<{
+    integrationId: z.ZodString;
+    integrationType: z.ZodLiteral<IntegrationType.RESEND>;
+    configType: z.ZodLiteral<ConfigType.RESEND_OUTPUT>;
 }, z.core.$strip>]>;
 export type SkillConfigData = z.infer<typeof skillConfigDataSchema>;
 export declare function isConfigComplete(config: ConfigData | undefined): boolean;
@@ -1515,6 +1544,7 @@ export type ConfigMetadataMap = EnsureExhaustiveMetadata<{
     [ConfigType.WEBHOOK_INPUT]: typeof WebhookInputConfig;
     [ConfigType.WEBMONITOR]: typeof WebMonitorConfig;
     [ConfigType.HEY_REACH_INPUT]: typeof HeyReachInputConfig;
+    [ConfigType.RESEND_OUTPUT]: typeof ResendOutputConfig;
 }>;
 export declare const CONFIG_METADATA: ConfigMetadataMap;
 export {};

package/dist/Configs.js

@@ -26,6 +26,7 @@ export var ConfigType;
     ConfigType["WEBHOOK_INPUT"] = "webhook_input";
     ConfigType["WEBMONITOR"] = "webmonitor";
     ConfigType["HEY_REACH_INPUT"] = "hey_reach_input";
+    ConfigType["RESEND_OUTPUT"] = "resend_output";
 })(ConfigType || (ConfigType = {}));
 export const configTypeEnum = z.enum(ConfigType);
 export const frequencyUnitSchema = z.enum(["hour", "day", "week"]);
@@ -222,6 +223,14 @@ export const HeyReachInputConfigMetadata = {
     isInput: true,
     isOutput: false
 };
+export const ResendOutputConfigMetadata = {
+    configType: ConfigType.RESEND_OUTPUT,
+    name: "Resend",
+    description: "Send transactional email using published Resend templates",
+    integrationType: IntegrationType.RESEND,
+    isInput: false,
+    isOutput: true
+};
 export const CONFIG_DETAILS = {
     [ConfigType.GMAIL]: GmailConfigMetadata,
     [ConfigType.GMAIL_OUTPUT]: GmailOutputConfigMetadata,
@@ -246,7 +255,8 @@ export const CONFIG_DETAILS = {
     [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfigMetadata,
     [ConfigType.WEBHOOK_INPUT]: WebhookInputConfigMetadata,
     [ConfigType.WEBMONITOR]: WebMonitorConfigMetadata,
-    [ConfigType.HEY_REACH_INPUT]: HeyReachInputConfigMetadata
+    [ConfigType.HEY_REACH_INPUT]: HeyReachInputConfigMetadata,
+    [ConfigType.RESEND_OUTPUT]: ResendOutputConfigMetadata
 };
 // MARK: Event Types — specific events within each integration trigger
 export const SlackEventType = {
@@ -917,6 +927,21 @@ export class SnowflakeOutputConfig extends BaseConfigInstance {
         return parts.join("\n");
     }
 }
+export const ResendOutputConfigSchema = ConfigInstanceSchema.extend({
+    integrationType: z.literal(IntegrationType.RESEND),
+    configType: z.literal(ConfigType.RESEND_OUTPUT)
+});
+export class ResendOutputConfig extends BaseConfigInstance {
+    constructor(integrationId) {
+        super(integrationId, IntegrationType.RESEND, ConfigType.RESEND_OUTPUT);
+    }
+    isComplete() {
+        return !!this.integrationId;
+    }
+    formatForAgent() {
+        return `Type: Resend Output\nIntegration ID: ${this.integrationId}`;
+    }
+}
 export const WebhookInputConfigSchema = ConfigInstanceSchema.extend({
     integrationId: z.literal("system"),
     integrationType: z.literal(IntegrationType.WEBHOOK),
@@ -1032,7 +1057,8 @@ export const configDataSchema = z.union([
     SnowflakeOutputConfigSchema,
     WebhookInputConfigSchema,
     WebMonitorConfigSchema,
-    HeyReachInputConfigSchema
+    HeyReachInputConfigSchema,
+    ResendOutputConfigSchema
 ]);
 /** Configs that can serve as triggers (event sources). */
 export const triggerConfigDataSchema = z.union([
@@ -1063,7 +1089,8 @@ export const skillConfigDataSchema = z.union([
     MemoryConfigSchema,
     WorkOSOutputConfigSchema,
     AttioOutputConfigSchema,
-    SnowflakeOutputConfigSchema
+    SnowflakeOutputConfigSchema,
+    ResendOutputConfigSchema
 ]);
 export function isConfigComplete(config) {
     if (!config) {
@@ -1090,6 +1117,7 @@ export function isConfigComplete(config) {
         case ConfigType.DATADOG:
         case ConfigType.WORKOS_OUTPUT:
         case ConfigType.SNOWFLAKE_OUTPUT:
+        case ConfigType.RESEND_OUTPUT:
             return !!config.integrationId;
         case ConfigType.GITHUB:
             return (config.repositoryIds?.length ?? 0) > 0;
@@ -1253,6 +1281,8 @@ export function formatConfigForAgent(config) {
         }
         case ConfigType.SNOWFLAKE_OUTPUT:
             return `Type: Snowflake Output\nIntegration ID: ${config.integrationId}`;
+        case ConfigType.RESEND_OUTPUT:
+            return `Type: Resend Output\nIntegration ID: ${config.integrationId}`;
         case ConfigType.WEBHOOK_INPUT:
             return "Type: Webhook Trigger";
         case ConfigType.WEBMONITOR: {
@@ -1293,5 +1323,6 @@ export const CONFIG_METADATA = {
     [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfig,
     [ConfigType.WEBHOOK_INPUT]: WebhookInputConfig,
     [ConfigType.WEBMONITOR]: WebMonitorConfig,
-    [ConfigType.HEY_REACH_INPUT]: HeyReachInputConfig
+    [ConfigType.HEY_REACH_INPUT]: HeyReachInputConfig,
+    [ConfigType.RESEND_OUTPUT]: ResendOutputConfig
 };

package/dist/Integrations.d.ts

@@ -2,6 +2,7 @@ import * as z from "zod";
 export declare enum IntegrationType {
     GITHUB = "github",
     HEY_REACH = "hey_reach",
+    RESEND = "resend",
     GMAIL = "gmail",
     LINEAR = "linear",
     SLACK = "slack",
@@ -18,6 +19,12 @@ export declare enum IntegrationType {
     WEBMONITOR = "webmonitor"
 }
 export declare const integrationTypeEnum: z.ZodEnum<typeof IntegrationType>;
+export declare const BUILT_IN_INTEGRATION_TYPES: readonly [IntegrationType.TERSE, IntegrationType.CRON_JOB, IntegrationType.WEBHOOK, IntegrationType.WEBMONITOR];
+export type BuiltInIntegrationType = (typeof BUILT_IN_INTEGRATION_TYPES)[number];
+export type ExternalIntegrationType = Exclude<IntegrationType, BuiltInIntegrationType>;
+export declare function isBuiltInIntegrationType(type: IntegrationType): type is BuiltInIntegrationType;
+export declare function isExternalIntegrationType(type: IntegrationType): type is ExternalIntegrationType;
+export declare const EXTERNAL_INTEGRATION_TYPES: readonly ExternalIntegrationType[];
 export interface IntegrationDetails {
     type: IntegrationType;
     name: string;
@@ -137,6 +144,13 @@ export declare const HeyReachIntegrationMetadata: {
     readonly isInput: true;
     readonly isOutput: false;
 };
+export declare const ResendIntegrationMetadata: {
+    readonly type: IntegrationType.RESEND;
+    readonly name: "Resend";
+    readonly description: "Send transactional email using published Resend templates";
+    readonly isInput: false;
+    readonly isOutput: true;
+};
 export type IntegrationMetadataMap = Record<IntegrationType, IntegrationDetails>;
 export declare const INTEGRATION_METADATA: IntegrationMetadataMap;
 export declare const IntegrationInstanceSchema: z.ZodObject<{
@@ -169,6 +183,7 @@ export declare const InstallationOptionsSchemas: {
     readonly webhook: z.ZodObject<{}, z.core.$strict>;
     readonly webmonitor: z.ZodObject<{}, z.core.$strict>;
     readonly hey_reach: z.ZodObject<{}, z.core.$strict>;
+    readonly resend: z.ZodObject<{}, z.core.$strict>;
 };
 export type InstallationOptionsFor<T extends IntegrationType> = z.infer<(typeof InstallationOptionsSchemas)[T]>;
 export declare const SlackIntegrationSchema: z.ZodObject<{
@@ -212,6 +227,34 @@ export declare const HeyReachIntegrationSchema: z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>;
 export type HeyReachIntegration = z.infer<typeof HeyReachIntegrationSchema>;
+export declare const ResendIntegrationSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ResendIntegration = z.infer<typeof ResendIntegrationSchema>;
+export declare const ResendTemplateVariableSchema: z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+    }>;
+    fallbackValue: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+export type ResendTemplateVariable = z.infer<typeof ResendTemplateVariableSchema>;
+export declare const ResendTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    alias: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    status: z.ZodString;
+    variables: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+        }>;
+        fallbackValue: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ResendTemplate = z.infer<typeof ResendTemplateSchema>;
 export declare const LaunchDarklyIntegrationSchema: z.ZodObject<{
     id: z.ZodString;
     email: z.ZodOptional<z.ZodEmail>;

package/dist/Integrations.js

@@ -4,6 +4,7 @@ export var IntegrationType;
 (function (IntegrationType) {
     IntegrationType["GITHUB"] = "github";
     IntegrationType["HEY_REACH"] = "hey_reach";
+    IntegrationType["RESEND"] = "resend";
     IntegrationType["GMAIL"] = "gmail";
     IntegrationType["LINEAR"] = "linear";
     IntegrationType["SLACK"] = "slack";
@@ -20,6 +21,15 @@ export var IntegrationType;
     IntegrationType["WEBMONITOR"] = "webmonitor";
 })(IntegrationType || (IntegrationType = {}));
 export const integrationTypeEnum = z.enum(IntegrationType);
+export const BUILT_IN_INTEGRATION_TYPES = [IntegrationType.TERSE, IntegrationType.CRON_JOB, IntegrationType.WEBHOOK, IntegrationType.WEBMONITOR];
+const builtInIntegrationTypes = new Set(BUILT_IN_INTEGRATION_TYPES);
+export function isBuiltInIntegrationType(type) {
+    return builtInIntegrationTypes.has(type);
+}
+export function isExternalIntegrationType(type) {
+    return !isBuiltInIntegrationType(type);
+}
+export const EXTERNAL_INTEGRATION_TYPES = Object.values(IntegrationType).filter(isExternalIntegrationType);
 // Metadata objects - using const objects instead of classes
 export const GmailIntegrationMetadata = {
     type: IntegrationType.GMAIL,
@@ -133,6 +143,13 @@ export const HeyReachIntegrationMetadata = {
     isInput: true,
     isOutput: false
 };
+export const ResendIntegrationMetadata = {
+    type: IntegrationType.RESEND,
+    name: "Resend",
+    description: "Send transactional email using published Resend templates",
+    isInput: false,
+    isOutput: true
+};
 export const INTEGRATION_METADATA = {
     [IntegrationType.GMAIL]: GmailIntegrationMetadata,
     [IntegrationType.NOTION]: NotionIntegrationMetadata,
@@ -149,7 +166,8 @@ export const INTEGRATION_METADATA = {
     [IntegrationType.SNOWFLAKE]: SnowflakeIntegrationMetadata,
     [IntegrationType.WEBHOOK]: WebhookIntegrationMetadata,
     [IntegrationType.WEBMONITOR]: WebMonitorIntegrationMetadata,
-    [IntegrationType.HEY_REACH]: HeyReachIntegrationMetadata
+    [IntegrationType.HEY_REACH]: HeyReachIntegrationMetadata,
+    [IntegrationType.RESEND]: ResendIntegrationMetadata
 };
 // MARK: Integration Details
 export const IntegrationInstanceSchema = z.object({
@@ -179,7 +197,8 @@ export const InstallationOptionsSchemas = {
     [IntegrationType.SNOWFLAKE]: NoInstallationOptionsSchema,
     [IntegrationType.WEBHOOK]: NoInstallationOptionsSchema,
     [IntegrationType.WEBMONITOR]: NoInstallationOptionsSchema,
-    [IntegrationType.HEY_REACH]: NoInstallationOptionsSchema
+    [IntegrationType.HEY_REACH]: NoInstallationOptionsSchema,
+    [IntegrationType.RESEND]: NoInstallationOptionsSchema
 };
 export const SlackIntegrationSchema = IntegrationInstanceSchema.extend({
     teamId: z.string().optional(),
@@ -207,6 +226,19 @@ export const PosthogIntegrationSchema = IntegrationInstanceSchema.extend({
     orgName: z.string().optional()
 });
 export const HeyReachIntegrationSchema = IntegrationInstanceSchema;
+export const ResendIntegrationSchema = IntegrationInstanceSchema;
+export const ResendTemplateVariableSchema = z.object({
+    key: z.string(),
+    type: z.enum(["string", "number"]),
+    fallbackValue: z.union([z.string(), z.number()]).nullable()
+});
+export const ResendTemplateSchema = z.object({
+    id: z.string(),
+    alias: z.string().nullable(),
+    name: z.string(),
+    status: z.string(),
+    variables: z.array(ResendTemplateVariableSchema)
+});
 export const LaunchDarklyIntegrationSchema = IntegrationInstanceSchema.extend({
     email: z.email().optional(),
     tokenName: z.string().optional()

package/dist/InvalidationKeys.d.ts

@@ -27,6 +27,7 @@ export declare const workosIntegrationsKey: () => readonly [string];
 export declare const attioIntegrationsKey: () => readonly [string];
 export declare const snowflakeIntegrationsKey: () => readonly [string];
 export declare const heyReachIntegrationsKey: () => readonly [string];
+export declare const resendIntegrationsKey: () => readonly [string];
 export declare const attioObjectsKey: (integrationId: string | null | undefined) => readonly [string, string] | null;
 export declare const allRunHistoryKey: (params?: GetRunHistoryParams) => readonly [string, string] | readonly [string];
 export declare const runHistoryKey: (agentId: string, params?: GetRunHistoryParams) => readonly [string, string, string] | readonly [string, string];

package/dist/InvalidationKeys.js

@@ -73,6 +73,7 @@ export const snowflakeIntegrationsKey = () => {
 export const heyReachIntegrationsKey = () => {
     return ["heyReachIntegrations"];
 };
+export const resendIntegrationsKey = () => ["resendIntegrations"];
 export const attioObjectsKey = (integrationId) => {
     if (!integrationId) {
         return null;

package/dist/Tools.d.ts

@@ -8863,6 +8863,90 @@ export declare const memoryTool: {
         result: z.ZodString;
     }, z.core.$strip>;
 };
+export declare const resendSendTemplateInputSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    templateId: z.ZodString;
+    to: z.ZodArray<z.ZodEmail>;
+    variables: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    subject: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    replyTo: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+    cc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEmail>>>;
+    bcc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEmail>>>;
+    idempotencyKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resendSendTemplateOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        integration: z.ZodEnum<typeof import("./Integrations.js").IntegrationType>;
+        target: z.ZodString;
+        details: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        step_id: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            error: "error";
+            approve: "approve";
+            create: "create";
+            update: "update";
+            delete: "delete";
+            read: "read";
+        }>;
+        isReadOnly: z.ZodOptional<z.ZodBoolean>;
+        output_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            output_item_id: z.ZodString;
+            output_item_type: z.ZodEnum<typeof import("./Configs.js").ConfigType>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    emailId: z.ZodString;
+    templateId: z.ZodString;
+    to: z.ZodArray<z.ZodString>;
+    summary: z.ZodString;
+}, z.core.$strip>;
+export declare const resendSendTemplateTool: {
+    name: "resend_send_template";
+    description: string;
+    inputSchema: z.ZodObject<{
+        integrationId: z.ZodString;
+        templateId: z.ZodString;
+        to: z.ZodArray<z.ZodEmail>;
+        variables: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        subject: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        replyTo: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+        cc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEmail>>>;
+        bcc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEmail>>>;
+        idempotencyKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    outputSchema: z.ZodObject<{
+        success: z.ZodBoolean;
+        actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            action: z.ZodString;
+            integration: z.ZodEnum<typeof import("./Integrations.js").IntegrationType>;
+            target: z.ZodString;
+            details: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+            step_id: z.ZodOptional<z.ZodString>;
+            type: z.ZodEnum<{
+                error: "error";
+                approve: "approve";
+                create: "create";
+                update: "update";
+                delete: "delete";
+                read: "read";
+            }>;
+            isReadOnly: z.ZodOptional<z.ZodBoolean>;
+            output_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                output_item_id: z.ZodString;
+                output_item_type: z.ZodEnum<typeof import("./Configs.js").ConfigType>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        emailId: z.ZodString;
+        templateId: z.ZodString;
+        to: z.ZodArray<z.ZodString>;
+        summary: z.ZodString;
+    }, z.core.$strip>;
+};
 export declare const ToolDefinitions: {
     readonly linear_create_ticket: {
         name: "linear_create_ticket";
@@ -14387,6 +14471,50 @@ export declare const ToolDefinitions: {
             result: z.ZodString;
         }, z.core.$strip>;
     };
+    readonly resend_send_template: {
+        name: "resend_send_template";
+        description: string;
+        inputSchema: z.ZodObject<{
+            integrationId: z.ZodString;
+            templateId: z.ZodString;
+            to: z.ZodArray<z.ZodEmail>;
+            variables: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            subject: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            replyTo: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+            cc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEmail>>>;
+            bcc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEmail>>>;
+            idempotencyKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        outputSchema: z.ZodObject<{
+            success: z.ZodBoolean;
+            actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                action: z.ZodString;
+                integration: z.ZodEnum<typeof import("./Integrations.js").IntegrationType>;
+                target: z.ZodString;
+                details: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+                step_id: z.ZodOptional<z.ZodString>;
+                type: z.ZodEnum<{
+                    error: "error";
+                    approve: "approve";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    read: "read";
+                }>;
+                isReadOnly: z.ZodOptional<z.ZodBoolean>;
+                output_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    output_item_id: z.ZodString;
+                    output_item_type: z.ZodEnum<typeof import("./Configs.js").ConfigType>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+            emailId: z.ZodString;
+            templateId: z.ZodString;
+            to: z.ZodArray<z.ZodString>;
+            summary: z.ZodString;
+        }, z.core.$strip>;
+    };
 };
 export type ToolName = keyof typeof ToolDefinitions;
 export type ToolDefinitionByName<TName extends ToolName> = (typeof ToolDefinitions)[TName];

package/dist/Tools.js

@@ -225,7 +225,8 @@ export const notionReadablePropertyValueSchema = z.union([
     z.array(notionFileReferenceSchema),
     notionLooseObjectSchema
 ]);
-export const notionPageBlockSchema = z.lazy(() => z.object({
+export const notionPageBlockSchema = z
+    .lazy(() => z.object({
     id: z.string(),
     type: z.string(),
     object: z.string(),
@@ -250,7 +251,8 @@ export const notionPageBlockSchema = z.lazy(() => z.object({
     page_id: z.string().optional(),
     database_id: z.string().optional(),
     children: z.array(notionPageBlockSchema).optional()
-}));
+}))
+    .meta({ id: "NotionBlock" });
 export const notionPageQueryMetadataSchema = z.object({
     page_id: z.string(),
     object: z.string(),
@@ -2792,6 +2794,30 @@ export const memoryTool = defineTool({
     inputSchema: memoryInputSchema,
     outputSchema: memoryOutputSchema
 });
+export const resendSendTemplateInputSchema = z.object({
+    integrationId: z.string().describe("Connected Resend integration ID"),
+    templateId: z.string().describe("Published template ID or alias"),
+    to: z.array(z.email()).min(1).max(50).describe("Recipient email addresses"),
+    variables: z.record(z.string(), z.union([z.string(), z.number()])).describe("Template variables keyed exactly as defined by the template"),
+    from: z.string().nullable().optional().describe("Optional sender override; omit when the template defines one"),
+    subject: z.string().nullable().optional().describe("Optional subject override; omit when the template defines one"),
+    replyTo: z.email().nullable().optional().describe("Optional reply-to override"),
+    cc: z.array(z.email()).nullable().optional().describe("Optional CC recipients"),
+    bcc: z.array(z.email()).nullable().optional().describe("Optional BCC recipients"),
+    idempotencyKey: z.string().max(256).nullable().optional().describe("Optional idempotency key, retained by Resend for 24 hours")
+});
+export const resendSendTemplateOutputSchema = toolOutputBaseSchema.extend({
+    emailId: z.string(),
+    templateId: z.string(),
+    to: z.array(z.string()),
+    summary: z.string()
+});
+export const resendSendTemplateTool = defineTool({
+    name: "resend_send_template",
+    description: "Send a published Resend email template. Supply every required template variable without a fallback value.",
+    inputSchema: resendSendTemplateInputSchema,
+    outputSchema: resendSendTemplateOutputSchema
+});
 export const ToolDefinitions = {
     [linearCreateTicketTool.name]: linearCreateTicketTool,
     [linearUpdateTicketTool.name]: linearUpdateTicketTool,
@@ -2873,7 +2899,8 @@ export const ToolDefinitions = {
     [webExtractTool.name]: webExtractTool,
     [webResearchTool.name]: webResearchTool,
     [imageEditTool.name]: imageEditTool,
-    [memoryTool.name]: memoryTool
+    [memoryTool.name]: memoryTool,
+    [resendSendTemplateTool.name]: resendSendTemplateTool
 };
 export const toolsWithIntegrationId = new Set(Object.entries(ToolDefinitions)
     .filter(([, def]) => {

package/dist/TriggerDefinition.d.ts

@@ -0,0 +1,34 @@
+import type { z } from "zod";
+import type { IntegrationType } from "./Integrations.js";
+export declare function defineTrigger<S extends z.ZodType>(definition: Omit<ConcreteTriggerDefinition<S>, "kind">): ConcreteTriggerDefinition<S>;
+export declare function defineTriggerUnion(definition: Omit<UnionTriggerDefinition, "kind">): UnionTriggerDefinition;
+export interface TriggerDisplay {
+    title: string;
+    subtitle: string;
+}
+export type TriggerPrintHints = {
+    readonly typeParams?: string;
+    readonly aliasArgs?: string;
+    readonly fieldOverrides?: Readonly<Record<string, string>>;
+    readonly imports?: readonly string[];
+};
+export type TriggerPresenter<T> = {
+    formatForAgent(trigger: T): string;
+    debug(trigger: T): string;
+    display(trigger: T): TriggerDisplay;
+};
+export type ConcreteTriggerDefinition<S extends z.ZodType = z.ZodType> = {
+    readonly kind: "concrete";
+    readonly integration: IntegrationType;
+    readonly schema: S;
+    readonly eventTypes: readonly string[];
+    readonly printHints?: TriggerPrintHints;
+    readonly presenter?: TriggerPresenter<z.infer<S>>;
+};
+export type UnionTriggerDefinition = {
+    readonly kind: "union";
+    readonly integration: IntegrationType;
+    readonly members: readonly string[];
+    readonly presenter?: TriggerPresenter<unknown>;
+};
+export type TriggerDefinition = ConcreteTriggerDefinition | UnionTriggerDefinition;

package/dist/TriggerDefinition.js

@@ -0,0 +1,6 @@
+export function defineTrigger(definition) {
+    return { kind: "concrete", ...definition };
+}
+export function defineTriggerUnion(definition) {
+    return { kind: "union", ...definition };
+}

package/dist/TriggerPresenters.d.ts

@@ -1,9 +1,39 @@
-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;
+import type { z } from "zod";
+import type { TriggerDisplay } from "./TriggerDefinition.js";
+import type { AttioTrigger, CronTrigger, GithubTrigger, GmailTrigger, HeyReachTrigger, LinearTrigger, ManualSampleTrigger, WebMonitorTrigger, WebhookTrigger, WorkOSTrigger, slackTriggerSchema } from "./Triggers.js";
+export type { TriggerDisplay } from "./TriggerDefinition.js";
+export declare function formatManualSampleTrigger(event: ManualSampleTrigger): string;
+export declare function debugManualSampleTrigger(event: ManualSampleTrigger): string;
+export declare function displayManualSampleTrigger(event: ManualSampleTrigger): TriggerDisplay;
+export declare function formatGithubTrigger(event: GithubTrigger): string;
+export declare function debugGithubTrigger(event: GithubTrigger): string;
+export declare function formatGithubDisplay(event: GithubTrigger): TriggerDisplay;
+export declare function formatSlackTrigger(event: SlackTriggerEvent): string;
+export declare function debugSlackTrigger(event: SlackTriggerEvent): string;
+export declare function formatSlackDisplay(event: SlackTriggerEvent): TriggerDisplay;
+export declare function formatGmailTrigger(event: GmailTrigger): string;
+export declare function debugGmailTrigger(event: GmailTrigger): string;
+export declare function formatGmailDisplay(event: GmailTrigger): TriggerDisplay;
+export declare function formatLinearTrigger(event: LinearTrigger): string;
+export declare function debugLinearTrigger(event: LinearTrigger): string;
+export declare function formatLinearDisplay(event: LinearTrigger): TriggerDisplay;
+export declare function formatWorkOSTrigger(event: WorkOSTrigger): string;
+export declare function debugWorkOSTrigger(event: WorkOSTrigger): string;
+export declare function formatWorkOSDisplay(event: WorkOSTrigger): TriggerDisplay;
+export declare function formatHeyReachTrigger(event: HeyReachTrigger): string;
+export declare function debugHeyReachTrigger(event: HeyReachTrigger): string;
+export declare function formatHeyReachDisplay(event: HeyReachTrigger): TriggerDisplay;
+export declare function formatAttioTrigger(event: AttioTrigger): string;
+export declare function debugAttioTrigger(event: AttioTrigger): string;
+export declare function formatAttioDisplay(event: AttioTrigger): TriggerDisplay;
 export declare function humanizeAttioEventType(eventType: string): string;
+export declare function formatWebhookTrigger(event: WebhookTrigger): string;
+export declare function debugWebhookTrigger(event: WebhookTrigger): string;
+export declare function formatWebhookDisplay(event: WebhookTrigger): TriggerDisplay;
+export declare function formatCronTrigger(event: CronTrigger): string;
+export declare function debugCronTrigger(event: CronTrigger): string;
+export declare function formatCronDisplay(event: CronTrigger): TriggerDisplay;
+export declare function formatWebMonitorTrigger(event: WebMonitorTrigger): string;
+export declare function debugWebMonitorTrigger(event: WebMonitorTrigger): string;
+export declare function formatWebMonitorDisplay(event: WebMonitorTrigger): TriggerDisplay;
+type SlackTriggerEvent = z.infer<typeof slackTriggerSchema>;