@rudderhq/server 0.2.0-canary.9 → 0.2.1

package/dist/routes/chats.js

@@ -3,14 +3,14 @@ import { Router } from "express";
 import multer from "multer";
 import { addChatMessageSchema, updateChatConversationUserStateSchema, convertChatToIssueSchema, createChatAttachmentMetadataSchema, createChatContextLinkSchema, createChatConversationSchema, resolveChatOperationProposalSchema, setChatProjectContextSchema, updateChatConversationSchema, } from "@rudderhq/shared";
 import { isAllowedContentType, MAX_ATTACHMENT_BYTES } from "../attachment-types.js";
-import { HttpError } from "../errors.js";
+import { forbidden, HttpError, unauthorized } from "../errors.js";
 import { observeExecutionEvent, updateExecutionObservation, updateExecutionTraceIO, withExecutionObservation, } from "../langfuse.js";
 import { emitExecutionTranscriptTree } from "../langfuse-transcript.js";
 import { validate } from "../middleware/validate.js";
 import { logger } from "../middleware/logger.js";
 import { ChatAssistantStreamError, chatAssistantService, } from "../services/chat-assistant.js";
-import { cancelActiveChatGeneration, claimChatGeneration } from "../services/chat-generation-locks.js";
-import { agentService, chatService, operatorProfileService, organizationService, goalService, issueService, logActivity, projectService, } from "../services/index.js";
+import { cancelActiveChatGeneration, claimChatGeneration, hasActiveChatGeneration } from "../services/chat-generation-locks.js";
+import { accessService, agentService, chatService, operatorProfileService, organizationService, goalService, issueService, logActivity, projectService, } from "../services/index.js";
 import { summarizeRuntimeSkillsForTrace } from "../services/runtime-trace-metadata.js";
 import { assertBoard, assertCompanyAccess, getActorInfo } from "./authz.js";
 export function chatRoutes(db, storage) {
@@ -21,6 +21,7 @@ export function chatRoutes(db, storage) {
     const projectsSvc = projectService(db);
     const agentsSvc = agentService(db);
     const goalsSvc = goalService(db);
+    const access = accessService(db);
     const assistantSvc = chatAssistantService(db);
     const operatorProfiles = operatorProfileService(db);
     const upload = multer({
@@ -84,6 +85,36 @@ export function chatRoutes(db, storage) {
         assertBoard(req);
         return req.actor.userId ?? "local-board";
     }
+    function canCreateAgentsLegacy(agent) {
+        if (agent.role === "ceo")
+            return true;
+        if (!agent.permissions || typeof agent.permissions !== "object")
+            return false;
+        return Boolean(agent.permissions.canCreateAgents);
+    }
+    async function assertCanAssignTasks(req, orgId) {
+        assertCompanyAccess(req, orgId);
+        if (req.actor.type === "board") {
+            if (req.actor.source === "local_implicit" || req.actor.isInstanceAdmin)
+                return;
+            const allowed = await access.canUser(orgId, req.actor.userId, "tasks:assign");
+            if (!allowed)
+                throw forbidden("Missing permission: tasks:assign");
+            return;
+        }
+        if (req.actor.type === "agent") {
+            if (!req.actor.agentId)
+                throw forbidden("Agent authentication required");
+            const allowedByGrant = await access.hasPermission(orgId, "agent", req.actor.agentId, "tasks:assign");
+            if (allowedByGrant)
+                return;
+            const actorAgent = await agentsSvc.getById(req.actor.agentId);
+            if (actorAgent && actorAgent.orgId === orgId && canCreateAgentsLegacy(actorAgent))
+                return;
+            throw forbidden("Missing permission: tasks:assign");
+        }
+        throw unauthorized();
+    }
     function buildChatObservabilityContext(conversation, input) {
         return {
             surface: input.surface ?? "chat_action",
@@ -153,6 +184,11 @@ export function chatRoutes(db, storage) {
             eventType: typeof systemPayload?.eventType === "string" ? systemPayload.eventType : null,
         };
     }
+    function modelTurnInputFromInvocationMeta(invocationMeta) {
+        return typeof invocationMeta.prompt === "string" && invocationMeta.prompt.trim().length > 0
+            ? invocationMeta.prompt
+            : undefined;
+    }
     function buildChatTraceInput(input, invocationMeta) {
         return {
             conversationId: input.conversationId,
@@ -313,50 +349,6 @@ export function chatRoutes(db, storage) {
     function chatReplyingAgentId(conversation) {
         return conversation?.chatRuntime?.runtimeAgentId ?? conversation?.preferredAgentId ?? null;
     }
-    async function defaultIssueAssigneeAgentId(conversation) {
-        const candidateAgentIds = [conversation?.preferredAgentId, conversation?.routedAgentId]
-            .filter((id) => typeof id === "string" && id.trim().length > 0);
-        if (!conversation)
-            return null;
-        for (const candidateAgentId of candidateAgentIds) {
-            const agent = await agentsSvc.getById(candidateAgentId);
-            if (!agent || agent.orgId !== conversation.orgId)
-                continue;
-            if (agent.status === "pending_approval" || agent.status === "terminated")
-                continue;
-            return agent.id;
-        }
-        return null;
-    }
-    function hasIssueProposalAssignee(proposal) {
-        return Boolean((typeof proposal.assigneeAgentId === "string" && proposal.assigneeAgentId.trim().length > 0)
-            || (typeof proposal.assigneeUserId === "string" && proposal.assigneeUserId.trim().length > 0));
-    }
-    function withDefaultIssueProposalAssignee(structuredPayload, assigneeAgentId) {
-        if (!structuredPayload || !assigneeAgentId)
-            return structuredPayload ?? null;
-        const nestedProposal = structuredPayload.issueProposal
-            && typeof structuredPayload.issueProposal === "object"
-            && !Array.isArray(structuredPayload.issueProposal)
-            ? structuredPayload.issueProposal
-            : null;
-        const proposal = nestedProposal ?? structuredPayload;
-        if (hasIssueProposalAssignee(proposal))
-            return structuredPayload;
-        if (nestedProposal) {
-            return {
-                ...structuredPayload,
-                issueProposal: {
-                    ...nestedProposal,
-                    assigneeAgentId,
-                },
-            };
-        }
-        return {
-            ...structuredPayload,
-            assigneeAgentId,
-        };
-    }
     function proposedIssuePayload(structuredPayload) {
         if (!structuredPayload)
             return structuredPayload ?? null;
@@ -367,25 +359,121 @@ export function chatRoutes(db, storage) {
             ? structuredPayload.issueProposal
             : structuredPayload;
     }
-    async function persistAssistantReply(conversation, actor, assistantReply, turnContext, transcript = [], replyingAgentId = assistantReply.replyingAgentId ?? chatReplyingAgentId(conversation)) {
+    function proposalAssignsOrReviewsIssue(proposal) {
+        if (!proposal)
+            return false;
+        return Boolean((typeof proposal.assigneeAgentId === "string" && proposal.assigneeAgentId.trim().length > 0)
+            || (typeof proposal.assigneeUserId === "string" && proposal.assigneeUserId.trim().length > 0)
+            || (typeof proposal.reviewerAgentId === "string" && proposal.reviewerAgentId.trim().length > 0)
+            || (typeof proposal.reviewerUserId === "string" && proposal.reviewerUserId.trim().length > 0));
+    }
+    async function proposedIssuePayloadForConversion(conversationId, input) {
+        if (input.proposal)
+            return proposedIssuePayload(input.proposal);
+        if (input.messageId) {
+            const message = await svc.getMessage(conversationId, input.messageId);
+            return proposedIssuePayload(message?.structuredPayload ?? null);
+        }
+        const messages = await svc.listMessages(conversationId);
+        const message = [...messages].reverse().find((entry) => entry.kind === "issue_proposal");
+        return proposedIssuePayload(message?.structuredPayload ?? null);
+    }
+    async function assertCanConvertIssueProposal(req, conversation, input) {
+        const proposal = await proposedIssuePayloadForConversion(conversation.id, input);
+        if (proposalAssignsOrReviewsIssue(proposal)) {
+            await assertCanAssignTasks(req, conversation.orgId);
+        }
+    }
+    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 persistAssistantReply(req, conversation, actor, assistantReply, turnContext, transcript = [], replyingAgentId = assistantReply.replyingAgentId ?? chatReplyingAgentId(conversation), existingMessageId) {
         const createdMessages = [];
         const { chatTurnId, turnVariant } = turnContext;
+        const attachGeneratedFiles = async (message, generatedAttachments) => {
+            if (!generatedAttachments || generatedAttachments.length === 0)
+                return message;
+            const attachments = [];
+            for (const generated of generatedAttachments) {
+                if (generated.body.length > MAX_ATTACHMENT_BYTES) {
+                    throw new ChatAssistantStreamError(`Generated attachment exceeds ${MAX_ATTACHMENT_BYTES} bytes`, assistantReply.body, generatedAttachments);
+                }
+                const stored = await storage.putFile({
+                    orgId: conversation.orgId,
+                    namespace: `chats/${conversation.id}/generated`,
+                    originalFilename: generated.originalFilename,
+                    contentType: generated.contentType,
+                    body: generated.body,
+                });
+                const attachment = await svc.createAttachment({
+                    orgId: conversation.orgId,
+                    conversationId: conversation.id,
+                    messageId: message.id,
+                    provider: stored.provider,
+                    objectKey: stored.objectKey,
+                    contentType: stored.contentType,
+                    byteSize: stored.byteSize,
+                    sha256: stored.sha256,
+                    originalFilename: stored.originalFilename,
+                    createdByAgentId: replyingAgentId,
+                    createdByUserId: null,
+                });
+                attachments.push(attachment);
+            }
+            return {
+                ...message,
+                attachments: [...(message.attachments ?? []), ...attachments],
+            };
+        };
+        const saveAssistantMessage = async (input) => {
+            if (existingMessageId) {
+                const updated = await svc.updateMessage(conversation.id, existingMessageId, {
+                    kind: input.kind,
+                    status: "completed",
+                    body: input.body,
+                    structuredPayload: input.structuredPayload ?? null,
+                    transcript,
+                    approvalId: input.approvalId ?? null,
+                    replyingAgentId,
+                });
+                if (updated)
+                    return updated;
+            }
+            return svc.addMessage(conversation.id, {
+                orgId: conversation.orgId,
+                role: "assistant",
+                kind: input.kind,
+                body: input.body,
+                structuredPayload: input.structuredPayload ?? null,
+                transcript,
+                approvalId: input.approvalId ?? null,
+                replyingAgentId,
+                chatTurnId,
+                turnVariant,
+            });
+        };
         if (assistantReply.kind === "issue_proposal") {
-            const issueProposalStructuredPayload = withDefaultIssueProposalAssignee(assistantReply.structuredPayload, await defaultIssueAssigneeAgentId(conversation));
-            const shouldAutoCreateIssue = conversation.planMode || conversation.issueCreationMode === "auto_create";
+            const issueProposalStructuredPayload = assistantReply.structuredPayload ?? null;
+            const shouldAutoCreateIssue = !conversation.planMode && conversation.issueCreationMode === "auto_create";
             if (shouldAutoCreateIssue) {
-                const proposalMessage = await svc.addMessage(conversation.id, {
-                    orgId: conversation.orgId,
-                    role: "assistant",
+                const proposalMessage = await saveAssistantMessage({
                     kind: "issue_proposal",
                     body: assistantReply.body,
                     structuredPayload: issueProposalStructuredPayload,
-                    transcript,
-                    replyingAgentId,
-                    chatTurnId,
-                    turnVariant,
                 });
-                createdMessages.push(proposalMessage);
+                createdMessages.push(await attachGeneratedFiles(proposalMessage, assistantReply.generatedAttachments));
+                await assertCanConvertIssueProposal(req, conversation, {
+                    proposal: issueProposalStructuredPayload,
+                });
                 const issue = await svc.convertToIssue(conversation.id, {
                     actorUserId: actor.actorType === "user" ? actor.actorId : null,
                     messageId: proposalMessage.id,
@@ -414,32 +502,28 @@ export function chatRoutes(db, storage) {
                     details: {
                         issueId: issue.id,
                         issueIdentifier: issue.identifier,
-                        source: conversation.planMode ? "plan_mode" : "auto_create",
+                        source: "auto_create",
                     },
                 });
                 return createdMessages;
             }
+            const planDocument = proposedPlanDocumentPayload(issueProposalStructuredPayload);
             const approval = await svc.createProposalApproval(conversation.orgId, {
                 type: "chat_issue_creation",
                 requestedByUserId: actor.actorType === "user" ? actor.actorId : null,
                 payload: {
                     chatConversationId: conversation.id,
                     proposedIssue: proposedIssuePayload(issueProposalStructuredPayload),
+                    ...(planDocument ? { planDocument } : {}),
                 },
             });
-            const proposalMessage = await svc.addMessage(conversation.id, {
-                orgId: conversation.orgId,
-                role: "assistant",
+            const proposalMessage = await saveAssistantMessage({
                 kind: "issue_proposal",
                 body: assistantReply.body,
                 structuredPayload: issueProposalStructuredPayload,
-                transcript,
                 approvalId: approval.id,
-                replyingAgentId,
-                chatTurnId,
-                turnVariant,
             });
-            createdMessages.push(proposalMessage);
+            createdMessages.push(await attachGeneratedFiles(proposalMessage, assistantReply.generatedAttachments));
             return createdMessages;
         }
         if (assistantReply.kind === "operation_proposal") {
@@ -455,9 +539,7 @@ export function chatRoutes(db, storage) {
                         : assistantReply.structuredPayload,
                 },
             });
-            const proposalMessage = await svc.addMessage(conversation.id, {
-                orgId: conversation.orgId,
-                role: "assistant",
+            const proposalMessage = await saveAssistantMessage({
                 kind: "operation_proposal",
                 body: assistantReply.body,
                 structuredPayload: {
@@ -469,41 +551,80 @@ export function chatRoutes(db, storage) {
                         decidedAt: null,
                     },
                 },
-                transcript,
                 approvalId: approval.id,
-                replyingAgentId,
-                chatTurnId,
-                turnVariant,
             });
-            createdMessages.push(proposalMessage);
+            createdMessages.push(await attachGeneratedFiles(proposalMessage, assistantReply.generatedAttachments));
             return createdMessages;
         }
-        const assistantMessage = await svc.addMessage(conversation.id, {
-            orgId: conversation.orgId,
-            role: "assistant",
-            kind: assistantReply.kind === "routing_suggestion" ? "routing_suggestion" : "message",
+        const assistantMessage = await saveAssistantMessage({
+            kind: "message",
             body: assistantReply.body,
             structuredPayload: assistantReply.structuredPayload,
-            transcript,
-            replyingAgentId,
-            chatTurnId,
-            turnVariant,
         });
-        createdMessages.push(assistantMessage);
+        createdMessages.push(await attachGeneratedFiles(assistantMessage, assistantReply.generatedAttachments));
         return createdMessages;
     }
-    async function persistPartialAssistantMessage(conversation, body, status, turnContext, transcript = [], replyingAgentId = chatReplyingAgentId(conversation)) {
+    async function attachGeneratedFilesToPartialMessage(conversation, message, generatedAttachments, replyingAgentId) {
+        if (!message || !generatedAttachments || generatedAttachments.length === 0)
+            return message;
+        const attachments = [];
+        for (const generated of generatedAttachments) {
+            if (generated.body.length > MAX_ATTACHMENT_BYTES)
+                continue;
+            const stored = await storage.putFile({
+                orgId: conversation.orgId,
+                namespace: `chats/${conversation.id}/generated`,
+                originalFilename: generated.originalFilename,
+                contentType: generated.contentType,
+                body: generated.body,
+            });
+            const attachment = await svc.createAttachment({
+                orgId: conversation.orgId,
+                conversationId: conversation.id,
+                messageId: message.id,
+                provider: stored.provider,
+                objectKey: stored.objectKey,
+                contentType: stored.contentType,
+                byteSize: stored.byteSize,
+                sha256: stored.sha256,
+                originalFilename: stored.originalFilename,
+                createdByAgentId: replyingAgentId,
+                createdByUserId: null,
+            });
+            attachments.push(attachment);
+        }
+        return {
+            ...message,
+            attachments: [...(message.attachments ?? []), ...attachments],
+        };
+    }
+    async function persistPartialAssistantMessage(conversation, body, status, turnContext, transcript = [], replyingAgentId = chatReplyingAgentId(conversation), existingMessageId) {
         const trimmed = body.trim();
-        if (!trimmed)
+        const fallbackBody = status === "stopped"
+            ? "Chat run stopped before a final reply. Continue the conversation to resume from the preserved context."
+            : "Chat run failed before a final reply. Continue the conversation to resume from the preserved context.";
+        const durableBody = trimmed || (transcript.length > 0 ? fallbackBody : "");
+        if (!durableBody)
             return null;
         const chatTurnId = turnContext?.chatTurnId ?? randomUUID();
         const turnVariant = turnContext?.turnVariant ?? 0;
+        if (existingMessageId) {
+            const updated = await svc.updateMessage(conversation.id, existingMessageId, {
+                kind: "message",
+                status,
+                body: durableBody,
+                transcript,
+                replyingAgentId,
+            });
+            if (updated)
+                return updated;
+        }
         const message = await svc.addMessage(conversation.id, {
             orgId: conversation.orgId,
             role: "assistant",
             kind: "message",
             status,
-            body: trimmed,
+            body: durableBody,
             transcript,
             replyingAgentId,
             chatTurnId,
@@ -524,8 +645,9 @@ export function chatRoutes(db, storage) {
         const status = statusParam === "resolved" || statusParam === "archived" || statusParam === "all"
             ? statusParam
             : "active";
+        const q = typeof req.query.q === "string" ? req.query.q : undefined;
         const userId = req.actor.type === "board" ? (req.actor.userId ?? "local-board") : null;
-        const conversations = await svc.list(orgId, { status }, userId);
+        const conversations = await svc.list(orgId, { status, q }, userId);
         res.json(await assistantSvc.enrichConversations(conversations));
     });
     router.post("/orgs/:orgId/chats", validate(createChatConversationSchema), async (req, res) => {
@@ -538,6 +660,13 @@ export function chatRoutes(db, storage) {
         }
         const contextLinks = req.body.contextLinks ?? [];
         await assertContextLinksBelongToCompany(orgId, contextLinks);
+        if (req.body.preferredAgentId) {
+            const agent = await agentsSvc.getById(req.body.preferredAgentId);
+            if (!agent || agent.orgId !== orgId) {
+                res.status(422).json({ error: "Preferred agent must belong to the same organization" });
+                return;
+            }
+        }
         const actor = getActorInfo(req);
         const conversation = await svc.create(orgId, {
             title: req.body.title,
@@ -629,6 +758,9 @@ export function chatRoutes(db, storage) {
             res.status(404).json({ error: "Chat conversation not found" });
             return;
         }
+        if (!hasActiveChatGeneration(conversation.id)) {
+            await svc.markInterruptedStreamingMessages(conversation.id);
+        }
         const messages = await svc.listMessages(conversation.id);
         res.json(messages);
     });
@@ -678,6 +810,7 @@ export function chatRoutes(db, storage) {
                 const assistantInput = await loadAssistantInput(conversation, actor);
                 const transcript = [];
                 const observedTranscript = [];
+                let modelTurnInput;
                 let fallbackOutput = null;
                 let finalChatOutput = null;
                 let finalChatStatus = "completed";
@@ -685,6 +818,7 @@ export function chatRoutes(db, storage) {
                     const streamed = await assistantSvc.streamChatAssistantReply({
                         ...assistantInput,
                         onInvocationMeta: async (meta) => {
+                            modelTurnInput = modelTurnInputFromInvocationMeta(meta);
                             currentChatTraceInput = buildChatTraceInput(traceInputBase, meta);
                             mergeChatInvocationTraceMetadata(chatObservation, meta);
                             updateExecutionObservation(observation, chatObservation, {
@@ -704,7 +838,7 @@ export function chatRoutes(db, storage) {
                         finalChatStatus = "failed";
                         throw new Error("Chat assistant reply was stopped before completion");
                     }
-                    const created = await persistAssistantReply(assistantInput.conversation, actor, streamed.reply, turnContext, transcript, streamed.replyingAgentId);
+                    const created = await persistAssistantReply(req, assistantInput.conversation, actor, streamed.reply, turnContext, transcript, streamed.replyingAgentId);
                     finalChatOutput = streamed.reply.body;
                     await logChatMessagesAdded(assistantInput.conversation, created, {
                         actorType: "system",
@@ -735,6 +869,7 @@ export function chatRoutes(db, storage) {
                             context: chatObservation,
                             parentObservation: observation,
                             transcript: observedTranscript,
+                            initialTurnInput: modelTurnInput,
                             fallbackResult: fallbackOutput
                                 ? {
                                     output: fallbackOutput,
@@ -779,6 +914,9 @@ export function chatRoutes(db, storage) {
                 });
             }
             logger.warn({ err, conversationId: conversation.id }, "chat assistant reply failed");
+            if (err instanceof HttpError) {
+                throw err;
+            }
             res.status(502).json({
                 error: err instanceof Error ? err.message : "Chat assistant failed to respond",
             });
@@ -837,6 +975,42 @@ export function chatRoutes(db, storage) {
         let chatObservation = null;
         const transcript = [];
         const observedTranscript = [];
+        let modelTurnInput;
+        let assistantProgressMessage = null;
+        let assistantProgressMessageId = null;
+        let assistantDraftBody = "";
+        const persistStreamProgress = async (progressConversation, replyingAgentId = chatReplyingAgentId(progressConversation)) => {
+            if (!turnContextForPartial)
+                return null;
+            const input = {
+                kind: "message",
+                status: "streaming",
+                body: assistantDraftBody,
+                transcript,
+                replyingAgentId,
+            };
+            if (assistantProgressMessage) {
+                const updated = await svc.updateMessage(progressConversation.id, assistantProgressMessage.id, input);
+                if (updated) {
+                    assistantProgressMessage = updated;
+                    assistantProgressMessageId = assistantProgressMessage.id;
+                    return assistantProgressMessage;
+                }
+            }
+            assistantProgressMessage = await svc.addMessage(progressConversation.id, {
+                orgId: progressConversation.orgId,
+                role: "assistant",
+                kind: "message",
+                status: "streaming",
+                body: assistantDraftBody,
+                transcript,
+                replyingAgentId,
+                chatTurnId: turnContextForPartial.chatTurnId,
+                turnVariant: turnContextForPartial.turnVariant,
+            });
+            assistantProgressMessageId = assistantProgressMessage.id;
+            return assistantProgressMessage;
+        };
         let clientClosed = false;
         const handleClosed = () => {
             if (clientClosed || res.writableEnded)
@@ -894,6 +1068,7 @@ export function chatRoutes(db, storage) {
                         ...assistantInput,
                         abortSignal: abortController.signal,
                         onInvocationMeta: async (meta) => {
+                            modelTurnInput = modelTurnInputFromInvocationMeta(meta);
                             currentChatTraceInput = buildChatTraceInput(traceInputBase, meta);
                             mergeChatInvocationTraceMetadata(chatObservation, meta);
                             updateExecutionObservation(observation, chatObservation, {
@@ -902,12 +1077,17 @@ export function chatRoutes(db, storage) {
                             updateExecutionTraceIO(observation, { input: currentChatTraceInput });
                         },
                         onAssistantDelta: async (delta) => {
+                            assistantDraftBody = `${assistantDraftBody}${delta}`;
+                            await persistStreamProgress(assistantInput.conversation);
+                            if (clientClosed)
+                                return;
                             writeStreamEvent(res, {
                                 type: "assistant_delta",
                                 delta,
                             });
                         },
                         onAssistantState: async (state) => {
+                            await persistStreamProgress(assistantInput.conversation);
                             if (clientClosed)
                                 return;
                             writeStreamEvent(res, {
@@ -917,6 +1097,7 @@ export function chatRoutes(db, storage) {
                         },
                         onTranscriptEntry: async (entry) => {
                             transcript.push(entry);
+                            await persistStreamProgress(assistantInput.conversation);
                             if (clientClosed)
                                 return;
                             writeStreamEvent(res, {
@@ -931,7 +1112,7 @@ export function chatRoutes(db, storage) {
                     if (streamed.outcome === "stopped") {
                         finalChatStatus = "stopped";
                         finalChatOutput = streamed.partialBody;
-                        const stoppedMessage = await persistPartialAssistantMessage(assistantInput.conversation, streamed.partialBody, "stopped", turnContextForPartial, transcript, streamed.replyingAgentId);
+                        const stoppedMessage = await persistPartialAssistantMessage(assistantInput.conversation, streamed.partialBody, "stopped", turnContextForPartial, transcript, streamed.replyingAgentId, assistantProgressMessageId);
                         if (stoppedMessage) {
                             await logChatMessagesAdded(assistantInput.conversation, [stoppedMessage], {
                                 actorType: "system",
@@ -957,7 +1138,7 @@ export function chatRoutes(db, storage) {
                         }
                         return;
                     }
-                    const createdMessages = await persistAssistantReply(assistantInput.conversation, actor, streamed.reply, turnContextForPartial, transcript, streamed.replyingAgentId);
+                    const createdMessages = await persistAssistantReply(req, assistantInput.conversation, actor, streamed.reply, turnContextForPartial, transcript, streamed.replyingAgentId, assistantProgressMessageId);
                     finalChatOutput = streamed.reply.body;
                     await logChatMessagesAdded(assistantInput.conversation, createdMessages, {
                         actorType: "system",
@@ -993,6 +1174,14 @@ export function chatRoutes(db, storage) {
                             context: chatObservation,
                             parentObservation: observation,
                             transcript: observedTranscript,
+                            initialTurnInput: modelTurnInput,
+                            fallbackResult: finalChatOutput
+                                ? {
+                                    output: finalChatOutput,
+                                    subtype: finalChatStatus,
+                                    isError: finalChatStatus === "failed",
+                                }
+                                : null,
                         });
                         finalChatOutput = finalChatOutput ?? transcriptStats.finalOutput ?? null;
                     }
@@ -1020,8 +1209,10 @@ export function chatRoutes(db, storage) {
         }
         catch (err) {
             const partialBody = err instanceof ChatAssistantStreamError ? err.partialBody : "";
+            const generatedAttachments = err instanceof ChatAssistantStreamError ? err.generatedAttachments : [];
             const failedReplyingAgentId = chatReplyingAgentId(assistantConversationForPartial);
-            const failedMessage = await persistPartialAssistantMessage(assistantConversationForPartial ?? conversation, partialBody, "failed", turnContextForPartial, transcript, failedReplyingAgentId).catch(() => null);
+            let failedMessage = await persistPartialAssistantMessage(assistantConversationForPartial ?? conversation, partialBody, "failed", turnContextForPartial, transcript, failedReplyingAgentId, assistantProgressMessageId).catch(() => null);
+            failedMessage = await attachGeneratedFilesToPartialMessage(assistantConversationForPartial ?? conversation, failedMessage, generatedAttachments, failedReplyingAgentId).catch(() => failedMessage);
             if (failedMessage && assistantConversationForPartial) {
                 await logChatMessagesAdded(assistantConversationForPartial, [failedMessage], {
                     actorType: "system",
@@ -1186,6 +1377,11 @@ export function chatRoutes(db, storage) {
                     entityId: projectId,
                 }]);
         }
+        const messages = await svc.listMessages(conversation.id);
+        if (messages.length > 0) {
+            res.status(409).json({ error: "Project context is locked after conversation starts" });
+            return;
+        }
         const updated = await svc.setProjectContextLink(conversation.id, conversation.orgId, projectId);
         if (!updated) {
             res.status(404).json({ error: "Chat conversation not found" });
@@ -1219,6 +1415,10 @@ export function chatRoutes(db, storage) {
                 return;
             }
         }
+        await assertCanConvertIssueProposal(req, conversation, {
+            messageId: req.body.messageId ?? null,
+            proposal: req.body.proposal ?? null,
+        });
         const chatObservation = buildChatObservabilityContext(conversation, {
             rootExecutionId: req.body.messageId ?? `chat-convert:${conversation.id}`,
             trigger: "convert_to_issue",
@@ -1365,6 +1565,14 @@ export function chatRoutes(db, storage) {
         if (typeof req.body.pinned === "boolean") {
             await svc.setPinned(conversation.id, conversation.orgId, userId, req.body.pinned);
         }
+        if (typeof req.body.unread === "boolean") {
+            if (req.body.unread) {
+                await svc.markUnread(conversation.id, conversation.orgId, userId);
+            }
+            else {
+                await svc.markRead(conversation.id, conversation.orgId, userId);
+            }
+        }
         const refreshed = await svc.getById(conversation.id, userId);
         res.json(await assistantSvc.enrichConversation(refreshed));
     });