@ahggg/dsh-side-chat 0.7.1 → 0.7.3

package/lib/client/rc6/runtime-compat.d.ts

@@ -0,0 +1,120 @@
+import type { SessionFace as CurrentSessionFace } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { ChatSnapshot } from '@deepseek-ai/dsh-client-ui-chat/client';
+import type { AssistantBlock, ConversationNode, PartialAssistant, RunningToolCall, ToolCallBlock } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { AskUserQuestionAnswer, AskUserQuestionItem } from '@deepseek-ai/dsh-user-questions/types';
+export type { AssistantBlock, ConversationNode, RunningToolCall, ToolCallBlock, };
+interface RuntimeFailure {
+    readonly code: string;
+    readonly message: string;
+}
+export type RuntimeResult<T = unknown> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: RuntimeFailure;
+};
+interface ObservableSnapshot<T> {
+    readonly getSnapshot: () => T;
+    readonly subscribe: (listener: () => void) => () => void;
+}
+export interface SideChatNodeStore {
+    get(key: string): {
+        readonly key: string;
+        readonly kind: string;
+        readonly anchorSeq: number;
+        readonly visibility: 'visible' | 'hidden';
+        readonly location: {
+            readonly kind: 'session' | 'unresolved';
+        } | {
+            readonly kind: 'turn';
+            readonly turn: {
+                readonly turn: number;
+                readonly status: 'open' | 'closed' | 'unknown';
+            };
+        } | {
+            readonly kind: 'step';
+            readonly turn: {
+                readonly turn: number;
+                readonly status: 'open' | 'closed' | 'unknown';
+            };
+            readonly step: {
+                readonly status: 'open' | 'closed' | 'unknown';
+            };
+        };
+    } | undefined;
+}
+export interface SideChatApprovalInteraction {
+    readonly kind: 'approval';
+    readonly key: string;
+    readonly toolName: string;
+    readonly reason?: string;
+    respond(decision: 'approve' | 'decline'): Promise<boolean>;
+}
+export interface SideChatQuestionInteraction {
+    readonly kind: 'question';
+    readonly key: string;
+    readonly questions: readonly AskUserQuestionItem[];
+    respond(answer: AskUserQuestionAnswer | null): Promise<boolean>;
+}
+export type SideChatPendingInteraction = SideChatApprovalInteraction | SideChatQuestionInteraction;
+export interface SideChatQueuedMessage {
+    readonly id: string;
+    readonly placement: 'queued' | 'steering' | 'context';
+    readonly preview: string;
+}
+export interface SideChatConversationSnapshot {
+    readonly nodes: readonly ConversationNode[];
+    readonly turnEnds: ReadonlyMap<number, number>;
+    readonly partial: PartialAssistant | null;
+    readonly runningCalls: readonly RunningToolCall[];
+    readonly pending: readonly SideChatPendingInteraction[];
+    readonly queue: readonly SideChatQueuedMessage[];
+    readonly running: boolean;
+    readonly openState: 'cold' | 'loading' | 'open' | 'error';
+    readonly promptError: {
+        readonly error: RuntimeFailure;
+    } | null;
+    readonly lastAgentError: string | null;
+    readonly chatNodes: SideChatNodeStore;
+}
+/** Stable surface consumed by Side Chat on both the monolithic and split DSH clients. */
+export interface SideChatConversationFace extends ObservableSnapshot<SideChatConversationSnapshot> {
+    readonly sessionId: SessionId;
+    prompt(content: unknown[], mode: 'queue' | 'steer'): Promise<RuntimeResult>;
+    updateQueue(itemId: string, action: unknown): Promise<RuntimeResult>;
+    cancel(): Promise<RuntimeResult>;
+    rename(title: string): Promise<RuntimeResult>;
+    open(): Promise<void>;
+}
+interface RuntimeSessionFace {
+    readonly sessionId: SessionId;
+    getSnapshot(): unknown;
+    subscribe(listener: () => void): () => void;
+    prompt(content: unknown[], mode: 'queue' | 'steer'): Promise<RuntimeResult>;
+    updateQueue(itemId: string, action: unknown): Promise<RuntimeResult>;
+    cancel(): Promise<RuntimeResult>;
+    rename(title: string): Promise<RuntimeResult>;
+    open?: () => Promise<void>;
+}
+/** Bridge DSH <=0.1.1's combined Session snapshot and 0.1.2's split stores. */
+export declare class CompatibleConversationFace implements SideChatConversationFace {
+    private readonly session;
+    private readonly chat?;
+    private readonly pending?;
+    readonly sessionId: SessionId;
+    private cache;
+    constructor(session: RuntimeSessionFace, chat?: ObservableSnapshot<ChatSnapshot | undefined> | undefined, pending?: ObservableSnapshot<ReadonlyMap<SessionId, unknown>> | undefined);
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly getSnapshot: () => SideChatConversationSnapshot;
+    prompt(content: unknown[], mode: 'queue' | 'steer'): Promise<RuntimeResult>;
+    updateQueue(itemId: string, action: unknown): Promise<RuntimeResult>;
+    cancel(): Promise<RuntimeResult>;
+    rename(title: string): Promise<RuntimeResult>;
+    open(): Promise<void>;
+}
+export declare function compatibleConversationFace(session: CurrentSessionFace, sources?: {
+    readonly chat?: ObservableSnapshot<ChatSnapshot | undefined>;
+    readonly pending?: ObservableSnapshot<ReadonlyMap<SessionId, unknown>>;
+}): CompatibleConversationFace;

package/lib/client/rc6/runtime-compat.js

@@ -0,0 +1,187 @@
+const EMPTY_NODES = [];
+const EMPTY_TURN_ENDS = new Map();
+const EMPTY_RUNNING_CALLS = [];
+const EMPTY_PENDING = [];
+const EMPTY_NODE_STORE = { get: () => undefined };
+function isLegacySnapshot(snapshot) {
+    return typeof snapshot === 'object'
+        && snapshot !== null
+        && Array.isArray(snapshot.nodes)
+        && Array.isArray(snapshot.pending);
+}
+function currentPending(source, sessionId) {
+    const pending = source?.get(sessionId);
+    if (typeof pending !== 'object' || pending === null)
+        return;
+    const candidate = pending;
+    if (candidate.kind === 'approval'
+        && typeof candidate.key === 'string'
+        && typeof candidate.toolName === 'string'
+        && typeof candidate.answer === 'function') {
+        return pending;
+    }
+    if ((candidate.kind === 'question' || candidate.kind === 'plan-review')
+        && typeof candidate.key === 'string'
+        && Array.isArray(candidate.questions)
+        && typeof candidate.answer === 'function'
+        && typeof candidate.cancel === 'function') {
+        return pending;
+    }
+    return undefined;
+}
+function normalizeLegacyPending(wait) {
+    if (wait.kind === 'approval') {
+        return {
+            kind: 'approval',
+            key: wait.key,
+            toolName: wait.payload.toolName,
+            ...(wait.payload.reason === undefined ? {} : { reason: wait.payload.reason }),
+            respond: async (decision) => {
+                const receipt = await wait.respond({
+                    ok: true,
+                    value: {
+                        sessionId: wait.sessionId,
+                        approvalId: wait.payload.approvalId,
+                        outcome: decision === 'approve' ? 'allowed-once' : 'rejected',
+                    },
+                });
+                return receipt.accepted;
+            },
+        };
+    }
+    return {
+        kind: 'question',
+        key: wait.key,
+        questions: wait.payload.questions,
+        respond: async (answer) => {
+            const receipt = await wait.respond(answer === null
+                ? {
+                    ok: false,
+                    error: { code: 'cancelled', message: 'Question cancelled.', details: {} },
+                }
+                : {
+                    ok: true,
+                    value: { sessionId: wait.sessionId, answer },
+                });
+            return receipt.accepted;
+        },
+    };
+}
+function normalizeCurrentPending(wait) {
+    if (wait.kind === 'approval') {
+        return {
+            kind: 'approval',
+            key: wait.key,
+            toolName: wait.toolName,
+            ...(wait.reason === undefined ? {} : { reason: wait.reason }),
+            respond: async (decision) => {
+                await wait.answer(decision === 'approve' ? 'allowed-once' : 'rejected');
+                return true;
+            },
+        };
+    }
+    return {
+        kind: 'question',
+        key: wait.key,
+        questions: wait.questions,
+        respond: async (answer) => {
+            if (answer === null)
+                await wait.cancel();
+            else
+                await wait.answer(answer);
+            return true;
+        },
+    };
+}
+/** Bridge DSH <=0.1.1's combined Session snapshot and 0.1.2's split stores. */
+export class CompatibleConversationFace {
+    session;
+    chat;
+    pending;
+    sessionId;
+    cache;
+    constructor(session, chat, pending) {
+        this.session = session;
+        this.chat = chat;
+        this.pending = pending;
+        this.sessionId = session.sessionId;
+    }
+    subscribe = (listener) => {
+        const removers = [this.session.subscribe(listener)];
+        if (this.chat !== undefined)
+            removers.push(this.chat.subscribe(listener));
+        if (this.pending !== undefined)
+            removers.push(this.pending.subscribe(listener));
+        return () => {
+            for (const remove of removers)
+                remove();
+        };
+    };
+    getSnapshot = () => {
+        const session = this.session.getSnapshot();
+        if (isLegacySnapshot(session)) {
+            if (this.cache?.session === session)
+                return this.cache.value;
+            const value = {
+                nodes: session.nodes,
+                turnEnds: session.turnEnds,
+                partial: session.partial,
+                runningCalls: session.runningCalls,
+                pending: session.pending.map(normalizeLegacyPending),
+                queue: session.queue,
+                running: session.running,
+                openState: session.openState,
+                promptError: session.promptError,
+                lastAgentError: session.lastAgentError,
+                chatNodes: session.chat.nodes,
+            };
+            this.cache = { session, chat: undefined, pending: undefined, value };
+            return value;
+        }
+        const lifecycle = session;
+        const chat = this.chat?.getSnapshot();
+        const pending = this.pending?.getSnapshot();
+        const cached = this.cache;
+        if (cached !== undefined
+            && cached.session === session
+            && cached.chat === chat
+            && cached.pending === pending) {
+            return cached.value;
+        }
+        const legacy = chat?.legacy;
+        const wait = currentPending(pending, this.sessionId);
+        const value = {
+            nodes: legacy?.nodes ?? EMPTY_NODES,
+            turnEnds: legacy?.turnEnds ?? EMPTY_TURN_ENDS,
+            partial: legacy?.partial ?? null,
+            runningCalls: legacy?.runningCalls ?? EMPTY_RUNNING_CALLS,
+            pending: wait === undefined ? EMPTY_PENDING : [normalizeCurrentPending(wait)],
+            queue: lifecycle.queue,
+            running: lifecycle.running,
+            openState: lifecycle.openState,
+            promptError: lifecycle.promptError,
+            lastAgentError: lifecycle.lastAgentError,
+            chatNodes: chat?.nodes ?? EMPTY_NODE_STORE,
+        };
+        this.cache = { session, chat, pending, value };
+        return value;
+    };
+    prompt(content, mode) {
+        return this.session.prompt(content, mode);
+    }
+    updateQueue(itemId, action) {
+        return this.session.updateQueue(itemId, action);
+    }
+    cancel() {
+        return this.session.cancel();
+    }
+    rename(title) {
+        return this.session.rename(title);
+    }
+    async open() {
+        await this.session.open?.call(this.session);
+    }
+}
+export function compatibleConversationFace(session, sources = {}) {
+    return new CompatibleConversationFace(session, sources.chat, sources.pending);
+}

package/lib/client/rc6/sessions-adapter.d.ts

@@ -1,14 +1,16 @@
-import type { ConversationSnapshot, SessionFace } from '@deepseek-ai/dsh-client-runtime/client';
 import type { ModelDirectory } from '@deepseek-ai/dsh-client-ui-model-selection/client';
 import type { SideChatClientSessions, SideChatSessionLease } from '../contracts.js';
 import type { ConversationSelection, SessionId, SideChatModelSelection } from '../../shared/contracts.js';
 import type { ParentComposerInputSnapshot } from '../parent-composer/add-to-conversation.js';
 import { type ReferencedSideChatConversation } from '../parent-composer/referenced-conversation.js';
 import type { Rc6ClientContext } from './context.js';
+import { type SideChatConversationFace, type SideChatConversationSnapshot } from './runtime-compat.js';
 /** Adapter over rc.6's public SessionRuntime and exported concrete Session type. */
 export declare class Rc6SideChatSessions implements SideChatClientSessions {
     private readonly ctx;
     private readonly renamed;
+    private readonly faces;
+    private readonly parentInputs;
     private readonly annotationPersistence;
     private readonly modelPreferences;
     constructor(ctx: Rc6ClientContext);
@@ -24,6 +26,8 @@ export declare class Rc6SideChatSessions implements SideChatClientSessions {
     addSelectionToConversation(selection: ConversationSelection, comment?: string): boolean;
     /** Add one immutable Side Chat transcript to its parent Session's composer. */
     addSideChatToConversation(parentSessionId: SessionId, reference: ReferencedSideChatConversation): boolean;
+    /** Remove one existing unsent annotation from the aggregated occurrence. */
+    removeConversationAnnotation(annotationIndex: number): boolean;
     /** Update an existing unsent annotation without adding a duplicate passage. */
     updateConversationAnnotation(annotationIndex: number, comment?: string): boolean;
     /** Mirror or recover the current Session's unsent annotation occurrence. */
@@ -38,16 +42,18 @@ export declare class Rc6SideChatSessions implements SideChatClientSessions {
         readonly kind: 'status' | 'warning';
         readonly text: string;
     }): void;
-    face(sessionId: SessionId): SessionFace | undefined;
+    face(sessionId: SessionId): SideChatConversationFace | undefined;
     title(sessionId: SessionId): string | undefined;
     cwd(sessionId: SessionId): string | undefined;
     modelDirectory(sessionId: SessionId): ModelDirectory | undefined;
     sideChatModelPreference(): SideChatModelSelection | undefined;
     rememberSideChatModelPreference(selection: SideChatModelSelection): void;
+    private adaptedFace;
     private currentParentInput;
+    private parentInput;
     private waitForBinding;
 }
-export declare function selectionDescriptor(snapshot: ConversationSnapshot, anchorKey: string): {
+export declare function selectionDescriptor(snapshot: SideChatConversationSnapshot, anchorKey: string): {
     readonly nodeKey: string;
     readonly nodeKind: string;
     readonly turnKey: string;
@@ -56,4 +62,3 @@ export declare function selectionDescriptor(snapshot: ConversationSnapshot, anch
     readonly modelVisible: boolean;
     readonly settled: boolean;
 } | undefined;
-//# sourceMappingURL=sessions-adapter.d.ts.map

package/lib/client/rc6/sessions-adapter.js

@@ -1,14 +1,17 @@
 import { SessionId as sideChatSessionId } from '../../shared/contracts.js';
-import { addSelectionToConversation as addSelectionToParentComposer, conversationAnnotations, removeConversationAnnotations as removeParentConversationAnnotations, updateConversationAnnotation as updateParentConversationAnnotation, } from '../parent-composer/add-to-conversation.js';
+import { addSelectionToConversation as addSelectionToParentComposer, conversationAnnotations, removeConversationAnnotation as removeParentConversationAnnotation, removeConversationAnnotations as removeParentConversationAnnotations, updateConversationAnnotation as updateParentConversationAnnotation, } from '../parent-composer/add-to-conversation.js';
 import { ConversationAnnotationPersistence } from '../parent-composer/annotation-persistence.js';
 import { addReferencedSideChatToConversation as addReferencedSideChatToParentComposer, } from '../parent-composer/referenced-conversation.js';
 import { SideChatModelPreferences } from '../model-preference.js';
+import { compatibleConversationFace, } from './runtime-compat.js';
 const BINDING_WAIT_MS = 8_000;
 function sideChatError(error, fallback) {
+    const badRequest = error.code === 'bad-request' || error.code === 'gateway/bad-request';
+    const missing = error.code === 'session-not-found' || error.code === 'session/not-found';
     return {
-        code: error.code === 'session-not-found' ? 'side_chat_not_found' : fallback,
+        code: missing ? 'side_chat_not_found' : fallback,
         message: error.message,
-        recoverable: error.code !== 'bad-request',
+        recoverable: !badRequest,
     };
 }
 function operationError(code, message) {
@@ -83,21 +86,12 @@ class Rc6SessionBinding {
             : { ok: false, error: sideChatError(result.error, 'side_chat_interrupt_failed') };
     }
     async respondApproval(interactionId, decision) {
-        const wait = this.face.getSnapshot().pending
-            .find(item => item.key === interactionId && item.kind === 'approval');
+        const wait = this.face.getSnapshot().pending.find((item) => item.key === interactionId && item.kind === 'approval');
         if (wait === undefined) {
             return { ok: false, error: operationError('invalid_request', 'The approval is no longer pending.') };
         }
         try {
-            const receipt = await wait.respond({
-                ok: true,
-                value: {
-                    sessionId: wait.sessionId,
-                    approvalId: wait.payload.approvalId,
-                    outcome: decision === 'approve' ? 'allowed-once' : 'rejected',
-                },
-            });
-            return receipt.accepted
+            return await wait.respond(decision)
                 ? { ok: true }
                 : { ok: false, error: operationError('transport_error', 'The approval response arrived too late.') };
         }
@@ -106,32 +100,21 @@ class Rc6SessionBinding {
         }
     }
     async respondQuestion(interactionId, answer) {
-        const wait = this.face.getSnapshot().pending
-            .find(item => item.key === interactionId && item.kind === 'question');
+        const wait = this.face.getSnapshot().pending.find((item) => item.key === interactionId && item.kind === 'question');
         if (wait === undefined) {
             return { ok: false, error: operationError('invalid_request', 'The question is no longer pending.') };
         }
         try {
-            const result = answer === null
-                ? {
-                    ok: false,
-                    error: { code: 'cancelled', message: 'Question cancelled.', details: {} },
-                }
+            const normalized = answer === null
+                ? null
                 : {
-                    ok: true,
-                    value: {
-                        sessionId: wait.sessionId,
-                        answer: {
-                            answers: answer.answers.map(item => ({
-                                id: item.id,
-                                selected: [...item.selected],
-                                ...(item.custom === undefined ? {} : { custom: item.custom }),
-                            })),
-                        },
-                    },
+                    answers: answer.answers.map(item => ({
+                        id: item.id,
+                        selected: [...item.selected],
+                        ...(item.custom === undefined ? {} : { custom: item.custom }),
+                    })),
                 };
-            const receipt = await wait.respond(result);
-            return receipt.accepted
+            return await wait.respond(normalized)
                 ? { ok: true }
                 : { ok: false, error: operationError('transport_error', 'The question response arrived too late.') };
         }
@@ -144,6 +127,8 @@ class Rc6SessionBinding {
 export class Rc6SideChatSessions {
     ctx;
     renamed = new Set();
+    faces = new Map();
+    parentInputs = new WeakMap();
     annotationPersistence = new ConversationAnnotationPersistence();
     modelPreferences = new SideChatModelPreferences();
     constructor(ctx) {
@@ -179,17 +164,17 @@ export class Rc6SideChatSessions {
         return current === undefined ? undefined : sideChatSessionId(current);
     }
     lastCompletedSeq(parentSessionId) {
-        const snapshot = this.ctx.sessions.binding(dshSessionId(parentSessionId))?.session.getSnapshot();
+        const snapshot = this.face(parentSessionId)?.getSnapshot();
         return snapshot === undefined ? undefined : latestCompleted(snapshot);
     }
     selectionIsCurrent(selection) {
         if (this.currentSessionId() !== selection.parentSessionId)
             return false;
-        const snapshot = this.ctx.sessions.binding(dshSessionId(selection.parentSessionId))?.session.getSnapshot();
+        const snapshot = this.face(selection.parentSessionId)?.getSnapshot();
         if (snapshot === undefined)
             return false;
         return selection.fragments.every((fragment) => {
-            const node = snapshot.chat.nodes.get(fragment.nodeKey);
+            const node = snapshot.chatNodes.get(fragment.nodeKey);
             return node !== undefined
                 && node.visibility === 'visible'
                 && node.kind === fragment.nodeKind
@@ -210,12 +195,23 @@ export class Rc6SideChatSessions {
     /** Add one immutable Side Chat transcript to its parent Session's composer. */
     addSideChatToConversation(parentSessionId, reference) {
         const scope = this.ctx.sessions.scope(dshSessionId(parentSessionId));
-        const input = scope === undefined ? undefined : this.ctx.conversation.input.for(scope);
+        const input = scope === undefined ? undefined : this.parentInput(scope);
         if (input === undefined || !addReferencedSideChatToParentComposer(input, reference))
             return false;
         this.annotationPersistence.reconcile(parentSessionId, input);
         return true;
     }
+    /** Remove one existing unsent annotation from the aggregated occurrence. */
+    removeConversationAnnotation(annotationIndex) {
+        const sessionId = this.currentSessionId();
+        const input = this.currentParentInput();
+        if (sessionId === undefined
+            || input === undefined
+            || !removeParentConversationAnnotation(input, annotationIndex))
+            return false;
+        this.annotationPersistence.reconcile(sessionId, input);
+        return true;
+    }
     /** Update an existing unsent annotation without adding a duplicate passage. */
     updateConversationAnnotation(annotationIndex, comment) {
         const sessionId = this.currentSessionId();
@@ -253,15 +249,15 @@ export class Rc6SideChatSessions {
     }
     async retain(sessionId) {
         const binding = await this.waitForBinding(dshSessionId(sessionId));
-        const concrete = binding.session;
-        await concrete.open();
+        const face = this.adaptedFace(binding.session);
+        await face.open();
         if (!this.renamed.has(sessionId)) {
             this.renamed.add(sessionId);
             const parentTitle = this.ctx.sessions.list.getSnapshot().byId[dshSessionId(sessionId)]?.displayTitle;
             const title = parentTitle === undefined ? 'Side Chat' : `Side Chat · ${parentTitle}`;
-            await binding.session.rename(title.slice(0, 160)).catch(() => undefined);
+            await face.rename(title.slice(0, 160)).catch(() => undefined);
         }
-        const adapted = new Rc6SessionBinding(binding.session);
+        const adapted = new Rc6SessionBinding(face);
         return { sessionId, binding: adapted, release: () => { } };
     }
     async openSession(sessionId) {
@@ -272,7 +268,8 @@ export class Rc6SideChatSessions {
         console[method](`[dsh-side-chat] ${message.text}`);
     }
     face(sessionId) {
-        return this.ctx.sessions.binding(dshSessionId(sessionId))?.session;
+        const source = this.ctx.sessions.binding(dshSessionId(sessionId))?.session;
+        return source === undefined ? undefined : this.adaptedFace(source);
     }
     title(sessionId) {
         return this.ctx.sessions.list.getSnapshot().byId[dshSessionId(sessionId)]?.displayTitle;
@@ -294,12 +291,44 @@ export class Rc6SideChatSessions {
     rememberSideChatModelPreference(selection) {
         this.modelPreferences.set(selection);
     }
+    adaptedFace(source) {
+        const existing = this.faces.get(source.sessionId);
+        if (existing?.source === source)
+            return existing.compatible;
+        const uiConversation = this.ctx.get('uiConversation');
+        const uiSession = this.ctx.get('uiSession');
+        const chat = uiConversation?.binding(source.sessionId).target('chat');
+        const pending = uiSession?.pendingInteractions;
+        const compatible = compatibleConversationFace(source, {
+            ...(chat === undefined ? {} : { chat }),
+            ...(pending === undefined ? {} : { pending }),
+        });
+        this.faces.set(source.sessionId, { source, compatible });
+        return compatible;
+    }
     currentParentInput() {
         const sessionId = this.currentSessionId();
         if (sessionId === undefined)
             return;
         const scope = this.ctx.sessions.scope(dshSessionId(sessionId));
-        return scope === undefined ? undefined : this.ctx.conversation.input.for(scope);
+        return scope === undefined ? undefined : this.parentInput(scope);
+    }
+    parentInput(scope) {
+        const source = this.ctx.conversation.input.for(scope);
+        if (source === undefined || this.ctx.get('uiConversation') === undefined)
+            return source;
+        const existing = this.parentInputs.get(source);
+        if (existing !== undefined)
+            return existing;
+        const adapted = {
+            referenceMode: 'lexical',
+            state: source.state,
+            setDraft: text => { source.setDraft(text); },
+            insertReference: (reference, span) => source.insertReference(reference, span),
+            replaceText: (text, span) => scope.bail(scope, 'slash/input-insert-text', { text, span }) === true,
+        };
+        this.parentInputs.set(source, adapted);
+        return adapted;
     }
     waitForBinding(sessionId) {
         const immediate = this.ctx.sessions.binding(sessionId);
@@ -331,7 +360,7 @@ export class Rc6SideChatSessions {
     }
 }
 export function selectionDescriptor(snapshot, anchorKey) {
-    const node = snapshot.chat.nodes.get(anchorKey);
+    const node = snapshot.chatNodes.get(anchorKey);
     if (node === undefined || node.visibility !== 'visible')
         return undefined;
     const source = node.kind === 'user' || node.kind === 'steering'
@@ -356,4 +385,3 @@ export function selectionDescriptor(snapshot, anchorKey) {
         settled: locationSettled(node.location),
     };
 }
-//# sourceMappingURL=sessions-adapter.js.map

package/lib/client/selection/ConversationAnnotationMarkers.d.ts

@@ -6,4 +6,3 @@ export declare function ConversationAnnotationMarkers({ annotations, activeAnnot
     readonly activeAnnotationIndex?: number;
     readonly onEdit: (annotation: ConversationSelectionAnnotation, selection: ConversationSelection) => void;
 }): (import("react/jsx-runtime").JSX.Element | null)[];
-//# sourceMappingURL=ConversationAnnotationMarkers.d.ts.map

package/lib/client/selection/ConversationAnnotationMarkers.js

@@ -238,4 +238,3 @@ export function ConversationAnnotationMarkers({ annotations, activeAnnotationInd
             }, onClick: activate, children: badge }, `${annotation.selection.parentSessionId}:${annotation.selection.fragments[0]?.nodeKey ?? ''}:${String(annotation.annotationIndex)}`));
     });
 }
-//# sourceMappingURL=ConversationAnnotationMarkers.js.map

package/lib/client/selection/SelectionActions.d.ts

@@ -13,6 +13,8 @@ export interface SelectionActionsProps {
     readonly onMoreDetails: (selection: ConversationSelection) => void;
     readonly onAskInSideChat: (selection: ConversationSelection) => void;
     readonly onAnnotationEditorChange?: (open: boolean) => void;
+    /** Explicit destructive action offered only while editing a persisted annotation. */
+    readonly onRemoveAnnotation?: () => void;
     readonly onDismiss: () => void;
 }
 export declare function calculateSelectionActionsPosition(rect: ConversationSelection['rect'], size: {
@@ -21,9 +23,10 @@ export declare function calculateSelectionActionsPosition(rect: ConversationSele
 }, touch: boolean, viewport?: {
     readonly width: number;
     readonly height: number;
+    readonly offsetLeft?: number;
+    readonly offsetTop?: number;
 }): {
     readonly left: number;
     readonly top: number;
 };
-export declare function SelectionActions({ selection, touchInteraction, askDisabledReason, annotationNumber, annotationEditor, onAddToChat, onMoreDetails, onAskInSideChat, onAnnotationEditorChange, onDismiss, }: SelectionActionsProps): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=SelectionActions.d.ts.map
+export declare function SelectionActions({ selection, touchInteraction, askDisabledReason, annotationNumber, annotationEditor, onAddToChat, onMoreDetails, onAskInSideChat, onAnnotationEditorChange, onRemoveAnnotation, onDismiss, }: SelectionActionsProps): import("react/jsx-runtime").JSX.Element;