captify 0.1.15

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

@@ -0,0 +1,1245 @@
+import { DEFAULT_URL_EXPIRY, MIN_PART_SIZE, MULTIPART_THRESHOLD, } from "../../../constants/file-upload";
+import { TABLES } from "../../../constants/tables";
+import { UpdateExpressionBuilder } from "../../dynamodb";
+import { DynamoDbInstances } from "../../dynamodb/services/dynamodb.singleton";
+import { getLLMService } from "../../llm";
+import { ModelNotFoundError, ProviderNotFoundError } from "../../llm/errors";
+import { LoggerFactory } from "../../logger";
+import { extractS3Key, S3ServiceSingleton } from "../../s3";
+import { ValidationError } from "../../shared/errors";
+import { BaseAwsService } from "../../shared/services";
+import { sanitizeFilename } from "../../../utils";
+// Import constants
+import { ARCHIVED_STATUS, buildChatSessionPK, buildGsiPK, buildGsiSK, buildMessageSK, CHAT_KEYS, CHAT_LIMITS, } from "../constants";
+// Import errors
+import { SessionIntegrityError, SessionMessageLimitError, SessionMetadataMissingError, SessionNotFoundError, } from "../errors";
+// Import schemas
+import { addMessageParamsSchema, chatMessageSchema, chatSessionSchema, createSessionParamsSchema, deleteAllSessionsParamsSchema, deleteMessageParamsSchema, deleteSessionParamsSchema, getMessagesParamsSchema, getSessionByIdParamsSchema, getSessionsParamsSchema, getUsageParamsSchema, updateSessionParamsSchema, uploadAttachmentsParamsSchema, } from "../schemas";
+// Import utilities
+import { aggregateTokenUsage, calculateTokenUsage } from "../utilities";
+/**
+ * This service handles all chat-related operations.
+ * Provides methods for managing chat sessions and messages with proper validation,
+ * error handling, and data integrity checks.
+ */
+export class ChatService extends BaseAwsService {
+    constructor(deps) {
+        var _a, _b;
+        super({ logger: deps.logger });
+        this.db = (_a = deps.db) !== null && _a !== void 0 ? _a : DynamoDbInstances.getInstance(TABLES.chat);
+        this.s3Service = (_b = deps.s3) !== null && _b !== void 0 ? _b : S3ServiceSingleton.getInstance();
+    }
+    /**
+     * Get all chat sessions metadata for a user sorted by lastUpdated in descending order.
+     *
+     * @param tenantId Tenant ID to scope the query
+     * @param userId User ID to get sessions for
+     * @param opts Optional parameters for filtering and pagination
+     * @param options Optional service options including user credentials
+     * @returns Promise resolving to sessions array and pagination token
+     * @throws ValidationError if userId is invalid
+     *
+     * @example
+     * ```typescript
+     * const { sessions, lastEvaluatedKey } = await chatService.get(tenantId, userId, {
+     *   status: 'active',
+     *   limit: 20
+     * }, { userCredentials });
+     * ```
+     */
+    async get(tenantId, userId, opts, options) {
+        const validated = getSessionsParamsSchema.parse({
+            tenantId,
+            userId,
+            status: opts.status,
+            limit: opts.limit,
+            lastEvaluatedKey: opts.lastEvaluatedKey,
+        });
+        const archivedStatus = validated.status === "archived" ? ARCHIVED_STATUS.ARCHIVED : ARCHIVED_STATUS.ACTIVE;
+        const { Items, LastEvaluatedKey } = await this.db.queryItems({
+            IndexName: CHAT_KEYS.GSI_NAME,
+            KeyConditionExpression: "GSI_PK = :gsiPk AND begins_with(GSI_SK, :prefix)",
+            ExpressionAttributeValues: {
+                ":gsiPk": buildGsiPK(validated.tenantId, validated.userId),
+                ":prefix": `${archivedStatus}${CHAT_KEYS.SEPARATOR}`,
+            },
+            ScanIndexForward: false,
+            Limit: validated.limit,
+            ExclusiveStartKey: validated.lastEvaluatedKey,
+        }, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        const sessions = (Items !== null && Items !== void 0 ? Items : []).filter((item) => chatSessionSchema.safeParse(item).success);
+        return {
+            sessions,
+            lastEvaluatedKey: LastEvaluatedKey,
+        };
+    }
+    /**
+     * Get a specific chat session by its ID for a user.
+     *
+     * @param tenantId Tenant ID to scope the query
+     * @param userId User ID to get session for
+     * @param id ID of the session to get
+     * @param options Optional service options including user credentials
+     * @returns Promise resolving to session with messages, or null if not found
+     * @throws ValidationError if userId or sessionId is invalid
+     * @throws SessionMetadataMissingError if session data is corrupt
+     * @throws SessionIntegrityError if session userId doesn't match
+     *
+     * @example
+     * ```typescript
+     * const session = await chatService.getById(tenantId, userId, sessionId, { userCredentials });
+     * if (session) {
+     *   console.log(session.title, session.messages);
+     * }
+     * ```
+     */
+    async getById(tenantId, userId, id, options) {
+        const validated = getSessionByIdParamsSchema.parse({
+            tenantId,
+            userId,
+            sessionId: id,
+        });
+        const { Items } = await this.db.queryItems({
+            KeyConditionExpression: "PK = :pk",
+            ExpressionAttributeValues: {
+                ":pk": buildChatSessionPK(validated.tenantId, validated.userId, validated.sessionId),
+            },
+        }, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        if (!(Items === null || Items === void 0 ? void 0 : Items.length)) {
+            return null;
+        }
+        // Find and validate metadata
+        const metadataItem = Items.find((item) => item.SK === CHAT_KEYS.SORT_KEY.METADATA);
+        if (!metadataItem) {
+            throw new SessionMetadataMissingError();
+        }
+        const parseResult = chatSessionSchema.safeParse(metadataItem);
+        if (!parseResult.success) {
+            throw new Error("Invalid session metadata structure");
+        }
+        const metadata = parseResult.data;
+        // Defensive check for data integrity
+        if (metadata.userId !== validated.userId) {
+            throw new SessionIntegrityError();
+        }
+        // Find and validate messages
+        const messageItems = Items.filter((item) => item.SK.startsWith(CHAT_KEYS.SORT_KEY.MESSAGE_PREFIX));
+        const messages = messageItems.filter((item) => chatMessageSchema.safeParse(item).success);
+        // Generate presigned URLs for attachments so they're accessible
+        const messagesWithPresignedUrls = await this.generatePresignedUrlsForMessages(messages, options);
+        return Object.assign(Object.assign({}, metadata), { messages: messagesWithPresignedUrls });
+    }
+    /**
+     * Create a new chat session for a user.
+     *
+     * @param tenantId Tenant ID to scope the session
+     * @param userId User ID who owns the session
+     * @param title Optional session title (defaults to "New Chat")
+     * @param options Optional service options including user credentials
+     * @returns Promise resolving to created session
+     * @throws ValidationError if userId or title is invalid
+     *
+     * @example
+     * ```typescript
+     * const session = await chatService.create(tenantId, userId, "My Chat Session", { userCredentials });
+     * console.log(session.id); // UUID
+     * ```
+     */
+    async create(tenantId, userId, title = "New Chat", options) {
+        const validated = createSessionParamsSchema.parse({
+            tenantId,
+            userId,
+            title,
+        });
+        const id = crypto.randomUUID();
+        const lastUpdated = Date.now();
+        const session = {
+            id,
+            userId: validated.userId,
+            title: validated.title,
+            lastUpdated,
+            isArchived: ARCHIVED_STATUS.ACTIVE,
+        };
+        await this.db.putItem(Object.assign({ PK: buildChatSessionPK(validated.tenantId, validated.userId, id), SK: CHAT_KEYS.SORT_KEY.METADATA, GSI_PK: buildGsiPK(validated.tenantId, validated.userId), GSI_SK: buildGsiSK(ARCHIVED_STATUS.ACTIVE, lastUpdated) }, session), { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        return session;
+    }
+    /**
+     * Update an existing session.
+     *
+     * @param tenantId Tenant ID to scope the session
+     * @param userId User ID who owns the session
+     * @param id ID of the session to update
+     * @param updates Partial session fields to update
+     * @param options Optional service options including user credentials
+     * @returns Promise resolving to updated session
+     * @throws ValidationError if userId, sessionId, or updates are invalid
+     * @throws SessionNotFoundError if session doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const updated = await chatService.update(tenantId, userId, sessionId, {
+     *   title: "Updated Title",
+     *   isArchived: 1
+     * }, { userCredentials });
+     * ```
+     */
+    async update(tenantId, userId, id, updates, options) {
+        const validated = updateSessionParamsSchema.parse({
+            tenantId,
+            userId,
+            sessionId: id,
+            updates: {
+                title: updates.title,
+                isArchived: updates.isArchived,
+            },
+        });
+        // Verify session exists
+        const current = await this.getById(validated.tenantId, validated.userId, validated.sessionId, options);
+        if (!current) {
+            throw new SessionNotFoundError();
+        }
+        const lastUpdated = Date.now();
+        const isArchived = validated.updates.isArchived !== undefined
+            ? validated.updates.isArchived
+                ? 1
+                : 0
+            : current.isArchived;
+        // Build update expression using UpdateExpressionBuilder
+        const builder = new UpdateExpressionBuilder()
+            .set("lastUpdated", lastUpdated)
+            .set("GSI_PK", buildGsiPK(validated.tenantId, validated.userId))
+            .set("GSI_SK", buildGsiSK(isArchived, lastUpdated))
+            .setOptional("title", validated.updates.title)
+            .setOptional("isArchived", isArchived);
+        const { UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues } = builder.build();
+        const { Attributes } = await this.db.updateItem({
+            PK: buildChatSessionPK(validated.tenantId, validated.userId, validated.sessionId),
+            SK: CHAT_KEYS.SORT_KEY.METADATA,
+        }, UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        const updateResult = chatSessionSchema.safeParse(Attributes);
+        if (!updateResult.success) {
+            throw new Error("Invalid session data returned from update");
+        }
+        return updateResult.data;
+    }
+    /**
+     * Delete a chat session and all its messages.
+     *
+     * @param tenantId Tenant ID to scope the session
+     * @param userId User ID who owns the session
+     * @param id ID of the session to delete
+     * @param options Optional service options including user credentials
+     * @returns Promise that resolves when deletion is complete
+     * @throws ValidationError if userId or sessionId is invalid
+     *
+     * @remarks
+     * This method is idempotent - calling delete on a non-existent session will
+     * succeed without error. This follows the principle that the desired state
+     * (session deleted) is achieved regardless of whether the session existed.
+     *
+     * Queries all items (metadata + messages) once, extracts attachments,
+     * deletes attachments from S3, then deletes items from DynamoDB
+     * using batch write (which handles chunking automatically).
+     *
+     * @example
+     * ```typescript
+     * await chatService.delete(tenantId, userId, sessionId, { userCredentials });
+     * // Calling again won't throw an error
+     * await chatService.delete(tenantId, userId, sessionId, { userCredentials }); // Silent success
+     * ```
+     */
+    async delete(tenantId, userId, id, options) {
+        const validated = deleteSessionParamsSchema.parse({
+            tenantId,
+            userId,
+            sessionId: id,
+        });
+        // Query once to get all items and collect both attachments and items to delete
+        const allItemsToDelete = [];
+        const allAttachments = [];
+        let lastEvaluatedKey;
+        do {
+            const { Items, LastEvaluatedKey } = await this.db.queryItems({
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: {
+                    ":pk": buildChatSessionPK(validated.tenantId, validated.userId, validated.sessionId),
+                },
+                ExclusiveStartKey: lastEvaluatedKey,
+            }, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+            if (Items === null || Items === void 0 ? void 0 : Items.length) {
+                // Extract items to delete and collect attachments in a single pass
+                for (const item of Items) {
+                    // Add item to delete list
+                    allItemsToDelete.push({
+                        PK: item.PK,
+                        SK: item.SK,
+                    });
+                    // Check if this is a message with attachments
+                    if (typeof item.SK === "string" &&
+                        item.SK.startsWith(CHAT_KEYS.SORT_KEY.MESSAGE_PREFIX) &&
+                        Array.isArray(item.attachments) &&
+                        item.attachments.length > 0) {
+                        allAttachments.push(...item.attachments);
+                    }
+                }
+            }
+            lastEvaluatedKey = LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+        // If no items found, session doesn't exist - we're done (idempotent)
+        if (allItemsToDelete.length === 0) {
+            return;
+        }
+        // Delete all attachments from S3
+        if (allAttachments.length > 0) {
+            await this.deleteMessageAttachments(allAttachments, options);
+        }
+        // Delete all items from DynamoDB
+        await this.db.batchWrite(allItemsToDelete, "delete", {
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+    }
+    /**
+     * Delete all chat sessions for a user.
+     * This will remove all sessions (both active and archived) and all their messages.
+     *
+     * @param tenantId Tenant ID to scope the sessions
+     * @param userId User ID whose sessions should be deleted
+     * @param options Optional service options including user credentials
+     * @returns Promise resolving to the number of sessions deleted
+     * @throws ValidationError if userId is invalid
+     *
+     * @remarks
+     * This is a destructive operation that cannot be undone. The method:
+     * 1. Queries all session metadata using the GSI to get session IDs
+     * 2. Queries all items (metadata + messages) for each session in parallel,
+     *    collecting both attachments and items to delete in a single pass
+     * 3. Deletes all attachments from S3
+     * 4. Batch deletes all items from DynamoDB (batchWrite handles chunking automatically)
+     * 5. Returns the total count of sessions deleted
+     *
+     * Uses Promise.all for parallel queries to minimize latency when deleting
+     * multiple sessions. The batchWrite operation automatically chunks items into
+     * groups of 25 and handles retries for unprocessed items.
+     *
+     * This method is idempotent - calling it multiple times will succeed
+     * without error, returning 0 for subsequent calls.
+     *
+     * @example
+     * ```typescript
+     * const deletedCount = await chatService.deleteAll(tenantId, userId, { userCredentials });
+     * console.log(`Deleted ${deletedCount} sessions`);
+     * ```
+     */
+    async deleteAll(tenantId, userId, options) {
+        const validated = deleteAllSessionsParamsSchema.parse({
+            tenantId,
+            userId,
+        });
+        // Step 1: Query all session metadata to get session IDs
+        const sessionIds = [];
+        let lastEvaluatedKey;
+        do {
+            const { Items, LastEvaluatedKey } = await this.db.queryItems({
+                IndexName: CHAT_KEYS.GSI_NAME,
+                KeyConditionExpression: "GSI_PK = :gsiPk",
+                ExpressionAttributeValues: {
+                    ":gsiPk": buildGsiPK(validated.tenantId, validated.userId),
+                },
+                ExclusiveStartKey: lastEvaluatedKey,
+                Limit: CHAT_LIMITS.MAX_SESSION_LIMIT,
+            }, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+            if (Items === null || Items === void 0 ? void 0 : Items.length) {
+                const sessions = Items.filter((item) => chatSessionSchema.safeParse(item).success);
+                sessionIds.push(...sessions.map((s) => s.id));
+            }
+            lastEvaluatedKey = LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+        if (sessionIds.length === 0) {
+            return 0;
+        }
+        // Step 2: Query all sessions in parallel, collecting both items to delete and attachments
+        const querySessionItemsAndAttachments = async (sessionId) => {
+            const items = [];
+            const attachments = [];
+            let sessionLastKey;
+            do {
+                const { Items, LastEvaluatedKey } = await this.db.queryItems({
+                    KeyConditionExpression: "PK = :pk",
+                    ExpressionAttributeValues: {
+                        ":pk": buildChatSessionPK(validated.tenantId, validated.userId, sessionId),
+                    },
+                    ExclusiveStartKey: sessionLastKey,
+                }, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+                if (Items === null || Items === void 0 ? void 0 : Items.length) {
+                    for (const item of Items) {
+                        // Add item to delete list
+                        items.push({
+                            PK: item.PK,
+                            SK: item.SK,
+                        });
+                        // Check if this is a message with attachments
+                        if (typeof item.SK === "string" &&
+                            item.SK.startsWith(CHAT_KEYS.SORT_KEY.MESSAGE_PREFIX) &&
+                            Array.isArray(item.attachments) &&
+                            item.attachments.length > 0) {
+                            attachments.push(...item.attachments);
+                        }
+                    }
+                }
+                sessionLastKey = LastEvaluatedKey;
+            } while (sessionLastKey);
+            return { items, attachments };
+        };
+        // Execute all queries in parallel
+        const allSessionData = await Promise.all(sessionIds.map((id) => querySessionItemsAndAttachments(id)));
+        // Step 3: Flatten items and attachments from all sessions
+        const allItemsToDelete = allSessionData.flatMap((data) => data.items);
+        const allAttachments = allSessionData.flatMap((data) => data.attachments);
+        // Step 4: Delete all attachments from S3
+        if (allAttachments.length > 0) {
+            await this.deleteMessageAttachments(allAttachments, options);
+        }
+        // Step 5: Batch delete all items from DynamoDB
+        if (allItemsToDelete.length > 0) {
+            await this.db.batchWrite(allItemsToDelete, "delete", {
+                userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+            });
+        }
+        return sessionIds.length;
+    }
+    /**
+     * Get all messages for a chat session sorted by timestamp.
+     *
+     * @param tenantId Tenant ID to scope the session
+     * @param userId User ID who owns the session
+     * @param sessionId Session ID to get messages for
+     * @param options Optional service options including user credentials
+     * @returns Promise resolving to array of messages
+     * @throws ValidationError if userId or sessionId is invalid
+     *
+     * @example
+     * ```typescript
+     * const messages = await chatService.getMessages(tenantId, userId, sessionId, { userCredentials });
+     * messages.forEach(msg => console.log(msg.content));
+     * ```
+     */
+    async getMessages(tenantId, userId, sessionId, options) {
+        const validated = getMessagesParamsSchema.parse({
+            tenantId,
+            userId,
+            sessionId,
+        });
+        const { Items } = await this.db.queryItems({
+            KeyConditionExpression: "PK = :pk AND begins_with(SK, :prefix)",
+            ExpressionAttributeValues: {
+                ":pk": buildChatSessionPK(validated.tenantId, validated.userId, validated.sessionId),
+                ":prefix": CHAT_KEYS.SORT_KEY.MESSAGE_PREFIX,
+            },
+            ScanIndexForward: true, // Sort by timestamp ascending
+        }, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        const messages = (Items !== null && Items !== void 0 ? Items : []).filter((item) => chatMessageSchema.safeParse(item).success);
+        // Generate presigned URLs for attachments so they're accessible
+        return this.generatePresignedUrlsForMessages(messages, options);
+    }
+    /**
+     * Add a new message to a chat session.
+     * Validates session exists, is not archived, and hasn't reached message limit before adding.
+     * Automatically updates the session's lastUpdated timestamp.
+     *
+     * @param params Message parameters
+     * @param params.tenantId Tenant ID to scope the session
+     * @param params.userId User ID who owns the session
+     * @param params.sessionId Session ID to add message to
+     * @param params.content Message content
+     * @param params.providerId AI provider ID (e.g., "openai")
+     * @param params.modelId Model ID (e.g., "gpt-4")
+     * @param params.role Message role ("user", "assistant", or "system")
+     * @param params.reasoning Optional AI reasoning/chain-of-thought
+     * @param params.reasoningDuration Optional reasoning duration in ms
+     * @param params.sources Optional web search sources
+     * @param params.attachments Optional file attachments
+     * @param params.messageId Optional existing message ID for versioning
+     * @param params.sdkUsage Optional SDK usage for token tracking
+     * @param options Optional service options including user credentials
+     * @returns Promise resolving to created message
+     * @throws ValidationError if any input is invalid
+     * @throws SessionNotFoundError if session doesn't exist
+     * @throws SessionMessageLimitError if session has reached maximum message count (10,000)
+     *
+     * @example
+     * ```typescript
+     * const message = await chatService.addMessage({
+     *   tenantId,
+     *   userId,
+     *   sessionId,
+     *   content: "Hello!",
+     *   providerId: "openai",
+     *   modelId: "gpt-4",
+     *   role: "user",
+     * }, { userCredentials });
+     * ```
+     */
+    async addMessage(params, options) {
+        var _a, _b, _c, _d, _e;
+        const validated = addMessageParamsSchema.parse(params);
+        // Validate provider and model exist in the system
+        const llmService = getLLMService();
+        const provider = await llmService.getProviderById(validated.tenantId, validated.providerId, options);
+        if (!provider) {
+            throw new ProviderNotFoundError(validated.providerId);
+        }
+        const model = await llmService.getModel(validated.tenantId, validated.providerId, validated.modelId, options);
+        if (!model) {
+            throw new ModelNotFoundError(validated.modelId);
+        }
+        // Verify session exists and belongs to user (prevent orphaned messages)
+        const session = await this.getById(validated.tenantId, validated.userId, validated.sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        // Check message count limit to prevent partition key size issues
+        const messageCount = (_b = (_a = session.messages) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        if (messageCount >= CHAT_LIMITS.MAX_MESSAGES_PER_SESSION) {
+            throw new SessionMessageLimitError(CHAT_LIMITS.MAX_MESSAGES_PER_SESSION);
+        }
+        const usage = validated.sdkUsage ? calculateTokenUsage(validated.sdkUsage, model) : undefined;
+        const timestamp = Date.now();
+        if (validated.messageId) {
+            const existingMessage = (_c = session.messages) === null || _c === void 0 ? void 0 : _c.find((m) => m.id === validated.messageId);
+            if (!existingMessage) {
+                throw new ValidationError("Message doesn't exist");
+            }
+            const newVersionId = crypto.randomUUID();
+            const updatedMessage = Object.assign(Object.assign({}, existingMessage), { timestamp, versions: [
+                    ...existingMessage.versions,
+                    {
+                        id: newVersionId,
+                        content: validated.content,
+                    },
+                ], reasoning: validated.reasoning
+                    ? {
+                        content: validated.reasoning,
+                        duration: validated.reasoningDuration || 0,
+                    }
+                    : existingMessage.reasoning, sources: (_d = validated.sources) !== null && _d !== void 0 ? _d : existingMessage.sources, usage: usage !== null && usage !== void 0 ? usage : existingMessage.usage, attachments: (_e = validated.attachments) !== null && _e !== void 0 ? _e : existingMessage.attachments });
+            await this.db.putItem(Object.assign({ PK: buildChatSessionPK(validated.tenantId, validated.userId, validated.sessionId), SK: buildMessageSK(existingMessage.timestamp, existingMessage.id) }, updatedMessage), { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+            await this.updateSessionUsage(validated.tenantId, validated.userId, validated.sessionId, options);
+            await this.update(validated.tenantId, validated.userId, validated.sessionId, {}, options); // update lastUpdated
+            // Generate presigned URLs for attachments before returning
+            // Return a new object to avoid mutating the saved data
+            if (updatedMessage.attachments && updatedMessage.attachments.length > 0) {
+                const presignedAttachments = await this.generatePresignedUrlsForAttachments(updatedMessage.attachments, options);
+                return Object.assign(Object.assign({}, updatedMessage), { attachments: presignedAttachments });
+            }
+            return updatedMessage;
+        }
+        const id = crypto.randomUUID();
+        const message = {
+            id,
+            sessionId: validated.sessionId,
+            timestamp,
+            providerId: provider.id,
+            modelId: model.id,
+            role: validated.role,
+            reasoning: validated.reasoning
+                ? {
+                    content: validated.reasoning,
+                    duration: validated.reasoningDuration || 0,
+                }
+                : undefined,
+            sources: validated.sources,
+            attachments: validated.attachments,
+            versions: [
+                {
+                    id,
+                    content: validated.content,
+                },
+            ],
+            usage,
+        };
+        await this.db.putItem(Object.assign({ PK: buildChatSessionPK(validated.tenantId, validated.userId, validated.sessionId), SK: buildMessageSK(timestamp, id) }, message), { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        // Update session's aggregated usage and lastUpdated timestamp
+        await this.updateSessionUsage(validated.tenantId, validated.userId, validated.sessionId, options);
+        await this.update(validated.tenantId, validated.userId, validated.sessionId, {}, options);
+        // Generate presigned URLs for attachments before returning
+        // Return a new object to avoid mutating the saved data
+        if (message.attachments && message.attachments.length > 0) {
+            const presignedAttachments = await this.generatePresignedUrlsForAttachments(message.attachments, options);
+            return Object.assign(Object.assign({}, message), { attachments: presignedAttachments });
+        }
+        return message;
+    }
+    /**
+     * Update aggregated usage statistics for a session
+     * This should be called after adding a new message to keep usage in sync
+     *
+     * @param tenantId - Tenant ID to scope the session
+     * @param userId - User ID who owns the session
+     * @param sessionId - Session ID to update
+     * @param options - Optional service options including user credentials
+     * @private
+     */
+    async updateSessionUsage(tenantId, userId, sessionId, options) {
+        // Fetch the session with all messages
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session || !session.messages) {
+            return;
+        }
+        // Filter messages that have usage data
+        const messagesWithUsage = session.messages.filter((msg) => msg.usage !== undefined);
+        if (messagesWithUsage.length === 0) {
+            return;
+        }
+        // Aggregate all usage data
+        const aggregated = aggregateTokenUsage(messagesWithUsage.map((msg) => msg.usage));
+        // Update the session metadata with aggregated usage
+        await this.db.updateItem({
+            PK: buildChatSessionPK(tenantId, userId, sessionId),
+            SK: CHAT_KEYS.SORT_KEY.METADATA,
+        }, "SET #aggregatedUsage = :aggregatedUsage", {
+            "#aggregatedUsage": "aggregatedUsage",
+        }, {
+            ":aggregatedUsage": Object.assign(Object.assign({}, aggregated), { lastCalculated: Date.now() }),
+        }, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+    }
+    /**
+     * Get usage statistics for a session
+     * Returns both aggregated session usage and per-message breakdown
+     *
+     * @param tenantId - Tenant ID to scope the session
+     * @param userId - User ID who owns the session
+     * @param sessionId - Session ID to get usage for
+     * @param options - Optional service options including user credentials
+     * @returns Usage statistics with session and message-level details
+     * @throws ValidationError if userId or sessionId is invalid
+     * @throws SessionNotFoundError if session doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const usage = await chatService.getUsage(tenantId, userId, sessionId, { userCredentials });
+     * console.log(`Total cost: $${usage.sessionUsage.totalCost.toFixed(4)}`);
+     * console.log(`Total tokens: ${usage.sessionUsage.totalTokens}`);
+     * ```
+     */
+    async getUsage(tenantId, userId, sessionId, options) {
+        const validated = getUsageParamsSchema.parse({
+            tenantId,
+            userId,
+            sessionId,
+        });
+        const session = await this.getById(validated.tenantId, validated.userId, validated.sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        // Get LLM service to fetch provider/model names
+        const llmService = getLLMService();
+        // Extract messages with usage and resolve names
+        const messagesWithUsage = (session.messages || []).filter((msg) => msg.usage);
+        // Batch fetch all unique providers and models to minimize queries
+        const uniqueProviderIds = new Set(messagesWithUsage.map((msg) => msg.providerId));
+        const uniqueModelPairs = new Map(messagesWithUsage.map((msg) => [
+            `${msg.providerId}#${msg.modelId}`,
+            { providerId: msg.providerId, modelId: msg.modelId },
+        ]));
+        // Fetch all providers in parallel
+        const providersMap = new Map();
+        await Promise.all(Array.from(uniqueProviderIds).map(async (providerId) => {
+            try {
+                const provider = await llmService.getProviderById(validated.tenantId, providerId, options);
+                if (provider) {
+                    providersMap.set(providerId, provider.name);
+                }
+            }
+            catch (_a) {
+                providersMap.set(providerId, "Unknown Provider");
+            }
+        }));
+        // Fetch all models in parallel
+        const modelsMap = new Map();
+        await Promise.all(Array.from(uniqueModelPairs.values()).map(async ({ providerId, modelId }) => {
+            const key = `${providerId}#${modelId}`;
+            try {
+                const model = await llmService.getModel(validated.tenantId, providerId, modelId, options);
+                if (model) {
+                    modelsMap.set(key, model.name);
+                }
+            }
+            catch (_a) {
+                // Use modelId as fallback since it's usually readable (e.g., "gpt-4")
+                modelsMap.set(key, modelId);
+            }
+        }));
+        // Extract message-level usage details
+        const messageUsages = messagesWithUsage
+            .filter((msg) => msg.usage !== undefined)
+            .map((msg) => {
+            var _a;
+            const modelKey = `${msg.providerId}#${msg.modelId}`;
+            return {
+                messageId: msg.id,
+                timestamp: msg.timestamp,
+                role: msg.role,
+                promptTokens: msg.usage.promptTokens,
+                completionTokens: msg.usage.completionTokens,
+                reasoningTokens: msg.usage.reasoningTokens,
+                totalTokens: msg.usage.totalTokens,
+                cost: msg.usage.estimatedCost,
+                model: {
+                    id: msg.modelId,
+                    name: modelsMap.get(modelKey) || msg.modelId,
+                },
+                provider: {
+                    id: msg.providerId,
+                    name: (_a = providersMap.get(msg.providerId)) !== null && _a !== void 0 ? _a : "Unknown Provider",
+                },
+            };
+        });
+        // Use cached aggregated usage if available, otherwise calculate from messages
+        let aggregated = session.aggregatedUsage;
+        if (!aggregated) {
+            // Compute from messages
+            const messagesWithUsageData = (session.messages || []).filter((msg) => msg.usage !== undefined);
+            if (messagesWithUsageData.length > 0) {
+                const computed = aggregateTokenUsage(messagesWithUsageData.map((msg) => msg.usage));
+                aggregated = Object.assign(Object.assign({}, computed), { lastCalculated: Date.now() });
+            }
+            else {
+                // No usage data at all - use zeros
+                aggregated = {
+                    totalPromptTokens: 0,
+                    totalCompletionTokens: 0,
+                    totalReasoningTokens: 0,
+                    totalTokens: 0,
+                    totalCost: 0,
+                    messageCount: 0,
+                    lastCalculated: Date.now(),
+                };
+            }
+        }
+        return {
+            sessionUsage: {
+                sessionId: session.id,
+                sessionTitle: session.title,
+                totalPromptTokens: aggregated.totalPromptTokens,
+                totalCompletionTokens: aggregated.totalCompletionTokens,
+                totalReasoningTokens: aggregated.totalReasoningTokens,
+                totalTokens: aggregated.totalTokens,
+                totalCost: aggregated.totalCost,
+                messageCount: aggregated.messageCount,
+                lastUpdated: aggregated.lastCalculated,
+            },
+            messageUsages,
+        };
+    }
+    /**
+     * Upload files for a chat message
+     * Returns array of MessageAttachment metadata
+     */
+    async uploadMessageAttachments(userId, sessionId, files, options) {
+        if (!files || files.length === 0) {
+            return [];
+        }
+        const validated = uploadAttachmentsParamsSchema.parse({
+            userId,
+            sessionId,
+        });
+        const s3UrlPrefix = this.s3Service.getObjectUrlPrefix() + "/";
+        const uploadPromises = files.map(async (file) => {
+            let fileSize;
+            // Sanitize filename to prevent security issues
+            const sanitizedFilename = sanitizeFilename(file.filename || "unnamed");
+            // Check if the file URL is already from our S3 bucket
+            if (file.url.startsWith(s3UrlPrefix)) {
+                // File is already uploaded to our S3 bucket - use existing URL
+                const s3Key = file.url.replace(s3UrlPrefix, "");
+                // Verify the file belongs to this session
+                const expectedPrefix = `conversations/${validated.sessionId}/`;
+                if (!s3Key.startsWith(expectedPrefix)) {
+                    throw new ValidationError("File does not belong to this session");
+                }
+                // Return attachment metadata with existing URL
+                const attachment = {
+                    filename: sanitizedFilename,
+                    mediaType: file.mediaType,
+                    url: file.url,
+                    size: file.size || 0,
+                    timestamp: Date.now(),
+                };
+                return attachment;
+            }
+            // Generate unique file key for new uploads
+            const fileId = crypto.randomUUID();
+            const fileExtension = sanitizedFilename.split(".").pop() || "bin";
+            const s3Key = `conversations/${validated.sessionId}/${fileId}.${fileExtension}`;
+            // Upload to S3 - prefer streaming when available
+            if (file.stream) {
+                // Stream upload - no memory buffering
+                await this.s3Service.uploadLargeFile({
+                    key: s3Key,
+                    body: file.stream,
+                    contentType: file.mediaType,
+                    metadata: {
+                        userId: validated.userId,
+                        sessionId: validated.sessionId,
+                        originalFilename: sanitizedFilename,
+                    },
+                    userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+                });
+                fileSize = file.size || 0;
+            }
+            else {
+                // Legacy: Load into memory for data URLs or external URLs
+                let fileData;
+                if (file.url.startsWith("data:")) {
+                    // Data URL - extract base64
+                    const base64Data = file.url.split(",")[1] || file.url;
+                    fileData = Buffer.from(base64Data, "base64");
+                    fileSize = fileData.length;
+                }
+                else {
+                    // External URL - fetch it
+                    const response = await fetch(file.url);
+                    const arrayBuffer = await response.arrayBuffer();
+                    fileData = Buffer.from(arrayBuffer);
+                    fileSize = arrayBuffer.byteLength;
+                }
+                await this.s3Service.uploadFile({
+                    key: s3Key,
+                    body: fileData,
+                    contentType: file.mediaType,
+                    metadata: {
+                        userId: validated.userId,
+                        sessionId: validated.sessionId,
+                        originalFilename: sanitizedFilename,
+                    },
+                    userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+                });
+            }
+            // Generate attachment metadata
+            const attachment = {
+                filename: sanitizedFilename,
+                mediaType: file.mediaType,
+                url: this.s3Service.getObjectUrl(s3Key),
+                size: fileSize,
+                timestamp: Date.now(),
+            };
+            return attachment;
+        });
+        return Promise.all(uploadPromises);
+    }
+    /**
+     * Delete a message and its attachments
+     *
+     * @param tenantId - Tenant ID to scope the session
+     * @param userId - User ID who owns the session
+     * @param sessionId - Session ID containing the message
+     * @param messageId - Message ID to delete
+     * @param options - Optional service options including user credentials
+     * @throws SessionNotFoundError if session doesn't exist
+     * @throws ValidationError if message is not found
+     *
+     * @example
+     * ```typescript
+     * await chatService.deleteMessage(tenantId, userId, sessionId, messageId, { userCredentials });
+     * ```
+     */
+    async deleteMessage(tenantId, userId, sessionId, messageId, options) {
+        var _a;
+        const validated = deleteMessageParamsSchema.parse({
+            tenantId,
+            userId,
+            sessionId,
+            messageId,
+        });
+        const session = await this.getById(validated.tenantId, validated.userId, validated.sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        const message = (_a = session.messages) === null || _a === void 0 ? void 0 : _a.find((m) => m.id === validated.messageId);
+        if (!message) {
+            throw new ValidationError("Message not found");
+        }
+        // Delete attachments from S3 if any
+        if (message.attachments && message.attachments.length > 0) {
+            await this.deleteMessageAttachments(message.attachments, options);
+        }
+        // Delete message from database
+        await this.db.deleteItem({
+            PK: buildChatSessionPK(validated.tenantId, validated.userId, validated.sessionId),
+            SK: buildMessageSK(message.timestamp, validated.messageId),
+        }, { userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        // Update aggregated usage after deletion
+        await this.updateSessionUsage(validated.tenantId, validated.userId, validated.sessionId, options);
+        await this.update(validated.tenantId, validated.userId, validated.sessionId, {}, options);
+    }
+    /**
+     * Delete attachments when a message is deleted
+     */
+    async deleteMessageAttachments(attachments, options) {
+        if (!attachments || attachments.length === 0) {
+            return;
+        }
+        const deletePromises = attachments.map(async (attachment) => {
+            const s3Key = extractS3Key(attachment.url);
+            try {
+                await this.s3Service.deleteFile({
+                    key: s3Key,
+                    userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+                });
+            }
+            catch (_a) {
+                // don't fail - orphaned files are better than failed deletions
+            }
+        });
+        await Promise.allSettled(deletePromises);
+    }
+    /**
+     * Generate presigned URLs for message attachments
+     * Replaces direct S3 URLs with presigned URLs that are accessible
+     */
+    async generatePresignedUrlsForAttachments(attachments, options) {
+        if (!attachments || attachments.length === 0) {
+            return [];
+        }
+        const presignedPromises = attachments.map(async (attachment) => {
+            try {
+                const s3Key = extractS3Key(attachment.url);
+                // Generate presigned URL valid for 1 hour
+                const presignedUrl = await this.s3Service.generateSignedUrl({
+                    key: s3Key,
+                    operation: "getObject",
+                    expiresIn: 3600, // 1 hour
+                    userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+                });
+                return Object.assign(Object.assign({}, attachment), { url: presignedUrl });
+            }
+            catch (error) {
+                // If presigned URL generation fails, return original attachment
+                // (will likely fail to load, but better than losing the metadata)
+                this.logger.warn("Failed to generate presigned URL for attachment", {
+                    url: attachment.url,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+                return attachment;
+            }
+        });
+        return Promise.all(presignedPromises);
+    }
+    /**
+     * Generate presigned URLs for all attachments in messages
+     * Only generates for recent messages (last 20 or within 24 hours) to optimize performance
+     */
+    async generatePresignedUrlsForMessages(messages, options) {
+        if (!messages || messages.length === 0) {
+            return [];
+        }
+        const now = Date.now();
+        const twentyFourHoursAgo = now - 24 * 60 * 60 * 1000;
+        // Only generate presigned URLs for recent messages to optimize performance
+        // Messages older than 24 hours or beyond the last 20 messages will need
+        // to generate presigned URLs on-demand when downloading
+        const messagesToProcess = messages
+            .filter((m) => m.timestamp > twentyFourHoursAgo || messages.indexOf(m) >= messages.length - 20)
+            .filter((m) => m.attachments && m.attachments.length > 0);
+        if (messagesToProcess.length === 0) {
+            return messages;
+        }
+        // Generate presigned URLs for filtered messages
+        const processedMessages = await Promise.all(messagesToProcess.map(async (message) => {
+            const presignedAttachments = await this.generatePresignedUrlsForAttachments(message.attachments, options);
+            return {
+                message,
+                presignedAttachments,
+            };
+        }));
+        // Replace attachments in original messages array
+        return messages.map((message) => {
+            const processed = processedMessages.find((p) => p.message.id === message.id);
+            if (processed) {
+                return Object.assign(Object.assign({}, message), { attachments: processed.presignedAttachments });
+            }
+            return message;
+        });
+    }
+    // ============================================================================
+    // File Operations
+    // ============================================================================
+    /**
+     * Get all file attachments for a session
+     */
+    async getSessionFiles(tenantId, userId, sessionId, options) {
+        var _a;
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        const files = [];
+        (_a = session.messages) === null || _a === void 0 ? void 0 : _a.forEach((message) => {
+            if (message.attachments && message.attachments.length > 0) {
+                message.attachments.forEach((attachment) => {
+                    files.push(Object.assign({ messageId: message.id }, attachment));
+                });
+            }
+        });
+        // Sort by timestamp (newest first)
+        files.sort((a, b) => b.timestamp - a.timestamp);
+        return files;
+    }
+    /**
+     * Generate a presigned download URL for a file in a session
+     */
+    async getFileDownloadUrl(tenantId, userId, sessionId, fileUrl, options) {
+        var _a;
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        const s3Key = extractS3Key(fileUrl);
+        // Verify this file belongs to this session
+        const fileInMessage = (_a = session.messages) === null || _a === void 0 ? void 0 : _a.some((msg) => {
+            var _a;
+            return (_a = msg.attachments) === null || _a === void 0 ? void 0 : _a.some((attachment) => {
+                try {
+                    return extractS3Key(attachment.url) === s3Key;
+                }
+                catch (_a) {
+                    return attachment.url === fileUrl;
+                }
+            });
+        });
+        // Also allow pending files that belong to this session
+        const expectedPrefix = `conversations/${sessionId}/`;
+        const isPendingFileForSession = s3Key.startsWith(expectedPrefix);
+        if (!fileInMessage && !isPendingFileForSession) {
+            throw new ValidationError("File not found in this session");
+        }
+        return this.s3Service.generateSignedUrl({
+            key: s3Key,
+            operation: "getObject",
+            expiresIn: 3600,
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+    }
+    /**
+     * Delete a temporary file (not yet attached to a message)
+     */
+    async deleteTempFile(tenantId, userId, sessionId, messageId, fileUrl, options) {
+        // Verify session exists
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        // Only allow deletion of temporary files
+        if (!messageId.startsWith("temp-")) {
+            throw new ValidationError("Cannot delete attachments from existing messages. Only temporary files can be deleted.");
+        }
+        const s3Key = extractS3Key(fileUrl);
+        // Verify the file belongs to this session
+        const expectedPrefix = `conversations/${sessionId}/`;
+        if (!s3Key.startsWith(expectedPrefix)) {
+            throw new ValidationError("File does not belong to this session");
+        }
+        try {
+            await this.s3Service.deleteFile({
+                key: s3Key,
+                userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+            });
+        }
+        catch (_a) {
+            // don't fail - file might already be deleted
+        }
+    }
+    /**
+     * Get a presigned URL for uploading a small file (≤5MB)
+     */
+    async getPresignedUploadUrl(tenantId, userId, sessionId, fileName, fileSize, contentType, options) {
+        // Verify session exists
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        // Check if should use multipart
+        if (fileSize > MULTIPART_THRESHOLD) {
+            throw new ValidationError(`File size ${fileSize} exceeds ${MULTIPART_THRESHOLD} bytes. Use multipart upload instead.`);
+        }
+        // Generate unique file key
+        const fileId = crypto.randomUUID();
+        const sanitizedFilename = sanitizeFilename(fileName);
+        const fileExtension = sanitizedFilename.split(".").pop() || "bin";
+        const s3Key = `conversations/${sessionId}/${fileId}.${fileExtension}`;
+        const url = await this.s3Service.generateSignedUrl({
+            key: s3Key,
+            operation: "putObject",
+            contentType,
+            expiresIn: DEFAULT_URL_EXPIRY,
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+        return {
+            fileId,
+            key: s3Key,
+            bucket: this.s3Service.getBucketName(),
+            url,
+            objectUrl: this.s3Service.getObjectUrl(s3Key),
+            expiresIn: DEFAULT_URL_EXPIRY,
+        };
+    }
+    /**
+     * Initiate a multipart upload for large files (>5MB)
+     */
+    async initiateMultipartUpload(tenantId, userId, sessionId, fileName, fileSize, contentType, options) {
+        // Verify session exists
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        // Generate unique file key
+        const fileId = crypto.randomUUID();
+        const sanitizedFilename = sanitizeFilename(fileName);
+        const fileExtension = sanitizedFilename.split(".").pop() || "bin";
+        const s3Key = `conversations/${sessionId}/${fileId}.${fileExtension}`;
+        const partSize = MIN_PART_SIZE;
+        const totalParts = Math.ceil(fileSize / partSize);
+        const result = await this.s3Service.createMultipartUpload({
+            key: s3Key,
+            contentType,
+            serverSideEncryption: "AES256",
+            metadata: {
+                "original-filename": sanitizedFilename,
+                "session-id": sessionId,
+            },
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+        return {
+            fileId,
+            key: s3Key,
+            bucket: result.bucket,
+            uploadId: result.uploadId,
+            partSize,
+            totalParts,
+        };
+    }
+    /**
+     * Get a presigned URL for uploading a specific part
+     */
+    async getMultipartPartUrl(tenantId, userId, sessionId, key, uploadId, partNumber, options) {
+        // Verify session exists
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        // Verify the key belongs to this session
+        const expectedPrefix = `conversations/${sessionId}/`;
+        if (!key.startsWith(expectedPrefix)) {
+            throw new ValidationError("Key does not belong to this session");
+        }
+        const url = await this.s3Service.getUploadPartUrl({
+            key,
+            uploadId,
+            partNumber,
+            expiresIn: DEFAULT_URL_EXPIRY,
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+        return {
+            url,
+            partNumber,
+            expiresIn: DEFAULT_URL_EXPIRY,
+        };
+    }
+    /**
+     * Complete a multipart upload after all parts are uploaded
+     */
+    async completeMultipartUpload(tenantId, userId, sessionId, key, uploadId, fileName, fileSize, contentType, parts, options) {
+        // Verify session exists
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        // Verify the key belongs to this session
+        const expectedPrefix = `conversations/${sessionId}/`;
+        if (!key.startsWith(expectedPrefix)) {
+            throw new ValidationError("Key does not belong to this session");
+        }
+        // Validate parts
+        const sortedParts = [...parts].sort((a, b) => a.partNumber - b.partNumber);
+        for (let i = 0; i < sortedParts.length; i++) {
+            if (sortedParts[i].partNumber !== i + 1) {
+                throw new ValidationError(`Missing part number ${i + 1}`);
+            }
+            if (!sortedParts[i].etag) {
+                throw new ValidationError(`Missing etag for part ${sortedParts[i].partNumber}`);
+            }
+        }
+        await this.s3Service.completeMultipartUpload({
+            key,
+            uploadId,
+            parts: sortedParts,
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+        return {
+            messageId: `temp-upload-${crypto.randomUUID()}`,
+            filename: sanitizeFilename(fileName),
+            mediaType: contentType,
+            url: this.s3Service.getObjectUrl(key),
+            size: fileSize,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Abort a multipart upload (cleanup)
+     */
+    async abortMultipartUpload(tenantId, userId, sessionId, key, uploadId, options) {
+        // Verify session exists
+        const session = await this.getById(tenantId, userId, sessionId, options);
+        if (!session) {
+            throw new SessionNotFoundError();
+        }
+        // Verify the key belongs to this session
+        const expectedPrefix = `conversations/${sessionId}/`;
+        if (!key.startsWith(expectedPrefix)) {
+            throw new ValidationError("Key does not belong to this session");
+        }
+        await this.s3Service.abortMultipartUpload({
+            key,
+            uploadId,
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+    }
+}
+/**
+ * Lazy-initialized singleton instance of ChatService.
+ * Use getChatService() to access the instance.
+ */
+let chatServiceInstance = null;
+/**
+ * Get the singleton ChatService instance.
+ * Lazily initializes the instance on first call.
+ *
+ * @returns ChatService instance
+ *
+ * @example
+ * ```typescript
+ * const chatService = getChatService();
+ * await chatService.create(userId, "My Chat");
+ * ```
+ */
+export function getChatService() {
+    if (!chatServiceInstance) {
+        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",
+                    },
+                },
+            }),
+        });
+    }
+    return chatServiceInstance;
+}
+//# sourceMappingURL=chat.service.js.map