@genesislcap/ai-assistant 15.19.6 → 15.20.0

package/dist/esm/main/main.js

@@ -55,11 +55,13 @@ import { AnimatedPanelToggle } from '../utils/animated-panel-toggle';
 import { resolveExclusiveLoadingStyle } from '../utils/animation-exclusivity';
 import { deleteBankedBaseline, getBankedBaseline, setBankedBaseline, } from '../utils/banked-usage-baselines';
 import { collectSessionModels } from '../utils/collect-session-models';
+import { estimateContextTokens, estimateSystemOverhead, isContextMeasurable, } from '../utils/context-tokens';
 import { clearCostSessionHistory, isCostSessionRecord, loadCostSessionHistory, resolveBankedUsage, saveCostSessionHistory, sortRecordsByRecency, upsertRecord, } from '../utils/cost-session-history';
 import { deriveCostSessionTitleFromMessages, resolveCostSessionTitle, } from '../utils/derive-cost-session-title';
 import { formatUsd } from '../utils/format-usd';
 import { logger } from '../utils/logger';
 import { filterVisibleMessages, trailingInteractionRow } from '../utils/message-partition';
+import { CONTEXT_ABORT_MARGIN_TOKENS, resolveContextBudget, } from '../utils/resolve-context-budget';
 import { resolveCostHistoryConfig, } from '../utils/resolve-cost-history-config';
 import { resolvePreferenceBaseline } from '../utils/resolve-preference-baseline';
 import { stripAgentHandlers } from '../utils/strip-agent-handlers';
@@ -641,7 +643,11 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      * restored/compacted history lands (GENC-1351 §6).
      */
     get sendBlocked() {
-        return this.busy || this.restoring || this.compacting || this.blocked;
+        return (this.busy ||
+            this.restoring ||
+            this.compacting ||
+            this.blocked ||
+            this.contextGate === 'blocked');
     }
     /**
      * Why a programmatic send was refused, for `submitMessage`'s `errors`. A
@@ -650,7 +656,14 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      * looping on "Assistant is busy" would spin forever.
      */
     sendRefusalReason() {
-        return this.blocked ? this.effectiveBlockedReason : 'Assistant is busy';
+        if (this.blocked)
+            return this.effectiveBlockedReason;
+        // Also a standing condition rather than a transient one — a caller looping on
+        // "Assistant is busy" would spin forever — but unlike a budget wall the user
+        // CAN clear this one, so the reason says how.
+        if (this.contextGate === 'blocked')
+            return this.contextGateReason;
+        return 'Assistant is busy';
     }
     /**
      * Re-runs `agentsChanged` if the live `agents` array no longer matches the
@@ -2602,6 +2615,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             // reassignment preserve both.
             driver.setPinnedAgent(this.pinnedAgentName);
             driver.setFlowOwner(this.flowOwnerAgentName);
+            driver.setContextGuard(this.contextGuardPolicy);
             const onOrchStart = () => {
                 this.showHalo = 'orchestrating';
             };
@@ -3009,12 +3023,45 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                     : yield this.providerRegistry.getStatus();
                 this.contextLimit = status === null || status === void 0 ? void 0 : status.contextLimit;
                 this.activeModel = status === null || status === void 0 ? void 0 : status.model;
+                this.syncContextGuard();
             }
             catch (_b) {
                 // Non-fatal — context limit / model display simply won't show
             }
         });
     }
+    /**
+     * Push the mid-loop context guard down to the driver (GENC-1567).
+     *
+     * Called wherever the inputs can change — the resolved provider status, and a
+     * freshly built driver. A driver that never receives one simply runs without
+     * the guard, which is the right default: it fires only when a real context
+     * window is known.
+     */
+    syncContextGuard() {
+        var _a, _b;
+        (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.setContextGuard) === null || _b === void 0 ? void 0 : _b.call(_a, this.contextGuardPolicy);
+    }
+    /**
+     * Guard policy pushed to the driver, or `undefined` when the host has switched
+     * the gate off — so `enabled: false` really does mean no local blocking of any
+     * kind, UI or mid-loop.
+     *
+     * A MARGIN, not a threshold: the driver resolves the window of the provider
+     * each call actually goes to. The fallback window rides along because the
+     * driver cannot learn it any other way — without it, a host that knows its
+     * window while its provider does not report one had `fallbackContextLimit`
+     * protecting the composer and nothing else.
+     */
+    get contextGuardPolicy() {
+        var _a;
+        if (!this.contextBudget.enabled)
+            return undefined;
+        return {
+            marginTokens: CONTEXT_ABORT_MARGIN_TOKENS,
+            fallbackLimit: (_a = this.chatConfig.context) === null || _a === void 0 ? void 0 : _a.fallbackContextLimit,
+        };
+    }
     loadProviderStatuses() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -3033,6 +3080,10 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.syncShowingSplash();
         this.syncActiveCostSessionTitle();
         this.reloadCostSessionHistory();
+        // `chatConfig.context` decides whether the mid-loop guard runs at all, so a
+        // late or changed binding has to reach the driver — otherwise switching the
+        // gate off leaves the guard armed from whatever the config said at connect.
+        this.syncContextGuard();
     }
     /**
      * `persistence` (like `chatConfig`) can bind after `connectedCallback` — a host may
@@ -3128,12 +3179,31 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         }
         this.syncShowHalo();
         this.syncShowingSplash();
-        // Update context token count from the most recent message that carries usage data.
-        for (let i = this.messages.length - 1; i >= 0; i -= 1) {
-            if (this.messages[i].inputTokens != null) {
-                this.contextTokens = this.messages[i].inputTokens;
-                break;
-            }
+        // Context size, from the estimator rather than from the last raw measurement.
+        //
+        // `inputTokens` on a response measured the prompt that PRODUCED it, so it is
+        // always at least one message out of date — it cannot see the response's own
+        // content, nor any tool results appended since, all of which ride the next
+        // prompt. As a display figure that lag was invisible; once it gates sending,
+        // a single large final response could carry the transcript past the block
+        // while the composer stayed live (GENC-1567).
+        //
+        // `estimateContextTokens` is that measurement rebased: calibrated against
+        // every usable anchor, with whatever followed the last one added on. It also
+        // discards anchors invalidated by a compaction — the case where trusting the
+        // raw figure was not a lag but a dead end, leaving the gate blocked on a
+        // conversation that had already shrunk, with sending (the only way to produce
+        // a fresh measurement) being the thing blocked.
+        //
+        // Gated on the transcript being MEASURABLE AT ALL rather than on a currently
+        // usable anchor. Straight after a compaction every retained measurement is
+        // invalidated, so the narrower test skipped the assignment and left a blocked
+        // figure latched — reintroducing the dead end from the other direction. The
+        // estimator handles the invalidated anchors; this only decides whether the
+        // gate gets an opinion, and a provider that has never reported usage still
+        // leaves `contextTokens` unset and the gate inert.
+        if (isContextMeasurable(this.messages)) {
+            this.contextTokens = estimateContextTokens(this.messages);
         }
         // Recompute cost and all four token buckets from the transcript in one walk.
         // Recomputing (rather than incrementing on append) keeps the totals correct under
@@ -3414,8 +3484,45 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      */
     get sessionMenuEnabled() {
         var _a;
+        // The context gate forces the menu open, whatever hid it (GENC-1567). Both
+        // reasons it can be hidden produce the same dead end — a disabled composer
+        // telling the user to compact, with no control anywhere on screen that
+        // compacts. Note that `showSessionMenu: false` is documented for exactly the
+        // guided-onboarding case this gate is most likely to fire in, so the override
+        // is not an edge case; the flow-entry reserve is what should keep it rare.
+        if (this.sessionMenuForcedByContext)
+            return true;
         return ((_a = this.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.showSessionMenu) !== false && !!this.persistence.provider;
     }
+    /**
+     * Whether the menu is on screen ONLY because the context gate put it there.
+     *
+     * @internal
+     */
+    get sessionMenuForcedByContext() {
+        var _a;
+        if (this.contextGate === 'ok')
+            return false;
+        return ((_a = this.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.showSessionMenu) === false || !this.persistence.provider;
+    }
+    /**
+     * Whether to withhold Clear from a menu the context gate forced open.
+     *
+     * The hosts who hid this menu did so to protect a flow from being cleared
+     * mid-journey, and handing someone a Clear button at the moment they are stuck
+     * hunting for a way out is how a conversation gets destroyed by accident.
+     *
+     * But only **while Compact is a real escape**. When the plan says compacting
+     * would not free enough, starting a new conversation is the only way out — and
+     * the blocked copy says exactly that, pointing the user at this menu to do it.
+     * Withholding Clear there would send them to a menu that does not contain the
+     * action they were just told to take.
+     *
+     * @internal
+     */
+    get clearWithheldByContext() {
+        return this.sessionMenuForcedByContext && this.compactable;
+    }
     /** The persistence toggle row renders only when a provider is configured. */
     get persistenceToggleable() {
         return !!this.persistence.provider;
@@ -3425,15 +3532,218 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         return !!this.persistence.enabled && !!this.persistence.provider;
     }
     /**
-     * Whether the menu's "Compact" action would do anything (GENC-1351 §5.7).
-     * Delegates to `driver.canCompact()` so the gate uses the exact same history
-     * `compact()` acts on — one source of truth. Also reads `messages`, purely to
-     * stay reactive as the conversation grows: the driver's history isn't a tracked
-     * observable, so the button keys its re-evaluation off the Redux mirror.
+     * Context-headroom thresholds for the active model (GENC-1567) — the warning
+     * and block lines, plus the tail budget compaction aims at.
+     *
+     * The agent's own `contextReserve` is deliberately NOT folded in here. This is
+     * the AMBIENT budget, which protects any turn from any agent; a per-agent
+     * reserve is an additional, larger requirement checked when that agent takes
+     * ownership of a flow, where there is a turn context to resolve its function
+     * form against.
+     *
+     * Overhead is read off `messages` (the Redux mirror) rather than the driver's
+     * own history, which the compaction plan uses. That is safe rather than sloppy:
+     * `estimateSystemOverhead` only looks at messages BEFORE the first usage-bearing
+     * one, and the two lists agree completely that early — the drift between mirror
+     * and driver history is only ever at the tail.
      */
-    get compactable() {
+    get contextBudget() {
+        return resolveContextBudget({
+            chatConfig: this.chatConfig,
+            contextLimit: this.contextLimit,
+            agentReserveTokens: this.activeAgentReserveTokens,
+            systemOverhead: estimateSystemOverhead(this.messages),
+        });
+    }
+    /**
+     * The active agent's declared `contextReserve`, when it is a plain number.
+     *
+     * Read off the LIVE active agent rather than checked at flow entry, which is
+     * where the design first put it. `flow-owner-changed` turned out to fire while
+     * the driver is already routing the turn — after the send was allowed — so it
+     * is not a pre-flight hook, and gating there would mean aborting a turn in
+     * flight. Reading the active agent instead means a hungry agent's reserve
+     * governs the gate from its next send onwards: one turn later than a true
+     * pre-flight, but synchronous, and it never has to interrupt anything.
+     *
+     * `contextReserve` is a plain number by design — see `ContextReserveInput` for
+     * why a resolver form was dropped rather than accepted and ignored.
+     *
+     * @internal
+     */
+    get activeAgentReserveTokens() {
         var _a, _b, _c;
-        return this.messages.length > 0 && ((_c = (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.canCompact) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false);
+        return (_c = (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.getActiveAgent) === null || _b === void 0 ? void 0 : _b.call(_a)) === null || _c === void 0 ? void 0 : _c.contextReserve;
+    }
+    /**
+     * What compacting right now would reclaim, or `null` when it would not be
+     * worth it (GENC-1567). Sized against {@link FoundationAiAssistant.contextBudget},
+     * so the plan aims at this model's window rather than a fixed default.
+     *
+     * Reads `messages` to stay reactive as the conversation grows: the driver's
+     * history is not a tracked observable, so every consumer of this keys its
+     * re-evaluation off the Redux mirror.
+     */
+    get compactionPlan() {
+        var _a, _b, _c;
+        if (this.messages.length === 0)
+            return null;
+        const budget = this.contextBudget;
+        return ((_c = (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.getCompactionPlan) === null || _b === void 0 ? void 0 : _b.call(_a, {
+            tailTokenBudget: budget.tailTokenBudget,
+            minReclaimTokens: budget.minReclaimTokens,
+        })) !== null && _c !== void 0 ? _c : null);
+    }
+    /**
+     * Tooltip and hint for the Compact row — why it is or is not available.
+     *
+     * Replaces a fixed "Not enough conversation yet to be worth compacting", which
+     * since GENC-1567 could be flatly wrong: a long conversation whose tail is one
+     * indivisible tool result has plenty of conversation and still cannot be
+     * compacted. Reading the plan means the hint states the actual reason.
+     *
+     * @internal
+     */
+    get compactHint() {
+        const plan = this.compactionPlan;
+        if (plan)
+            return `Summarize older messages to free up context`;
+        return this.messages.length === 0
+            ? 'Nothing to compact yet'
+            : 'There is nothing left to summarize here — the recent messages are too large to shrink further';
+    }
+    /**
+     * How close this conversation is to the model's context window (GENC-1567).
+     *
+     * **Derived, never latched** — the opposite of {@link FoundationAiAssistant.blocked}.
+     * A budget wall stays set because nothing the user does fixes it; this clears
+     * itself the moment the conversation shrinks, which is precisely what the user
+     * is being asked to do. The two must not be conflated: `blocked` is also
+     * deliberately preserved across `resetSession`, and a context gate obviously
+     * must not survive starting a new chat.
+     *
+     * **A flow in progress is never blocked, only warned.** Machine state lives
+     * outside the transcript, so a stateful flow is not desynced by compaction —
+     * but the summary can still drop detail the flow's own prompt leans on, and
+     * blocking mid-journey would strand the user between a flow they cannot finish
+     * and a compaction that is a poor idea right there. Letting the flow complete
+     * and gating on the way out is the lesser harm; the headroom reserve exists so
+     * this is rare rather than routine.
+     */
+    get contextGate() {
+        const budget = this.contextBudget;
+        if (!budget.enabled)
+            return 'ok';
+        const tokens = this.contextTokens;
+        if (tokens == null || budget.blockAt == null || budget.warnAt == null)
+            return 'ok';
+        if (tokens >= budget.blockAt)
+            return this.flowOwnerAgentName !== null ? 'warn' : 'blocked';
+        return tokens >= budget.warnAt ? 'warn' : 'ok';
+    }
+    /**
+     * What the composer notice says about the context gate.
+     *
+     * The copy is a function of whether compaction can actually clear the gate,
+     * which is why it reads {@link FoundationAiAssistant.compactionPlan} rather
+     * than assuming. Telling someone to compact when the projection says it would
+     * not free enough — a tail that is one indivisible tool result, say — sends
+     * them into a summarizer call that leaves them exactly where they were.
+     *
+     * @internal
+     */
+    get contextGateReason() {
+        const level = this.contextGate;
+        const canHelp = this.compactionPlan != null;
+        if (level === 'blocked') {
+            return canHelp
+                ? 'There is not enough room in the model context for more work. Click the error pill and compact the context to continue working.'
+                : 'There is not enough room in the model context for more work. Compacting the context will not free enough room, click the error pill to clear and start a new conversation.';
+        }
+        if (this.flowOwnerAgentName !== null) {
+            return 'This conversation is nearly full. The task in progress will finish, but compact before starting another.';
+        }
+        return canHelp
+            ? 'This conversation is getting long. Compact it to free up room.'
+            : 'This conversation is getting long and is close to the limit.';
+    }
+    /**
+     * Short label the session-menu pill wears while the gate is active — the
+     * primary visible signal, in place of a banner.
+     *
+     * Borrowed from the agent pin, which is the established way this composer says
+     * "a mode is in force": a pill that grows a label rather than a strip of prose
+     * above the input. It states the CONDITION only; the remedy lives in the
+     * placeholder once the composer is actually blocked, which is the moment the
+     * user needs to be told what to do rather than merely warned.
+     *
+     * @internal
+     */
+    get contextGateLabel() {
+        switch (this.contextGate) {
+            case 'blocked':
+                return 'At context limit';
+            case 'warn':
+                return 'Approaching context limit';
+            default:
+                return '';
+        }
+    }
+    /**
+     * Whether the composer notice has anything to show — a budget wall or the
+     * context gate. One region for both, so the live region stays single and
+     * registered (see the banner template's accessibility note).
+     *
+     * @internal
+     */
+    get composerNoticeVisible() {
+        return this.bannerVisible || this.contextGate !== 'ok';
+    }
+    /**
+     * Text for that region. A budget wall outranks the context gate: it is the
+     * condition the user cannot clear, so it must not be hidden behind advice
+     * about compacting that would not restore sending anyway.
+     *
+     * For the context gate the region is present and announced but not drawn — see
+     * {@link FoundationAiAssistant.composerNoticeSrOnly}.
+     *
+     * @internal
+     */
+    get composerNoticeText() {
+        if (this.bannerVisible)
+            return this.effectiveBlockedReason;
+        return this.contextGate === 'ok' ? '' : this.contextGateReason;
+    }
+    /**
+     * Whether the notice region should be announced but not drawn.
+     *
+     * The context gate shows itself visually through the pill's label, the
+     * composer outline and the placeholder — a strip of prose on top of those
+     * would be a fourth statement of the same thing. But dropping the region
+     * outright would be an accessibility regression, and a documented one: a
+     * `role="status"` region announces MUTATIONS to a region already being
+     * observed, and it is the only announcement available here, because the
+     * composer flips to `disabled` at the same moment and a disabled control is out
+     * of the tab order — so neither the placeholder nor an `aria-label` on it is
+     * ever voiced.
+     *
+     * So the region stays mounted, keeps its text and keeps announcing; only the
+     * visual treatment is withheld. A budget wall still draws its banner, because
+     * that condition has no other visible expression.
+     *
+     * @internal
+     */
+    get composerNoticeSrOnly() {
+        return !this.bannerVisible && this.contextGate !== 'ok';
+    }
+    /**
+     * Whether the menu's "Compact" action would do anything (GENC-1351 §5.7,
+     * GENC-1567). Delegates to the driver's plan so the gate uses the exact same
+     * history `compact()` acts on, judged against the same budget — one source of
+     * truth for both whether a cut is legal and whether it reclaims enough.
+     */
+    get compactable() {
+        return this.compactionPlan != null;
     }
     toggleSessionMenu() {
         // Mutually exclusive with the agent picker; always reopen showing the menu
@@ -3562,7 +3872,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      */
     compactSession() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e, _f;
             const driver = this.driver;
             if (!(driver === null || driver === void 0 ? void 0 : driver.compact) || driver.isBusy() || this.compacting)
                 return;
@@ -3579,16 +3889,32 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             // false` in the `finally` would then clear the SUCCESSOR session's flag. A write
             // through the captured ref is a no-op on a detached store.
             const ref = this._sessionRef;
+            // Capture the plan the affordance was gated on and hand the SAME budget to
+            // the action, so the compaction that runs is the one the user was shown
+            // (GENC-1567) — and so the projected reclaim can be logged next to what the
+            // compaction actually did.
+            const budget = this.contextBudget;
+            const planOptions = {
+                tailTokenBudget: budget.tailTokenBudget,
+                minReclaimTokens: budget.minReclaimTokens,
+            };
+            const plan = (_b = (_a = driver.getCompactionPlan) === null || _a === void 0 ? void 0 : _a.call(driver, planOptions)) !== null && _b !== void 0 ? _b : null;
             ref === null || ref === void 0 ? void 0 : ref.actions.aiAssistant.setCompacting(true);
             try {
-                const summary = yield driver.compact();
+                const summary = yield driver.compact(planOptions);
                 if (summary) {
                     this.logMeta('context.compacted', {
-                        compactedCount: (_a = summary.compaction) === null || _a === void 0 ? void 0 : _a.compactedCount,
-                        coveredThroughTimestamp: (_b = summary.compaction) === null || _b === void 0 ? void 0 : _b.coveredThroughTimestamp,
-                        model: (_c = summary.compaction) === null || _c === void 0 ? void 0 : _c.model,
+                        compactedCount: (_c = summary.compaction) === null || _c === void 0 ? void 0 : _c.compactedCount,
+                        coveredThroughTimestamp: (_d = summary.compaction) === null || _d === void 0 ? void 0 : _d.coveredThroughTimestamp,
+                        model: (_e = summary.compaction) === null || _e === void 0 ? void 0 : _e.model,
                         trigger: 'manual',
-                        tokensBefore: (_d = summary.compaction) === null || _d === void 0 ? void 0 : _d.tokensBefore,
+                        tokensBefore: (_f = summary.compaction) === null || _f === void 0 ? void 0 : _f.tokensBefore,
+                        // The projection the gate promised. Logged alongside the real figures
+                        // so a drifting estimator shows up in the diagnostics rather than as an
+                        // unexplained "I compacted and it did not help".
+                        projectedTokensAfter: plan === null || plan === void 0 ? void 0 : plan.tokensAfter,
+                        projectedReclaim: plan === null || plan === void 0 ? void 0 : plan.reclaimed,
+                        contextLimit: budget.limit,
                         summaryText: summary.content,
                     });
                 }
@@ -4083,6 +4409,11 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         // anyway, so naming the pinned agent would only imply a send is possible.
         if (this.blocked)
             return BLOCKED_PLACEHOLDER;
+        // The full explanation, not a stub. With no banner above it this is the only
+        // place the remedy is stated, and the composer it sits in is the control the
+        // remedy is about — so the sentence is where the user is already looking.
+        if (this.contextGate === 'blocked')
+            return this.contextGateReason;
         if (this.pinnedAgentName)
             return `Message ${this.pinnedAgentName}...`;
         return this.placeholder;
@@ -5162,6 +5493,9 @@ __decorate([
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "visibleMessages", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "contextGuardPolicy", null);
 __decorate([
     observable
 ], FoundationAiAssistant.prototype, "confirmingClear", void 0);
@@ -5171,12 +5505,48 @@ __decorate([
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "sessionMenuEnabled", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "sessionMenuForcedByContext", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "clearWithheldByContext", null);
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "persistenceToggleable", null);
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "persistenceActive", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "contextBudget", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "activeAgentReserveTokens", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "compactionPlan", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "compactHint", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "contextGate", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "contextGateReason", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "contextGateLabel", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "composerNoticeVisible", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "composerNoticeText", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "composerNoticeSrOnly", null);
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "compactable", null);