@ahggg/dsh-side-chat 0.7.3 → 1.0.0

package/lib/client/parent-composer/annotation-persistence.d.ts

@@ -1,18 +1,18 @@
 import type { SessionId } from '../../shared/contracts.js';
-import type { ParentComposerInput } from './add-to-conversation.js';
-interface AnnotationStorage {
+import type { ParentComposerInput } from './composer-reference.js';
+interface ReferenceStorage {
     getItem(key: string): string | null;
     setItem(key: string, value: string): void;
     removeItem(key: string): void;
 }
-/** Tab-scoped recovery for drafts persisted as a reference clipboard projection. */
+/** Recover the complete reference-bearing draft, not only a leading annotation.
+ * DSH persists clipboard text, so conversation chips need recovery as well. */
 export declare class ConversationAnnotationPersistence {
     private readonly storage;
-    private readonly observedSessions;
-    constructor(storage?: AnnotationStorage | undefined);
+    private readonly observedInputs;
+    private reconciling;
+    constructor(storage?: ReferenceStorage | undefined);
     reconcile(sessionId: SessionId, input: ParentComposerInput): void;
-    private read;
-    private write;
-    private remove;
+    private restore;
 }
 export {};

package/lib/client/parent-composer/annotation-persistence.js

@@ -1,134 +1,138 @@
-import { conversationAnnotationRecoveryRecord, removeOrphanedConversationAnnotationPlaceholder, restoreConversationAnnotationReference, } from './add-to-conversation.js';
-const STORAGE_PREFIX = 'dsh-side-chat:composer-annotations:';
+import { SELECTION_REFERENCE_SOURCE } from './add-to-conversation.js';
+import { SIDE_CHAT_CONVERSATION_REFERENCE_SOURCE } from './referenced-conversation.js';
+const STORAGE_PREFIX = 'dsh-side-chat:composer-references:';
 function browserSessionStorage() {
-    if (typeof window === 'undefined')
-        return;
     try {
-        return window.sessionStorage;
+        return typeof window === 'undefined' ? undefined : window.sessionStorage;
     }
     catch {
         return;
     }
 }
-function storageKey(sessionId) {
-    return `${STORAGE_PREFIX}${encodeURIComponent(sessionId)}`;
-}
-function recordOf(snapshot) {
-    const record = conversationAnnotationRecoveryRecord(snapshot);
-    return record === undefined ? undefined : { version: 2, ...record };
+function ownsReference(snapshot) {
+    return snapshot.occurrences.some(occurrence => occurrence.source === SELECTION_REFERENCE_SOURCE
+        || occurrence.source === SIDE_CHAT_CONVERSATION_REFERENCE_SOURCE);
 }
-function displayDraft(record) {
-    return record.version === 1 ? record.draft : record.displayDraft;
+function validOccurrences(draft, value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return false;
+    let end = 0;
+    return value.every((candidate) => {
+        if (typeof candidate !== 'object' || candidate === null)
+            return false;
+        const item = candidate;
+        if (!Number.isSafeInteger(item.offset) || !Number.isSafeInteger(item.length)
+            || item.offset < end || item.length < 0 || item.offset + item.length > draft.length
+            || typeof item.source !== 'string' || typeof item.ref !== 'string'
+            || typeof item.label !== 'string' || typeof item.clipboardText !== 'string'
+            || draft.slice(item.offset, item.offset + item.length) !== item.clipboardText
+            || (item.appearance !== undefined && !['session', 'file', 'folder'].includes(item.appearance)))
+            return false;
+        end = item.offset + item.length;
+        return true;
+    });
 }
-function mirrorDraft(record) {
-    return record.version === 1 ? record.projection : record.mirrorDraft;
-}
-/** Tab-scoped recovery for drafts persisted as a reference clipboard projection. */
+/** Recover the complete reference-bearing draft, not only a leading annotation.
+ * DSH persists clipboard text, so conversation chips need recovery as well. */
 export class ConversationAnnotationPersistence {
     storage;
-    observedSessions = new Set();
+    observedInputs = new WeakSet();
+    reconciling = false;
     constructor(storage = browserSessionStorage()) {
         this.storage = storage;
     }
     reconcile(sessionId, input) {
-        const key = storageKey(sessionId);
-        const snapshot = input.state.getSnapshot();
-        const current = recordOf(snapshot);
-        if (current !== undefined) {
-            this.observedSessions.add(key);
-            this.write(key, current);
+        if (this.reconciling || this.storage === undefined)
             return;
-        }
-        const stored = this.read(key);
-        if (stored !== undefined) {
-            const exactDisplayDraft = snapshot.draft === displayDraft(stored);
-            const storedMirrorDraft = mirrorDraft(stored);
-            const exactMirrorDraft = storedMirrorDraft !== undefined && snapshot.draft === storedMirrorDraft;
-            if (exactDisplayDraft || exactMirrorDraft) {
-                this.observedSessions.add(key);
-                const restored = restoreConversationAnnotationReference(input, stored.ref, storedMirrorDraft, stored.version === 2 ? stored.baseDraft : undefined);
-                if (restored)
-                    return;
-                // A refused insertion may move an exact display record to its exact
-                // mirror. Keep either v1 or v2 storage retryable from that safe state.
-                if (storedMirrorDraft !== undefined
-                    && input.state.getSnapshot().draft === storedMirrorDraft)
-                    return;
-                this.remove(key);
-                removeOrphanedConversationAnnotationPlaceholder(input);
+        this.reconciling = true;
+        const key = STORAGE_PREFIX + encodeURIComponent(sessionId);
+        try {
+            const snapshot = input.state.getSnapshot();
+            if (ownsReference(snapshot)) {
+                this.observedInputs.add(input);
+                this.storage.setItem(key, JSON.stringify({ version: 1, draft: snapshot.draft, occurrences: snapshot.occurrences }));
+                return;
+            }
+            // Deleting a chip in the same editor is authoritative. Never resurrect
+            // it just because its plain-text clipboard projection is unchanged.
+            if (this.observedInputs.has(input)) {
+                this.storage.removeItem(key);
                 return;
             }
-        }
-        // A live occurrence disappeared in this plugin lifetime: removal or send
-        // is authoritative, including the transition to an empty draft.
-        if (this.observedSessions.has(key)) {
-            this.remove(key);
-            removeOrphanedConversationAnnotationPlaceholder(input);
-            return;
-        }
-        // A new shell starts empty before ConversationSession seeds its persisted
-        // draft. Keep the tab record until that one mount-time adoption occurs.
-        if (stored !== undefined && snapshot.draft === '')
-            return;
-        if (stored !== undefined)
-            this.remove(key);
-        removeOrphanedConversationAnnotationPlaceholder(input);
-    }
-    read(key) {
-        if (this.storage === undefined)
-            return;
-        try {
             const raw = this.storage.getItem(key);
             if (raw === null)
                 return;
-            const value = JSON.parse(raw);
-            if (value.version === 1
-                && typeof value.draft === 'string'
-                && typeof value.ref === 'string'
-                && (value.projection === undefined || typeof value.projection === 'string')) {
-                return {
-                    version: 1,
-                    draft: value.draft,
-                    ...(value.projection === undefined ? {} : { projection: value.projection }),
-                    ref: value.ref,
-                };
+            const stored = JSON.parse(raw);
+            if (stored === null || stored.version !== 1 || typeof stored.draft !== 'string'
+                || !validOccurrences(stored.draft, stored.occurrences)) {
+                this.storage.removeItem(key);
+                return;
             }
-            return value.version === 2
-                && typeof value.displayDraft === 'string'
-                && typeof value.mirrorDraft === 'string'
-                && typeof value.baseDraft === 'string'
-                && typeof value.ref === 'string'
-                ? {
-                    version: 2,
-                    displayDraft: value.displayDraft,
-                    mirrorDraft: value.mirrorDraft,
-                    baseDraft: value.baseDraft,
-                    ref: value.ref,
-                }
-                : undefined;
+            // A fresh Session shell starts empty before its persisted draft is seeded.
+            if (snapshot.draft === '')
+                return;
+            if (snapshot.draft !== stored.draft || snapshot.occurrences.length !== 0) {
+                this.storage.removeItem(key);
+                return;
+            }
+            if (snapshot.phase !== undefined && snapshot.phase !== 'plain')
+                return;
+            if (this.restore(input, stored))
+                this.observedInputs.add(input);
         }
         catch {
-            return;
+            // Storage denial or a stale codec must not alter or erase the user's draft.
         }
-    }
-    write(key, record) {
-        if (this.storage === undefined)
-            return;
-        try {
-            this.storage.setItem(key, JSON.stringify(record));
-        }
-        catch {
-            // Draft recovery is best-effort; the orphan-prefix guard remains active.
+        finally {
+            this.reconciling = false;
         }
     }
-    remove(key) {
-        if (this.storage === undefined)
-            return;
+    restore(input, stored) {
+        let ownedSnapshot;
+        let complete = false;
         try {
-            this.storage.removeItem(key);
+            // Right-to-left edits leave every unprocessed clipboard offset unchanged.
+            for (const occurrence of [...stored.occurrences].reverse()) {
+                const before = input.state.getSnapshot();
+                if (before.draft !== stored.draft)
+                    return false;
+                if (!input.insertReference({
+                    source: occurrence.source, ref: occurrence.ref, label: occurrence.label,
+                    clipboardText: occurrence.clipboardText,
+                    ...(occurrence.appearance === undefined ? {} : { appearance: occurrence.appearance }),
+                }, { start: occurrence.offset, end: occurrence.offset + occurrence.length, draftRev: before.draftRev }))
+                    return false;
+                const after = input.state.getSnapshot();
+                const addedGap = stored.draft[occurrence.offset + occurrence.length] !== ' ';
+                const expected = addedGap
+                    ? stored.draft.slice(0, occurrence.offset + occurrence.length) + ' '
+                        + stored.draft.slice(occurrence.offset + occurrence.length)
+                    : stored.draft;
+                if (after.draft !== expected)
+                    return false;
+                ownedSnapshot = after;
+                if (addedGap) {
+                    if (!input.replaceText('', {
+                        start: occurrence.offset + 1, end: occurrence.offset + 2, draftRev: after.draftRev,
+                    }))
+                        return false;
+                    const normalized = input.state.getSnapshot();
+                    if (normalized.draft !== stored.draft)
+                        return false;
+                    ownedSnapshot = normalized;
+                }
+            }
+            complete = true;
+            return true;
         }
-        catch {
-            // Storage denial must not block composer cleanup.
+        finally {
+            // Keep a refused multi-chip restoration retryable; don't save a partial
+            // projection, and don't roll back edits from synchronous subscribers.
+            const current = input.state.getSnapshot();
+            if (!complete && ownedSnapshot === current) {
+                const length = current.draft.length - current.occurrences.reduce((sum, item) => sum + item.length - 1, 0);
+                input.replaceText(stored.draft, { start: 0, end: length, draftRev: current.draftRev });
+            }
         }
     }
 }

package/lib/client/parent-composer/composer-reference.d.ts

@@ -1,49 +1,23 @@
 import type { Context } from '@deepseek-ai/cordis';
-export declare const LEGACY_REFERENCE_PLACEHOLDER = "\uFFFC";
-export interface ParentComposerOccurrence {
-    readonly occurrenceId: number;
-    readonly source: string;
-    readonly ref: string;
-    readonly offset: number;
-    /** Occupied projection length (display text through 0.1.1, clipboard text in 0.1.2). */
-    readonly length?: number;
-    /** Insert-time display label, present in current DSH input snapshots. */
-    readonly label?: string;
-    /** Draft-persistence projection cached by current DSH input snapshots. */
-    readonly clipboardText?: string;
-    readonly appearance?: 'session' | 'file' | 'folder';
-}
-export interface ParentComposerInputSnapshot {
-    readonly draft: string;
-    readonly draftRev: number;
-    readonly occurrences: readonly ParentComposerOccurrence[];
-}
-export interface ParentComposerSpan {
-    readonly start: number;
-    readonly end: number;
-    readonly draftRev: number;
-}
+import type { InputState, ReferenceInsert, SessionInput, TokenSpan } from '@deepseek-ai/dsh-client-ui-conversation/client';
+export type ParentComposerOccurrence = InputState['occurrences'][number];
+export type ParentComposerSpan = TokenSpan;
+export type ParentComposerInputSnapshot = Pick<InputState, 'draft' | 'draftRev' | 'occurrences'> & Partial<Pick<InputState, 'phase'>>;
+/** DSH 0.2's Lexical editor: published offsets are clipboard coordinates,
+ * mutation spans count each reference chip as one character. */
 export interface ParentComposerInput {
     readonly state: {
         getSnapshot(): ParentComposerInputSnapshot;
-        subscribe?(listener: () => void): () => void;
+        subscribe(listener: () => void): () => void;
     };
-    /** DSH 0.1.2's Lexical editor projects each reference as one mutation coordinate. */
-    readonly referenceMode?: 'text' | 'lexical';
     setDraft(text: string): void;
-    /** Atomic plain-text replacement supplied by Side Chat's scoped input-event adapter. */
-    replaceText?(text: string, span: ParentComposerSpan): boolean;
-    insertReference(reference: {
-        readonly source: string;
-        readonly ref: string;
-        readonly label: string;
-        readonly appearance?: 'session' | 'file' | 'folder';
-        readonly clipboardText: string;
-    }, span: ParentComposerSpan): boolean;
+    replaceText(text: string, span: ParentComposerSpan): boolean;
+    insertReference(reference: ReferenceInsert, span: ParentComposerSpan): boolean;
+    notify?: SessionInput['notify'];
 }
 export interface ParentConversationService {
     readonly input: {
-        for(scope: Context): ParentComposerInput;
+        for(scope: Context): SessionInput;
     };
 }
 export interface SelectionReferenceSource {
@@ -57,25 +31,13 @@ export interface SelectionReferenceSource {
         serialize(ref: string, signal: AbortSignal): Promise<string>;
     };
 }
-export interface OccurrenceRange {
-    readonly start: number;
-    readonly end: number;
-}
-export declare function referenceDisplayText(label: string): string;
-/**
- * Resolve one occurrence's occupied draft range across both DSH reference
- * representations: current full `@label` text with `length`, and the legacy
- * one-code-unit U+FFFC placeholder without it.
- */
-export declare function occurrenceRange(snapshot: ParentComposerInputSnapshot, occurrence: ParentComposerOccurrence, expectedLabel: string): OccurrenceRange | undefined;
+export declare function occurrenceRange(snapshot: ParentComposerInputSnapshot, occurrence: ParentComposerOccurrence, expectedLabel: string): {
+    start: number;
+    end: number;
+} | undefined;
 export declare function occurrenceMatchesDraft(snapshot: ParentComposerInputSnapshot, occurrence: ParentComposerOccurrence, expectedLabel: string): boolean;
-/** Convert one published occurrence range to the host input machine's mutation coordinates. */
-export declare function occurrenceEditSpan(input: ParentComposerInput, snapshot: ParentComposerInputSnapshot, occurrence: ParentComposerOccurrence, options?: {
+/** Convert a reference's clipboard range to the editor's atomic coordinates. */
+export declare function occurrenceEditSpan(_input: ParentComposerInput, snapshot: ParentComposerInputSnapshot, occurrence: ParentComposerOccurrence, options?: {
     readonly consumeFollowingSeparator?: boolean;
 }): ParentComposerSpan | undefined;
-/** Find the exact occurrence minted by one synchronous insertReference call. */
 export declare function newlyInsertedOccurrence(before: ParentComposerInputSnapshot, after: ParentComposerInputSnapshot, source: string, ref: string): ParentComposerOccurrence | undefined;
-/** Remove one occurrence's display range and, optionally, its separating ASCII gap. */
-export declare function draftWithoutOccurrence(snapshot: ParentComposerInputSnapshot, occurrence: ParentComposerOccurrence, expectedLabel: string, options?: {
-    readonly consumeAdjacentSpace?: boolean;
-}): string | undefined;

package/lib/client/parent-composer/composer-reference.js

@@ -1,89 +1,37 @@
-export const LEGACY_REFERENCE_PLACEHOLDER = '\uFFFC';
-export function referenceDisplayText(label) {
-    return `@${label}`;
-}
-/**
- * Resolve one occurrence's occupied draft range across both DSH reference
- * representations: current full `@label` text with `length`, and the legacy
- * one-code-unit U+FFFC placeholder without it.
- */
 export function occurrenceRange(snapshot, occurrence, expectedLabel) {
-    const start = occurrence.offset;
-    if (!Number.isSafeInteger(start) || start < 0 || start > snapshot.draft.length)
+    const { offset, length } = occurrence;
+    if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length)
+        || offset < 0 || length < 0 || offset + length > snapshot.draft.length
+        || occurrence.label !== expectedLabel
+        || snapshot.draft.slice(offset, offset + length) !== occurrence.clipboardText)
         return;
-    if (occurrence.length !== undefined
-        && Number.isSafeInteger(occurrence.length)
-        && occurrence.length > 0
-        && start + occurrence.length <= snapshot.draft.length) {
-        return { start, end: start + occurrence.length };
-    }
-    if (snapshot.draft.startsWith(LEGACY_REFERENCE_PLACEHOLDER, start)) {
-        return { start, end: start + LEGACY_REFERENCE_PLACEHOLDER.length };
-    }
-    const display = referenceDisplayText(expectedLabel);
-    if (snapshot.draft.startsWith(display, start))
-        return { start, end: start + display.length };
-    return;
+    return { start: offset, end: offset + length };
 }
 export function occurrenceMatchesDraft(snapshot, occurrence, expectedLabel) {
-    const range = occurrenceRange(snapshot, occurrence, expectedLabel);
-    if (range === undefined)
-        return false;
-    const text = snapshot.draft.slice(range.start, range.end);
-    if (text === LEGACY_REFERENCE_PLACEHOLDER || text === referenceDisplayText(expectedLabel))
-        return true;
-    return occurrence.label === expectedLabel
-        && occurrence.clipboardText !== undefined
-        && text === occurrence.clipboardText;
+    return occurrenceRange(snapshot, occurrence, expectedLabel) !== undefined;
 }
-/** Convert one published occurrence range to the host input machine's mutation coordinates. */
-export function occurrenceEditSpan(input, snapshot, occurrence, options = {}) {
-    const range = occurrenceRange(snapshot, occurrence, occurrence.label ?? '');
+/** Convert a reference's clipboard range to the editor's atomic coordinates. */
+export function occurrenceEditSpan(_input, snapshot, occurrence, options = {}) {
+    const range = occurrenceRange(snapshot, occurrence, occurrence.label);
     if (range === undefined)
         return;
     let start = range.start;
-    let end = range.end;
-    if (input.referenceMode === 'lexical') {
-        if (occurrence.length === undefined)
+    for (const previous of snapshot.occurrences) {
+        if (previous.offset >= occurrence.offset)
+            continue;
+        if (occurrenceRange(snapshot, previous, previous.label) === undefined
+            || previous.offset + previous.length > occurrence.offset)
             return;
-        start = occurrence.offset;
-        for (const candidate of [...snapshot.occurrences].sort((left, right) => left.offset - right.offset)) {
-            if (candidate.occurrenceId === occurrence.occurrenceId)
-                break;
-            if (candidate.offset > occurrence.offset || candidate.length === undefined)
-                return;
-            start -= candidate.length - 1;
-        }
-        end = start + 1;
-    }
-    if (options.consumeFollowingSeparator === true) {
-        const tail = snapshot.draft.slice(range.end);
-        if (tail.startsWith('\n\n'))
-            end += 2;
-        else if (tail.startsWith('\n') || tail.startsWith(' '))
-            end += 1;
+        start -= previous.length - 1;
     }
+    let end = start + 1;
+    if (options.consumeFollowingSeparator && snapshot.draft[range.end] === ' ')
+        end += 1;
     return { start, end, draftRev: snapshot.draftRev };
 }
-/** Find the exact occurrence minted by one synchronous insertReference call. */
 export function newlyInsertedOccurrence(before, after, source, ref) {
     const previousIds = new Set(before.occurrences.map(occurrence => occurrence.occurrenceId));
     const inserted = after.occurrences.filter(occurrence => !previousIds.has(occurrence.occurrenceId)
-        && occurrence.source === source
-        && occurrence.ref === ref);
+        && occurrence.source === source && occurrence.ref === ref);
     return inserted.length === 1 ? inserted[0] : undefined;
 }
-/** Remove one occurrence's display range and, optionally, its separating ASCII gap. */
-export function draftWithoutOccurrence(snapshot, occurrence, expectedLabel, options = {}) {
-    const range = occurrenceRange(snapshot, occurrence, expectedLabel);
-    if (range === undefined)
-        return;
-    let { start, end } = range;
-    if (options.consumeAdjacentSpace === true) {
-        if (snapshot.draft[end] === ' ')
-            end += 1;
-        else if (start > 0 && snapshot.draft[start - 1] === ' ')
-            start -= 1;
-    }
-    return snapshot.draft.slice(0, start) + snapshot.draft.slice(end);
-}

package/lib/client/parent-composer/referenced-conversation.d.ts

@@ -1,5 +1,4 @@
-import type { ConversationNode } from '@deepseek-ai/dsh-client-ui-conversation/client';
-import type { SessionId } from '../../shared/contracts.js';
+import type { SideChatId, SideChatMessage } from '../../shared/contracts.js';
 import type { ParentComposerInput, SelectionReferenceSource } from './composer-reference.js';
 export declare const SIDE_CHAT_CONVERSATION_REFERENCE_SOURCE = "dsh-side-chat-conversation";
 export interface ReferencedConversationMessage {
@@ -9,7 +8,7 @@ export interface ReferencedConversationMessage {
 /** One immutable snapshot carried by the parent composer's conversation label. */
 export interface ReferencedSideChatConversation {
     readonly version: 1;
-    readonly conversationId: SessionId;
+    readonly conversationId: string;
     readonly title: string;
     readonly conversation: readonly ReferencedConversationMessage[];
 }
@@ -17,12 +16,11 @@ export interface ParsedReferencedConversationPrompt {
     readonly reference: ReferencedSideChatConversation;
     readonly message: string;
 }
-/** Project exactly the user/assistant history visible in the Side Chat modal. */
+/** Capture only the plugin transcript, not the parent context or model reasoning. */
 export declare function referencedSideChatConversation(input: {
-    readonly conversationId: SessionId;
+    readonly conversationId: SideChatId;
     readonly title: string;
-    readonly nodes: readonly ConversationNode[];
-    readonly inheritedThroughSeq: number;
+    readonly messages: readonly SideChatMessage[];
 }): ReferencedSideChatConversation;
 /** Durable model-facing form of the referenced conversation label. */
 export declare function serializeReferencedConversation(reference: ReferencedSideChatConversation): string;

package/lib/client/parent-composer/referenced-conversation.js

@@ -1,4 +1,4 @@
-import { draftWithoutOccurrence, newlyInsertedOccurrence, occurrenceEditSpan, } from './composer-reference.js';
+import { newlyInsertedOccurrence, occurrenceEditSpan, } from './composer-reference.js';
 export const SIDE_CHAT_CONVERSATION_REFERENCE_SOURCE = 'dsh-side-chat-conversation';
 const OPEN_TAG = '<referenced_conversation>';
 const CLOSE_TAG = '</referenced_conversation>';
@@ -6,48 +6,16 @@ function normalizedTitle(title) {
     const normalized = title.trim().replace(/\s+/gu, ' ');
     return normalized.length === 0 ? 'Side Chat' : normalized;
 }
-function visibleContentText(content) {
-    return content.map((block) => {
-        if (typeof block !== 'object' || block === null)
-            return '';
-        const value = block;
-        if (value.type === 'text' && typeof value.text === 'string')
-            return value.text;
-        if (value.type === 'image')
-            return '[Image attachment]';
-        return '';
-    }).filter(Boolean).join('\n').trim();
-}
-function assistantText(node) {
-    return node.blocks
-        .flatMap((block) => block.kind === 'text' ? [block.text] : [])
-        .join('\n')
-        .trim();
-}
-/** Project exactly the user/assistant history visible in the Side Chat modal. */
+/** Capture only the plugin transcript, not the parent context or model reasoning. */
 export function referencedSideChatConversation(input) {
-    const conversation = [];
-    for (const node of input.nodes) {
-        if (node.seq <= input.inheritedThroughSeq)
-            continue;
-        if (node.kind === 'user' || node.kind === 'steering') {
-            const content = visibleContentText(node.content);
-            if (content.length > 0)
-                conversation.push({ role: 'user', content });
-            continue;
-        }
-        if (node.kind === 'assistant') {
-            const content = assistantText(node);
-            if (content.length > 0)
-                conversation.push({ role: 'assistant', content });
-        }
-    }
-    return {
-        version: 1,
-        conversationId: input.conversationId,
-        title: normalizedTitle(input.title),
-        conversation,
-    };
+    const conversation = input.messages.flatMap((message) => {
+        if (message.status === 'streaming' || message.text.trim().length === 0)
+            return [];
+        const content = message.selectedText === undefined ? message.text
+            : `Selected passage:\n${message.selectedText}\n\nQuestion:\n${message.text}`;
+        return [{ role: message.role, content }];
+    });
+    return { version: 1, conversationId: input.conversationId, title: normalizedTitle(input.title), conversation };
 }
 function isReferencedConversationMessage(value) {
     if (typeof value !== 'object' || value === null)
@@ -144,24 +112,9 @@ function removeOccurrence(input, occurrenceId) {
     const occurrence = snapshot.occurrences.find(candidate => candidate.occurrenceId === occurrenceId);
     if (occurrence === undefined)
         return;
-    let title;
-    try {
-        title = decodeReferencedConversation(occurrence.ref).title;
-    }
-    catch {
-        return;
-    }
-    if (input.referenceMode === 'lexical' && input.replaceText !== undefined) {
-        const span = occurrenceEditSpan(input, snapshot, occurrence, {
-            consumeFollowingSeparator: true,
-        });
-        if (span !== undefined)
-            input.replaceText('', span);
-        return;
-    }
-    const draft = draftWithoutOccurrence(snapshot, occurrence, title, { consumeAdjacentSpace: true });
-    if (draft !== undefined)
-        input.setDraft(draft);
+    const span = occurrenceEditSpan(input, snapshot, occurrence);
+    if (span !== undefined)
+        input.replaceText('', span);
 }
 /** Insert or refresh one Side Chat label without duplicating an older snapshot. */
 export function addReferencedSideChatToConversation(input, reference) {
@@ -172,7 +125,7 @@ export function addReferencedSideChatToConversation(input, reference) {
     const encoded = encodeReferencedConversation(reference);
     if (existing.some(occurrence => occurrence.ref === encoded))
         return true;
-    const target = input.referenceMode === 'lexical' ? existing[0] : undefined;
+    const target = existing[0];
     const span = target === undefined
         ? { start: 0, end: 0, draftRev: before.draftRev }
         : occurrenceEditSpan(input, before, target);
@@ -187,18 +140,13 @@ export function addReferencedSideChatToConversation(input, reference) {
     }, span);
     if (!inserted)
         return false;
-    if (input.referenceMode === 'lexical') {
-        const after = input.state.getSnapshot();
-        const occurrence = newlyInsertedOccurrence(before, after, SIDE_CHAT_CONVERSATION_REFERENCE_SOURCE, encoded);
-        if (occurrence === undefined)
-            return false;
-        for (const duplicate of existing.slice(1))
-            removeOccurrence(input, duplicate.occurrenceId);
-        return matchingOccurrences(input.state.getSnapshot(), reference).length === 1;
-    }
-    for (const occurrence of existing)
-        removeOccurrence(input, occurrence.occurrenceId);
-    return true;
+    const after = input.state.getSnapshot();
+    const occurrence = newlyInsertedOccurrence(before, after, SIDE_CHAT_CONVERSATION_REFERENCE_SOURCE, encoded);
+    if (occurrence === undefined)
+        return false;
+    for (const duplicate of existing.slice(1))
+        removeOccurrence(input, duplicate.occurrenceId);
+    return matchingOccurrences(input.state.getSnapshot(), reference).length === 1;
 }
 /** Reference codec used by the native composer chip and submit pipeline. */
 export const sideChatConversationReferenceSource = {