captify 0.1.18 → 0.1.19

package/dist/chat/services/chat.service.js

@@ -1,26 +1,29 @@
-import { TABLES } from "../../shared/shared.constants";
-import { UpdateExpressionBuilder } from "../../shared/services/dynamodb";
-import { DynamoDbInstances } from "../../shared/services/dynamodb";
-import { getLLMService } from "../../llm-providers/services";
 import { ModelNotFoundError, ProviderNotFoundError, } from "../../llm-providers/llm-providers.errors";
-import { LoggerFactory } from "../../shared/services/logger";
-import { extractS3Key, S3ServiceSingleton } from "../../shared/services/s3";
+import { getLLMService } from "../../llm-providers/services";
 import { NotFoundError, ValidationError } from "../../shared/services";
 import { BaseAwsService } from "../../shared/services/base-aws-service";
+import { DynamoDbInstances } from "../../shared/services/dynamodb";
+import { LoggerFactory } from "../../shared/services/logger";
+import { S3ServiceSingleton, extractS3Key } from "../../shared/services/s3";
+import { TABLES, USER_CONTEXT_WITH_METADATA } from "../../shared/shared.constants";
 // Import constants
-import { buildMessageSK, buildMessagesPK, buildSessionSK, buildSessionsGsiSK, buildSessionsPK, CHAT_LIMITS, toArchivedGsiValue, } from "../chat.constants";
+import { CHAT_LIMITS, isValidChatAttachmentKey } from "../chat.constants";
+// Import tool extraction utility for persisting tool calls
+import { extractToolCallsFromUIMessage } from "../../shared/utilities/message-conversion";
+import { markInterruptedToolCallsAsError, sanitizeUnpairedToolCalls, } from "../../shared/utilities/messages";
 // Import errors
 import { SessionMessageLimitError, SessionNotFoundError } from "../chat.errors";
 // Import schemas
 import { addMessageParamsSchema } from "../chat.schemas";
 // Import utilities
-import { calculateTokenUsage } from "../chat.utilities";
+import { calculateTokenUsage, filterMessagesForModelCapabilities } from "../chat.utilities";
 // Import specialized services
+import { getAgentsService } from "../../agents/services/agents.service";
 import { ChatAttachmentService } from "./chat-attachment.service";
 import { ChatMessageService } from "./chat-message.service";
 import { ChatSessionService } from "./chat-session.service";
 import { ChatUsageService } from "./chat-usage.service";
-import { getAgentsService } from "../../agents/services/agents.service";
+import { chatMessageKeys, chatSessionKeys } from "../../db/schemas";
 /**
  * This service acts as a FACADE for all chat-related operations.
  * It delegates to specialized services while maintaining backwards compatibility
@@ -41,8 +44,10 @@ export class ChatService extends BaseAwsService {
     constructor(deps) {
         var _a, _b, _c;
         super({ logger: deps.logger });
-        this.sessionsDb = (_a = deps.sessionsDb) !== null && _a !== void 0 ? _a : DynamoDbInstances.getInstance(TABLES.chatSessions);
-        this.messagesDb = (_b = deps.messagesDb) !== null && _b !== void 0 ? _b : DynamoDbInstances.getInstance(TABLES.chatMessages);
+        this.sessionsDb =
+            (_a = deps.sessionsDb) !== null && _a !== void 0 ? _a : DynamoDbInstances.getInstance(TABLES.chatSessions);
+        this.messagesDb =
+            (_b = deps.messagesDb) !== null && _b !== void 0 ? _b : DynamoDbInstances.getInstance(TABLES.chatMessages);
         this.s3Service = (_c = deps.s3) !== null && _c !== void 0 ? _c : S3ServiceSingleton.getInstance();
         // Initialize specialized services
         this.sessionService = new ChatSessionService({
@@ -66,7 +71,7 @@ export class ChatService extends BaseAwsService {
     // Session Operations - Delegate to ChatSessionService
     // ============================================================================
     /**
-     * Get all chat sessions metadata for a user sorted by lastUpdated in descending order.
+     * Get all chat sessions metadata for a user sorted by updatedAt in descending order.
      * Delegates to ChatSessionService.
      */
     async get(tenantId, userId, opts, options) {
@@ -163,7 +168,7 @@ export class ChatService extends BaseAwsService {
     // Message Operations - Orchestrate across services
     // ============================================================================
     /**
-     * Get messages for a chat session sorted by timestamp with optional pagination.
+     * Get messages for a chat session sorted by createdAt with optional pagination.
      * Orchestrates: session check (ChatSessionService) + messages retrieval (ChatMessageService).
      */
     async getMessages(tenantId, userId, sessionId, params, options) {
@@ -183,7 +188,7 @@ export class ChatService extends BaseAwsService {
      * Orchestrates: validation → message creation (ChatMessageService) → session updates (ChatSessionService).
      */
     async addMessage(params, options) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         const validated = addMessageParamsSchema.parse(params);
         // Validate provider and model exist in the system
         const llmService = getLLMService();
@@ -205,7 +210,7 @@ export class ChatService extends BaseAwsService {
             throw new SessionMessageLimitError(CHAT_LIMITS.MAX_MESSAGES_PER_SESSION);
         }
         const usage = validated.sdkUsage ? calculateTokenUsage(validated.sdkUsage, model) : undefined;
-        const timestamp = Date.now();
+        const now = Date.now();
         // Handle message versioning (updating existing message)
         if (validated.messageId) {
             const existingMessage = await this.messageService.getMessageById(validated.sessionId, validated.messageId, options);
@@ -213,55 +218,31 @@ export class ChatService extends BaseAwsService {
                 throw new ValidationError("Message doesn't exist");
             }
             const newVersionId = crypto.randomUUID();
-            const updatedMessage = Object.assign(Object.assign({}, existingMessage), { 
-                // Keep existing timestamp - it's part of the sort key and should not change
-                versions: [
-                    ...existingMessage.versions,
-                    {
-                        id: newVersionId,
-                        content: validated.content,
-                    },
-                ], reasoning: validated.reasoning
-                    ? {
-                        content: validated.reasoning,
-                        duration: validated.reasoningDuration || 0,
-                    }
-                    : existingMessage.reasoning, usage: usage !== null && usage !== void 0 ? usage : existingMessage.usage, attachments: (_a = validated.attachments) !== null && _a !== void 0 ? _a : existingMessage.attachments });
-            // Build update expression for session using builder
-            const builder = new UpdateExpressionBuilder()
-                .set("lastUpdated", timestamp)
-                .set("GSI_SK", buildSessionsGsiSK(toArchivedGsiValue(session.isArchived), timestamp));
-            // Calculate usage delta if both old and new usage exist.
-            // NOTE: We intentionally do NOT decrement aggregatedUsage when usage is removed
-            // (!usage && existingMessage.usage). Usage represents actual API consumption that
-            // occurred and should remain counted for billing/analytics purposes, even if the
-            // message is later modified to remove its usage data.
-            if (usage && existingMessage.usage) {
-                // Both exist - calculate deltas
-                const promptDelta = usage.promptTokens - existingMessage.usage.promptTokens;
-                const completionDelta = usage.completionTokens - existingMessage.usage.completionTokens;
-                const reasoningDelta = usage.reasoningTokens - existingMessage.usage.reasoningTokens;
-                const totalDelta = usage.totalTokens - existingMessage.usage.totalTokens;
-                const costDelta = usage.estimatedCost - existingMessage.usage.estimatedCost;
-                // Update aggregated usage with deltas using builder
-                builder
-                    .incrementIfNotExists("aggregatedUsage.totalPromptTokens", promptDelta)
-                    .incrementIfNotExists("aggregatedUsage.totalCompletionTokens", completionDelta)
-                    .incrementIfNotExists("aggregatedUsage.totalReasoningTokens", reasoningDelta)
-                    .incrementIfNotExists("aggregatedUsage.totalTokens", totalDelta)
-                    .incrementIfNotExists("aggregatedUsage.totalCost", costDelta)
-                    .set("aggregatedUsage.lastCalculated", timestamp);
-            }
-            else if (usage && !existingMessage.usage) {
-                // New usage added where none existed - use full values
+            const newVersion = this.buildMessageVersion({
+                id: newVersionId,
+                content: validated.content,
+                reasoning: (_a = validated.reasoning) !== null && _a !== void 0 ? _a : undefined,
+                reasoningDuration: (_b = validated.reasoningDuration) !== null && _b !== void 0 ? _b : undefined,
+                usage,
+            });
+            const updatedMessage = Object.assign(Object.assign(Object.assign(Object.assign({}, existingMessage), { 
+                // Keep existing createdAt - it's part of the sort key and should not change
+                updatedAt: now, versions: [...existingMessage.versions, newVersion], attachments: (_c = validated.attachments) !== null && _c !== void 0 ? _c : existingMessage.attachments }), (validated.toolCalls !== undefined && { toolCalls: validated.toolCalls })), (validated.orderedParts !== undefined && { orderedParts: validated.orderedParts }));
+            // Build update expression for session (type-safe field names + nested paths)
+            const builder = this.sessionsDb
+                .createUpdateBuilder()
+                .set("updatedAt", now)
+                .set("GSI_SK", chatSessionKeys.gsiSk(session.isArchived, now));
+            // Add new version's usage to aggregated totals
+            // Each regeneration adds its own usage - we accumulate, not replace
+            if (usage) {
                 builder
                     .incrementIfNotExists("aggregatedUsage.totalPromptTokens", usage.promptTokens)
                     .incrementIfNotExists("aggregatedUsage.totalCompletionTokens", usage.completionTokens)
                     .incrementIfNotExists("aggregatedUsage.totalReasoningTokens", usage.reasoningTokens)
                     .incrementIfNotExists("aggregatedUsage.totalTokens", usage.totalTokens)
                     .incrementIfNotExists("aggregatedUsage.totalCost", usage.estimatedCost)
-                    .incrementIfNotExists("aggregatedUsage.messageCount", 1)
-                    .set("aggregatedUsage.lastCalculated", timestamp);
+                    .set("aggregatedUsage.updatedAt", now);
             }
             const { UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues } = builder.build();
             // Use transaction to update message and session atomically
@@ -269,14 +250,14 @@ export class ChatService extends BaseAwsService {
                 {
                     operation: "put",
                     tableName: TABLES.chatMessages,
-                    item: Object.assign({ PK: buildMessagesPK(validated.sessionId), SK: buildMessageSK(existingMessage.timestamp, existingMessage.id) }, updatedMessage),
+                    item: Object.assign({ PK: chatMessageKeys.pk(validated.sessionId), SK: chatMessageKeys.sk(existingMessage.createdAt, existingMessage.id) }, updatedMessage),
                 },
                 {
                     operation: "update",
                     tableName: TABLES.chatSessions,
                     key: {
-                        PK: buildSessionsPK(validated.tenantId, validated.userId),
-                        SK: buildSessionSK(validated.sessionId),
+                        PK: chatSessionKeys.pk(validated.tenantId, validated.userId),
+                        SK: chatSessionKeys.sk(validated.sessionId),
                     },
                     updateExpression: UpdateExpression,
                     expressionAttributeNames: ExpressionAttributeNames,
@@ -292,36 +273,20 @@ export class ChatService extends BaseAwsService {
         }
         // Create new message
         const id = crypto.randomUUID();
-        const message = {
+        const version = this.buildMessageVersion({
             id,
-            sessionId: validated.sessionId,
-            tenantId: validated.tenantId,
-            userId: validated.userId,
-            timestamp,
-            providerId: provider.id,
-            modelId: model.id,
-            agentId: validated.agentId,
-            role: validated.role,
-            reasoning: validated.reasoning
-                ? {
-                    content: validated.reasoning,
-                    duration: validated.reasoningDuration || 0,
-                }
-                : undefined,
-            attachments: validated.attachments,
-            versions: [
-                {
-                    id,
-                    content: validated.content,
-                },
-            ],
+            content: validated.content,
+            reasoning: (_d = validated.reasoning) !== null && _d !== void 0 ? _d : undefined,
+            reasoningDuration: (_e = validated.reasoningDuration) !== null && _e !== void 0 ? _e : undefined,
             usage,
-        };
-        // Build update expression for session using builder with nested attribute support
-        const builder = new UpdateExpressionBuilder()
-            .set("lastUpdated", timestamp)
+        });
+        const message = Object.assign(Object.assign({ id, sessionId: validated.sessionId, tenantId: validated.tenantId, createdById: validated.userId, createdAt: now, updatedAt: now, providerId: provider.id, modelId: model.id, agentId: validated.agentId, role: validated.role, attachments: validated.attachments, versions: [version] }, (validated.toolCalls !== undefined && { toolCalls: validated.toolCalls })), (validated.orderedParts !== undefined && { orderedParts: validated.orderedParts }));
+        // Build update expression for session (type-safe field names + nested paths)
+        const builder = this.sessionsDb
+            .createUpdateBuilder()
+            .set("updatedAt", now)
             .increment("messageCount", 1)
-            .set("GSI_SK", buildSessionsGsiSK(toArchivedGsiValue(session.isArchived), timestamp));
+            .set("GSI_SK", chatSessionKeys.gsiSk(session.isArchived, now));
         // If message has usage, update aggregated usage incrementally using nested increments
         if (usage) {
             builder
@@ -331,7 +296,7 @@ export class ChatService extends BaseAwsService {
                 .incrementIfNotExists("aggregatedUsage.totalTokens", usage.totalTokens)
                 .incrementIfNotExists("aggregatedUsage.totalCost", usage.estimatedCost)
                 .incrementIfNotExists("aggregatedUsage.messageCount", 1)
-                .set("aggregatedUsage.lastCalculated", timestamp);
+                .set("aggregatedUsage.updatedAt", now);
         }
         const { UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues } = builder.build();
         // Use transaction to add message and update session atomically
@@ -339,14 +304,14 @@ export class ChatService extends BaseAwsService {
             {
                 operation: "put",
                 tableName: TABLES.chatMessages,
-                item: Object.assign({ PK: buildMessagesPK(validated.sessionId), SK: buildMessageSK(timestamp, id) }, message),
+                item: Object.assign({ PK: chatMessageKeys.pk(validated.sessionId), SK: chatMessageKeys.sk(now, id) }, message),
             },
             {
                 operation: "update",
                 tableName: TABLES.chatSessions,
                 key: {
-                    PK: buildSessionsPK(validated.tenantId, validated.userId),
-                    SK: buildSessionSK(validated.sessionId),
+                    PK: chatSessionKeys.pk(validated.tenantId, validated.userId),
+                    SK: chatSessionKeys.sk(validated.sessionId),
                 },
                 updateExpression: UpdateExpression,
                 expressionAttributeNames: ExpressionAttributeNames,
@@ -406,14 +371,15 @@ export class ChatService extends BaseAwsService {
         if (message.attachments && message.attachments.length > 0) {
             await this.attachmentService.deleteMessageAttachments(message.attachments, options);
         }
-        const timestamp = Date.now();
-        // Build update expression for session using builder
+        const updatedAt = Date.now();
+        // Build update expression for session (type-safe field names)
         // NOTE: aggregatedUsage is NOT decremented - usage represents actual API consumption
         // that occurred, so it should remain for billing/analytics even if the message is deleted
-        const builder = new UpdateExpressionBuilder()
-            .set("lastUpdated", timestamp)
+        const builder = this.sessionsDb
+            .createUpdateBuilder()
+            .set("updatedAt", updatedAt)
             .increment("messageCount", -1) // Always decrement by 1 atomically
-            .set("GSI_SK", buildSessionsGsiSK(toArchivedGsiValue(session.isArchived), timestamp));
+            .set("GSI_SK", chatSessionKeys.gsiSk(session.isArchived, updatedAt));
         const { UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues } = builder.build();
         // Add :zero for condition expression to prevent negative messageCount
         // The condition ensures the decrement only happens if messageCount > 0
@@ -423,16 +389,16 @@ export class ChatService extends BaseAwsService {
                 operation: "delete",
                 tableName: TABLES.chatMessages,
                 key: {
-                    PK: buildMessagesPK(sessionId),
-                    SK: buildMessageSK(message.timestamp, messageId),
+                    PK: chatMessageKeys.pk(sessionId),
+                    SK: chatMessageKeys.sk(message.createdAt, messageId),
                 },
             },
             {
                 operation: "update",
                 tableName: TABLES.chatSessions,
                 key: {
-                    PK: buildSessionsPK(tenantId, userId),
-                    SK: buildSessionSK(sessionId),
+                    PK: chatSessionKeys.pk(tenantId, userId),
+                    SK: chatSessionKeys.sk(sessionId),
                 },
                 updateExpression: UpdateExpression,
                 conditionExpression: "#messageCount > :zero",
@@ -449,8 +415,8 @@ export class ChatService extends BaseAwsService {
      * Files must be uploaded to S3 via presigned URLs before calling this method.
      * Delegates to ChatAttachmentService.
      */
-    uploadMessageAttachments(userId, sessionId, files) {
-        return this.attachmentService.uploadMessageAttachments(userId, sessionId, files);
+    uploadMessageAttachments(tenantId, userId, sessionId, files) {
+        return this.attachmentService.uploadMessageAttachments(tenantId, userId, sessionId, files);
     }
     /**
      * Get all file attachments for a session.
@@ -497,13 +463,12 @@ export class ChatService extends BaseAwsService {
                 }
             });
         });
-        // Also allow pending files that belong to this session
-        const expectedPrefix = `conversations/${sessionId}/`;
-        const isPendingFileForSession = s3Key.startsWith(expectedPrefix);
+        // Also allow pending files that belong to this session (tenant/user scoped)
+        const isPendingFileForSession = isValidChatAttachmentKey(s3Key, tenantId, userId, sessionId);
         if (!fileInMessage && !isPendingFileForSession) {
             throw new ValidationError("File not found in this session");
         }
-        return this.attachmentService.getFileDownloadUrl(sessionId, fileUrl, options);
+        return this.attachmentService.getFileDownloadUrl(tenantId, userId, sessionId, fileUrl, options);
     }
     /**
      * Delete a temporary file (not yet attached to a message).
@@ -515,7 +480,7 @@ export class ChatService extends BaseAwsService {
         if (!session) {
             throw new SessionNotFoundError();
         }
-        await this.attachmentService.deleteTempFile(sessionId, messageId, fileUrl, options);
+        await this.attachmentService.deleteTempFile(tenantId, userId, sessionId, messageId, fileUrl, options);
     }
     /**
      * Get a presigned URL for uploading a small file (≤5MB).
@@ -527,7 +492,7 @@ export class ChatService extends BaseAwsService {
         if (!session) {
             throw new SessionNotFoundError();
         }
-        return this.attachmentService.getPresignedUploadUrl(sessionId, fileName, fileSize, contentType, options);
+        return this.attachmentService.getPresignedUploadUrl(tenantId, userId, sessionId, fileName, fileSize, contentType, options);
     }
     /**
      * Initiate a multipart upload for large files (>5MB).
@@ -539,7 +504,7 @@ export class ChatService extends BaseAwsService {
         if (!session) {
             throw new SessionNotFoundError();
         }
-        return this.attachmentService.initiateMultipartUpload(sessionId, fileName, fileSize, contentType, options);
+        return this.attachmentService.initiateMultipartUpload(tenantId, userId, sessionId, fileName, fileSize, contentType, options);
     }
     /**
      * Get a presigned URL for uploading a specific part.
@@ -551,7 +516,7 @@ export class ChatService extends BaseAwsService {
         if (!session) {
             throw new SessionNotFoundError();
         }
-        return this.attachmentService.getMultipartPartUrl(sessionId, key, uploadId, partNumber, options);
+        return this.attachmentService.getMultipartPartUrl(tenantId, userId, sessionId, key, uploadId, partNumber, options);
     }
     /**
      * Complete a multipart upload after all parts are uploaded.
@@ -563,7 +528,7 @@ export class ChatService extends BaseAwsService {
         if (!session) {
             throw new SessionNotFoundError();
         }
-        return this.attachmentService.completeMultipartUpload(sessionId, key, uploadId, fileName, fileSize, contentType, parts, options);
+        return this.attachmentService.completeMultipartUpload(tenantId, userId, sessionId, key, uploadId, fileName, fileSize, contentType, parts, options);
     }
     /**
      * Abort a multipart upload (cleanup).
@@ -575,7 +540,7 @@ export class ChatService extends BaseAwsService {
         if (!session) {
             throw new SessionNotFoundError();
         }
-        await this.attachmentService.abortMultipartUpload(sessionId, key, uploadId, options);
+        await this.attachmentService.abortMultipartUpload(tenantId, userId, sessionId, key, uploadId, options);
     }
     // ============================================================================
     // Message Streaming - Orchestrates LLM interaction
@@ -600,7 +565,7 @@ export class ChatService extends BaseAwsService {
         const fileParts = lastUserMessage.parts.filter((part) => part.type === "file");
         let attachments;
         if (fileParts.length > 0) {
-            attachments = this.uploadMessageAttachments(userId, sessionId, fileParts);
+            attachments = this.uploadMessageAttachments(tenantId, userId, sessionId, fileParts);
         }
         // Add user message if this is a new submission
         if (trigger === "submit-message") {
@@ -616,38 +581,69 @@ export class ChatService extends BaseAwsService {
             }, options);
         }
         // Find message ID for regeneration
+        // If regenerating but no assistant message exists (failed request), treat as new message
         let messageId;
         if (trigger === "regenerate-message") {
             const lastAssistantMessage = (_a = session.messages) === null || _a === void 0 ? void 0 : _a.slice().reverse().find((msg) => msg.role === "assistant");
-            if (!lastAssistantMessage) {
-                throw new ValidationError("No assistant message found to regenerate");
-            }
-            messageId = lastAssistantMessage.id;
+            messageId = lastAssistantMessage === null || lastAssistantMessage === void 0 ? void 0 : lastAssistantMessage.id;
         }
         const startReasoning = performance.now();
         const llmService = getLLMService();
+        // Get model to check capabilities for attachment filtering
+        const model = await llmService.getModel(tenantId, providerId, modelId, options);
+        if (!model) {
+            throw new ModelNotFoundError(modelId);
+        }
+        // Filter out attachments that the model doesn't support
+        // This prevents errors when switching to a model that doesn't support certain file types
+        let filteredMessages = filterMessagesForModelCapabilities(messages, model.capabilities);
+        // Sanitize any incomplete tool calls from history to prevent validation errors
+        // This is crucial for models (like Anthropic) that strictly validate tool_use/tool_result pairing
+        filteredMessages = sanitizeUnpairedToolCalls(filteredMessages);
         // Stream response from the LLM service
+        // Chart tool is only enabled for models with function-calling capability
         // Note: Don't pass abortSignal to streamText - it interferes with isAborted detection
         // in toUIMessageStreamResponse. Abort is handled at the HTTP response level.
-        const result = await llmService.streamResponse(tenantId, providerId, modelId, messages, undefined, { userCredentials: options.userCredentials });
+        const result = await llmService.streamResponse(tenantId, providerId, modelId, filteredMessages, undefined, {
+            userCredentials: options.userCredentials,
+        });
         // Return the stream with onFinish callback for persistence
+        // Wrap in try-catch to prevent errors from breaking the stream response
         return result.toUIMessageStreamResponse({
             originalMessages: messages,
             sendReasoning: true,
             onFinish: async ({ responseMessage, isAborted }) => {
-                await this.handleStreamFinish({
-                    tenantId,
-                    userId,
-                    sessionId,
-                    providerId,
-                    modelId,
-                    responseMessage,
-                    isAborted,
-                    messageId,
-                    startReasoning,
-                    result,
-                    options,
-                });
+                var _a;
+                try {
+                    await this.handleStreamFinish({
+                        tenantId,
+                        userId,
+                        sessionId,
+                        providerId,
+                        modelId,
+                        responseMessage,
+                        isAborted,
+                        messageId,
+                        startReasoning,
+                        result,
+                        options,
+                    });
+                }
+                catch (error) {
+                    // Log error but don't throw - onFinish errors should not break the stream
+                    // Include Zod validation errors if present
+                    const zodError = error && typeof error === "object" && "issues" in error
+                        ? error.issues
+                        : undefined;
+                    this.logger.error("Error in handleStreamFinish - MESSAGE NOT SAVED", {
+                        sessionId,
+                        errorType: (_a = error === null || error === void 0 ? void 0 : error.constructor) === null || _a === void 0 ? void 0 : _a.name,
+                        error: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : undefined,
+                        zodIssues: zodError ? JSON.stringify(zodError) : undefined,
+                        fullError: JSON.stringify(error, Object.getOwnPropertyNames(error || {})),
+                    });
+                }
             },
         });
     }
@@ -684,7 +680,7 @@ export class ChatService extends BaseAwsService {
         const fileParts = lastUserMessage.parts.filter((part) => part.type === "file");
         let attachments;
         if (fileParts.length > 0) {
-            attachments = this.uploadMessageAttachments(userId, sessionId, fileParts);
+            attachments = this.uploadMessageAttachments(tenantId, userId, sessionId, fileParts);
         }
         // Add user message if this is a new submission
         if (trigger === "submit-message") {
@@ -701,38 +697,57 @@ export class ChatService extends BaseAwsService {
             }, options);
         }
         // Find message ID for regeneration
+        // If regenerating but no assistant message exists (failed request), treat as new message
         let messageId;
         if (trigger === "regenerate-message") {
             const lastAssistantMessage = (_a = session.messages) === null || _a === void 0 ? void 0 : _a.slice().reverse().find((msg) => msg.role === "assistant");
-            if (!lastAssistantMessage) {
-                throw new ValidationError("No assistant message found to regenerate");
-            }
-            messageId = lastAssistantMessage.id;
+            messageId = lastAssistantMessage === null || lastAssistantMessage === void 0 ? void 0 : lastAssistantMessage.id;
         }
         const startReasoning = performance.now();
+        // Get the agent's model to check capabilities for attachment filtering
+        const llmService = getLLMService();
+        const agentModel = await llmService.getModel(tenantId, agent.providerId, agent.modelId, options);
+        if (!agentModel) {
+            throw new ModelNotFoundError(agent.modelId);
+        }
+        // Filter out attachments that the agent's model doesn't support
+        const filteredMessages = filterMessagesForModelCapabilities(messages, agentModel.capabilities);
         // Stream response through the agent with onFinish callback for persistence
         // streamResponse returns a Response object directly
         // Note: ToolLoopAgent doesn't support abortSignal - cancellation handled at HTTP level
+        // Wrap in try-catch to prevent errors from breaking the stream response
         return await agentsService.streamResponse({
             agentId,
             tenantId,
-            messages,
+            userId,
+            messages: filteredMessages,
             userCredentials: options.userCredentials,
             onFinish: async ({ responseMessage, usage, isAborted }) => {
-                await this.handleAgentStreamFinish({
-                    tenantId,
-                    userId,
-                    sessionId,
-                    agentId,
-                    providerId: agent.providerId,
-                    modelId: agent.modelId,
-                    responseMessage,
-                    isAborted,
-                    messageId,
-                    startReasoning,
-                    usage,
-                    options,
-                });
+                try {
+                    await this.handleAgentStreamFinish({
+                        tenantId,
+                        userId,
+                        sessionId,
+                        agentId,
+                        providerId: agent.providerId,
+                        modelId: agent.modelId,
+                        responseMessage,
+                        isAborted,
+                        messageId,
+                        startReasoning,
+                        usage,
+                        options,
+                    });
+                }
+                catch (error) {
+                    // Log error but don't throw - onFinish errors should not break the stream
+                    this.logger.error("Error in handleAgentStreamFinish", {
+                        sessionId,
+                        agentId,
+                        error: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : undefined,
+                    });
+                }
             },
         });
     }
@@ -753,24 +768,42 @@ export class ChatService extends BaseAwsService {
         const assistantText = ((_a = responseMessage.parts) === null || _a === void 0 ? void 0 : _a.filter((part) => part.type === "text").map((part) => ("text" in part ? part.text : "")).join("\n")) || "";
         // Extract reasoning content
         const reasoningText = ((_b = responseMessage.parts) === null || _b === void 0 ? void 0 : _b.filter((part) => part.type === "reasoning").map((part) => ("text" in part ? part.text : "")).join("\n")) || undefined;
-        if (!assistantText.trim()) {
+        // Extract tool calls and ordered parts for persistence
+        const { toolCalls, orderedParts } = extractToolCallsFromUIMessage(responseMessage);
+        // If stream was aborted, sanitize tool calls to ensure valid history
+        // Incomplete tool calls must be marked as errors so subsequent requests
+        // include a tool_result block (with error) instead of leaving a dangling tool_use
+        if (isAborted) {
+            markInterruptedToolCallsAsError(toolCalls, orderedParts);
+        }
+        // Debug logging for tool calls
+        if (toolCalls.length > 0) {
+            this.logger.info("Extracted tool calls from response", {
+                sessionId,
+                toolCallCount: toolCalls.length,
+                toolCalls: toolCalls.map((tc) => ({
+                    toolName: tc.toolName,
+                    state: tc.state,
+                    hasInput: tc.input !== undefined &&
+                        tc.input !== null &&
+                        Object.keys(tc.input).length > 0,
+                    inputKeys: tc.input != null ? Object.keys(tc.input) : [],
+                    hasOutput: tc.output !== undefined,
+                    outputType: tc.output ? tc.output.__type : undefined,
+                })),
+            });
+        }
+        if (!assistantText.trim() && toolCalls.length === 0) {
+            this.logger.warn("No content to save - empty text and no tool calls", { sessionId });
             return;
         }
         const usage = await result.totalUsage;
-        // Persist assistant message
-        await this.addMessage({
-            tenantId,
+        // Persist assistant message with tool calls
+        await this.addMessage(Object.assign(Object.assign({ tenantId,
             userId,
-            sessionId,
-            content: assistantText,
-            providerId,
-            modelId,
-            role: "assistant",
-            reasoning: reasoningText,
-            reasoningDuration,
-            messageId,
-            sdkUsage: usage,
-        }, options);
+            sessionId, content: assistantText, providerId,
+            modelId, role: "assistant", reasoning: reasoningText, reasoningDuration,
+            messageId, sdkUsage: usage }, (toolCalls.length > 0 && { toolCalls })), (orderedParts.length > 0 && { orderedParts })), options);
         // Auto-generate title for new conversations
         if (!isAborted) {
             await this.maybeGenerateTitle({
@@ -801,30 +834,40 @@ export class ChatService extends BaseAwsService {
         const assistantText = ((_a = responseMessage.parts) === null || _a === void 0 ? void 0 : _a.filter((part) => part.type === "text").map((part) => ("text" in part ? part.text : "")).join("\n")) || "";
         // Extract reasoning content
         const reasoningText = ((_b = responseMessage.parts) === null || _b === void 0 ? void 0 : _b.filter((part) => part.type === "reasoning").map((part) => ("text" in part ? part.text : "")).join("\n")) || undefined;
-        if (!assistantText.trim()) {
+        // Extract tool calls and ordered parts for persistence
+        const { toolCalls, orderedParts } = extractToolCallsFromUIMessage(responseMessage);
+        // If stream was aborted, sanitize tool calls to ensure valid history
+        // Incomplete tool calls must be marked as errors so subsequent requests
+        // include a tool_result block (with error) instead of leaving a dangling tool_use
+        if (isAborted) {
+            markInterruptedToolCallsAsError(toolCalls, orderedParts);
+        }
+        if (!assistantText.trim() && toolCalls.length === 0) {
             return;
         }
-        // Convert usage to SDK format for addMessage (LanguageModelV3Usage uses inputTokens/outputTokens)
+        // Convert usage to SDK format for addMessage (LanguageModelUsage uses inputTokens/outputTokens)
         const sdkUsage = {
             inputTokens: usage.promptTokens,
             outputTokens: usage.completionTokens,
             totalTokens: usage.totalTokens,
+            inputTokenDetails: {
+                noCacheTokens: undefined,
+                cacheReadTokens: undefined,
+                cacheWriteTokens: undefined,
+            },
+            outputTokenDetails: {
+                textTokens: undefined,
+                reasoningTokens: undefined,
+            },
         };
-        // Persist assistant message with agentId
-        await this.addMessage({
-            tenantId,
+        // Persist assistant message with agentId and tool calls
+        await this.addMessage(Object.assign(Object.assign({ tenantId,
             userId,
-            sessionId,
-            content: assistantText,
-            providerId,
+            sessionId, content: assistantText, providerId,
             modelId,
-            agentId,
-            role: "assistant",
-            reasoning: reasoningText,
-            reasoningDuration,
+            agentId, role: "assistant", reasoning: reasoningText, reasoningDuration,
             messageId,
-            sdkUsage,
-        }, options);
+            sdkUsage }, (toolCalls.length > 0 && { toolCalls })), (orderedParts.length > 0 && { orderedParts })), options);
         // Auto-generate title for new conversations
         if (!isAborted) {
             await this.maybeGenerateTitle({
@@ -838,6 +881,26 @@ export class ChatService extends BaseAwsService {
             });
         }
     }
+    /**
+     * Build a message version object with optional reasoning and usage.
+     * @internal
+     */
+    buildMessageVersion(params) {
+        const version = {
+            id: params.id,
+            content: params.content,
+        };
+        if (params.reasoning) {
+            version.reasoning = {
+                content: params.reasoning,
+                duration: params.reasoningDuration || 0,
+            };
+        }
+        if (params.usage) {
+            version.usage = params.usage;
+        }
+        return version;
+    }
     /**
      * Auto-generate a title for a new conversation if conditions are met.
      * @internal
@@ -847,11 +910,11 @@ export class ChatService extends BaseAwsService {
         const { tenantId, userId, sessionId, providerId, modelId, assistantText, options } = params;
         // Refresh session to get updated message count
         const updatedSession = await this.getById(tenantId, userId, sessionId, options);
-        const messageCount = ((_a = updatedSession === null || updatedSession === void 0 ? void 0 : updatedSession.messages) === null || _a === void 0 ? void 0 : _a.length) || 0;
-        // Only generate title for new conversations with default title
+        const assistantMessageCount = ((_a = updatedSession === null || updatedSession === void 0 ? void 0 : updatedSession.messages) === null || _a === void 0 ? void 0 : _a.filter((m) => m.role === "assistant").length) || 0;
+        // Only generate title for new conversations with default title (first assistant message)
         if (!updatedSession ||
             updatedSession.title !== "New Chat" ||
-            messageCount !== 2 ||
+            assistantMessageCount !== 1 ||
             assistantText.trim().length < 10) {
             return;
         }
@@ -900,16 +963,7 @@ export function getChatService() {
         chatServiceInstance = new ChatService({
             logger: LoggerFactory.createLogger({
                 serviceName: "ChatService",
-                userContext: {
-                    userId: "system",
-                    email: "system@captify.com",
-                    name: "System Service Account",
-                    roles: ["service"],
-                    metadata: {
-                        isSystemUser: true,
-                        note: "Service-level logger - user context should be provided by caller",
-                    },
-                },
+                userContext: USER_CONTEXT_WITH_METADATA,
             }),
         });
     }