@deepseek-ai/dsh-api-session-controller 0.1.2-alpha.5 → 0.1.3-alpha.2

package/lib/types/commands.js

@@ -53,12 +53,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { randomUUID } from 'node:crypto';
 import { brandString } from '@deepseek-ai/dsh-brand';
-import { AttachmentError, admitPromptContent } from '@deepseek-ai/dsh-attachment';
-import { ReasoningEffortId, createUserMessage, freezeMessage, } from '@deepseek-ai/dsh-llm';
+import { AttachmentError } from '@deepseek-ai/dsh-attachment';
+import { ReasoningEffortId, assistantStreamChunks, createUserMessage, freezeMessage, } from '@deepseek-ai/dsh-llm';
 import { SessionLogOffset, SessionSeq } from '@deepseek-ai/dsh-session';
 import { SessionQueryError } from '@deepseek-ai/dsh-session-query';
 import { SessionTitleInvalidError } from '@deepseek-ai/dsh-session-title';
 import { canonicalClientTimeZone } from '@deepseek-ai/dsh-util-time';
+import { assertNever } from '@deepseek-ai/dsh-util-values';
 import { RemoteError, remoteErrorOf } from '@deepseek-ai/dsh-typert-protocol';
 import { ApiSessionCwdConflict, ApiSessionNotFound, ApiSessionPresetConflict, ApiSessionSubagentOwnership, apiSessionSubagentOwnershipError, hasApiSessionSubagentOwner, inspectApiSession, } from "./agent.js";
 /** Implements Session business commands delegated by the Session Controller Remote service. */
@@ -282,6 +283,8 @@ export class SessionCommandController {
             throw new RemoteError('session/invalid-time-zone', 'clientTimeZone must be UTC or a valid IANA Area/Location name', { value: request.clientTimeZone });
         }
         const agent = await this.resolveAgent(request.sessionId);
+        if (hasPromptRequest(agent, request.requestId))
+            return { accepted: true };
         const selection = this.agents.selectionFor(agent).current;
         if (!routeServed(this.ctx, selection.provider)) {
             throw new RemoteError('session/model-unavailable', `no adapter serves provider "${selection.provider}"; select a model for this session`, { provider: selection.provider, model: selection.model });
@@ -294,19 +297,35 @@ export class SessionCommandController {
         const hasImage = request.content.some(part => part.type === 'image');
         const admit = async () => {
             try {
-                if (hasImage) {
-                    const current = this.agents.selectionFor(agent).current;
-                    const model = await this.ctx.llm.resolveModelInfo(current.provider, current.model);
-                    if (model.inputModalities !== undefined && !model.inputModalities.includes('image')) {
-                        throw new RemoteError('session/attachment-invalid', `Model "${current.model}" does not support image input.`, { reason: 'MODEL_DOES_NOT_SUPPORT_IMAGES' });
+                const env_2 = { stack: [], error: void 0, hasError: false };
+                try {
+                    if (hasImage) {
+                        const current = this.agents.selectionFor(agent).current;
+                        const model = await this.ctx.llm.resolveModelInfo(current.provider, current.model);
+                        if (model.inputModalities !== undefined && !model.inputModalities.includes('image')) {
+                            throw new RemoteError('session/attachment-invalid', `Model "${current.model}" does not support image input.`, { reason: 'MODEL_DOES_NOT_SUPPORT_IMAGES' });
+                        }
+                    }
+                    const admission = resolvePromptFileReceipts(request.content, receiptId => this.ctx.fileUploads.resolve(agent, receiptId));
+                    const content = await this.ctx.attachments.admitPromptContent(admission.content);
+                    const message = createUserMessage({ content, source });
+                    if (this.ctx.agents.get(agent.id) !== agent) {
+                        throw new RemoteError('session/not-found', `session "${agent.id}" was disposed during prompt admission`, { sessionId: agent.id });
                     }
+                    const binding = __addDisposableResource(env_2, this.ctx.fileUploads.bindPrompt(agent, admission.receiptIds, request.requestId), false);
+                    if (request.mode === 'steer')
+                        agent.steer(message);
+                    else
+                        agent.followup(message);
+                    binding.commit();
+                }
+                catch (e_2) {
+                    env_2.error = e_2;
+                    env_2.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_2);
                 }
-                const content = await admitPromptContent(this.ctx.attachments, request.content);
-                const message = createUserMessage({ content, source });
-                if (request.mode === 'steer')
-                    agent.steer(message);
-                else
-                    agent.followup(message);
             }
             catch (error) {
                 if (remoteErrorOf(error) !== undefined)
@@ -365,12 +384,18 @@ export class SessionCommandController {
             throw new RemoteError('session/attachment-invalid', 'queue edits accept text content only', { reason: 'QUEUE_EDIT_NON_TEXT' });
         }
         const agent = this.ctx.agents.get(request.sessionId);
-        if (agent !== undefined && hasApiSessionSubagentOwner(this.ctx, agent.session, agent)) {
-            throw apiSessionSubagentOwnershipError(request.sessionId);
-        }
         if (agent === undefined) {
             throw new RemoteError('session/queue-item-not-found', 'queued item is no longer pending', { itemId: request.itemId });
         }
+        if (hasApiSessionSubagentOwner(this.ctx, agent.session, agent)) {
+            const identity = this.ctx.sessionProjections
+                .snapshot(agent.session, ['subagent'])
+                .values.subagent;
+            if (identity?.mode !== 'continuable'
+                || !agent.session.isOwnSeq(identity.seq)) {
+                throw apiSessionSubagentOwnershipError(request.sessionId);
+            }
+        }
         const nextTurn = agent.inbox.nextTurn.find(message => message.id === request.itemId);
         const nextStep = agent.inbox.nextStep.find(message => message.id === request.itemId);
         const located = nextTurn === undefined
@@ -383,16 +408,28 @@ export class SessionCommandController {
         if (request.action.kind === 'steer' && (target !== 'next-turn' || agent.status !== 'running')) {
             throw new RemoteError('session/steer-unavailable', 'current turn no longer accepts steering', { itemId: request.itemId });
         }
-        if (request.action.kind === 'edit') {
-            agent.inbox.replace(request.itemId, freezeMessage({
-                ...message,
-                content: [...request.action.content],
-            }));
-        }
-        else {
-            agent.inbox.remove(request.itemId);
-            if (request.action.kind === 'steer')
+        switch (request.action.kind) {
+            case 'edit':
+                agent.inbox.replace(request.itemId, freezeMessage({
+                    ...message,
+                    content: [...request.action.content],
+                }));
+                break;
+            case 'remove': {
+                agent.inbox.remove(request.itemId);
+                const source = message.source;
+                if (source.kind === 'user' && 'rpcId' in source) {
+                    this.ctx.fileUploads.retirePrompt(agent, source.rpcId);
+                }
+                break;
+            }
+            case 'steer':
+                agent.inbox.remove(request.itemId);
                 agent.steer(message);
+                break;
+            /* v8 ignore next 2 -- closed-union exhaustiveness guard */
+            default:
+                assertNever(request.action, 'queue action');
         }
         return { accepted: true };
     }
@@ -462,6 +499,34 @@ export class SessionCommandController {
         return undefined;
     }
 }
+function resolvePromptFileReceipts(content, stagedFile) {
+    const receiptIds = new Set();
+    const resolved = content.map((part) => {
+        if (part.type !== 'file')
+            return part;
+        const attachment = stagedFile(part.receiptId);
+        if (attachment === undefined) {
+            throw new RemoteError('session/attachment-invalid', 'File was not uploaded for this session.', { reason: 'FILE_NOT_STAGED' });
+        }
+        receiptIds.add(part.receiptId);
+        return { type: 'file', attachment };
+    });
+    return { content: resolved, receiptIds: [...receiptIds] };
+}
+function hasPromptRequest(agent, requestId) {
+    const matches = (message) => {
+        const source = message.source;
+        return source.kind === 'user' && 'rpcId' in source && source.rpcId === requestId;
+    };
+    if (agent.inbox.nextTurn.some(matches) || agent.inbox.nextStep.some(matches))
+        return true;
+    return agent.session.snapshotEvents().some((event) => {
+        if (event.type !== 'user/message')
+            return false;
+        const source = event.data.source;
+        return source.kind === 'user' && 'rpcId' in source && source.rpcId === requestId;
+    });
+}
 function imageBlockIn(content, match) {
     if (!Array.isArray(content))
         return undefined;
@@ -495,9 +560,14 @@ function imageInEvent(event, match) {
         if (found !== undefined)
             return found;
     }
-    return event.type === 'assistant/chunk' && data.chunk?.type === 'block-end'
-        ? imageBlockIn([data.chunk.block], match)
-        : undefined;
+    if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
+        for (const chunk of assistantStreamChunks(event.data.stream, 'block-end')) {
+            const found = imageBlockIn([chunk.block], match);
+            if (found !== undefined)
+                return found;
+        }
+    }
+    return undefined;
 }
 function referencedImage(events, attachmentId) {
     for (const event of events) {

package/lib/types/history.d.ts

@@ -7,6 +7,7 @@ export declare class SessionHistoryController {
     private readonly ctx;
     private readonly promote;
     private readonly closeFollowers;
+    private readonly assistantStreams;
     /**
      * @param ctx - Host context carrying Session query and projection services.
      * @param promote - starts ordinary Session activation after snapshot delivery.
@@ -23,7 +24,7 @@ export declare class SessionHistoryController {
      * Follow events appended after an initial cursor on one durable address.
      * @param request - durable address and last committed sequence already held by the caller.
      * @param signal - stream cancellation owned by the Remote carrier.
-     * @returns a complete opening snapshot followed by gap-free event frames.
+     * @returns a complete opening snapshot followed by gap-free durable events and opted-in assistant frames.
      */
     follow(request: SessionFollowRequest, signal: AbortSignal): AsyncIterable<SessionFollowFrame>;
     private sourceFor;

package/lib/types/history.js

@@ -53,9 +53,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { Deque } from '@deepseek-ai/dsh-deque';
 import { isAppendSurfaceEvent, SessionLogOffset, SessionSeq, } from '@deepseek-ai/dsh-session';
-import { isChunkRow, packChunkRuns } from '@deepseek-ai/dsh-session/chunk-rows';
 import { SessionQueryError } from '@deepseek-ai/dsh-session-query';
 import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+import { SessionAssistantStreamAccumulator } from "./assistant-stream.js";
 const DEFAULT_MAX_MESSAGES = 50;
 const MESSAGE_TYPES = new Set(['user/message', 'assistant/message']);
 /** Implements cold-safe history operations delegated by the Session Controller. */
@@ -63,6 +63,7 @@ export class SessionHistoryController {
     ctx;
     promote;
     closeFollowers = new Set();
+    assistantStreams = new Map();
     /**
      * @param ctx - Host context carrying Session query and projection services.
      * @param promote - starts ordinary Session activation after snapshot delivery.
@@ -70,6 +71,17 @@ export class SessionHistoryController {
     constructor(ctx, promote) {
         this.ctx = ctx;
         this.promote = promote;
+        ctx.on('agent/assistant-stream', ({ agent, frame }) => {
+            let stream = this.assistantStreams.get(agent.session.id);
+            if (stream === undefined) {
+                stream = new SessionAssistantStreamAccumulator();
+                this.assistantStreams.set(agent.session.id, stream);
+            }
+            stream.accept(frame, cursorBeforeNext(agent.session.seq));
+        }, { global: true });
+        ctx.on('agent/disposed', ({ agent }) => {
+            this.assistantStreams.delete(agent.session.id);
+        }, { global: true });
         ctx.effect(() => () => {
             for (const close of this.closeFollowers)
                 close();
@@ -122,7 +134,7 @@ export class SessionHistoryController {
      * Follow events appended after an initial cursor on one durable address.
      * @param request - durable address and last committed sequence already held by the caller.
      * @param signal - stream cancellation owned by the Remote carrier.
-     * @returns a complete opening snapshot followed by gap-free event frames.
+     * @returns a complete opening snapshot followed by gap-free durable events and opted-in assistant frames.
      */
     async *follow(request, signal) {
         validateFollowRequest(request);
@@ -130,6 +142,7 @@ export class SessionHistoryController {
         const target = addressId(address);
         const buffered = new Deque();
         let snapshotCursor;
+        let assistantStreamOrdinal = 0;
         let wake;
         const notify = () => {
             const resume = wake;
@@ -145,7 +158,7 @@ export class SessionHistoryController {
         const disposeEvent = this.ctx.on('session/event', (session, event) => {
             if (session.id !== target)
                 return;
-            buffered.pushBack(event);
+            buffered.pushBack({ type: 'event', event });
             notify();
         }, { global: true });
         const disposeCreated = this.ctx.on('session/created', (session) => {
@@ -158,10 +171,22 @@ export class SessionHistoryController {
                 ? session.firstLiveSeq
                 : SessionLogOffset(snapshotCursor + 1));
             for (let index = suffix.length - 1; index >= 0; index -= 1) {
-                buffered.pushFront(suffix[index]);
+                buffered.pushFront({ type: 'event', event: suffix[index] });
             }
             notify();
         }, { global: true });
+        const disposeAssistantStream = request.assistantStream !== true
+            ? undefined
+            : this.ctx.on('agent/assistant-stream', ({ agent, frame }) => {
+                if (agent.session.id !== target)
+                    return;
+                buffered.pushBack({
+                    type: 'assistant-stream',
+                    frame: wireAssistantStreamFrame(frame, cursorBeforeNext(agent.session.seq)),
+                    ordinal: ++assistantStreamOrdinal,
+                });
+                notify();
+            }, { global: true });
         const onAbort = () => { notify(); };
         signal.addEventListener('abort', onAbort, { once: true });
         try {
@@ -173,15 +198,24 @@ export class SessionHistoryController {
                 const cursor = source.cursor;
                 snapshotCursor = cursor;
                 const page = paginate(events, undefined, request.maxMessages ?? DEFAULT_MAX_MESSAGES);
+                const assistantStream = request.assistantStream === true
+                    ? this.assistantStreams.get(target)?.snapshot() ?? { revision: 0 }
+                    : undefined;
+                // The accumulator snapshot and this watermark are synchronous. Frames
+                // through the cut are represented or superseded by that baseline,
+                // including larger revisions from a retired Agent; later revision
+                // resets reach Client continuity validation.
+                const assistantStreamOrdinalCut = assistantStreamOrdinal;
                 yield {
                     type: 'snapshot',
-                    header: wireHeader(source.header, source.inheritedEventCount),
+                    header: wireHeader(source.header),
                     cursor,
                     records: pageRecords(page.events),
                     hasMore: page.hasMore,
                     projections: source.projections === undefined
                         ? { asOfSeq: cursor, values: {} }
                         : projectionBlock(source.projections),
+                    ...assistantStream === undefined ? {} : { assistantStream },
                 };
                 if (address.kind === 'session' && source.source === 'prepared') {
                     const promotion = source.retain();
@@ -200,14 +234,20 @@ export class SessionHistoryController {
                         await new Promise((resolve) => { wake = resolve; });
                         continue;
                     }
+                    if (item.type === 'assistant-stream') {
+                        if (item.ordinal > assistantStreamOrdinalCut) {
+                            yield { type: 'assistant-stream', frame: item.frame };
+                        }
+                        continue;
+                    }
                     const expectedSeq = SessionSeq(nextOffset);
-                    if (item.seq < expectedSeq)
+                    if (item.event.seq < expectedSeq)
                         continue;
-                    if (item.seq !== expectedSeq) {
+                    if (item.event.seq !== expectedSeq) {
                         throw new RemoteError('gateway/internal', `session event stream skipped seq ${String(expectedSeq)}`, {});
                     }
                     nextOffset = SessionLogOffset(nextOffset + 1);
-                    yield entryFor(item);
+                    yield entryFor(item.event);
                 }
             }
             catch (e_2) {
@@ -223,6 +263,7 @@ export class SessionHistoryController {
             signal.removeEventListener('abort', onAbort);
             disposeCreated();
             disposeEvent();
+            disposeAssistantStream?.();
         }
     }
     async sourceFor(address, signal, withProjections) {
@@ -253,6 +294,19 @@ export class SessionHistoryController {
         }
     }
 }
+function cursorBeforeNext(nextSeq) {
+    return nextSeq === 0 ? -1 : SessionSeq(nextSeq - 1);
+}
+function wireAssistantStreamFrame(frame, durableCursor) {
+    if (frame.type === 'start')
+        return { ...frame, startedAfterSeq: durableCursor };
+    if (frame.type === 'end')
+        return frame;
+    return {
+        ...frame,
+        chunk: frame.chunk,
+    };
+}
 function projectionBlock(snapshot) {
     return {
         asOfSeq: snapshot.asOfSeq,
@@ -354,13 +408,9 @@ function paginate(events, beforeSeq, maxMessages, throughSeq = events.at(-1)?.se
     }
     return { events: events.slice(cut, end), hasMore: cut > 0 };
 }
-/** Translate logical Session metadata to the unchanged v0 browser wire. */
-function wireHeader(header, inheritedEventCount) {
-    const { isSeeded, ...wire } = header;
-    return {
-        ...wire,
-        ...isSeeded ? { seedLength: inheritedEventCount } : {},
-    };
+/** Translate current logical Session metadata to the browser wire. */
+function wireHeader(header) {
+    return { ...header };
 }
 function entryFor(event) {
     return {
@@ -369,29 +419,8 @@ function entryFor(event) {
         event: event,
     };
 }
-function chunkEntryFor(row) {
-    switch (row.type) {
-        case 'text-chunks':
-            return {
-                type: 'chunks',
-                event: { type: 'chunkrow/text-chunks', seq: row.seq0, time: row.time0, data: row.data },
-            };
-        case 'reasoning-chunks':
-            return {
-                type: 'chunks',
-                event: { type: 'chunkrow/reasoning-chunks', seq: row.seq0, time: row.time0, data: row.data },
-            };
-        case 'tool-call-chunks':
-            return {
-                type: 'chunks',
-                event: { type: 'chunkrow/tool-call-chunks', seq: row.seq0, time: row.time0, data: row.data },
-            };
-    }
-}
 /** Encode one bounded logical page without changing its pagination cut. */
 function pageRecords(events) {
-    return packChunkRuns(events).map(record => isChunkRow(record)
-        ? chunkEntryFor(record)
-        : entryFor(record));
+    return events.map(entryFor);
 }
 //# sourceMappingURL=history.js.map

package/lib/types/index.d.ts

@@ -19,8 +19,6 @@ declare module '@deepseek-ai/cordis' {
 }
 /** Session Controller deployment policy. */
 export interface Config {
-    /** Maximum cold Session artifact size eligible for one full projection observation. */
-    readonly coldBlankProbeMaxBytes?: number;
     /** Override platform desktop-opener detection. */
     readonly nativeOpen?: boolean;
 }
@@ -45,7 +43,8 @@ export declare class SessionController extends TypertRemoteService {
     private readonly promotions;
     /**
      * @param ctx - Host context containing the Session capability assembly.
-     * @param config - cold-list observation policy.
+     * @param config - native-opener deployment policy.
+     * @param internals - host integrations replaceable by direct unit tests.
      */
     constructor(ctx: Context, config: Config, internals?: SessionControllerInternals);
     private promote;
@@ -154,7 +153,8 @@ export declare class SessionController extends TypertRemoteService {
      * Follow one Session log from its opening or resume cursor.
      * @param request - durable address and last committed sequence already held by the caller.
      * @param signal - cancellation owned by the Remote stream carrier.
-     * @returns a complete opening snapshot followed by gap-free event frames.
+     * @returns a complete opening snapshot followed by gap-free durable event
+     *   frames and optional cursorless assistant-stream frames.
      */
     follow(request: SessionFollowRequest, signal: AbortSignal): AsyncIterable<SessionFollowFrame>;
     /**

package/lib/types/index.js

@@ -94,7 +94,7 @@ import { SessionCommandController } from "./commands.js";
 import { SessionControlController } from "./control.js";
 import { SessionHistoryController } from "./history.js";
 import { SessionFileReferences } from "./file-references.js";
-import { ApiSessionList, DEFAULT_COLD_BLANK_PROBE_MAX_BYTES } from "./list.js";
+import { ApiSessionList } from "./list.js";
 import { buildModelCatalog } from "./catalog.js";
 import { installModelSelectionProjection } from "./model-selection-projection.js";
 import { SessionSkillCatalog } from "./skill-catalog.js";
@@ -162,6 +162,7 @@ let SessionController = (() => {
             'agentDefaultModel',
             'agents',
             'attachments',
+            'fileUploads',
             'llm',
             'sessions',
             'sessionProjections',
@@ -170,7 +171,6 @@ let SessionController = (() => {
             'workspaceRegistry',
         ];
         static Config = z.object({
-            coldBlankProbeMaxBytes: z.natural().default(DEFAULT_COLD_BLANK_PROBE_MAX_BYTES),
             nativeOpen: z.boolean(),
         });
         agents = __runInitializers(this, _instanceExtraInitializers);
@@ -183,13 +183,20 @@ let SessionController = (() => {
         promotions = new Set();
         /**
          * @param ctx - Host context containing the Session capability assembly.
-         * @param config - cold-list observation policy.
+         * @param config - native-opener deployment policy.
+         * @param internals - host integrations replaceable by direct unit tests.
          */
         constructor(ctx, config, internals = {}) {
             super(ctx, 'sessionController', { namespace: 'session' });
             installModelSelectionProjection(ctx);
             this.agents = new ApiSessionAgentController(ctx);
             this.commands = new SessionCommandController(ctx, this.agents, process.cwd());
+            ctx.effect(() => ctx.fileUploads.registerAgentResolver(async (sessionId) => {
+                const result = await this.agents.resolveAgent(sessionId);
+                if ('error' in result)
+                    throw result.error;
+                return result.agent;
+            }), 'session-controller: file-upload Agent resolver');
             this.controlState = new SessionControlController(ctx);
             // Registered before history so reverse-order teardown closes every
             // follower before waiting for already-admitted promotions.
@@ -197,7 +204,7 @@ let SessionController = (() => {
                 await Promise.allSettled([...this.promotions]);
             }, 'session-controller.promotions');
             this.history = new SessionHistoryController(ctx, (observation) => { this.promote(observation); });
-            this.listState = new ApiSessionList(ctx, config.coldBlankProbeMaxBytes ?? DEFAULT_COLD_BLANK_PROBE_MAX_BYTES);
+            this.listState = new ApiSessionList(ctx);
             this.openPath = internals.openPath ?? openNativePath;
             this.canOpenPath = internals.canOpenPath
                 ?? (() => config.nativeOpen ?? (internals.openPath !== undefined || canOpenNativePath()));
@@ -407,7 +414,8 @@ let SessionController = (() => {
          * Follow one Session log from its opening or resume cursor.
          * @param request - durable address and last committed sequence already held by the caller.
          * @param signal - cancellation owned by the Remote stream carrier.
-         * @returns a complete opening snapshot followed by gap-free event frames.
+         * @returns a complete opening snapshot followed by gap-free durable event
+         *   frames and optional cursorless assistant-stream frames.
          */
         follow(request, signal) {
             return this.history.follow(request, signal);

package/lib/types/list.d.ts

@@ -2,8 +2,6 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session';
 import type { SessionListMetadata, SessionSearchValue, SessionSummary } from './types.ts';
-/** Default maximum artifact size eligible for one cold projection observation. */
-export declare const DEFAULT_COLD_BLANK_PROBE_MAX_BYTES = 1024;
 /**
  * Advance the Session-list metadata projection by one committed event.
  * @param state - metadata before the event.
@@ -21,12 +19,8 @@ export declare function truncateUnicodeCodePoints(value: string, maximum: number
 /** Owns list projection registration, bounded cold summaries, and authorized search. */
 export declare class ApiSessionList {
     private readonly ctx;
-    private readonly coldBlankProbeMaxBytes;
-    /**
-     * @param ctx - Host context carrying Session, query, persistence, and projection services.
-     * @param coldBlankProbeMaxBytes - maximum physical artifact size eligible for a full observation.
-     */
-    constructor(ctx: Context, coldBlankProbeMaxBytes: number);
+    /** @param ctx - Host context carrying Session, query, persistence, and projection services. */
+    constructor(ctx: Context);
     /**
      * Build one current attached-Session summary.
      * @param session - attached Session to summarize.
@@ -40,7 +34,6 @@ export declare class ApiSessionList {
      */
     list(signal?: AbortSignal): Promise<SessionSummary[]>;
     private summarizeCold;
-    private probeSmallCold;
     /**
      * Search current visible message content without activating any matching Session.
      * @param query - literal message-content query.