@superblocksteam/vite-plugin-file-sync 1.99.99-next.2 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

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

@@ -0,0 +1,862 @@
+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 { EVICTION_PROTECTED_MESSAGE_TYPES, EXCLUDED_MESSAGE_TYPES, parsePersistedChatMessage, } from "@superblocksteam/library-shared/types";
+import { CHAT_PAYLOAD_PROMPT_ID_KEY, } from "@superblocksteam/shared";
+import { getErrorMeta } from "../../util/logger.js";
+import llmobs from "../llmobs/index.js";
+import { recordChatPushFailure } from "./chat-push-metrics.js";
+import { recordChatGetMessages } from "./chat-session-store-metrics.js";
+import { getLastUserMessage } from "./extract-history.js";
+import { TranscriptBudget, } from "./transcript-budget.js";
+import { ensureTranscriptInstruments, recordTranscriptEviction, recordTranscriptServerLoad, registerTranscriptResidentBytesSource, } from "./transcript-metrics.js";
+import { sanitizeAiProviderResponse, sanitizeToolOutput } from "./utils.js";
+export function isAiChatMessage(item) {
+    return "role" in item && "content" in item;
+}
+export function isAiChatSummary(item) {
+    return "summary" in item && "relevantFilePaths" in item;
+}
+const CHAT_PAYLOAD_INELIGIBILITY_MARKER = "ineligibleSinceRestore";
+function isEligibleSummary(item) {
+    // Filter out summaries marked as ineligible (from checkpoint restores)
+    return isAiChatSummary(item) && !(CHAT_PAYLOAD_INELIGIBILITY_MARKER in item);
+}
+/**
+ * Default maximum number of messages to load from the server.
+ * This prevents large requests from failing when there are many messages.
+ */
+const DEFAULT_MESSAGE_LIMIT = 3000;
+/**
+ * Minimum gap between `chatTranscriptEvicted` warn logs for the *same*
+ * trigger. The OTel counters fire on every eviction (cheap, cumulative); the
+ * warn is a low-frequency sentinel. A pathological session evicts on every
+ * append, so an unthrottled warn would emit thousands of lines per session.
+ * A trigger change is always logged (it is a meaningful state transition);
+ * repeated same-trigger evictions are collapsed to one line per window.
+ */
+const EVICTION_WARN_THROTTLE_MS = 30_000;
+/**
+ * Chat item types that are never evicted from the resident transcript. The list
+ * itself is EVICTION_PROTECTED_MESSAGE_TYPES in library-shared, which carries
+ * the rationale; it lives there because the editor's pod-reconcile merge has to
+ * exclude these types when it infers this pod's eviction frontier from a
+ * payload. Derived into a Set here because isEvictableChatItem is on the
+ * per-item path of every enforce() pass. Summaries are protected separately via
+ * isAiChatSummary.
+ */
+const EVICTION_PROTECTED_TYPES = new Set(EVICTION_PROTECTED_MESSAGE_TYPES.filter((type) => type !== undefined));
+function isEvictableChatItem(item) {
+    if (isAiChatSummary(item)) {
+        return false;
+    }
+    return item.type === undefined || !EVICTION_PROTECTED_TYPES.has(item.type);
+}
+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 });
+        }
+        applicationId = __runInitializers(this, _instanceExtraInitializers);
+        rpcClient;
+        logger;
+        tracer;
+        messages;
+        inFlightLoadFromServer;
+        loadedFromServer = "no";
+        inProgressMessages = {};
+        messageLimit;
+        transcriptBudget;
+        /**
+         * Kill-switch for the in-heap transcript budget. When set, the transcript
+         * grows unbounded as it did before the fix — a remediation lever if
+         * eviction ever misbehaves in production. Read once at startup, so toggling
+         * the env var needs a pod restart (no code deploy or rebuild) to take
+         * effect.
+         */
+        transcriptBudgetDisabled = process.env.CLARK_TRANSCRIPT_BUDGET_DISABLED === "true";
+        lastEvictionWarnAt = 0;
+        lastEvictionWarnTrigger = null;
+        constructor(config) {
+            this.rpcClient = config.rpcClient;
+            this.applicationId = config.applicationId;
+            this.messages = [];
+            this.logger = config.logger;
+            this.messageLimit = config.messageLimit ?? DEFAULT_MESSAGE_LIMIT;
+            this.transcriptBudget = new TranscriptBudget({
+                isEvictable: isEvictableChatItem,
+                maxResidentBytes: config.transcriptBudget?.maxResidentBytes,
+                // The count cap defaults to messageLimit, which the load-time filter
+                // already enforces; it is a coarse backstop for items appended past the
+                // limit mid-session, behind the byte and heap-pressure triggers.
+                maxResidentItems: config.transcriptBudget?.maxResidentItems ?? this.messageLimit,
+                minResidentItems: config.transcriptBudget?.minResidentItems,
+                heapMonitor: config.transcriptBudget?.heapMonitor,
+            });
+            // The observable gauge pulls resident bytes from the live budget every
+            // collect interval (one store per dev-server process; replace semantics).
+            registerTranscriptResidentBytesSource(() => this.transcriptBudget.residentBytes);
+            this.tracer = config.tracer ?? llmobs;
+            // 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();
+        }
+        validateChatMessageV1(payload, fallbackTimestamp) {
+            // Validation lives in library-shared so the editor's durable reader of the
+            // same rows accepts and normalizes exactly what this transcript does.
+            return parsePersistedChatMessage(payload, {
+                fallbackTimestamp,
+                onInvalid: (detail) => this.logger.warn(`[ai-service] ${detail}`),
+                onError: (error) => this.logger.error("[ai-service] Failed to validate message payload", getErrorMeta(error)),
+            });
+        }
+        validateChatSummaryV1(payload, fallbackTimestamp) {
+            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 = Number.isFinite(summary.timestamp)
+                    ? summary.timestamp
+                    : fallbackTimestamp;
+                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, fallbackTimestamp) {
+            // First try to validate as a message
+            const messageResult = this.validateChatMessageV1(payload, fallbackTimestamp);
+            if (messageResult) {
+                return messageResult;
+            }
+            // If not a valid message, try to validate as a summary
+            const summaryResult = this.validateChatSummaryV1(payload, fallbackTimestamp);
+            if (summaryResult) {
+                return summaryResult;
+            }
+            return null;
+        }
+        recordTranscriptLoadOutcome(input) {
+            const outcome = input.droppedCount > 0
+                ? "invalid_message_dropped"
+                : input.acceptedCount > 0
+                    ? "success_non_empty"
+                    : "success_empty";
+            recordTranscriptServerLoad({ outcome });
+            if (input.droppedCount === 0) {
+                return;
+            }
+            const attributes = {
+                event: "clark.chat_transcript_invalid_messages_dropped",
+                application_id: this.applicationId,
+                accepted_count: input.acceptedCount,
+                dropped_count: input.droppedCount,
+                total_count: input.totalCount,
+                message_limit: this.messageLimit,
+            };
+            if (this.logger.warnStructured) {
+                this.logger.warnStructured("[ai-service] chatTranscriptInvalidMessagesDropped", attributes);
+            }
+            else {
+                this.logger.warn(`[ai-service] chatTranscriptInvalidMessagesDropped accepted=${attributes.accepted_count} dropped=${attributes.dropped_count} total=${attributes.total_count} message_limit=${attributes.message_limit}`);
+            }
+        }
+        async ensureLoadedFromServer(options = { forceReload: false }) {
+            const { forceReload } = options;
+            if (forceReload) {
+                this.loadedFromServer = "no";
+            }
+            // 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;
+            }
+            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,
+                        limit: this.messageLimit,
+                    });
+                    const rawMessages = data?.messages ?? [];
+                    const mapped = rawMessages.map((msg) => {
+                        // The row's own created column, not Date.now(). This value is what
+                        // the sort below orders on when a payload carries no timestamp, so
+                        // inventing one here filed old rows at the end of history on every
+                        // load. It is also half of the composite key the editor dedupes
+                        // id-less rows on, which the durable reader derives the same way.
+                        const persistedAt = msg.created
+                            ? Date.parse(msg.created)
+                            : Date.now();
+                        const chatItem = this.validateChatItemV1(msg.chatPayload, Number.isFinite(persistedAt) ? persistedAt : Date.now());
+                        if (chatItem && isAiChatMessage(chatItem)) {
+                            chatItem.authorEmail = msg.authorEmail;
+                            chatItem.authorName = msg.authorName;
+                        }
+                        return chatItem;
+                    });
+                    const droppedTotal = mapped.filter((item) => item === null).length;
+                    const fromRpcTotal = rawMessages.length;
+                    this.messages =
+                        mapped
+                            .filter((item) => item !== null)
+                            .sort((a, b) => {
+                            return (a.timestamp || 0) - (b.timestamp || 0);
+                        }) ?? [];
+                    this.transcriptBudget.reset(this.messages);
+                    this.enforceTranscriptBudget();
+                    this.logger.info(`[ai-service] chatHistoryLoadSummary accepted=${this.messages.length} dropped=${droppedTotal} total=${fromRpcTotal}`);
+                    this.recordTranscriptLoadOutcome({
+                        acceptedCount: this.messages.length,
+                        droppedCount: droppedTotal,
+                        totalCount: fromRpcTotal,
+                    });
+                });
+                await this.inFlightLoadFromServer;
+                this.loadedFromServer = "loaded";
+            }
+            catch (error) {
+                this.loadedFromServer = "no";
+                recordTranscriptServerLoad({ outcome: "fetch_failed" });
+                this.logger.error("[ai-service] Failed to load chat messages from server", getErrorMeta(error));
+            }
+        }
+        getLastUserMessage() {
+            const messages = this.messages.filter(isAiChatMessage);
+            return getLastUserMessage(messages);
+        }
+        async getMessages(options) {
+            const force = options?.force ?? false;
+            const loadState = this.loadedFromServer;
+            const start = Date.now();
+            try {
+                await this.ensureLoadedFromServer({ forceReload: force });
+                const messages = this.messages.filter(isAiChatMessage);
+                recordChatGetMessages({
+                    durationMs: Date.now() - start,
+                    force,
+                    loadState,
+                    status: this.loadedFromServer === "loaded" ? "success" : "error",
+                });
+                return messages;
+            }
+            catch (error) {
+                recordChatGetMessages({
+                    durationMs: Date.now() - start,
+                    force,
+                    loadState,
+                    status: "error",
+                });
+                throw error;
+            }
+        }
+        /**
+         * Get the most recent commitId from draftCommitted or commitRestored messages.
+         * Waits for messages to load from server first.
+         * Returns undefined if no commits found.
+         */
+        async getLatestCommitId() {
+            await this.ensureLoadedFromServer();
+            // Find most recent message with a commitId (iterate backwards)
+            // - draftCommitted: created when a draft is accepted
+            // - commitRestored: created when restoring to a checkpoint (contains new SAVEPOINT_RESTORE commit)
+            for (let i = this.messages.length - 1; i >= 0; i--) {
+                const msg = this.messages[i];
+                if (msg &&
+                    isAiChatMessage(msg) &&
+                    (msg.type === "draftCommitted" || msg.type === "commitRestored") &&
+                    "commitId" in msg &&
+                    typeof msg.commitId === "string") {
+                    return msg.commitId;
+                }
+            }
+            return undefined;
+        }
+        async newChat() {
+            try {
+                this.logger.info("[ai-service] chatSessionNewStart");
+                await this.rpcClient.call(async (client) => {
+                    const applicationId = this.applicationId;
+                    return await client.call.v1.ai.chat.new({ applicationId });
+                });
+                this.resetTranscriptState();
+                this.logger.info("[ai-service] chatSessionNewSuccess");
+            }
+            catch (error) {
+                this.logger.error("[ai-service] Failed to create new chat", getErrorMeta(error));
+                throw error;
+            }
+        }
+        async truncateAfterTimestamp(sinceTimestamp) {
+            try {
+                this.logger.info("[ai-service] chatSessionTruncateStart");
+                // Truncate chat messages on server
+                await this.rpcClient.call(async (client) => {
+                    const applicationId = this.applicationId;
+                    return await client.call.v1.ai.chat.truncateAfterTimestamp({
+                        applicationId,
+                        sinceTimestamp,
+                    });
+                });
+                // Reload messages from server after truncation
+                await this.ensureLoadedFromServer({ forceReload: true });
+                this.logger.info(`[ai-service] chatSessionTruncateSuccess messages=${this.messages.length}`);
+            }
+            catch (error) {
+                this.logger.error("[ai-service] Failed to truncate chat messages", getErrorMeta(error));
+                throw error;
+            }
+        }
+        async recordUser(text, options = {}) {
+            const message = {
+                role: "user",
+                content: text,
+                id: options.messageId ?? crypto.randomUUID(),
+                timestamp: Date.now(),
+                type: "text",
+            };
+            if (options.attachments) {
+                message.attachments = options.attachments;
+            }
+            return (await this.appendMessage(message)) ?? "";
+        }
+        async recordUserAcceptance() {
+            const message = {
+                role: "user",
+                content: "",
+                id: crypto.randomUUID(),
+                timestamp: Date.now(),
+                type: "draftAccepted",
+            };
+            return (await this.appendMessage(message)) ?? "";
+        }
+        async recordUserRejection() {
+            const message = {
+                role: "user",
+                content: "",
+                id: crypto.randomUUID(),
+                timestamp: Date.now(),
+                type: "draftRejected",
+            };
+            return (await this.appendMessage(message)) ?? "";
+        }
+        async recordUserResponse(text, responseType, metadata) {
+            const baseMessage = {
+                role: "user",
+                content: text,
+                id: metadata.messageId ?? crypto.randomUUID(),
+                timestamp: Date.now(),
+                type: responseType,
+                responseToMessageId: metadata.responseToMessageId,
+            };
+            if (responseType === "multi_choice_response" &&
+                "selectedChoiceIndices" in metadata &&
+                metadata.selectedChoiceIndices) {
+                baseMessage.selectedChoiceIndices =
+                    metadata.selectedChoiceIndices;
+                baseMessage.selectedScopes =
+                    metadata.selectedScopes;
+            }
+            else if (responseType === "remember_knowledge_draft_response" &&
+                "selectedCandidateIndices" in metadata &&
+                metadata.selectedCandidateIndices) {
+                baseMessage.selectedCandidateIndices = metadata.selectedCandidateIndices;
+                baseMessage.selectedScopes =
+                    metadata.selectedScopes;
+            }
+            else if (responseType === "confirm_response") {
+                baseMessage.approved =
+                    metadata.approved ?? false;
+                baseMessage.selectedScopes =
+                    metadata.selectedScopes;
+            }
+            else if (responseType === "plan_response") {
+                baseMessage.approved =
+                    metadata.approved ?? true;
+                baseMessage.enableTesting =
+                    metadata.enableTesting;
+            }
+            else if (responseType === "searchable_dropdown_response") {
+                baseMessage.selectedValue =
+                    metadata.selectedValue ?? "";
+                baseMessage.selectedLabel =
+                    metadata.selectedLabel ?? "";
+            }
+            return (await this.appendMessage(baseMessage)) ?? "";
+        }
+        recordInProgressMessage(payload) {
+            // given an id and a partial message (string) either add or append the message to the inProgressMessages record
+            const { id, text, type } = payload;
+            const key = `${id}-${type}`;
+            if (this.inProgressMessages[key]) {
+                this.inProgressMessages[key] += text;
+            }
+            else {
+                this.inProgressMessages[key] = text;
+            }
+        }
+        async commitMessage(id, type, group) {
+            const key = `${id}-${type}`;
+            const message = this.inProgressMessages[key];
+            if (!message) {
+                return;
+            }
+            delete this.inProgressMessages[key];
+            // Per-chunk sanitization of streamed deltas is unreliable (the sentinel
+            // regex can't span chunk boundaries), so we sanitize the fully
+            // accumulated text here before persistence. This keeps any provider-side
+            // HTML error pages out of the chat history even when the streaming UI
+            // briefly displayed them.
+            const sanitized = sanitizeAiProviderResponse(message) ?? message;
+            await this.recordAssistant({
+                role: "assistant",
+                content: sanitized,
+                type,
+                group,
+            });
+        }
+        async recordAssistant(payload) {
+            let message = {
+                ...payload,
+                id: payload.id ?? crypto.randomUUID(),
+                timestamp: payload.timestamp ?? Date.now(),
+            };
+            if (message.type === "tool-result" &&
+                "toolName" in message &&
+                "output" in message) {
+                const m = message;
+                message = {
+                    ...m,
+                    output: sanitizeToolOutput(m.toolName, m.output),
+                };
+            }
+            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",
+                id: crypto.randomUUID(),
+                timestamp: Date.now(),
+            };
+            await this.appendMessage(message);
+        }
+        // Remote persistence is strictly serialized through this chain so message
+        // order is preserved even when callers do not await (APPS-4729). The chain
+        // link is caught so one failed push can never wedge all later pushes.
+        pushChain = Promise.resolve();
+        // Bounds a single remote push. The underlying socket's noResponseTimeout is
+        // 5 minutes (sized for judge evaluation calls); a chat push on a half-open
+        // socket must fail much faster than that or it stalls everything queued
+        // behind it. Hitting the bound aborts the in-flight RPC and drops the shared
+        // socket, so the next push reconnects instead of queueing behind a dead one.
+        static PUSH_TIMEOUT_MS = 20_000;
+        static PUSH_TIMEOUT_MESSAGE = "chat push timed out";
+        promptIdProvider;
+        /**
+         * Lets the AI service expose the active turn's promptId so every chat
+         * message this store persists carries it. The server reconstructs the
+         * prompt->checkpoint interval from these stamps at accept time. Best-effort:
+         * a provider failure must never block a chat append.
+         */
+        setPromptIdProvider(provider) {
+            this.promptIdProvider = provider;
+        }
+        stampPromptId(message) {
+            try {
+                const promptId = this.promptIdProvider?.();
+                if (promptId && !(CHAT_PAYLOAD_PROMPT_ID_KEY in message)) {
+                    // CHAT_PAYLOAD_PROMPT_ID_KEY is not declared on AiChatItem; the server
+                    // persists the payload as untyped jsonb, so we stamp it through unknown.
+                    // The key is shared with the server reader so a rename fails to compile
+                    // on both sides instead of silently zeroing out the mapping.
+                    return {
+                        ...message,
+                        [CHAT_PAYLOAD_PROMPT_ID_KEY]: promptId,
+                    };
+                }
+            }
+            catch (error) {
+                // Best-effort: never block a chat append. Stays consistent with sibling
+                // boundedAppendMessage, which logs its failures rather than swallowing
+                // them silently, so a future stamping regression is visible.
+                this.logger.warn("[ai-service] Failed to stamp promptId on chat message; appending unstamped", { ...getErrorMeta(error) });
+            }
+            return message;
+        }
+        appendMessage(message) {
+            const stamped = this.stampPromptId(message);
+            const result = this.pushChain.then(() => this.boundedAppendMessage(stamped));
+            this.pushChain = result.catch(() => undefined);
+            return result;
+        }
+        /**
+         * Resolves when every push queued so far has completed (or failed/timed
+         * out). Never rejects. Callers use this to make chat history durable at a
+         * boundary (end of generation) without coupling stream consumption to the
+         * RPC socket (APPS-4729).
+         */
+        async flushPendingPushes() {
+            await this.pushChain.catch(() => undefined);
+        }
+        async boundedAppendMessage(message) {
+            const abortController = new AbortController();
+            // The socket the push was dispatched on, when it got that far. The bound
+            // also covers the chat-history load that precedes the push, so this can
+            // still be unset when the timer fires — then invalidate() targets whatever
+            // client is current, which is the one the bound was waiting on either way.
+            const dispatch = {};
+            let timer;
+            try {
+                return await Promise.race([
+                    this.doAppendMessage(message, abortController.signal, dispatch),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            abortController.abort();
+                            reject(new Error(`${ChatSessionStore.PUSH_TIMEOUT_MESSAGE} after ${ChatSessionStore.PUSH_TIMEOUT_MS}ms`));
+                        }, ChatSessionStore.PUSH_TIMEOUT_MS);
+                    }),
+                ]);
+            }
+            catch (error) {
+                if (ChatSessionStore.isPushTimeoutError(error)) {
+                    // The bound elapsed with no answer, so treat the socket as half-open:
+                    // aborting this push alone would leave the next one queued behind the
+                    // same dead client.
+                    this.rpcClient.invalidate("chat_push_timeout", dispatch.client);
+                }
+                const reason = ChatSessionStore.isPushTimeoutError(error)
+                    ? "timeout"
+                    : "rpc_error";
+                recordChatPushFailure({ reason });
+                this.logger.error("[ai-service] Chat message push failed or timed out", {
+                    ...getErrorMeta(error),
+                    reason,
+                });
+                return undefined;
+            }
+            finally {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+            }
+        }
+        static isPushTimeoutError(error) {
+            return (error instanceof Error &&
+                error.message.startsWith(ChatSessionStore.PUSH_TIMEOUT_MESSAGE));
+        }
+        async doAppendMessage(message, signal, 
+        /** Set to the client the push ran on so a timeout can invalidate that exact handle. */
+        dispatch) {
+            const messageType = "type" in message && typeof message.type === "string"
+                ? message.type
+                : "unknown";
+            return this.tracer.trace({ kind: "task", name: "chat.record" }, async (span) => {
+                const startedAt = performance.now();
+                const annotate = (outcome) => {
+                    this.tracer.annotate(span, {
+                        metadata: {
+                            durationMs: Math.round(performance.now() - startedAt),
+                            messageType,
+                            pushed: outcome.pushed,
+                        },
+                        ...(outcome.error !== undefined ? { error: outcome.error } : {}),
+                    });
+                };
+                await this.ensureLoadedFromServer();
+                const localMessageCountBefore = this.messages.length;
+                this.logger.info(`[ai-service] chatMessagePushStart count=${localMessageCountBefore}`);
+                this.messages.push(message);
+                this.transcriptBudget.track(message);
+                // Keep the resident-bytes gauge bound to the live MeterProvider. The
+                // observable gauge has no other regularly-called rebind trigger, so a
+                // provider installed after this store was constructed would otherwise
+                // never see it (the eviction counters self-heal on every record).
+                // OpenTelemetry metric API calls are no-throw by contract.
+                ensureTranscriptInstruments();
+                this.enforceTranscriptBudget();
+                const payload = {
+                    ...message,
+                };
+                // Skip sending excluded message types to the server
+                if ("type" in payload &&
+                    typeof payload.type === "string" &&
+                    EXCLUDED_MESSAGE_TYPES.includes(payload.type)) {
+                    this.logger.info("[ai-service] chatMessagePushSkipped (excluded type)");
+                    annotate({ pushed: false });
+                    return undefined;
+                }
+                try {
+                    const response = await this.rpcClient.call(async (client) => {
+                        if (dispatch) {
+                            dispatch.client = client;
+                        }
+                        const applicationId = this.applicationId;
+                        return await client.call.v1.ai.chat.pushMessage({
+                            applicationId,
+                            payload,
+                        });
+                    }, { signal });
+                    this.logger.info("[ai-service] chatMessagePushSuccess");
+                    annotate({ pushed: true });
+                    return response.data?.chatmessageId;
+                }
+                catch (error) {
+                    if (signal?.aborted) {
+                        // boundedAppendMessage owns timeout accounting once the timer fires.
+                        return undefined;
+                    }
+                    recordChatPushFailure({ reason: "rpc_error" });
+                    this.logger.error("[ai-service] Failed to write chat message to server", {
+                        ...getErrorMeta(error),
+                        reason: "rpc_error",
+                    });
+                    annotate({ pushed: false, error });
+                    return undefined;
+                }
+            });
+        }
+        async submitWorkflowSummary(summary) {
+            await this.rpcClient.call(async (client) => {
+                return await client.call.v1.ai.billing.workflowSummary.submit(summary);
+            });
+        }
+        async calculatePromptCost(promptId, usage) {
+            const response = await this.rpcClient.call(async (client) => {
+                return await client.call.v1.ai.billing.promptCost.calculate({
+                    promptId,
+                    usage,
+                });
+            });
+            return response.data?.totalCreditsUsed ?? 0;
+        }
+        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";
+        }
+        async recordSummary(summaryData) {
+            const summaryPayload = {
+                ...summaryData,
+                timestamp: Date.now(),
+            };
+            await this.appendMessage(summaryPayload);
+        }
+        async getSummaries() {
+            await this.ensureLoadedFromServer();
+            return this.messages.filter(isEligibleSummary);
+        }
+        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),
+            }));
+        }
+        /**
+         * Invalidate the loaded cache to force a fresh reload from the server
+         * Used when checkpoint is restored to ensure ineligible summaries are filtered out
+         */
+        invalidateCache() {
+            this.resetTranscriptState();
+        }
+        /**
+         * Reset everything tied to the resident transcript for a fresh session
+         * (newChat) or a cache invalidation (checkpoint restore): the loaded flag,
+         * the message array, the byte accounting, and the eviction-warn throttle.
+         * The throttle must reset too, otherwise a fresh transcript that evicts on
+         * the same trigger within the throttle window would skip its first
+         * chatTranscriptEvicted warn even though it is a different session.
+         */
+        resetTranscriptState() {
+            this.loadedFromServer = "no";
+            this.messages = [];
+            this.transcriptBudget.reset([]);
+            this.lastEvictionWarnAt = 0;
+            this.lastEvictionWarnTrigger = null;
+        }
+        /** Resident-transcript accounting, exposed for telemetry. */
+        getTranscriptStats() {
+            return {
+                residentBytes: this.transcriptBudget.residentBytes,
+                residentCount: this.messages.length,
+            };
+        }
+        /**
+         * Drop the oldest evictable transcript entries when over the byte budget,
+         * over the count cap, or under live heap pressure. The durable
+         * transcript stays server-side; this only bounds the in-heap copy.
+         */
+        enforceTranscriptBudget() {
+            if (this.transcriptBudgetDisabled) {
+                return;
+            }
+            const result = this.transcriptBudget.enforce(this.messages);
+            // enforce() returns a non-null trigger whenever it evicts; bail otherwise.
+            if (result.evictedCount === 0 || !result.trigger) {
+                return;
+            }
+            const trigger = result.trigger;
+            this.messages = result.kept;
+            // Counter fires on every eviction; the warn below is throttled.
+            recordTranscriptEviction({
+                trigger,
+                messages: result.evictedCount,
+                bytes: result.evictedBytes,
+            });
+            if (!this.shouldWarnForEviction(trigger)) {
+                return;
+            }
+            const attributes = {
+                evicted_count: result.evictedCount,
+                evicted_bytes: result.evictedBytes,
+                resident_count: this.messages.length,
+                resident_bytes: this.transcriptBudget.residentBytes,
+                trigger,
+                used_heap_bytes: result.usedHeapBytes,
+                heap_limit_bytes: result.heapLimitBytes,
+            };
+            if (this.logger.warnStructured) {
+                this.logger.warnStructured("[ai-service] chatTranscriptEvicted", attributes);
+            }
+            else {
+                this.logger.warn(`[ai-service] chatTranscriptEvicted trigger=${attributes.trigger} evicted_count=${attributes.evicted_count} evicted_bytes=${attributes.evicted_bytes} resident_count=${attributes.resident_count} resident_bytes=${attributes.resident_bytes}`);
+            }
+        }
+        /**
+         * Throttle the eviction warn to one line per trigger per window. A trigger
+         * change always warns (meaningful transition); repeated same-trigger
+         * evictions on every append collapse to one line per EVICTION_WARN_THROTTLE_MS.
+         */
+        shouldWarnForEviction(trigger) {
+            const now = Date.now();
+            if (trigger === this.lastEvictionWarnTrigger &&
+                now - this.lastEvictionWarnAt < EVICTION_WARN_THROTTLE_MS) {
+                return false;
+            }
+            this.lastEvictionWarnAt = now;
+            this.lastEvictionWarnTrigger = trigger;
+            return true;
+        }
+    };
+})();
+export { ChatSessionStore };
+//# sourceMappingURL=chat-session-store.js.map