agiagent-dev 2026.1.39 → 2026.1.40

package/dist/gateway/email-trigger-handler.js

@@ -0,0 +1,192 @@
+/**
+ * Email trigger handler for hosted mode.
+ *
+ * When Composio fires a GMAIL_NEW_GMAIL_MESSAGE webhook:
+ * 1. Looks up the hosted user from the Composio user_id
+ * 2. If node connected → runs the AI agent with full tool access so it can
+ *    read the email, decide the correct action (reply vs new email, attach
+ *    resume, etc.), and create the draft via the gmail tool
+ * 3. If node not connected → sends Telegram-only notification
+ */
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { runHostedAgentReply } from "./hosted-agent.js";
+import { getHostedDb, getHostedUserNodeId } from "./hosted-db.js";
+import { getHostedTelegramSession, sendHostedTelegramNotification } from "./hosted-telegram.js";
+const log = createSubsystemLogger("email-trigger");
+/** Try to extract a Gmail message ID from the Composio trigger data. */
+function extractMessageIdFromPayload(data) {
+    for (const key of ["messageId", "message_id", "id", "messageID"]) {
+        const val = data[key];
+        if (typeof val === "string" && val.trim()) {
+            return val.trim();
+        }
+    }
+    for (const outer of ["messageData", "message", "email"]) {
+        const nested = data[outer];
+        if (nested && typeof nested === "object") {
+            const rec = nested;
+            for (const key of ["id", "messageId", "message_id"]) {
+                const val = rec[key];
+                if (typeof val === "string" && val.trim()) {
+                    return val.trim();
+                }
+            }
+        }
+    }
+    return null;
+}
+/** Extract sender from trigger payload (best-effort). */
+function extractSenderFromPayload(data) {
+    for (const key of ["from", "sender", "senderEmail", "sender_email"]) {
+        const val = data[key];
+        if (typeof val === "string" && val.trim()) {
+            return val.trim();
+        }
+    }
+    return "unknown sender";
+}
+/** Extract subject from trigger payload (best-effort). */
+function extractSubjectFromPayload(data) {
+    for (const key of ["subject", "Subject"]) {
+        const val = data[key];
+        if (typeof val === "string" && val.trim()) {
+            return val.trim();
+        }
+    }
+    return "(no subject)";
+}
+// ---------------------------------------------------------------------------
+// AI agent prompt
+// ---------------------------------------------------------------------------
+/**
+ * Build the prompt that instructs the AI agent to handle the incoming email.
+ * The agent has full tool access: gmail (read, draft, send), exec (resume
+ * skills), browser, etc. It decides the best action autonomously.
+ */
+function buildEmailTriggerPrompt(params) {
+    const { messageId, senderHint, subjectHint } = params;
+    const readStep = messageId
+        ? `First, use the gmail tool with action "messages_get" and messageId "${messageId}" to read the full email content.`
+        : `The email metadata: From: ${senderHint}, Subject: ${subjectHint}. Try searching for it with the gmail tool if you need the full content.`;
+    return (`[EMAIL AUTO-DRAFT] A new email has arrived in the user's Gmail inbox.\n\n` +
+        `${readStep}\n\n` +
+        `After reading the email, analyze it carefully and take the appropriate action:\n\n` +
+        `1. **Determine the intent**: Is this a job posting/requirement, a conversation, a newsletter, a notification, etc.?\n\n` +
+        `2. **Determine the recipient**: Read the email body carefully. The reply might NOT go to the sender. ` +
+        `For example, if the email says "send your resume to someone@example.com", the draft should go to that address, not the sender. ` +
+        `Decide whether to:\n` +
+        `   - Create a **reply draft** in the same thread (use gmail drafts_create with messageId)\n` +
+        `   - Create a **new email draft** to a different recipient mentioned in the email (use gmail drafts_create with to + subject)\n\n` +
+        `3. **Job postings / requirements**: If the email contains a job posting, recruiter outreach, or asks for a resume:\n` +
+        `   - Customize the resume for the role using the resume tool (extract -> patch -> apply)\n` +
+        `   - In new bullets you add, bold only the important ATS keywords (tools/platforms/product names), not full sentences\n` +
+        `   - Attach the customized resume to the draft (pass the file path in the attachments array)\n` +
+        `   - Write a professional, concise cover note as the draft body\n\n` +
+        `4. **Regular emails**: For normal conversations, compose a professional reply draft that matches a natural email tone.\n\n` +
+        `5. **Newsletters / notifications / no-reply**: If the email doesn't need a response, do NOT create a draft. ` +
+        `Just respond with a brief note like "No draft needed — this is a notification email."\n\n` +
+        `IMPORTANT:\n` +
+        `- Always use the gmail tool's "drafts_create" action to save drafts — do NOT use "messages_send" or "messages_reply" (those send immediately).\n` +
+        `- Your text response here will be shown to the user on Telegram as a notification. ` +
+        `Briefly tell them what you did (e.g. "Drafted a reply to X about Y" or "Drafted an email to recruiter@co.com with your customized resume attached").`);
+}
+// ---------------------------------------------------------------------------
+// Core handler
+// ---------------------------------------------------------------------------
+/**
+ * Handle a GMAIL_NEW_GMAIL_MESSAGE webhook event.
+ *
+ * Composio V2 payload structure:
+ *   { type, timestamp, log_id, data: { connection_id, connection_nano_id,
+ *     trigger_nano_id, trigger_id, user_id, ...email fields } }
+ */
+export async function handleNewGmailMessage(payload) {
+    const data = payload.data ?? {};
+    // V2: user_id is inside data, not at the top level
+    const userId = (typeof data.user_id === "string" ? data.user_id.trim() : "") || payload.user_id?.trim() || "";
+    if (!userId) {
+        log.warn("webhook missing user_id, cannot route");
+        log.info(`payload keys: ${Object.keys(payload).join(", ")}`);
+        log.info(`payload.data keys: ${Object.keys(data).join(", ")}`);
+        return;
+    }
+    const db = getHostedDb();
+    if (!db) {
+        log.warn("hosted DB unavailable");
+        return;
+    }
+    const user = await db.getUserById(userId);
+    if (!user) {
+        log.warn(`unknown user_id from webhook: ${userId}`);
+        return;
+    }
+    const senderInfo = extractSenderFromPayload(data);
+    const subjectInfo = extractSubjectFromPayload(data);
+    const messageId = extractMessageIdFromPayload(data);
+    log.info(`new email for ${user.name}: from=${senderInfo.slice(0, 60)} ` +
+        `subject=${subjectInfo.slice(0, 60)} msgId=${messageId ?? "?"}`);
+    log.info(`trigger data keys: ${Object.keys(data).join(", ")}`);
+    // Check if user has an active Telegram session with a connected node
+    const telegramSession = getHostedTelegramSession(userId);
+    if (!telegramSession) {
+        log.info(`user ${user.name} has no active Telegram session, skipping`);
+        return;
+    }
+    const { nodeId, userName, sendNodeEvent } = telegramSession;
+    // Check if the node is actually connected
+    const connectedNodeId = getHostedUserNodeId(userId);
+    if (!connectedNodeId) {
+        log.info(`user ${user.name} node not connected, sending notification only`);
+        const msg = `New email received from <b>${escapeHtml(senderInfo)}</b>\n` +
+            `Subject: <b>${escapeHtml(subjectInfo)}</b>\n\n` +
+            `Your device is not connected, so I couldn't draft a reply. ` +
+            `Connect with <code>agiagent connect</code> to enable auto-drafting.`;
+        await sendHostedTelegramNotification(userId, msg);
+        return;
+    }
+    // Node IS connected — let the AI agent handle everything via tools
+    log.info(`running AI agent for email draft — user ${user.name}`);
+    const agentPrompt = buildEmailTriggerPrompt({
+        messageId,
+        senderHint: senderInfo,
+        subjectHint: subjectInfo,
+    });
+    let agentResponse = "";
+    try {
+        agentResponse = await runHostedAgentReply({
+            userId,
+            userName,
+            nodeId,
+            messageText: agentPrompt,
+            senderJid: "email-trigger",
+            chatJid: `email-draft-${userId}`,
+            isGroup: false,
+            sendNodeEvent,
+        });
+    }
+    catch (err) {
+        log.error(`AI agent failed for user ${user.name}: ${String(err)}`);
+        await sendHostedTelegramNotification(userId, `New email from <b>${escapeHtml(senderInfo)}</b> — ` +
+            `<b>${escapeHtml(subjectInfo)}</b>\n\n` +
+            `I tried to process this email but encountered an error. ` +
+            `You can handle it manually in Gmail.`);
+        return;
+    }
+    // Send the AI's response as a Telegram notification.
+    // The AI should have already created the draft via the gmail tool.
+    if (agentResponse?.trim()) {
+        await sendHostedTelegramNotification(userId, agentResponse);
+    }
+    else {
+        await sendHostedTelegramNotification(userId, `New email from <b>${escapeHtml(senderInfo)}</b> — ` +
+            `<b>${escapeHtml(subjectInfo)}</b>\n\n` +
+            `I processed the email but had nothing to report.`);
+    }
+    log.info(`email trigger complete for user ${user.name}`);
+}
+// ---------------------------------------------------------------------------
+// Utility
+// ---------------------------------------------------------------------------
+function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}

package/dist/gateway/hosted-db.d.ts

@@ -27,6 +27,16 @@ export type ComposioConnectedAccountRecord = {
     createdAt: Date;
     updatedAt: Date;
 };
+export type ComposioTriggerRecord = {
+    id: string;
+    userId: string;
+    toolkitSlug: string;
+    triggerSlug: string;
+    triggerId: string;
+    enabled: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+};
 export type HostedDbClient = {
     /** Look up a connection token and return the associated user */
     lookupToken: (token: string) => Promise<{
@@ -65,6 +75,29 @@ export type HostedDbClient = {
         userId: string;
         toolkitSlug: string;
     }) => Promise<void>;
+    /** Upsert a Composio trigger record */
+    upsertComposioTrigger: (params: {
+        userId: string;
+        toolkitSlug: string;
+        triggerSlug: string;
+        triggerId: string;
+    }) => Promise<void>;
+    /** Get a Composio trigger record for a user/toolkit/slug */
+    getComposioTrigger: (params: {
+        userId: string;
+        toolkitSlug: string;
+        triggerSlug: string;
+    }) => Promise<ComposioTriggerRecord | null>;
+    /** Delete a Composio trigger record */
+    deleteComposioTrigger: (params: {
+        userId: string;
+        toolkitSlug: string;
+        triggerSlug: string;
+    }) => Promise<void>;
+    /** Look up a user by their UUID (used to map Composio user_id from webhooks). */
+    getUserById: (userId: string) => Promise<HostedUser | null>;
+    /** Get the connection token record for a user (first match). */
+    getTokenByUserId: (userId: string) => Promise<ConnectionToken | null>;
     /** Close the database connection */
     close: () => Promise<void>;
 };

package/dist/gateway/hosted-db.js

@@ -49,6 +49,19 @@ export async function initHostedDb() {
         updated_at TIMESTAMPTZ DEFAULT now(),
         PRIMARY KEY (user_id, toolkit_slug)
       )
+    `;
+        await sql `
+      CREATE TABLE IF NOT EXISTS composio_triggers (
+        id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+        user_id UUID REFERENCES users(id),
+        toolkit_slug TEXT NOT NULL,
+        trigger_slug TEXT NOT NULL,
+        trigger_id TEXT NOT NULL,
+        enabled BOOLEAN DEFAULT true,
+        created_at TIMESTAMPTZ DEFAULT now(),
+        updated_at TIMESTAMPTZ DEFAULT now(),
+        UNIQUE (user_id, toolkit_slug, trigger_slug)
+      )
     `;
         dbClient = {
             lookupToken: async (token) => {
@@ -208,6 +221,90 @@ export async function initHostedDb() {
           WHERE user_id = ${params.userId} AND toolkit_slug = ${params.toolkitSlug}
         `;
             },
+            upsertComposioTrigger: async (params) => {
+                await sql `
+          INSERT INTO composio_triggers (
+            user_id, toolkit_slug, trigger_slug, trigger_id, updated_at
+          )
+          VALUES (
+            ${params.userId}, ${params.toolkitSlug},
+            ${params.triggerSlug}, ${params.triggerId}, now()
+          )
+          ON CONFLICT (user_id, toolkit_slug, trigger_slug) DO UPDATE SET
+            trigger_id = EXCLUDED.trigger_id,
+            enabled = true,
+            updated_at = now()
+        `;
+            },
+            getComposioTrigger: async (params) => {
+                const rows = await sql `
+          SELECT id, user_id, toolkit_slug, trigger_slug, trigger_id,
+                 enabled, created_at, updated_at
+          FROM composio_triggers
+          WHERE user_id = ${params.userId}
+            AND toolkit_slug = ${params.toolkitSlug}
+            AND trigger_slug = ${params.triggerSlug}
+          LIMIT 1
+        `;
+                if (rows.length === 0) {
+                    return null;
+                }
+                const row = rows[0];
+                return {
+                    id: row.id,
+                    userId: row.user_id,
+                    toolkitSlug: row.toolkit_slug,
+                    triggerSlug: row.trigger_slug,
+                    triggerId: row.trigger_id,
+                    enabled: row.enabled,
+                    createdAt: row.created_at,
+                    updatedAt: row.updated_at,
+                };
+            },
+            deleteComposioTrigger: async (params) => {
+                await sql `
+          DELETE FROM composio_triggers
+          WHERE user_id = ${params.userId}
+            AND toolkit_slug = ${params.toolkitSlug}
+            AND trigger_slug = ${params.triggerSlug}
+        `;
+            },
+            getUserById: async (userId) => {
+                const rows = await sql `
+          SELECT id, name, created_at FROM users WHERE id = ${userId} LIMIT 1
+        `;
+                if (rows.length === 0) {
+                    return null;
+                }
+                return {
+                    id: rows[0].id,
+                    name: rows[0].name,
+                    createdAt: rows[0].created_at,
+                };
+            },
+            getTokenByUserId: async (userId) => {
+                const rows = await sql `
+          SELECT id, user_id, token, whatsapp_account_id, telegram_bot_token,
+                 telegram_owner_id, created_at, last_connected_at
+          FROM connection_tokens
+          WHERE user_id = ${userId}
+          LIMIT 1
+        `;
+                if (rows.length === 0) {
+                    return null;
+                }
+                const row = rows[0];
+                return {
+                    id: row.id,
+                    userId: row.user_id,
+                    token: row.token,
+                    whatsappAccountId: row.whatsapp_account_id,
+                    telegramBotToken: row.telegram_bot_token,
+                    telegramOwnerId: row.telegram_owner_id,
+                    createdAt: row.created_at,
+                    lastConnectedAt: row.last_connected_at,
+                };
+            },
             close: async () => {
                 await sql.end();
                 dbClient = null;

package/dist/gateway/hosted-telegram.d.ts

@@ -27,3 +27,18 @@ export declare function stopHostedTelegramBot(userId: string): Promise<void>;
  * Check if a hosted user has an active Telegram bot.
  */
 export declare function isHostedTelegramBotRunning(userId: string): boolean;
+/**
+ * Get the active Telegram session info for a hosted user.
+ * Returns null if no active bot or bot not running.
+ */
+export declare function getHostedTelegramSession(userId: string): {
+    nodeId: string;
+    userName: string;
+    telegramOwnerId: string | null;
+    sendNodeEvent: (event: string, payload: unknown) => void;
+} | null;
+/**
+ * Send a notification message to a hosted user's Telegram bot.
+ * Sends to the bot owner's DM chat. Returns true if sent, false if bot not available.
+ */
+export declare function sendHostedTelegramNotification(userId: string, text: string): Promise<boolean>;

package/dist/gateway/hosted-telegram.js

@@ -233,3 +233,44 @@ export function isHostedTelegramBotRunning(userId) {
     const session = activeHostedBots.get(userId);
     return session?.running ?? false;
 }
+/**
+ * Get the active Telegram session info for a hosted user.
+ * Returns null if no active bot or bot not running.
+ */
+export function getHostedTelegramSession(userId) {
+    const session = activeHostedBots.get(userId);
+    if (!session?.running) {
+        return null;
+    }
+    return {
+        nodeId: session.nodeId,
+        userName: session.userName,
+        telegramOwnerId: session.telegramOwnerId,
+        sendNodeEvent: session.sendNodeEvent,
+    };
+}
+/**
+ * Send a notification message to a hosted user's Telegram bot.
+ * Sends to the bot owner's DM chat. Returns true if sent, false if bot not available.
+ */
+export async function sendHostedTelegramNotification(userId, text) {
+    const session = activeHostedBots.get(userId);
+    if (!session?.running || !session.telegramOwnerId) {
+        return false;
+    }
+    try {
+        await session.bot.api
+            .sendMessage(Number(session.telegramOwnerId), text, { parse_mode: "HTML" })
+            .catch(async () => {
+            // Fallback to plain text if HTML fails
+            await session.bot.api.sendMessage(Number(session.telegramOwnerId), text);
+        });
+        return true;
+    }
+    catch (err) {
+        log.error(`Failed to send Telegram notification to user ${userId}`, {
+            error: String(err),
+        });
+        return false;
+    }
+}

package/dist/gateway/server-http.js

@@ -4,6 +4,7 @@ import { resolveAgentAvatar } from "../agents/identity-avatar.js";
 import { handleA2uiHttpRequest } from "../canvas-host/a2ui.js";
 import { loadConfig } from "../config/config.js";
 import { handleSlackHttpRequest } from "../slack/http/index.js";
+import { handleComposioWebhookRequest } from "./composio-webhook.js";
 import { handleControlUiAvatarRequest, handleControlUiHttpRequest } from "./control-ui.js";
 import { applyHookMappings } from "./hooks-mapping.js";
 import { extractHookToken, getHookChannelError, normalizeAgentPayload, normalizeHookHeaders, normalizeWakePayload, readJsonBody, resolveHookChannel, resolveHookDeliver, } from "./hooks.js";
@@ -162,6 +163,10 @@ export function createGatewayHttpServer(opts) {
             if (await handleHooksRequest(req, res)) {
                 return;
             }
+            // Composio trigger webhooks (e.g. GMAIL_NEW_GMAIL_MESSAGE)
+            if (await handleComposioWebhookRequest(req, res)) {
+                return;
+            }
             if (await handleToolsInvokeHttpRequest(req, res, {
                 auth: resolvedAuth,
                 trustedProxies,

package/dist/gateway/server-methods/composio.js

@@ -1,6 +1,72 @@
-import { composioCreateConnectedAccountLink, composioGetConnectedAccount, } from "../../infra/composio.js";
+import { composioCreateConnectedAccountLink, composioCreateGmailTrigger, composioDeleteTrigger, composioGetConnectedAccount, } from "../../infra/composio.js";
+import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { getHostedDb, isHostedMode, validateHostedToken } from "../hosted-db.js";
 import { ErrorCodes, errorShape } from "../protocol/index.js";
+const log = createSubsystemLogger("composio-handlers");
+const GMAIL_TRIGGER_SLUG = "GMAIL_NEW_GMAIL_MESSAGE";
+/**
+ * Ensure a Gmail trigger exists for a user. Best-effort — logs errors but
+ * does not throw so it never blocks the link/status response.
+ */
+async function ensureGmailTrigger(userId, connectedAccountId) {
+    const db = getHostedDb();
+    if (!db) {
+        return;
+    }
+    try {
+        const existing = await db.getComposioTrigger({
+            userId,
+            toolkitSlug: "gmail",
+            triggerSlug: GMAIL_TRIGGER_SLUG,
+        });
+        if (existing) {
+            log.info(`gmail trigger already exists for user ${userId}: ${existing.triggerId}`);
+            return;
+        }
+        const { triggerId } = await composioCreateGmailTrigger({ connectedAccountId });
+        await db.upsertComposioTrigger({
+            userId,
+            toolkitSlug: "gmail",
+            triggerSlug: GMAIL_TRIGGER_SLUG,
+            triggerId,
+        });
+        log.info(`created gmail trigger ${triggerId} for user ${userId}`);
+    }
+    catch (err) {
+        log.error(`failed to ensure gmail trigger for user ${userId}: ${String(err)}`);
+    }
+}
+/**
+ * Remove the Gmail trigger for a user. Best-effort.
+ */
+async function removeGmailTrigger(userId) {
+    const db = getHostedDb();
+    if (!db) {
+        return;
+    }
+    try {
+        const record = await db.getComposioTrigger({
+            userId,
+            toolkitSlug: "gmail",
+            triggerSlug: GMAIL_TRIGGER_SLUG,
+        });
+        if (!record) {
+            return;
+        }
+        await composioDeleteTrigger(record.triggerId).catch((err) => {
+            log.warn(`composio delete trigger failed (may already be gone): ${String(err)}`);
+        });
+        await db.deleteComposioTrigger({
+            userId,
+            toolkitSlug: "gmail",
+            triggerSlug: GMAIL_TRIGGER_SLUG,
+        });
+        log.info(`removed gmail trigger for user ${userId}`);
+    }
+    catch (err) {
+        log.error(`failed to remove gmail trigger for user ${userId}: ${String(err)}`);
+    }
+}
 function requireHostedTokenFromClient(client) {
     const token = client?.connect?.auth?.token?.trim();
     if (!token) {
@@ -57,6 +123,8 @@ export const composioHandlers = {
                     statusReason: account.status_reason ?? null,
                 });
                 if (account.status === "ACTIVE") {
+                    // Ensure email trigger is set up for this user
+                    void ensureGmailTrigger(hostedUser.userId, existing.connectedAccountId);
                     respond(true, {
                         alreadyConnected: true,
                         status: account.status,
@@ -146,6 +214,10 @@ export const composioHandlers = {
                 status: account.status,
                 statusReason: account.status_reason ?? null,
             });
+            // Ensure email trigger is set up when status confirmed ACTIVE
+            if (account.status === "ACTIVE") {
+                void ensureGmailTrigger(hostedUser.userId, record.connectedAccountId);
+            }
             respond(true, {
                 linked: true,
                 status: account.status,
@@ -186,6 +258,8 @@ export const composioHandlers = {
             respond(true, { disconnected: false, linked: false });
             return;
         }
+        // Remove the email trigger before disconnecting
+        await removeGmailTrigger(hostedUser.userId);
         await db.deleteComposioConnectedAccount({
             userId: hostedUser.userId,
             toolkitSlug: "gmail",

package/dist/infra/composio.d.ts

@@ -22,6 +22,16 @@ export declare function composioCreateConnectedAccountLink(params: {
 export declare function composioGetConnectedAccount(params: {
     connectedAccountId: string;
 }): Promise<ComposioConnectedAccount>;
+/** Create (or re-enable) a GMAIL_NEW_GMAIL_MESSAGE trigger for a connected account. */
+export declare function composioCreateGmailTrigger(params: {
+    connectedAccountId: string;
+}): Promise<{
+    triggerId: string;
+}>;
+/** Delete a Composio trigger instance. */
+export declare function composioDeleteTrigger(triggerId: string): Promise<void>;
+/** Enable or disable a Composio trigger instance. */
+export declare function composioSetTriggerEnabled(triggerId: string, enabled: boolean): Promise<void>;
 export declare function composioExtractAccessToken(connectedAccount: unknown): {
     accessToken: string;
     expiresAt?: string;

package/dist/infra/composio.js

@@ -97,6 +97,65 @@ function findStringFieldDeep(value, predicate, depth) {
     }
     return null;
 }
+/** Create (or re-enable) a GMAIL_NEW_GMAIL_MESSAGE trigger for a connected account. */
+export async function composioCreateGmailTrigger(params) {
+    const apiKey = requireComposioApiKey();
+    const id = params.connectedAccountId.trim();
+    if (!id) {
+        throw new Error("connectedAccountId required");
+    }
+    const res = await composioFetch("/api/v3/trigger_instances/GMAIL_NEW_GMAIL_MESSAGE/upsert", {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": apiKey,
+        },
+        body: JSON.stringify({
+            connected_account_id: id,
+            trigger_config: {},
+        }),
+    });
+    const payload = (await res.json());
+    if (!payload || typeof payload.trigger_id !== "string") {
+        log.warn(`unexpected trigger upsert response: ${JSON.stringify(payload).slice(0, 500)}`);
+        throw new Error("unexpected composio trigger upsert response");
+    }
+    log.info(`created gmail trigger ${payload.trigger_id} for account ${id}`);
+    return { triggerId: payload.trigger_id };
+}
+/** Delete a Composio trigger instance. */
+export async function composioDeleteTrigger(triggerId) {
+    const apiKey = requireComposioApiKey();
+    const id = triggerId.trim();
+    if (!id) {
+        throw new Error("triggerId required");
+    }
+    await composioFetch(`/api/v3/trigger_instances/manage/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+        headers: { "x-api-key": apiKey },
+    });
+    log.info(`deleted trigger ${id}`);
+}
+/** Enable or disable a Composio trigger instance. */
+export async function composioSetTriggerEnabled(triggerId, enabled) {
+    const apiKey = requireComposioApiKey();
+    const id = triggerId.trim();
+    if (!id) {
+        throw new Error("triggerId required");
+    }
+    await composioFetch(`/api/v3/trigger_instances/manage/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": apiKey,
+        },
+        body: JSON.stringify({ enabled }),
+    });
+    log.info(`trigger ${id} ${enabled ? "enabled" : "disabled"}`);
+}
+// ---------------------------------------------------------------------------
+// Access token extraction
+// ---------------------------------------------------------------------------
 export function composioExtractAccessToken(connectedAccount) {
     // Prefer known nesting when present; fall back to a deep search.
     const record = isRecord(connectedAccount) ? connectedAccount : null;

package/dist/node-host/resume-docx.d.ts

@@ -0,0 +1,21 @@
+export type ResumeDocxExtractMode = "digest" | "full";
+export declare function resumeDocxCheck(): Promise<{
+    ok: boolean;
+    python: string;
+}>;
+export declare function resumeDocxExtract(params: {
+    docxPath: string;
+    mode?: ResumeDocxExtractMode;
+}): Promise<{
+    ok: boolean;
+    mode: string;
+    schema: any;
+}>;
+export declare function resumeDocxApply(params: {
+    inPath: string;
+    outPath: string;
+    patch: unknown;
+}): Promise<{
+    ok: boolean;
+    outPath: string;
+}>;