@superblocksteam/vite-plugin-file-sync 2.0.42 → 2.0.43-next.0

package/dist/ai-service/chat/chat-session-store.js

@@ -1,4 +1,39 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 import { getErrorMeta } from "../../util/logger.js";
+import llmobs from "../llmobs/index.js";
 import { extractProductiveHistoryForContext, getLastUserMessage, } from "./extract-history.js";
 export function isAiChatMessage(item) {
     return "role" in item && "content" in item;
@@ -6,401 +41,505 @@ export function isAiChatMessage(item) {
 export function isAiChatSummary(item) {
     return "summary" in item && "relevantFilePaths" in item;
 }
-export class ChatSessionStore {
-    applicationId;
-    rpcClient;
-    logger;
-    messages;
-    inFlightLoadFromServer;
-    loadedFromServer = "no";
-    constructor(config) {
-        this.rpcClient = config.rpcClient;
-        this.applicationId = config.applicationId;
-        this.messages = [];
-        this.logger = config.logger;
-        // NOTE: This is used to serialize messages to be after any load.
-        // We initialize it as resolved to handle the prompt-from-empty-state case.
-        // TODO(ai): consider replacing this with a queue-based approach
-        this.inFlightLoadFromServer = Promise.resolve();
-    }
-    /***
-     * Validates and sanitizes the attachments array
-     * @param attachments - The attachments array to validate
-     * @returns A tuple containing:
-     *   - a boolean indicating if the attachments are valid
-     *   - the sanitized attachments array
-     */
-    validateAttachments(attachments) {
-        if (!attachments) {
-            return [true, undefined];
+let ChatSessionStore = (() => {
+    let _instanceExtraInitializers = [];
+    let _getMessages_decorators;
+    let _getLatestSummary_decorators;
+    return class ChatSessionStore {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getMessages_decorators = [llmobs.decorate({
+                    kind: "task",
+                    name: "ChatSessionStore.getMessages",
+                })];
+            _getLatestSummary_decorators = [llmobs.decorate({
+                    kind: "task",
+                    name: "ChatSessionStore.getLatestSummary",
+                })];
+            __esDecorate(this, null, _getMessages_decorators, { kind: "method", name: "getMessages", static: false, private: false, access: { has: obj => "getMessages" in obj, get: obj => obj.getMessages }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getLatestSummary_decorators, { kind: "method", name: "getLatestSummary", static: false, private: false, access: { has: obj => "getLatestSummary" in obj, get: obj => obj.getLatestSummary }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        if (typeof attachments !== "object" || !Array.isArray(attachments)) {
-            return [false, undefined];
+        // Approximate number of characters per token for estimating token usage
+        static CHARS_PER_TOKEN = 3.5;
+        applicationId = __runInitializers(this, _instanceExtraInitializers);
+        rpcClient;
+        logger;
+        messages;
+        inFlightLoadFromServer;
+        loadedFromServer = "no";
+        constructor(config) {
+            this.rpcClient = config.rpcClient;
+            this.applicationId = config.applicationId;
+            this.messages = [];
+            this.logger = config.logger;
+            // NOTE: This is used to serialize messages to be after any load.
+            // We initialize it as resolved to handle the prompt-from-empty-state case.
+            // TODO(ai): consider replacing this with a queue-based approach
+            this.inFlightLoadFromServer = Promise.resolve();
         }
-        const validAttachments = attachments
-            .map((attachment) => {
-            if (typeof attachment !== "object" || !("type" in attachment)) {
-                return undefined;
+        /***
+         * Validates and sanitizes the attachments array
+         * @param attachments - The attachments array to validate
+         * @returns A tuple containing:
+         *   - a boolean indicating if the attachments are valid
+         *   - the sanitized attachments array
+         */
+        validateAttachments(attachments) {
+            if (!attachments) {
+                return [true, undefined];
             }
-            // Validate image attachment
-            if (attachment.type === "image") {
-                if (typeof attachment.image !== "string") {
+            if (typeof attachments !== "object" || !Array.isArray(attachments)) {
+                return [false, undefined];
+            }
+            const validAttachments = attachments
+                .map((attachment) => {
+                if (typeof attachment !== "object" || !("type" in attachment)) {
                     return undefined;
                 }
-                return {
-                    type: attachment.type,
-                    image: attachment.image,
-                    fileName: attachment.fileName,
-                };
-            }
-            return undefined;
-        })
-            .filter(Boolean);
-        return [validAttachments.length === attachments.length, validAttachments];
-    }
-    validateChatMessageV1(payload) {
-        try {
-            if (!payload || typeof payload !== "object") {
-                return null;
-            }
-            const msg = payload;
-            // Validate required fields
-            if (typeof msg.role !== "string" ||
-                !["user", "assistant", "server"].includes(msg.role)) {
-                this.logger.warn(`[ai-service] Invalid message role: ${msg.role}`);
-                return null;
-            }
-            if (typeof msg.content !== "string") {
-                this.logger.warn(`[ai-service] Invalid message content`);
-                return null;
-            }
-            if (typeof msg.type !== "string") {
-                this.logger.warn(`[ai-service] Invalid message type: ${msg.type}`);
-                return null;
-            }
-            // Validate optional fields with defaults
-            const timestamp = typeof msg.timestamp === "number" ? msg.timestamp : Date.now();
-            const group = typeof msg.group === "string" ? msg.group : undefined;
-            const status = typeof msg.status === "string" ? msg.status : undefined;
-            const action = typeof msg.action === "string" ? msg.action : undefined;
-            const [isAttachmentsValid, attachments] = this.validateAttachments(msg.attachments);
-            if (!isAttachmentsValid) {
-                this.logger.warn(`[ai-service] Invalid attachments`);
-                return null;
-            }
-            if (msg.type === "tool") {
-                if (typeof msg.data !== "object") {
-                    this.logger.warn(`[ai-service] Invalid message data`);
+                // Validate image attachment
+                if (attachment.type === "image") {
+                    if (typeof attachment.image !== "string") {
+                        return undefined;
+                    }
+                    return {
+                        type: attachment.type,
+                        image: attachment.image,
+                        fileName: attachment.fileName,
+                    };
+                }
+                return undefined;
+            })
+                .filter(Boolean);
+            return [validAttachments.length === attachments.length, validAttachments];
+        }
+        validateChatMessageV1(payload) {
+            try {
+                if (!payload || typeof payload !== "object") {
+                    return null;
+                }
+                const msg = payload;
+                // Validate required fields
+                if (typeof msg.role !== "string" ||
+                    !["user", "assistant", "server"].includes(msg.role)) {
+                    this.logger.warn(`[ai-service] Invalid message role: ${msg.role}`);
                     return null;
                 }
+                if (typeof msg.content !== "string") {
+                    this.logger.warn(`[ai-service] Invalid message content`);
+                    return null;
+                }
+                if (typeof msg.type !== "string") {
+                    this.logger.warn(`[ai-service] Invalid message type: ${msg.type}`);
+                    return null;
+                }
+                // Validate optional fields with defaults
+                const timestamp = typeof msg.timestamp === "number" ? msg.timestamp : Date.now();
+                const group = typeof msg.group === "string" ? msg.group : undefined;
+                const status = typeof msg.status === "string" ? msg.status : undefined;
+                const action = typeof msg.action === "string" ? msg.action : undefined;
+                const [isAttachmentsValid, attachments] = this.validateAttachments(msg.attachments);
+                if (!isAttachmentsValid) {
+                    this.logger.warn(`[ai-service] Invalid attachments`);
+                    return null;
+                }
+                if (msg.type === "tool") {
+                    return {
+                        role: msg.role,
+                        content: msg.content,
+                        type: "tool",
+                        id: typeof msg.id === "string" ? msg.id : undefined,
+                        timestamp,
+                        status: status,
+                        action: action,
+                        args: msg.args,
+                        tool: msg.tool,
+                    };
+                }
+                else if (msg.group === "checklist") {
+                    if (typeof msg.checklistData !== "object") {
+                        this.logger.warn(`[ai-service] Invalid checklist data`);
+                        return null;
+                    }
+                    return {
+                        role: msg.role,
+                        content: msg.content,
+                        type: "tool",
+                        id: typeof msg.id === "string" ? msg.id : undefined,
+                        timestamp,
+                        group,
+                        status,
+                        action,
+                        checklistData: msg.checklistData,
+                    };
+                }
+                else if (msg.type === "multi_choice") {
+                    if (!Array.isArray(msg.choices) || msg.choices.length === 0) {
+                        this.logger.warn(`[ai-service] Invalid choices for multi_choice message`);
+                        return null;
+                    }
+                    return {
+                        role: msg.role,
+                        content: msg.content,
+                        type: "multi_choice",
+                        id: typeof msg.id === "string" ? msg.id : undefined,
+                        timestamp,
+                        choices: msg.choices,
+                        selectionType: typeof msg.selectionType === "string"
+                            ? msg.selectionType
+                            : "single",
+                    };
+                }
+                else if (msg.type === "multi_choice_response") {
+                    if (typeof msg.responseToMessageId !== "string") {
+                        this.logger.warn(`[ai-service] Invalid responseToMessageId for multi_choice_response`);
+                        return null;
+                    }
+                    if (!Array.isArray(msg.selectedChoiceIndices)) {
+                        this.logger.warn(`[ai-service] Invalid selectedChoiceIndices for multi_choice_response`);
+                        return null;
+                    }
+                    return {
+                        role: msg.role,
+                        content: msg.content,
+                        type: "multi_choice_response",
+                        id: typeof msg.id === "string" ? msg.id : undefined,
+                        timestamp,
+                        responseToMessageId: msg.responseToMessageId,
+                        selectedChoiceIndices: msg.selectedChoiceIndices,
+                    };
+                }
+                else if (msg.type === "plan_response") {
+                    if (typeof msg.responseToMessageId !== "string") {
+                        this.logger.warn(`[ai-service] Invalid responseToMessageId for plan_response`);
+                        return null;
+                    }
+                    return {
+                        role: msg.role,
+                        content: msg.content,
+                        type: "plan_response",
+                        id: typeof msg.id === "string" ? msg.id : undefined,
+                        timestamp,
+                        responseToMessageId: msg.responseToMessageId,
+                    };
+                }
                 return {
                     role: msg.role,
                     content: msg.content,
-                    type: "tool",
+                    type: msg.type,
+                    id: typeof msg.id === "string" ? msg.id : undefined,
                     timestamp,
+                    group,
                     status: status,
                     action: action,
-                    data: msg.data,
+                    attachments,
                 };
             }
-            else if (msg.group === "checklist") {
-                if (typeof msg.checklistData !== "object") {
-                    this.logger.warn(`[ai-service] Invalid checklist data`);
+            catch (error) {
+                this.logger.error("[ai-service] Failed to validate message payload", getErrorMeta(error));
+                return null;
+            }
+        }
+        validateChatSummaryV1(payload) {
+            try {
+                if (!payload || typeof payload !== "object") {
+                    return null;
+                }
+                const summary = payload;
+                // Validate required fields
+                if (typeof summary.summary !== "string") {
+                    this.logger.warn(`[ai-service] Invalid summary content`);
+                    return null;
+                }
+                if (!Array.isArray(summary.relevantFilePaths)) {
+                    this.logger.warn(`[ai-service] Invalid relevantFilePaths - must be array`);
+                    return null;
+                }
+                if (!summary.relevantFilePaths.every((path) => typeof path === "string")) {
+                    this.logger.warn(`[ai-service] Invalid relevantFilePaths - all items must be strings`);
+                    return null;
+                }
+                if (!Array.isArray(summary.goals)) {
+                    this.logger.warn(`[ai-service] Invalid goals - must be array`);
+                    return null;
+                }
+                if (!summary.goals.every((goal) => typeof goal === "string")) {
+                    this.logger.warn(`[ai-service] Invalid goals - all items must be strings`);
+                    return null;
+                }
+                if (!Array.isArray(summary.decisions)) {
+                    this.logger.warn(`[ai-service] Invalid decisions - must be array`);
+                    return null;
+                }
+                if (!summary.decisions.every((decision) => typeof decision === "string")) {
+                    this.logger.warn(`[ai-service] Invalid decisions - all items must be strings`);
                     return null;
                 }
+                // Validate optional fields with defaults
+                const timestamp = typeof summary.timestamp === "number" ? summary.timestamp : Date.now();
                 return {
-                    role: msg.role,
-                    content: msg.content,
-                    type: "tool",
+                    summary: summary.summary,
+                    relevantFilePaths: summary.relevantFilePaths,
+                    goals: summary.goals,
+                    decisions: summary.decisions,
+                    adviceToAgents: summary.adviceToAgents,
                     timestamp,
-                    group,
-                    status,
-                    action,
-                    checklistData: msg.checklistData,
                 };
             }
-            return {
-                role: msg.role,
-                content: msg.content,
-                type: msg.type,
-                timestamp,
-                group,
-                status: status,
-                action: action,
-                attachments,
-            };
-        }
-        catch (error) {
-            this.logger.error("[ai-service] Failed to validate message payload", getErrorMeta(error));
-            return null;
-        }
-    }
-    validateChatSummaryV1(payload) {
-        try {
-            if (!payload || typeof payload !== "object") {
-                return null;
-            }
-            const summary = payload;
-            // Validate required fields
-            if (typeof summary.summary !== "string") {
-                this.logger.warn(`[ai-service] Invalid summary content`);
+            catch (error) {
+                this.logger.error("[ai-service] Failed to validate summary payload", getErrorMeta(error));
                 return null;
             }
-            if (!Array.isArray(summary.relevantFilePaths)) {
-                this.logger.warn(`[ai-service] Invalid relevantFilePaths - must be array`);
-                return null;
-            }
-            if (!summary.relevantFilePaths.every((path) => typeof path === "string")) {
-                this.logger.warn(`[ai-service] Invalid relevantFilePaths - all items must be strings`);
-                return null;
+        }
+        validateChatItemV1(payload) {
+            // First try to validate as a message
+            const messageResult = this.validateChatMessageV1(payload);
+            if (messageResult) {
+                return messageResult;
             }
-            if (!Array.isArray(summary.goals)) {
-                this.logger.warn(`[ai-service] Invalid goals - must be array`);
-                return null;
+            // If not a valid message, try to validate as a summary
+            const summaryResult = this.validateChatSummaryV1(payload);
+            if (summaryResult) {
+                return summaryResult;
             }
-            if (!summary.goals.every((goal) => typeof goal === "string")) {
-                this.logger.warn(`[ai-service] Invalid goals - all items must be strings`);
-                return null;
+            return null;
+        }
+        async ensureLoadedFromServer() {
+            // NOTE: we will want to re-evaluate this if/when the auth token associated with this sandbox is changed
+            // the existing solution is that each time the page loaded by the client, we re-fetch from the server,
+            // so this may be a non-issue.
+            if (this.loadedFromServer === "loaded" ||
+                this.loadedFromServer === "loading") {
+                await this.inFlightLoadFromServer;
+                return;
             }
-            if (!Array.isArray(summary.decisions)) {
-                this.logger.warn(`[ai-service] Invalid decisions - must be array`);
-                return null;
+            try {
+                this.loadedFromServer = "loading";
+                this.inFlightLoadFromServer = this.rpcClient.call(async (client) => {
+                    const applicationId = this.applicationId;
+                    const { data } = await client.call.v1.ai.chat.getMessages({
+                        applicationId,
+                    });
+                    this.messages =
+                        data?.messages
+                            .map((msg) => this.validateChatItemV1(msg.chatPayload))
+                            .filter((item) => item !== null)
+                            .sort((a, b) => {
+                            return (a.timestamp || 0) - (b.timestamp || 0);
+                        }) ?? [];
+                });
+                await this.inFlightLoadFromServer;
+                this.loadedFromServer = "loaded";
             }
-            if (!summary.decisions.every((decision) => typeof decision === "string")) {
-                this.logger.warn(`[ai-service] Invalid decisions - all items must be strings`);
-                return null;
+            catch (error) {
+                this.logger.error("[ai-service] Failed to load chat messages from server", getErrorMeta(error));
             }
-            // Validate optional fields with defaults
-            const timestamp = typeof summary.timestamp === "number" ? summary.timestamp : Date.now();
-            return {
-                summary: summary.summary,
-                relevantFilePaths: summary.relevantFilePaths,
-                goals: summary.goals,
-                decisions: summary.decisions,
-                adviceToAgents: summary.adviceToAgents,
-                timestamp,
-            };
-        }
-        catch (error) {
-            this.logger.error("[ai-service] Failed to validate summary payload", getErrorMeta(error));
-            return null;
-        }
-    }
-    validateChatItemV1(payload) {
-        // First try to validate as a message
-        const messageResult = this.validateChatMessageV1(payload);
-        if (messageResult) {
-            return messageResult;
         }
-        // If not a valid message, try to validate as a summary
-        const summaryResult = this.validateChatSummaryV1(payload);
-        if (summaryResult) {
-            return summaryResult;
-        }
-        return null;
-    }
-    async ensureLoadedFromServer() {
-        // NOTE: we will want to re-evaluate this if/when the auth token associated with this sandbox is changed
-        // the existing solution is that each time the page loaded by the client, we re-fetch from the server,
-        // so this may be a non-issue.
-        if (this.loadedFromServer === "loaded" ||
-            this.loadedFromServer === "loading") {
-            await this.inFlightLoadFromServer;
-            return;
+        getLastUserMessage() {
+            const messages = this.messages.filter(isAiChatMessage);
+            return getLastUserMessage(messages);
         }
-        try {
-            this.loadedFromServer = "loading";
-            this.inFlightLoadFromServer = this.rpcClient.call(async (client) => {
-                const applicationId = this.applicationId;
-                const { data } = await client.call.v1.ai.chat.getMessages({
-                    applicationId,
-                });
-                this.messages =
-                    data?.messages
-                        .map((msg) => this.validateChatItemV1(msg.chatPayload))
-                        .filter((item) => item !== null)
-                        .sort((a, b) => {
-                        return (a.timestamp || 0) - (b.timestamp || 0);
-                    }) ?? [];
+        getRecentExchanges() {
+            // Filter out summaries but keep regular messages for the existing logic
+            const messages = this.messages.filter(isAiChatMessage);
+            return extractProductiveHistoryForContext(messages, {
+                maxAcceptedExchanges: 2,
+                includeRecentUnknown: true,
             });
-            await this.inFlightLoadFromServer;
-            this.loadedFromServer = "loaded";
         }
-        catch (error) {
-            this.logger.error("[ai-service] Failed to load chat messages from server", getErrorMeta(error));
+        async getMessages() {
+            await this.ensureLoadedFromServer();
+            return this.messages.filter(isAiChatMessage);
         }
-    }
-    getLastUserMessage() {
-        const messages = this.messages.filter(isAiChatMessage);
-        return getLastUserMessage(messages);
-    }
-    getRecentExchanges() {
-        // Filter out summaries but keep regular messages for the existing logic
-        const messages = this.messages.filter(isAiChatMessage);
-        return extractProductiveHistoryForContext(messages, {
-            maxAcceptedExchanges: 2,
-            includeRecentUnknown: true,
-        });
-    }
-    async getMessages() {
-        await this.ensureLoadedFromServer();
-        return this.messages.filter(isAiChatMessage);
-    }
-    async newChat() {
-        try {
-            await this.rpcClient.call(async (client) => {
-                const applicationId = this.applicationId;
-                return await client.call.v1.ai.chat.new({ applicationId });
-            });
-            this.messages = [];
+        async newChat() {
+            try {
+                await this.rpcClient.call(async (client) => {
+                    const applicationId = this.applicationId;
+                    return await client.call.v1.ai.chat.new({ applicationId });
+                });
+                this.messages = [];
+            }
+            catch (error) {
+                this.logger.error("[ai-service] Failed to create new chat", getErrorMeta(error));
+            }
         }
-        catch (error) {
-            this.logger.error("[ai-service] Failed to create new chat", getErrorMeta(error));
+        async recordUser(text, options = {}) {
+            const message = {
+                role: "user",
+                content: text,
+                id: crypto.randomUUID(),
+                timestamp: Date.now(),
+                type: "text",
+            };
+            if (options.attachments) {
+                message.attachments = options.attachments;
+            }
+            await this.appendMessage(message);
         }
-    }
-    async recordUser(text, options = {}) {
-        const message = {
-            role: "user",
-            content: text,
-            timestamp: Date.now(),
-            type: "text",
-        };
-        if (options.attachments) {
-            message.attachments = options.attachments;
+        async recordUserAcceptance() {
+            const message = {
+                role: "user",
+                content: "",
+                id: crypto.randomUUID(),
+                timestamp: Date.now(),
+                type: "draftAccepted",
+            };
+            await this.appendMessage(message);
         }
-        await this.appendMessage(message);
-    }
-    async recordUserAcceptance() {
-        const message = {
-            role: "user",
-            content: "",
-            timestamp: Date.now(),
-            type: "draftAccepted",
-        };
-        await this.appendMessage(message);
-    }
-    async recordUserRejection() {
-        const message = {
-            role: "user",
-            content: "",
-            timestamp: Date.now(),
-            type: "draftRejected",
-        };
-        await this.appendMessage(message);
-    }
-    async recordAssistant(payload) {
-        let message;
-        if ("checklistData" in payload) {
-            message = {
-                role: "assistant",
-                content: payload.text,
-                type: "tool",
-                group: "checklist",
-                status: payload.status,
+        async recordUserRejection() {
+            const message = {
+                role: "user",
+                content: "",
+                id: crypto.randomUUID(),
                 timestamp: Date.now(),
-                checklistData: payload.checklistData,
+                type: "draftRejected",
             };
+            await this.appendMessage(message);
         }
-        else if (payload.type === "tool") {
-            message = {
-                role: "assistant",
-                content: payload.text,
-                type: "tool",
-                status: payload.status,
+        async recordUserResponse(text, responseType, metadata) {
+            const baseMessage = {
+                role: "user",
+                content: text,
+                id: crypto.randomUUID(),
                 timestamp: Date.now(),
-                data: {
-                    label: payload.label,
-                    name: payload.name,
-                    displayType: payload.displayType,
-                },
+                type: responseType,
+                responseToMessageId: metadata.responseToMessageId,
             };
+            if (responseType === "multi_choice_response" &&
+                metadata.selectedChoiceIndices) {
+                baseMessage.selectedChoiceIndices =
+                    metadata.selectedChoiceIndices;
+            }
+            await this.appendMessage(baseMessage);
+        }
+        async recordAssistant(payload) {
+            let message;
+            // Use ID from payload if present, otherwise generate new one
+            const messageId = payload.id ?? crypto.randomUUID();
+            if ("checklistData" in payload) {
+                message = {
+                    role: "assistant",
+                    content: payload.text,
+                    type: "tool",
+                    group: "checklist",
+                    status: payload.status,
+                    id: messageId,
+                    timestamp: Date.now(),
+                    checklistData: payload.checklistData,
+                };
+            }
+            else if (payload.type === "tool") {
+                message = {
+                    role: "assistant",
+                    content: "",
+                    type: "tool",
+                    status: payload.status,
+                    id: messageId,
+                    timestamp: Date.now(),
+                    args: payload.args,
+                    tool: payload.tool,
+                    group: "group" in payload ? payload.group : "",
+                };
+            }
+            else {
+                message = {
+                    role: "assistant",
+                    content: payload.text,
+                    type: payload.type || "text",
+                    group: "group" in payload ? payload.group : "",
+                    status: payload.status,
+                    id: messageId,
+                    timestamp: Date.now(),
+                    ...("choices" in payload && payload.choices
+                        ? { choices: payload.choices }
+                        : {}),
+                    ...("selectionType" in payload && payload.selectionType
+                        ? { selectionType: payload.selectionType }
+                        : {}),
+                };
+            }
+            await this.appendMessage(message);
         }
-        else {
-            message = {
+        async recordAssistantChangeInfo(payload) {
+            const message = {
                 role: "assistant",
-                content: payload.text,
-                type: payload.type || "text",
-                group: "group" in payload ? payload.group : "",
+                group: payload.type,
+                content: payload.name,
+                action: payload.action,
                 status: payload.status,
+                type: "changeInfo",
+                id: crypto.randomUUID(),
                 timestamp: Date.now(),
             };
+            await this.appendMessage(message);
         }
-        await this.appendMessage(message);
-    }
-    async recordAssistantChangeInfo(payload) {
-        const message = {
-            role: "assistant",
-            group: payload.type,
-            content: payload.name,
-            action: payload.action,
-            status: payload.status,
-            type: "changeInfo",
-            timestamp: Date.now(),
-        };
-        await this.appendMessage(message);
-    }
-    async appendMessage(payload) {
-        await this.ensureLoadedFromServer();
-        this.messages.push(payload);
-        try {
-            await this.rpcClient.call(async (client) => {
-                const applicationId = this.applicationId;
-                return await client.call.v1.ai.chat.pushMessage({
-                    applicationId,
-                    payload: payload,
+        async appendMessage(message) {
+            await this.ensureLoadedFromServer();
+            this.messages.push(message);
+            const payload = {
+                ...message,
+            };
+            try {
+                await this.rpcClient.call(async (client) => {
+                    const applicationId = this.applicationId;
+                    return await client.call.v1.ai.chat.pushMessage({
+                        applicationId,
+                        payload,
+                    });
                 });
-            });
-        }
-        catch (error) {
-            this.logger.error("[ai-service] Failed to write chat message to server", getErrorMeta(error));
-        }
-    }
-    determineSummaryOutcome(summary, allMessages) {
-        // Find the index of this summary in all messages
-        const summaryIndex = allMessages.findIndex((item) => isAiChatSummary(item) &&
-            item.timestamp === summary.timestamp &&
-            item.summary === summary.summary);
-        if (summaryIndex === -1) {
-            return "unknown";
+            }
+            catch (error) {
+                this.logger.error("[ai-service] Failed to write chat message to server", getErrorMeta(error));
+            }
         }
-        // Look for acceptance/rejection messages after this summary
-        const messagesAfterSummary = allMessages.slice(summaryIndex + 1);
-        for (const item of messagesAfterSummary) {
-            if (isAiChatMessage(item) && item.role === "user") {
-                if (item.type === "draftAccepted") {
-                    return "accepted";
-                }
-                if (item.type === "draftRejected") {
-                    return "rejected";
+        determineSummaryOutcome(summary, allMessages) {
+            // Find the index of this summary in all messages
+            const summaryIndex = allMessages.findIndex((item) => isAiChatSummary(item) &&
+                item.timestamp === summary.timestamp &&
+                item.summary === summary.summary);
+            if (summaryIndex === -1) {
+                return "unknown";
+            }
+            // Look for acceptance/rejection messages after this summary
+            const messagesAfterSummary = allMessages.slice(summaryIndex + 1);
+            for (const item of messagesAfterSummary) {
+                if (isAiChatMessage(item) && item.role === "user") {
+                    if (item.type === "draftAccepted") {
+                        return "accepted";
+                    }
+                    if (item.type === "draftRejected") {
+                        return "rejected";
+                    }
                 }
             }
+            return "unknown";
         }
-        return "unknown";
-    }
-    async recordSummary(summaryData) {
-        const summaryPayload = {
-            ...summaryData,
-            timestamp: Date.now(),
-        };
-        await this.appendMessage(summaryPayload);
-    }
-    async getSummaries() {
-        await this.ensureLoadedFromServer();
-        return this.messages.filter(isAiChatSummary);
-    }
-    async getLatestSummary() {
-        return (await this.getLatestSummaries(1))[0];
-    }
-    async getLatestSummaries(count) {
-        const summaries = await this.getSummaries();
-        const sortedSummaries = summaries
-            .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
-            .slice(0, count);
-        // Add outcome information to each summary
-        return sortedSummaries.map((summary) => ({
-            ...summary,
-            outcome: this.determineSummaryOutcome(summary, this.messages),
-        }));
-    }
-}
+        async recordSummary(summaryData) {
+            const summaryPayload = {
+                ...summaryData,
+                timestamp: Date.now(),
+            };
+            await this.appendMessage(summaryPayload);
+        }
+        async getSummaries() {
+            await this.ensureLoadedFromServer();
+            return this.messages.filter(isAiChatSummary);
+        }
+        async getLatestSummary() {
+            return (await this.getLatestSummaries(1))[0];
+        }
+        async getLatestSummaries(count) {
+            const summaries = await this.getSummaries();
+            const sortedSummaries = summaries
+                .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
+                .slice(0, count);
+            // Add outcome information to each summary
+            return sortedSummaries.map((summary) => ({
+                ...summary,
+                outcome: this.determineSummaryOutcome(summary, this.messages),
+            }));
+        }
+    };
+})();
+export { ChatSessionStore };
 //# sourceMappingURL=chat-session-store.js.map