captify 0.1.15 → 0.1.18

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

@@ -1,1245 +0,0 @@
-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