@rudderhq/server 0.2.10-canary.8 → 0.2.10

package/dist/services/automations.js

@@ -1,15 +1,23 @@
 import crypto from "node:crypto";
 import { and, asc, desc, eq, inArray, isNotNull, isNull, lte, ne, sql } from "drizzle-orm";
 import { agents, organizationSecrets, goals, heartbeatRuns, issues, projects, automationRuns, automations, automationTriggers, chatContextLinks, chatConversations, chatMessages, } from "@rudderhq/db";
+import { chatIssueProposalFromStructuredPayload } from "@rudderhq/shared";
 import { conflict, forbidden, notFound, unauthorized, unprocessable } from "../errors.js";
+import { MAX_ATTACHMENT_BYTES } from "../attachment-types.js";
 import { logger } from "../middleware/logger.js";
 import { issueService } from "./issues.js";
+import { chatService } from "./chats.js";
+import { chatAssistantService, ChatAssistantStreamError } from "./chat-assistant.js";
+import { claimChatGeneration, hasActiveChatGeneration } from "./chat-generation-locks.js";
 import { secretService } from "./secrets.js";
+import { getStorageService } from "../storage/index.js";
 import { validateCron } from "./cron.js";
 import { heartbeatService } from "./heartbeat.js";
 import { queueIssueAssignmentWakeup } from "./issue-assignment-wakeup.js";
 import { logActivity } from "./activity-log.js";
+import { publishLiveEvent } from "./live-events.js";
 import { assertTimeZone, LIVE_HEARTBEAT_RUN_STATUSES, MAX_CATCH_UP_RUNS, nextCronTickInTimeZone, nextResultText, normalizeWebhookTimestampMs, OPEN_ISSUE_STATUSES, } from "./automations.scheduler.js";
+const CHAT_OUTPUT_STALE_RUN_MS = 30 * 60 * 1000;
 function toAutomation(row) {
     return {
         ...row,
@@ -18,8 +26,12 @@ function toAutomation(row) {
 }
 export function automationService(db, deps = {}) {
     const issueSvc = issueService(db);
+    const chatSvc = chatService(db);
+    const storageSvc = deps.storage ?? (deps.chatAssistant ? null : getStorageService());
+    const assistantSvc = deps.chatAssistant ?? chatAssistantService(db, storageSvc ?? undefined);
     const secretsSvc = secretService(db);
     const heartbeat = deps.heartbeat ?? heartbeatService(db);
+    const autoStartChatOutputRuns = deps.autoStartChatOutputRuns ?? true;
     async function getAutomationById(id) {
         return db
             .select()
@@ -142,6 +154,414 @@ export function automationService(db, deps = {}) {
             .where(eq(automationRuns.id, input.runId));
         return conversation.id;
     }
+    function automationChatPrompt(input) {
+        const base = input.automation.description?.trim() || input.automation.title.trim();
+        const context = [
+            `Automation: ${input.automation.title}`,
+            `Trigger source: ${input.source}`,
+        ];
+        if (input.payload && Object.keys(input.payload).length > 0) {
+            context.push(`Trigger payload: ${JSON.stringify(input.payload)}`);
+        }
+        return `${base}\n\n${context.join("\n")}`.trim();
+    }
+    function notifyChatChanged(orgId, conversationId, details) {
+        publishLiveEvent({
+            orgId,
+            type: "activity.logged",
+            payload: {
+                actorType: "system",
+                actorId: "automation-chat-output",
+                action: "chat.message_updated",
+                entityType: "chat",
+                entityId: conversationId,
+                agentId: null,
+                runId: null,
+                details: details ?? null,
+            },
+        });
+    }
+    async function logChatMessageAdded(input) {
+        await logActivity(db, {
+            orgId: input.orgId,
+            actorType: "system",
+            actorId: "automation-chat-output",
+            agentId: input.agentId ?? null,
+            action: "chat.message_added",
+            entityType: "chat",
+            entityId: input.conversationId,
+            details: {
+                messageId: input.message.id,
+                role: input.message.role,
+                kind: input.message.kind,
+                status: input.message.status,
+                source: "automation_chat_output",
+            },
+        });
+    }
+    function automationChatRunMetadata(automation, run, conversationId) {
+        return {
+            automationId: automation.id,
+            automationTitle: automation.title,
+            runId: run.id,
+            links: {
+                automation: `/automations/${automation.id}`,
+                chat: `/messenger/chat/${conversationId}`,
+            },
+        };
+    }
+    function proposedPlanDocumentPayload(structuredPayload) {
+        if (!structuredPayload)
+            return null;
+        const rawDocument = structuredPayload.planDocument
+            && typeof structuredPayload.planDocument === "object"
+            && !Array.isArray(structuredPayload.planDocument)
+            ? structuredPayload.planDocument
+            : structuredPayload.plan && typeof structuredPayload.plan === "object" && !Array.isArray(structuredPayload.plan)
+                ? structuredPayload.plan
+                : null;
+        return rawDocument ? rawDocument : null;
+    }
+    async function attachGeneratedFiles(input) {
+        if (!input.message || !input.generatedAttachments || input.generatedAttachments.length === 0) {
+            return input.message;
+        }
+        const attachments = [];
+        for (const generated of input.generatedAttachments) {
+            if (generated.body.length > MAX_ATTACHMENT_BYTES) {
+                throw new ChatAssistantStreamError(`Generated attachment exceeds ${MAX_ATTACHMENT_BYTES} bytes`, input.message.body, input.generatedAttachments);
+            }
+            const stored = await (storageSvc ?? getStorageService()).putFile({
+                orgId: input.conversation.orgId,
+                namespace: `chats/${input.conversation.id}/generated`,
+                originalFilename: generated.originalFilename,
+                contentType: generated.contentType,
+                body: generated.body,
+            });
+            const attachment = await chatSvc.createAttachment({
+                orgId: input.conversation.orgId,
+                conversationId: input.conversation.id,
+                messageId: input.message.id,
+                provider: stored.provider,
+                objectKey: stored.objectKey,
+                contentType: stored.contentType,
+                byteSize: stored.byteSize,
+                sha256: stored.sha256,
+                originalFilename: stored.originalFilename,
+                createdByAgentId: input.replyingAgentId ?? null,
+                createdByUserId: null,
+            });
+            attachments.push(attachment);
+        }
+        return {
+            ...input.message,
+            attachments: [...(input.message.attachments ?? []), ...attachments],
+        };
+    }
+    async function automationAssistantReplyPersistence(input) {
+        if (input.reply.kind === "issue_proposal") {
+            const proposal = chatIssueProposalFromStructuredPayload(input.reply.structuredPayload);
+            const planDocument = proposedPlanDocumentPayload(input.reply.structuredPayload);
+            const approval = await chatSvc.createProposalApproval(input.conversation.orgId, {
+                type: "chat_issue_creation",
+                requestedByUserId: null,
+                payload: {
+                    chatConversationId: input.conversation.id,
+                    proposedByAgentId: input.reply.replyingAgentId ?? input.conversation.preferredAgentId ?? null,
+                    proposedIssue: proposal,
+                    ...(planDocument ? { planDocument } : {}),
+                },
+            });
+            return {
+                kind: "issue_proposal",
+                approvalId: approval.id,
+                structuredPayload: input.reply.structuredPayload,
+            };
+        }
+        if (input.reply.kind === "operation_proposal") {
+            const approval = await chatSvc.createProposalApproval(input.conversation.orgId, {
+                type: "chat_operation",
+                requestedByUserId: null,
+                payload: {
+                    chatConversationId: input.conversation.id,
+                    operationProposal: input.reply.structuredPayload &&
+                        typeof input.reply.structuredPayload.operationProposal === "object" &&
+                        input.reply.structuredPayload.operationProposal !== null
+                        ? input.reply.structuredPayload.operationProposal
+                        : input.reply.structuredPayload ?? {},
+                },
+            });
+            return {
+                kind: "operation_proposal",
+                approvalId: approval.id,
+                structuredPayload: {
+                    ...(input.reply.structuredPayload ?? {}),
+                    operationProposalState: {
+                        status: "pending",
+                        decisionNote: null,
+                        decidedByUserId: null,
+                        decidedAt: null,
+                    },
+                },
+            };
+        }
+        if (input.reply.kind === "ask_user") {
+            return {
+                kind: "ask_user",
+                approvalId: null,
+                structuredPayload: input.reply.structuredPayload,
+            };
+        }
+        return {
+            kind: "message",
+            approvalId: null,
+            structuredPayload: input.reply.structuredPayload,
+        };
+    }
+    async function expireStaleChatOutputRuns(automation, runId, executor = db) {
+        const staleBefore = new Date(Date.now() - CHAT_OUTPUT_STALE_RUN_MS);
+        const staleRuns = await executor
+            .select({
+            id: automationRuns.id,
+            linkedChatConversationId: automationRuns.linkedChatConversationId,
+        })
+            .from(automationRuns)
+            .where(and(eq(automationRuns.orgId, automation.orgId), eq(automationRuns.automationId, automation.id), ne(automationRuns.id, runId), inArray(automationRuns.status, ["received", "running"]), lte(automationRuns.updatedAt, staleBefore)));
+        for (const staleRun of staleRuns) {
+            if (staleRun.linkedChatConversationId && hasActiveChatGeneration(staleRun.linkedChatConversationId)) {
+                continue;
+            }
+            await executor
+                .update(automationRuns)
+                .set({
+                status: "failed",
+                failureReason: "Automation chat run was interrupted before completion",
+                completedAt: new Date(),
+                updatedAt: new Date(),
+            })
+                .where(eq(automationRuns.id, staleRun.id));
+        }
+    }
+    async function findLiveChatOutputRun(automation, runId, executor = db) {
+        await expireStaleChatOutputRuns(automation, runId, executor);
+        return executor
+            .select()
+            .from(automationRuns)
+            .where(and(eq(automationRuns.orgId, automation.orgId), eq(automationRuns.automationId, automation.id), ne(automationRuns.id, runId), inArray(automationRuns.status, ["received", "running"])))
+            .orderBy(desc(automationRuns.updatedAt), desc(automationRuns.createdAt))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+    }
+    async function loadAutomationChatAssistantInput(conversationId) {
+        const conversation = await chatSvc.getById(conversationId);
+        if (!conversation)
+            throw notFound("Automation chat conversation not found");
+        const enriched = await assistantSvc.enrichConversation(conversation);
+        const messages = (await chatSvc.listMessages(conversationId)).filter((message) => !message.supersededAt);
+        const issueLabels = await issueSvc.listLabels(conversation.orgId);
+        return {
+            conversation: enriched,
+            messages,
+            contextLinks: (enriched.contextLinks ?? []),
+            issueLabels,
+            operatorProfile: null,
+        };
+    }
+    async function executeChatOutputAutomationRun(runId) {
+        const run = await getAutomationRunById(runId);
+        if (!run || run.status !== "running" || !run.linkedChatConversationId)
+            return;
+        const automation = await getAutomationById(run.automationId);
+        if (!automation || automation.outputMode !== "chat_output")
+            return;
+        const conversation = await chatSvc.getById(run.linkedChatConversationId);
+        if (!conversation) {
+            await finalizeRun(run.id, {
+                status: "failed",
+                failureReason: "Automation chat conversation not found",
+                completedAt: new Date(),
+            });
+            return;
+        }
+        const abortController = new AbortController();
+        const releaseGeneration = claimChatGeneration(conversation.id, abortController);
+        if (!releaseGeneration) {
+            await finalizeRun(run.id, {
+                status: "failed",
+                failureReason: "A chat reply is already being generated for this conversation",
+                completedAt: new Date(),
+            });
+            return;
+        }
+        const transcript = [];
+        let assistantDraftBody = "";
+        let assistantProgressMessage = null;
+        let assistantProgressMessageId = null;
+        let userMessage = null;
+        let lastRunProgressTouchMs = 0;
+        const touchRunChatProgress = async (messageId) => {
+            const nowMs = Date.now();
+            if (nowMs - lastRunProgressTouchMs < 15_000)
+                return;
+            lastRunProgressTouchMs = nowMs;
+            await db
+                .update(automationRuns)
+                .set({
+                lastChatMessageId: messageId,
+                updatedAt: new Date(nowMs),
+            })
+                .where(eq(automationRuns.id, run.id));
+        };
+        const persistProgress = async (progressConversation, status = "streaming", body = assistantDraftBody, replyingAgentId = progressConversation.chatRuntime?.runtimeAgentId ?? progressConversation.preferredAgentId ?? null, structuredPayload = null, kind = "message", approvalId = null) => {
+            if (!userMessage?.chatTurnId)
+                return null;
+            const input = {
+                kind,
+                status,
+                body,
+                transcript,
+                structuredPayload,
+                approvalId,
+                replyingAgentId,
+            };
+            if (assistantProgressMessage) {
+                const updated = await chatSvc.updateMessage(progressConversation.id, assistantProgressMessage.id, input);
+                if (updated) {
+                    assistantProgressMessage = updated;
+                    assistantProgressMessageId = assistantProgressMessage.id;
+                    notifyChatChanged(progressConversation.orgId, progressConversation.id, {
+                        messageId: assistantProgressMessage.id,
+                        status,
+                    });
+                    await touchRunChatProgress(assistantProgressMessage.id);
+                    return assistantProgressMessage;
+                }
+            }
+            assistantProgressMessage = await chatSvc.addMessage(progressConversation.id, {
+                orgId: progressConversation.orgId,
+                role: "assistant",
+                kind,
+                status,
+                body,
+                transcript,
+                structuredPayload,
+                approvalId,
+                replyingAgentId,
+                chatTurnId: userMessage.chatTurnId,
+                turnVariant: userMessage.turnVariant,
+            });
+            assistantProgressMessageId = assistantProgressMessage.id;
+            await logChatMessageAdded({
+                orgId: progressConversation.orgId,
+                conversationId: progressConversation.id,
+                message: assistantProgressMessage,
+                agentId: replyingAgentId,
+            });
+            await touchRunChatProgress(assistantProgressMessage.id);
+            return assistantProgressMessage;
+        };
+        try {
+            const prompt = automationChatPrompt({
+                automation,
+                source: run.source,
+                payload: run.triggerPayload,
+            });
+            userMessage = await chatSvc.addUserChatMessage(conversation.id, conversation.orgId, prompt);
+            await logChatMessageAdded({
+                orgId: conversation.orgId,
+                conversationId: conversation.id,
+                message: userMessage,
+            });
+            await finalizeRun(run.id, {
+                startedChatMessageId: userMessage.id,
+                lastChatMessageId: userMessage.id,
+            });
+            const assistantInput = await loadAutomationChatAssistantInput(conversation.id);
+            const streamed = await assistantSvc.streamChatAssistantReply({
+                ...assistantInput,
+                abortSignal: abortController.signal,
+                onAssistantDelta: async (delta) => {
+                    assistantDraftBody = `${assistantDraftBody}${delta}`;
+                    await persistProgress(assistantInput.conversation);
+                },
+                onAssistantState: async () => {
+                    await persistProgress(assistantInput.conversation);
+                },
+                onTranscriptEntry: async (entry) => {
+                    transcript.push(entry);
+                    await persistProgress(assistantInput.conversation);
+                },
+            });
+            const finalStatus = streamed.outcome === "stopped" ? "stopped" : "completed";
+            const finalBody = streamed.outcome === "stopped" ? streamed.partialBody : streamed.reply.body;
+            const finalReplyPersistence = streamed.outcome === "completed"
+                ? await automationAssistantReplyPersistence({
+                    conversation: assistantInput.conversation,
+                    automation,
+                    run,
+                    reply: streamed.reply,
+                })
+                : {
+                    kind: "message",
+                    approvalId: null,
+                    structuredPayload: null,
+                };
+            const finalMessage = await persistProgress(assistantInput.conversation, finalStatus, finalBody, streamed.replyingAgentId, {
+                ...(finalReplyPersistence.structuredPayload ?? {}),
+                automationChatRun: {
+                    ...automationChatRunMetadata(automation, run, conversation.id),
+                    status: streamed.outcome,
+                },
+            }, finalReplyPersistence.kind, finalReplyPersistence.approvalId);
+            const finalMessageWithAttachments = streamed.outcome === "completed"
+                ? await attachGeneratedFiles({
+                    conversation: assistantInput.conversation,
+                    message: finalMessage,
+                    generatedAttachments: streamed.reply.generatedAttachments,
+                    replyingAgentId: streamed.replyingAgentId,
+                })
+                : finalMessage;
+            await finalizeRun(run.id, {
+                status: finalStatus === "completed" ? "completed" : "failed",
+                terminalChatMessageId: finalMessageWithAttachments?.id ?? assistantProgressMessageId,
+                lastChatMessageId: finalMessageWithAttachments?.id ?? assistantProgressMessageId ?? userMessage.id,
+                completedAt: new Date(),
+            });
+        }
+        catch (error) {
+            const partialBody = error instanceof ChatAssistantStreamError ? error.partialBody : "";
+            const failureReason = error instanceof Error ? error.message : String(error);
+            const fallbackBody = partialBody.trim() || "Automation chat run failed before it produced a final response.";
+            const latestConversation = await chatSvc.getById(conversation.id);
+            const failedMessage = await persistProgress((latestConversation ?? conversation), "failed", fallbackBody, automation.assigneeAgentId, {
+                eventType: "automation_chat_run_result",
+                automationId: automation.id,
+                automationTitle: automation.title,
+                runId: run.id,
+                status: "failed",
+                failureReason,
+                links: {
+                    automation: `/automations/${automation.id}`,
+                    chat: `/messenger/chat/${conversation.id}`,
+                },
+            });
+            await finalizeRun(run.id, {
+                status: "failed",
+                failureReason,
+                terminalChatMessageId: failedMessage?.id ?? assistantProgressMessageId,
+                lastChatMessageId: failedMessage?.id ?? assistantProgressMessageId ?? userMessage?.id ?? null,
+                completedAt: new Date(),
+            });
+            logger.warn({ err: error, automationId: automation.id, runId: run.id }, "automation chat output run failed");
+        }
+        finally {
+            releaseGeneration();
+            notifyChatChanged(conversation.orgId, conversation.id, {
+                automationId: automation.id,
+                runId: run.id,
+            });
+        }
+    }
     async function listTriggersForAutomationIds(orgId, automationIds) {
         if (automationIds.length === 0)
             return new Map();
@@ -525,6 +945,46 @@ export function automationService(db, deps = {}) {
                 : undefined;
             let createdIssue = null;
             try {
+                if (input.automation.outputMode === "chat_output") {
+                    const activeRun = await findLiveChatOutputRun(input.automation, createdRun.id, txDb);
+                    if (activeRun && input.automation.concurrencyPolicy !== "always_enqueue") {
+                        const status = input.automation.concurrencyPolicy === "skip_if_active" ? "skipped" : "coalesced";
+                        const updated = await finalizeRun(createdRun.id, {
+                            status,
+                            linkedChatConversationId: activeRun.linkedChatConversationId,
+                            coalescedIntoRunId: activeRun.id,
+                            completedAt: triggeredAt,
+                        }, txDb);
+                        await updateAutomationTouchedState({
+                            automationId: input.automation.id,
+                            triggerId: input.trigger?.id ?? null,
+                            triggeredAt,
+                            status,
+                            nextRunAt,
+                        }, txDb);
+                        return await getAutomationRunById(createdRun.id, txDb) ?? updated ?? createdRun;
+                    }
+                    const conversationId = await resolveAutomationRunChatConversationId({
+                        automation: input.automation,
+                        runId: createdRun.id,
+                        executor: txDb,
+                    });
+                    if (!conversationId) {
+                        throw new Error("Failed to create automation chat conversation");
+                    }
+                    const updated = await finalizeRun(createdRun.id, {
+                        status: "running",
+                        linkedChatConversationId: conversationId,
+                    }, txDb);
+                    await updateAutomationTouchedState({
+                        automationId: input.automation.id,
+                        triggerId: input.trigger?.id ?? null,
+                        triggeredAt,
+                        status: "running",
+                        nextRunAt,
+                    }, txDb);
+                    return await getAutomationRunById(createdRun.id, txDb) ?? updated ?? createdRun;
+                }
                 const activeIssue = await findLiveExecutionIssue(input.automation, txDb);
                 if (activeIssue && input.automation.concurrencyPolicy !== "always_enqueue") {
                     const status = input.automation.concurrencyPolicy === "skip_if_active" ? "skipped" : "coalesced";
@@ -687,6 +1147,7 @@ export function automationService(db, deps = {}) {
                         triggerId: input.trigger?.id ?? null,
                         source: run.source,
                         status: run.status,
+                        outputMode: input.automation.outputMode,
                     },
                 });
             }
@@ -694,11 +1155,17 @@ export function automationService(db, deps = {}) {
                 logger.warn({ err, automationId: input.automation.id, runId: run.id }, "failed to log automated run");
             }
         }
+        if (autoStartChatOutputRuns && input.automation.outputMode === "chat_output" && run.status === "running") {
+            void executeChatOutputAutomationRun(run.id).catch((err) => {
+                logger.warn({ err, automationId: input.automation.id, runId: run.id }, "automation chat output worker failed");
+            });
+        }
         return run;
     }
     return {
         get: getAutomationById,
         getTrigger: getTriggerById,
+        executeChatOutputAutomationRun,
         list: async (orgId) => {
             const rows = await db
                 .select()