@rudderhq/server 0.7.15 → 0.7.18

package/dist/routes/chats.stream-routes.js

@@ -1,4 +1,4 @@
-import { addChatMessageSchema, chatClientCheckpointSchema, chatInlineAnnotationsFromStructuredPayload, convertChatToIssueSchema, createChatAttachmentMetadataSchema, createChatContextLinkSchema, createChatFirstTurnSchema, resolveChatOperationProposalSchema, setChatProjectContextSchema, stopChatGenerationSchema, } from "@rudderhq/shared";
+import { addChatMessageSchema, chatClientCheckpointSchema, chatInlineAnnotationsFromStructuredPayload, convertChatToIssueSchema, createChatAttachmentMetadataSchema, createChatContextLinkSchema, createChatFirstTurnSchema, resolveChatOperationProposalSchema, setChatProjectContextSchema, } from "@rudderhq/shared";
 import { coalesceChatTranscriptTextEntries, withChatTranscriptGenerationProvenance, } from "@rudderhq/shared/chat-transcript-provenance";
 import multer from "multer";
 import { randomUUID } from "node:crypto";
@@ -8,13 +8,15 @@ import { logger } from "../middleware/logger.js";
 import { validate } from "../middleware/validate.js";
 import { chatAssistantErrorForLog } from "../services/chat-assistant.helpers.js";
 import { CHAT_ASSISTANT_USER_ERROR_MESSAGE, ChatAssistantStreamError, userVisiblePartialBodyFromError } from "../services/chat-assistant.js";
-import { cancelActiveChatGeneration, claimChatGeneration, createChatRuntimeControlCoordinator, getActiveChatGeneration, setActiveChatGenerationId, } from "../services/chat-generation-locks.js";
+import { claimChatGeneration, createChatRuntimeControlCoordinator, getActiveChatGeneration, setActiveChatGenerationId, } from "../services/chat-generation-locks.js";
 import { hashChatGenerationBody } from "../services/chat-generation-protocol.js";
+import { replayChatStreamMessage } from "../services/chat-message-mutation-fingerprint.js";
 import { logActivity } from "../services/index.js";
 import { assertCompanyAccess, getActorInfo } from "./authz.js";
 import { wakeIssueAssigneeAfterChatConversion } from "./chat-issue-assignment-wakeup.js";
 import { chatRuntimeSnapshot } from "./chats.runtime-controls.js";
-import { CHAT_ASSISTANT_RECOVERABLE_FAILURE_FALLBACK_MESSAGE, CHAT_ASSISTANT_STOPPED_FALLBACK_MESSAGE, createChatStreamFileStaging, createStartingChatGenerationGate, normalizeMultipartFirstTurnBody, normalizeMultipartMessageBody, outputAdmissionClosed, resolveStoppedAssistantState, startingChatGenerationGates, withMergedChatMessageAttachments, } from "./chats.stream-support.js";
+import { registerChatStopRoute } from "./chats.stop-route.js";
+import { CHAT_ASSISTANT_RECOVERABLE_FAILURE_FALLBACK_MESSAGE, CHAT_ASSISTANT_STOPPED_FALLBACK_MESSAGE, createChatStreamFileStaging, createStartingChatGenerationGate, normalizeMultipartFirstTurnBody, normalizeMultipartMessageBody, outputAdmissionClosed, persistChatStreamUserMessageBeforeGeneration, resolveStoppedAssistantState, startingChatGenerationGates, withMergedChatMessageAttachments, } from "./chats.stream-support.js";
 import { registerChatUserStateRoutes } from "./chats.user-state-routes.js";
 export function registerChatStreamRoutes(ctx) {
     const { router, db, storage, svc, assistantSvc, agentsSvc, issuesSvc, projectsSvc, goalsSvc, access, operatorProfiles, heartbeat, assertConversationAccess, assertChatLocalMutationAllowed, assertSideChatMutationAllowed, touchSideChat, boardUserId, assertCanAssignTasks, runSingleFileUpload, runMessageFileUpload, isMultipartRequest, uploadedMessageFiles, validateUploadedMessageFiles, preflightChatDraft, logChatMessagesAdded, assertContextLinksBelongToCompany, turnContextFromUserMessage, addUserMessage, inlineAnnotations, storeUserMessageFiles, cleanupStoredUserMessageFiles, storeQueuedAnnotationFiles, cleanupUncommittedQueuedAnnotationFiles, startChatTitleGeneration, attachFilesToUserMessage, loadAssistantInput, chatReplyingAgentId, assertCanConvertIssueProposal, persistAssistantReply, linkChatRunMessages, attachGeneratedFilesToPartialMessage, persistPartialAssistantMessage, recoverableFailurePayload, recoverableFailureBody, writeStreamEvent, queueRequestActor, wakeServerQueue, wakeTerminalProjector, } = ctx;
@@ -75,6 +77,25 @@ export function registerChatStreamRoutes(ctx) {
             });
             return;
         }
+        const clientMutationId = parsedBody.data.clientMutationId ?? null;
+        const clientMutationFingerprint = await replayChatStreamMessage({
+            atomicFirstTurn: Boolean(atomicFirstTurn),
+            clientMutationId,
+            body: parsedBody.data.body,
+            editUserMessageId: parsedBody.data.editUserMessageId,
+            inlineAnnotationsProvided,
+            inlineAnnotations: parsedBody.data.inlineAnnotations,
+            modelOverride: parsedBody.data.modelOverride,
+            effortOverride: parsedBody.data.effortOverride,
+            files: messageFiles,
+            orgId: conversation.orgId,
+            conversationId: conversation.id,
+            lookup: svc.getUserMessageMutationByClientMutationId,
+            response: res,
+            writeStreamEvent,
+        });
+        if (clientMutationFingerprint === undefined)
+            return;
         const preparedAnnotations = !atomicFirstTurn && inlineAnnotationsProvided
             ? await inlineAnnotations.prepare({
                 orgId: conversation.orgId,
@@ -107,7 +128,7 @@ export function registerChatStreamRoutes(ctx) {
         if (!runtimeSnapshot)
             throw new Error("Chat runtime snapshot is unavailable");
         const abortController = new AbortController();
-        const releaseGeneration = claimChatGeneration(conversation.id, abortController, null);
+        const releaseGeneration = claimChatGeneration(conversation.id, abortController, null, clientMutationId);
         if (!releaseGeneration) {
             if (parsedBody.data.editUserMessageId) {
                 res.status(409).json({ error: "Stop the current response before editing this message" });
@@ -117,14 +138,22 @@ export function registerChatStreamRoutes(ctx) {
                 res.status(409).json({ error: "A chat reply is already being generated for this conversation" });
                 return;
             }
-            const clientMutationId = `stream:${randomUUID()}`;
+            const activeGeneration = getActiveChatGeneration(conversation.id);
+            if (clientMutationId && activeGeneration?.clientMutationId === clientMutationId) {
+                throw conflict("This message is already being sent. Try again shortly.", {
+                    code: "chat_send_in_progress",
+                    phase: "message_acceptance",
+                });
+            }
+            const queueClientMutationId = clientMutationId ?? `stream:${randomUUID()}`;
             const storedQueueFiles = await storeQueuedAnnotationFiles(conversation, messageFiles);
             let queuedResult;
             try {
                 queuedResult = await svc.createQueuedMessageWithStagedAttachments({
                     orgId: conversation.orgId,
                     conversationId: conversation.id,
-                    clientMutationId,
+                    clientMutationId: queueClientMutationId,
+                    mutationFingerprint: clientMutationFingerprint ?? undefined,
                     runtimeSnapshotVersion: 1,
                     expectedGenerationId: getActiveChatGeneration(conversation.id)?.generationId ?? null,
                     requestActor: queueRequestActor(req),
@@ -152,10 +181,10 @@ export function registerChatStreamRoutes(ctx) {
                 });
             }
             catch (error) {
-                await cleanupUncommittedQueuedAnnotationFiles(conversation.orgId, clientMutationId, storedQueueFiles);
+                await cleanupUncommittedQueuedAnnotationFiles(conversation.orgId, queueClientMutationId, storedQueueFiles);
                 throw error;
             }
-            await cleanupUncommittedQueuedAnnotationFiles(conversation.orgId, clientMutationId, queuedResult.cleanupAttachments);
+            await cleanupUncommittedQueuedAnnotationFiles(conversation.orgId, queueClientMutationId, queuedResult.cleanupAttachments);
             const item = queuedResult.item;
             const queuedAnnotations = (item.payload.inlineAnnotations ?? []);
             await logActivity(db, {
@@ -209,22 +238,45 @@ export function registerChatStreamRoutes(ctx) {
         }
         const startupGate = createStartingChatGenerationGate();
         startingChatGenerationGates.set(conversation.id, startupGate);
-        if (queuedMessageId) {
-            try {
-                await svc.assertQueuedMessageClaimedForDelivery({
-                    conversationId: conversation.id,
-                    itemId: queuedMessageId,
-                    body: parsedBody.data.body,
-                });
-            }
-            catch (error) {
-                startupGate.resolveGeneration(null);
-                startingChatGenerationGates.delete(conversation.id);
-                releaseGeneration();
-                await stagedMessageFiles.cleanup();
-                throw error;
-            }
+        const messagePersistence = await persistChatStreamUserMessageBeforeGeneration({
+            atomicFirstTurn,
+            queuedMessageId,
+            conversation: conversation,
+            body: parsedBody.data.body,
+            editUserMessageId: parsedBody.data.editUserMessageId ?? null,
+            preparedAnnotations,
+            inlineAnnotationsProvided,
+            clientMutationId,
+            clientMutationFingerprint,
+            svc,
+            addUserMessage,
+            actor,
+            startupGate,
+            releaseGeneration,
+            stagedMessageFiles,
+        });
+        if (messagePersistence.kind === "error") {
+            logger.warn({ err: chatAssistantErrorForLog(messagePersistence.error), conversationId: conversation.id }, "chat user-message persistence failed before generation");
+            res.status(201);
+            res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
+            res.setHeader("Cache-Control", "no-cache, no-transform");
+            res.setHeader("X-Accel-Buffering", "no");
+            writeStreamEvent(res, { type: "error", error: CHAT_ASSISTANT_USER_ERROR_MESSAGE, messageId: messagePersistence.messageId });
+            res.end();
+            return;
+        }
+        if (messagePersistence.kind === "replayed") {
+            res.status(200);
+            res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
+            res.setHeader("Cache-Control", "no-cache, no-transform");
+            res.setHeader("X-Accel-Buffering", "no");
+            writeStreamEvent(res, { type: "ack", userMessage: messagePersistence.message });
+            writeStreamEvent(res, { type: "final", messages: [] });
+            res.end();
+            return;
         }
+        let { userMessagePersisted, committedUserMessageId } = messagePersistence;
+        const persistedUserMessage = messagePersistence.userMessage;
         let generation = null;
         try {
             const createdGeneration = await svc.createGeneration(conversation.orgId, conversation.id);
@@ -237,42 +289,39 @@ export function registerChatStreamRoutes(ctx) {
             startingChatGenerationGates.delete(conversation.id);
             releaseGeneration();
             await stagedMessageFiles.cleanup();
-            if (atomicFirstTurn) {
-                const failurePayload = recoverableFailurePayload(error, null);
-                const failureBody = recoverableFailureBody(failurePayload) || CHAT_ASSISTANT_RECOVERABLE_FAILURE_FALLBACK_MESSAGE;
-                const failedMessage = await svc.addMessage(conversation.id, {
-                    orgId: conversation.orgId,
-                    role: "assistant",
-                    kind: "message",
-                    status: "failed",
-                    body: failureBody,
-                    structuredPayload: failurePayload,
-                    replyingAgentId: conversation.preferredAgentId,
-                    chatTurnId: atomicFirstTurn.userMessage.chatTurnId,
-                });
-                await logChatMessagesAdded(conversation, [failedMessage], {
-                    actorType: "system",
-                    actorId: "chat-assistant",
-                    agentId: conversation.preferredAgentId,
-                });
-                res.status(201);
-                res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
-                res.setHeader("Cache-Control", "no-cache, no-transform");
-                res.setHeader("X-Accel-Buffering", "no");
-                writeStreamEvent(res, {
-                    type: "ack",
-                    conversation: atomicFirstTurn.conversation,
-                    userMessage: atomicFirstTurn.userMessage,
-                });
-                writeStreamEvent(res, {
-                    type: "error",
-                    error: failureBody,
-                    messageId: failedMessage.id,
-                });
-                res.end();
-                return;
-            }
-            throw error;
+            const failurePayload = recoverableFailurePayload(error, null);
+            const failureBody = recoverableFailureBody(failurePayload) || CHAT_ASSISTANT_RECOVERABLE_FAILURE_FALLBACK_MESSAGE;
+            const failedMessage = await svc.addMessage(conversation.id, {
+                orgId: conversation.orgId,
+                role: "assistant",
+                kind: "message",
+                status: "failed",
+                body: failureBody,
+                structuredPayload: failurePayload,
+                replyingAgentId: conversation.preferredAgentId,
+                chatTurnId: persistedUserMessage.chatTurnId,
+            });
+            await logChatMessagesAdded(conversation, [failedMessage], {
+                actorType: "system",
+                actorId: "chat-assistant",
+                agentId: conversation.preferredAgentId,
+            });
+            res.status(201);
+            res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
+            res.setHeader("Cache-Control", "no-cache, no-transform");
+            res.setHeader("X-Accel-Buffering", "no");
+            writeStreamEvent(res, {
+                type: "ack",
+                ...(atomicFirstTurn ? { conversation: atomicFirstTurn.conversation } : {}),
+                userMessage: persistedUserMessage,
+            });
+            writeStreamEvent(res, {
+                type: "error",
+                error: failureBody,
+                messageId: failedMessage.id,
+            });
+            res.end();
+            return;
         }
         if (abortController.signal.aborted && startupGate.stopRequested) {
             await startupGate.stopApplied;
@@ -282,8 +331,6 @@ export function registerChatStreamRoutes(ctx) {
         const transcript = [];
         let assistantProgressMessageId = null;
         let activeChatRunId = null;
-        let userMessagePersisted = Boolean(atomicFirstTurn);
-        let committedUserMessageId = atomicFirstTurn?.userMessage.id ?? null;
         let generationTerminalStatus = "failed";
         let generationWaitingForNetwork = false;
         let admittedAssistantBody = "";
@@ -382,16 +429,7 @@ export function registerChatStreamRoutes(ctx) {
         res.setHeader("X-Accel-Buffering", "no");
         res.flushHeaders();
         try {
-            let userMessage = atomicFirstTurn?.userMessage ?? await addUserMessage(conversation, parsedBody.data.body, actor, parsedBody.data.editUserMessageId ?? null, {
-                provided: inlineAnnotationsProvided,
-                prepared: preparedAnnotations,
-                storedAttachments: stagedMessageFiles.files,
-                onPersisted: (messageId) => {
-                    userMessagePersisted = true;
-                    committedUserMessageId = messageId;
-                    stagedMessageFiles.markCommitted();
-                },
-            });
+            let userMessage = persistedUserMessage;
             userMessagePersisted = true;
             committedUserMessageId = userMessage.id;
             stagedMessageFiles.markCommitted();
@@ -957,237 +995,7 @@ export function registerChatStreamRoutes(ctx) {
             advanced: checkpoint.advanced,
         });
     });
-    router.post("/chats/:id/messages/stream/stop", async (req, res) => {
-        const parsed = stopChatGenerationSchema.safeParse(req.body ?? {});
-        if (!parsed.success) {
-            res.status(400).json({ error: "Invalid chat Stop request", details: parsed.error.issues });
-            return;
-        }
-        const conversation = await assertConversationAccess(req, req.params.id);
-        if (!conversation) {
-            res.status(404).json({ error: "Chat conversation not found" });
-            return;
-        }
-        assertChatLocalMutationAllowed(conversation);
-        await assertSideChatMutationAllowed(req, conversation);
-        const controlActionId = parsed.data.controlActionId ?? randomUUID();
-        const startupGate = startingChatGenerationGates.get(conversation.id) ?? null;
-        let startupStopRequested = false;
-        let startupInterruptRequested = false;
-        try {
-            let active = getActiveChatGeneration(conversation.id);
-            if (active && !active.generationId && startupGate) {
-                startupStopRequested = true;
-                startupGate.stopRequested = true;
-                startupInterruptRequested = cancelActiveChatGeneration(conversation.id);
-                const startupGenerationId = await startupGate.generationReady;
-                active = startupGenerationId ? getActiveChatGeneration(conversation.id) : null;
-                if (!startupGenerationId) {
-                    res.json({
-                        stopped: startupInterruptRequested,
-                        controlActionId,
-                        generationId: null,
-                        disposition: startupInterruptRequested ? "startup_cancelled" : "interrupted_unverified",
-                    });
-                    return;
-                }
-            }
-            const latestActiveGeneration = active?.generationId
-                ? null
-                : await svc.getLatestActiveGeneration(conversation.id);
-            const generationId = parsed.data.expectedGenerationId
-                ?? active?.generationId
-                ?? latestActiveGeneration?.id
-                ?? null;
-            if (!generationId) {
-                res.json({
-                    stopped: false,
-                    controlActionId,
-                    generationId: null,
-                    disposition: "no_active_generation",
-                });
-                return;
-            }
-            let durableCheckpoint = await svc.generationProtocol.getLatestVisibleCheckpoint({
-                orgId: conversation.orgId,
-                conversationId: conversation.id,
-                generationId,
-            });
-            if (durableCheckpoint.generation.runtimeTerminalAt && !parsed.data.controlActionId) {
-                wakeTerminalProjector();
-                res.json({
-                    stopped: false,
-                    controlActionId,
-                    generationId,
-                    disposition: "no_active_generation",
-                });
-                return;
-            }
-            const expectedAttemptEpoch = parsed.data.expectedAttemptEpoch
-                ?? durableCheckpoint.generation.attemptEpoch;
-            const requestedControlVersion = parsed.data.expectedControlVersion
-                ?? durableCheckpoint.generation.controlVersion;
-            const requestedRenderSeq = parsed.data.lastCommittedRenderSeq
-                ?? durableCheckpoint.generationSeq;
-            const requestedBodyHash = parsed.data.renderedBodyHash
-                ?? durableCheckpoint.bodyHash;
-            let stop = null;
-            for (let attempt = 0; attempt < 2 && !stop; attempt += 1) {
-                try {
-                    stop = await svc.generationProtocol.beginStopAction({
-                        orgId: conversation.orgId,
-                        conversationId: conversation.id,
-                        controlActionId,
-                        expectedGenerationId: generationId,
-                        expectedAttemptEpoch,
-                        expectedControlVersion: requestedControlVersion,
-                        admissionControlVersion: attempt === 0
-                            ? requestedControlVersion
-                            : durableCheckpoint.generation.controlVersion,
-                        requestedRenderSeq,
-                        requestedBodyHash,
-                    });
-                }
-                catch (error) {
-                    const status = error && typeof error === "object" && "status" in error
-                        ? Number(error.status)
-                        : null;
-                    if (attempt > 0 || status !== 409)
-                        throw error;
-                    durableCheckpoint = await svc.generationProtocol.getLatestVisibleCheckpoint({
-                        orgId: conversation.orgId,
-                        conversationId: conversation.id,
-                        generationId,
-                    });
-                    if (durableCheckpoint.generation.runtimeTerminalAt && !parsed.data.controlActionId) {
-                        wakeTerminalProjector();
-                        res.json({
-                            stopped: false,
-                            controlActionId,
-                            generationId,
-                            disposition: "no_active_generation",
-                        });
-                        return;
-                    }
-                    if (durableCheckpoint.generation.attemptEpoch !== expectedAttemptEpoch)
-                        throw error;
-                }
-            }
-            if (!stop)
-                throw new Error("Failed to establish the chat Stop cutoff");
-            const wasWaitingForNetwork = durableCheckpoint.generation.status === "waiting_for_network";
-            if (stop.idempotent
-                && parsed.data.expectedControlVersion !== undefined
-                && stop.action.expectedControlVersion !== parsed.data.expectedControlVersion) {
-                throw conflict("Control action id was already used for a different Stop request");
-            }
-            if (stop.outcome === "completion_committed") {
-                res.json({
-                    stopped: false,
-                    controlActionId,
-                    generationId,
-                    disposition: "completion_committed",
-                });
-                return;
-            }
-            if (stop.outcome === "already_terminal") {
-                const alreadyStopped = stop.generation.status === "stopped"
-                    || stop.action.localDisposition === "stopped";
-                wakeTerminalProjector();
-                res.json({
-                    stopped: alreadyStopped,
-                    controlActionId,
-                    generationId,
-                    disposition: alreadyStopped ? "stopped" : "no_active_generation",
-                    acceptedThroughSeq: stop.action.acceptedThroughSeq,
-                    frozenBodyHash: stop.action.frozenBodyHash,
-                });
-                return;
-            }
-            if (stop.outcome === "stop_in_progress" && !stop.generation.runtimeTerminalAt) {
-                const localInterruptRequested = startupInterruptRequested || cancelActiveChatGeneration(conversation.id);
-                res.json({
-                    stopped: Boolean(localInterruptRequested),
-                    controlActionId,
-                    generationId,
-                    disposition: "stopping",
-                    acceptedThroughSeq: stop.action.acceptedThroughSeq,
-                    frozenBodyHash: stop.action.frozenBodyHash,
-                });
-                return;
-            }
-            if (stop.idempotent && stop.generation.runtimeTerminalAt) {
-                const terminalDisposition = stop.generation.status === "stopped"
-                    || stop.action.localDisposition === "stopped"
-                    ? "stopped"
-                    : "stopping";
-                wakeTerminalProjector();
-                res.json({
-                    stopped: true,
-                    controlActionId,
-                    generationId,
-                    disposition: terminalDisposition,
-                    acceptedThroughSeq: stop.action.acceptedThroughSeq,
-                    frozenBodyHash: stop.action.frozenBodyHash,
-                });
-                return;
-            }
-            const localInterruptRequested = startupInterruptRequested || cancelActiveChatGeneration(conversation.id);
-            let stopped = Boolean(localInterruptRequested);
-            let disposition = "stopping";
-            if (startupStopRequested) {
-                await svc.generationProtocol.recordRuntimeTerminal({
-                    orgId: conversation.orgId,
-                    conversationId: conversation.id,
-                    generationId,
-                    expectedAttemptEpoch: stop.generation.attemptEpoch,
-                    finalStatus: "stopped",
-                    terminalReason: "operator_stop",
-                    controlActionId,
-                });
-                wakeTerminalProjector();
-            }
-            else if (wasWaitingForNetwork) {
-                stopped = true;
-                disposition = "stopped";
-                await svc.generationProtocol.recordRuntimeTerminal({
-                    orgId: conversation.orgId,
-                    conversationId: conversation.id,
-                    generationId,
-                    expectedAttemptEpoch: stop.generation.attemptEpoch,
-                    finalStatus: "stopped",
-                    terminalReason: "operator_stop",
-                    controlActionId,
-                });
-                wakeTerminalProjector();
-            }
-            else if (!localInterruptRequested) {
-                disposition = "interrupted_unverified";
-                await svc.generationProtocol.recordRuntimeTerminal({
-                    orgId: conversation.orgId,
-                    conversationId: conversation.id,
-                    generationId,
-                    expectedAttemptEpoch: stop.generation.attemptEpoch,
-                    finalStatus: "interrupted_unverified",
-                    terminalReason: "stop_without_local_runtime_owner",
-                    controlActionId,
-                });
-                wakeTerminalProjector();
-            }
-            res.json({
-                stopped,
-                controlActionId,
-                generationId,
-                disposition,
-                acceptedThroughSeq: stop.action.acceptedThroughSeq,
-                frozenBodyHash: stop.action.frozenBodyHash,
-            });
-        }
-        finally {
-            if (startupStopRequested)
-                startupGate?.resolveStopApplied();
-        }
-    });
+    registerChatStopRoute(ctx);
     router.post("/orgs/:orgId/chats/:chatId/attachments", async (req, res) => {
         const orgId = req.params.orgId;
         const chatId = req.params.chatId;