terse-types 0.0.76 → 0.0.77

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/AttioRecordFlatten.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Collapses a single Attio value entry (or nested structure) toward primitives /
+ * simple objects, matching the shape produced for generated Attio tool outputs.
+ */
+export declare function flattenAttioLeafValue(value: unknown): unknown;
+/**
+ * Flattens one attribute’s raw value (often an array of interaction rows from the REST API).
+ * @param preferArray When true, keep all entries as an array; when false, use the first entry only.
+ */
+export declare function flattenAttioAttributeValue(rawValue: unknown, preferArray: boolean): unknown;
+/**
+ * Flattens `record.values` from Attio’s GET record / webhook enrichment payload.
+ */
+export declare function flattenAttioRecordValues(values: Record<string, unknown>, isMultiValueAttribute: (attributeSlug: string) => boolean): Record<string, unknown>;
+/**
+ * Slug-only heuristic when object attribute metadata is unavailable (e.g. Attio webhook triggers).
+ * Prefer {@link flattenAttioRecordValues} with object-aware multi-value info from codegen when possible.
+ */
+export declare function isProbablyAttioMultiValueAttributeSlug(attributeSlug: string): boolean;

package/dist/AttioRecordFlatten.js

@@ -0,0 +1,71 @@
+/** Keys Attio nests on attribute timeline entries (not the semantic payload). */
+const ATTIO_VALUE_METADATA_KEYS = new Set([
+    "active_from",
+    "active_until",
+    "attribute_type",
+    "created_by_actor"
+]);
+/**
+ * Collapses a single Attio value entry (or nested structure) toward primitives /
+ * simple objects, matching the shape produced for generated Attio tool outputs.
+ */
+export function flattenAttioLeafValue(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value))
+        return value.map(entry => flattenAttioLeafValue(entry));
+    if (typeof value !== "object")
+        return value;
+    const rawObject = value;
+    if (typeof rawObject.full_name === "string")
+        return rawObject.full_name;
+    if (typeof rawObject.email_address === "string")
+        return rawObject.email_address;
+    if (typeof rawObject.domain === "string")
+        return rawObject.domain;
+    if (typeof rawObject.phone_number === "string")
+        return rawObject.phone_number;
+    if ("value" in rawObject)
+        return flattenAttioLeafValue(rawObject.value);
+    const dataEntries = Object.entries(rawObject).filter(([key]) => !ATTIO_VALUE_METADATA_KEYS.has(key));
+    if (dataEntries.length === 0)
+        return rawObject;
+    if (dataEntries.length === 1)
+        return flattenAttioLeafValue(dataEntries[0][1]);
+    return Object.fromEntries(dataEntries.map(([key, entryValue]) => [key, flattenAttioLeafValue(entryValue)]));
+}
+/**
+ * Flattens one attribute’s raw value (often an array of interaction rows from the REST API).
+ * @param preferArray When true, keep all entries as an array; when false, use the first entry only.
+ */
+export function flattenAttioAttributeValue(rawValue, preferArray) {
+    if (!Array.isArray(rawValue))
+        return flattenAttioLeafValue(rawValue);
+    const flattened = rawValue.map(entry => flattenAttioLeafValue(entry)).filter(entry => entry !== undefined);
+    return preferArray ? flattened : flattened[0];
+}
+/**
+ * Flattens `record.values` from Attio’s GET record / webhook enrichment payload.
+ */
+export function flattenAttioRecordValues(values, isMultiValueAttribute) {
+    const flattenedValues = {};
+    for (const [attributeSlug, rawValue] of Object.entries(values)) {
+        flattenedValues[attributeSlug] = flattenAttioAttributeValue(rawValue, isMultiValueAttribute(attributeSlug));
+    }
+    return flattenedValues;
+}
+/**
+ * Slug-only heuristic when object attribute metadata is unavailable (e.g. Attio webhook triggers).
+ * Prefer {@link flattenAttioRecordValues} with object-aware multi-value info from codegen when possible.
+ */
+export function isProbablyAttioMultiValueAttributeSlug(attributeSlug) {
+    const slug = attributeSlug.toLowerCase();
+    return (slug === "email_addresses" ||
+        slug === "domains" ||
+        slug === "phone_numbers" ||
+        slug === "social_profiles" ||
+        slug === "links" ||
+        slug === "tags" ||
+        slug.endsWith("_addresses") ||
+        slug.endsWith("_ids"));
+}

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",
@@ -137,6 +138,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 +177,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 +221,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";
@@ -133,6 +134,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 +157,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 +188,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 +217,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/OrganizationMetadata.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const organizationMetadataSchema: z.ZodObject<{
+    stripeCustomerId: z.ZodString;
+    runExecutionBlocked: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>, z.ZodTransform<boolean, string | boolean | undefined>>;
+}, z.core.$strip>;
+export type OrganizationMetadata = z.infer<typeof organizationMetadataSchema>;

package/dist/OrganizationMetadata.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+// Can be serialized a string, supports deserialization
+const booleanMetadataSchema = z
+    .union([z.boolean(), z.string()])
+    .optional()
+    .transform(value => value === true || value === "true");
+export const organizationMetadataSchema = z.object({
+    stripeCustomerId: z.string(),
+    runExecutionBlocked: booleanMetadataSchema
+});

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

@@ -2792,6 +2792,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 +2897,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]) => {