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

package/lib/types/client/index.js

@@ -7,6 +7,8 @@ export { SessionCreateError, SessionForkError } from "./sessions/service.js";
 export { MutableSessionEventSource } from "./contract/events.js";
 /** Required Remote and Context projection services. */
 export const inject = [
+    'connection',
+    'fileUpload',
     'typert',
     'remote',
     'remote.commands',

package/lib/types/client/sessions/assistant-stream.d.ts

@@ -0,0 +1,51 @@
+/** Web presentation fold joining transient Assistant frames to one durable v2 settlement. */
+import type { SessionAssistantStreamBaseline, SessionAssistantStreamFrame } from '../../types.ts';
+import type { LlmAttemptId } from '@deepseek-ai/dsh-llm/brand';
+import type { SessionAssistantSettlementEntry, SessionEventLikeEntry, SessionLiveEventEntry, SessionTransientEventEntry } from '../contract/events.ts';
+/** One Web publication decision from the assistant stream fold. */
+export type ClientAssistantStreamResult = {
+    readonly type: 'publish';
+    readonly entry: SessionLiveEventEntry;
+} | {
+    readonly type: 'settlement';
+    readonly attemptId: LlmAttemptId;
+    readonly entry: SessionAssistantSettlementEntry;
+} | {
+    readonly type: 'abandonment';
+    readonly attemptId: LlmAttemptId;
+} | {
+    readonly type: 'transient';
+    readonly entry: SessionTransientEventEntry;
+} | {
+    readonly type: 'rebaseline';
+} | undefined;
+/** Keeps transient Assistant presentation behind one settlement-aware interface. */
+export declare class ClientAssistantStream {
+    private activeAttempt;
+    private readonly pending;
+    private publishedSeqs;
+    private durableCursor;
+    private transientInGap;
+    /**
+     * Replace the durable Web window and adopt an optional reconnect baseline.
+     * @param entries - durable entries in the replacement window.
+     * @param baseline - compact prefix for an Assistant attempt that is still live.
+     * @returns immediately visible durable entries plus reconstructed transient chunks.
+     */
+    replace(entries: readonly SessionEventLikeEntry[], baseline?: SessionAssistantStreamBaseline): readonly SessionEventLikeEntry[];
+    /**
+     * Stage one durable v2 settlement while its matching live attempt is open.
+     * @param entry - newly followed durable entry.
+     * @returns a publication decision, or `undefined` when no entry becomes visible.
+     */
+    acceptDurable(entry: SessionLiveEventEntry): ClientAssistantStreamResult;
+    /**
+     * Fold one dense transient frame and release its named durable settlement.
+     * @param frame - next Assistant stream frame received by the follow connection.
+     * @returns a transient, publication, or rebaseline decision, or `undefined` when no entry becomes visible.
+     */
+    acceptFrame(frame: SessionAssistantStreamFrame): ClientAssistantStreamResult;
+    private attemptForSettlement;
+    private publish;
+}
+//# sourceMappingURL=assistant-stream.d.ts.map

package/lib/types/client/sessions/assistant-stream.js

@@ -0,0 +1,168 @@
+/** Web presentation fold joining transient Assistant frames to one durable v2 settlement. */
+import { expandAssistantStream } from '@deepseek-ai/dsh-llm/assistant-stream';
+/** Keeps transient Assistant presentation behind one settlement-aware interface. */
+export class ClientAssistantStream {
+    activeAttempt;
+    pending = new Map();
+    publishedSeqs = new Set();
+    durableCursor = -1;
+    transientInGap = 0;
+    /**
+     * Replace the durable Web window and adopt an optional reconnect baseline.
+     * @param entries - durable entries in the replacement window.
+     * @param baseline - compact prefix for an Assistant attempt that is still live.
+     * @returns immediately visible durable entries plus reconstructed transient chunks.
+     */
+    replace(entries, baseline) {
+        this.pending.clear();
+        this.transientInGap = 0;
+        this.activeAttempt = undefined;
+        const opening = baseline?.activeAttempt;
+        if (opening !== undefined) {
+            this.activeAttempt = {
+                attemptId: opening.attemptId,
+                startedAfterSeq: opening.startedAfterSeq,
+                turn: opening.turn,
+                step: opening.step,
+                nextIndex: opening.nextIndex,
+            };
+        }
+        const visible = [...entries];
+        this.publishedSeqs = new Set(visible.map(entry => entry.event.seq));
+        this.durableCursor = visible.reduce((cursor, entry) => Math.max(cursor, entry.event.seq), -1);
+        if (opening !== undefined) {
+            for (const [index, member] of expandAssistantStream(opening.stream).entries()) {
+                this.transientInGap += 1;
+                visible.push({
+                    type: 'transient',
+                    event: {
+                        type: 'assistant/live-chunk',
+                        seq: this.durableCursor + 1 - 1 / (this.transientInGap + 1),
+                        time: member.time,
+                        data: {
+                            attemptId: opening.attemptId,
+                            turn: opening.turn,
+                            step: opening.step,
+                            chunk: member.chunk,
+                        },
+                    },
+                });
+                if (index + 1 >= opening.nextIndex)
+                    break;
+            }
+        }
+        return visible;
+    }
+    /**
+     * Stage one durable v2 settlement while its matching live attempt is open.
+     * @param entry - newly followed durable entry.
+     * @returns a publication decision, or `undefined` when no entry becomes visible.
+     */
+    acceptDurable(entry) {
+        const event = entry.event;
+        this.durableCursor = Math.max(this.durableCursor, event.seq);
+        this.transientInGap = 0;
+        const settlement = assistantSettlementEntry(entry);
+        if (settlement !== undefined && this.attemptForSettlement(settlement.event) !== undefined) {
+            if (this.pending.has(event.seq))
+                return { type: 'rebaseline' };
+            this.pending.set(event.seq, settlement);
+            return undefined;
+        }
+        return this.publish(entry);
+    }
+    /**
+     * Fold one dense transient frame and release its named durable settlement.
+     * @param frame - next Assistant stream frame received by the follow connection.
+     * @returns a transient, publication, or rebaseline decision, or `undefined` when no entry becomes visible.
+     */
+    acceptFrame(frame) {
+        switch (frame.type) {
+            case 'start':
+                if (this.activeAttempt !== undefined || this.pending.size > 0)
+                    return { type: 'rebaseline' };
+                this.pending.clear();
+                this.activeAttempt = {
+                    attemptId: frame.attemptId,
+                    startedAfterSeq: frame.startedAfterSeq,
+                    turn: frame.turn,
+                    step: frame.step,
+                    nextIndex: 0,
+                };
+                return undefined;
+            case 'chunk': {
+                const attempt = this.activeAttempt;
+                // A controller mounted after the Host saw this attempt has no start
+                // frame to reconstruct. Its durable settlement publishes directly;
+                // ignore the transient suffix until the next known start.
+                if (attempt === undefined || attempt.attemptId !== frame.attemptId)
+                    return undefined;
+                if (frame.index !== attempt.nextIndex)
+                    return { type: 'rebaseline' };
+                attempt.nextIndex += 1;
+                this.transientInGap += 1;
+                return {
+                    type: 'transient',
+                    entry: {
+                        type: 'transient',
+                        event: {
+                            type: 'assistant/live-chunk',
+                            seq: this.durableCursor + 1 - 1 / (this.transientInGap + 1),
+                            time: frame.time,
+                            data: {
+                                attemptId: frame.attemptId,
+                                turn: attempt.turn,
+                                step: attempt.step,
+                                chunk: frame.chunk,
+                            },
+                        },
+                    },
+                };
+            }
+            case 'end': {
+                const attempt = this.activeAttempt;
+                if (attempt === undefined || attempt.attemptId !== frame.attemptId) {
+                    return undefined;
+                }
+                this.activeAttempt = undefined;
+                if (frame.index !== attempt.nextIndex)
+                    return { type: 'rebaseline' };
+                if (frame.outcome.kind === 'abandoned') {
+                    return this.pending.size === 0
+                        ? { type: 'abandonment', attemptId: attempt.attemptId }
+                        : { type: 'rebaseline' };
+                }
+                if (this.publishedSeqs.has(frame.outcome.seq))
+                    return undefined;
+                const entry = this.pending.get(frame.outcome.seq);
+                if (entry === undefined
+                    || entry.event.type !== frame.outcome.eventType) {
+                    return { type: 'rebaseline' };
+                }
+                this.pending.delete(frame.outcome.seq);
+                this.publishedSeqs.add(entry.event.seq);
+                return { type: 'settlement', attemptId: attempt.attemptId, entry };
+            }
+        }
+    }
+    attemptForSettlement(event) {
+        const attempt = this.activeAttempt;
+        if (attempt === undefined
+            || (event.type === 'assistant/message' && event.surfaceOp !== 'append')
+            || event.seq <= attempt.startedAfterSeq
+            || attempt.turn !== event.data.turn
+            || attempt.step !== event.data.step)
+            return undefined;
+        return attempt;
+    }
+    publish(entry) {
+        this.publishedSeqs.add(entry.event.seq);
+        return { type: 'publish', entry };
+    }
+}
+function assistantSettlementEntry(entry) {
+    return entry.event.type === 'assistant/message' || entry.event.type === 'assistant/attempt'
+        ? entry
+        : undefined;
+}
+//# sourceMappingURL=assistant-stream.js.map

package/lib/types/client/sessions/history-records.d.ts

@@ -9,13 +9,13 @@ import type { SessionEventLikeEntry } from '../contract/events.ts';
 export declare function historyEntries(records: readonly SessionHistoryRecord[]): readonly SessionEventLikeEntry[];
 /**
  * Read the first logical sequence represented by one wire record.
- * @param record - validated scalar event or packed Assistant delta run.
+ * @param record - validated Session event.
  * @returns inclusive first Session sequence.
  */
 export declare function historyRecordFirstSeq(record: SessionHistoryRecord): number;
 /**
  * Read the final logical sequence represented by one wire record.
- * @param record - validated scalar event or packed Assistant delta run.
+ * @param record - validated Session event.
  * @returns inclusive final Session sequence.
  */
 export declare function historyRecordLastSeq(record: SessionHistoryRecord): number;

package/lib/types/client/sessions/history-records.js

@@ -9,7 +9,7 @@ export function historyEntries(records) {
 }
 /**
  * Read the first logical sequence represented by one wire record.
- * @param record - validated scalar event or packed Assistant delta run.
+ * @param record - validated Session event.
  * @returns inclusive first Session sequence.
  */
 export function historyRecordFirstSeq(record) {
@@ -17,15 +17,10 @@ export function historyRecordFirstSeq(record) {
 }
 /**
  * Read the final logical sequence represented by one wire record.
- * @param record - validated scalar event or packed Assistant delta run.
+ * @param record - validated Session event.
  * @returns inclusive final Session sequence.
  */
 export function historyRecordLastSeq(record) {
-    if (record.type === 'event')
-        return record.event.seq;
-    const length = record.event.type === 'chunkrow/tool-call-chunks'
-        ? record.event.data.args.length
-        : record.event.data.texts.length;
-    return record.event.seq + length - 1;
+    return record.event.seq;
 }
 //# sourceMappingURL=history-records.js.map

package/lib/types/client/sessions/queue-mirror.js

@@ -1,9 +1,9 @@
 const QUEUE_PREVIEW_CHARS = 200;
-// Image blocks are excluded: queue presentation renders them as thumbnails
-// from `content`, so the text preview covers only what has no visual form.
+// Attachment blocks are excluded: queue presentation renders them from
+// `content`, so the text preview covers only what has no visual form.
 function previewOf(content) {
     const flat = content
-        .filter(block => block.type !== 'image')
+        .filter(block => block.type !== 'image' && block.type !== 'file')
         .map(block => (block.type === 'text' ? block.text : `[${block.type}]`))
         .join(' ').replace(/\s+/g, ' ').trim();
     const chars = Array.from(flat);

package/lib/types/client/sessions/remotes.d.ts

@@ -4,15 +4,15 @@
  *
  * @module @deepseek-ai/dsh-api-session-controller/client/sessions/remotes
  */
-import type { EncodedImageAttachment } from '@deepseek-ai/dsh-attachment/types';
 import type { ClientRemote } from '@deepseek-ai/dsh-api-gateway/client';
+import type { CommandSubmitAttachment } from '@deepseek-ai/dsh-commands/types';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { SubagentCatalog, SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from '@deepseek-ai/dsh-subagent/client';
 import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionRemote } from '../transport.ts';
 /** Narrow Commands namespace consumed by a Client Session. */
 export interface SessionCommandsRemote {
-    execute(agentId: SessionId, line: string, images: readonly EncodedImageAttachment[], signal?: AbortSignal): Promise<RemoteResult<object | undefined>>;
+    execute(agentId: SessionId, line: string, attachments: readonly CommandSubmitAttachment[], signal?: AbortSignal): Promise<RemoteResult<object | undefined>>;
 }
 /** Narrow subagent namespace consumed by a Client Session and its manager. */
 export interface SessionSubagentsRemote {

package/lib/types/client/sessions/session.d.ts

@@ -61,6 +61,7 @@ export declare class Session implements SessionFace {
     private jumpPromise;
     /** Authoritative stream-only inbox snapshot; pending work never hits history. */
     private readonly queueMirror;
+    private readonly assistantStream;
     private running;
     private address;
     private parentAvailable;
@@ -136,7 +137,7 @@ export declare class Session implements SessionFace {
     beginSubmission(input: BeginSubmissionInput): SubmissionHandle;
     /**
      * Send (queue/steer passed through 1:1); failures land in the snapshot's promptError.
-     * @param content - text plus browser-owned temporary image uploads.
+     * @param content - text, browser-owned temporary image uploads, and staged-file receipts.
      * @param mode - queue appends after the current turn; steer interrupts it.
      * @param signal - optional caller cancellation for the complete admission round-trip.
      * @param requestId - identity from {@link beginSubmission}; a failed identified prompt retires its echo.
@@ -267,6 +268,7 @@ export declare class Session implements SessionFace {
     private acceptEventChange;
     /** Replace the complete contiguous window and apply page-owned projection metadata. */
     private installWindow;
+    private publishAssistantEntry;
     /** Prepend one stream-validated history page. */
     private prependWindow;
     /** Append one stream-validated live event. */

package/lib/types/client/sessions/session.js

@@ -5,9 +5,11 @@ import { SessionEventStream } from "../transport.js";
 import { MutableSessionEventSource } from "../contract/events.js";
 import { Notifier } from "./notifier.js";
 import { isRemoteFailure } from '@deepseek-ai/dsh-api-gateway/client';
+import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
 import { ProjectionValueStore } from "./projection-store.js";
 import { resolvedClientTimeZone } from "../time-zone.js";
 import { SessionQueueMirror } from "./queue-mirror.js";
+import { ClientAssistantStream, } from "./assistant-stream.js";
 function projectionsBaseline(value) {
     return {
         ...value,
@@ -44,6 +46,7 @@ export class Session {
     jumpPromise = null;
     /** Authoritative stream-only inbox snapshot; pending work never hits history. */
     queueMirror = new SessionQueueMirror();
+    assistantStream = new ClientAssistantStream();
     running = false;
     address;
     parentAvailable;
@@ -143,7 +146,7 @@ export class Session {
                     : 'transcript',
                 time: Date.now(),
                 text: input.text,
-                images: input.images,
+                attachments: input.attachments,
             }];
         this.submissionSettlements.set(requestId, { onRetire: input.onRetire, retiring: false });
         // The blank → engaging edge flips here, ahead of prompt(): the composer
@@ -154,7 +157,7 @@ export class Session {
     }
     /**
      * Send (queue/steer passed through 1:1); failures land in the snapshot's promptError.
-     * @param content - text plus browser-owned temporary image uploads.
+     * @param content - text, browser-owned temporary image uploads, and staged-file receipts.
      * @param mode - queue appends after the current turn; steer interrupts it.
      * @param signal - optional caller cancellation for the complete admission round-trip.
      * @param requestId - identity from {@link beginSubmission}; a failed identified prompt retires its echo.
@@ -181,13 +184,23 @@ export class Session {
                 clientTimeZone,
             }, signal);
         }
+        else if (content.some(part => part.type === 'file')) {
+            result = {
+                ok: false,
+                error: new RemoteError('subagent/attachment-invalid', 'subagent continuation does not accept files', { reason: 'SUBAGENT_FILE_UNSUPPORTED' }),
+            };
+        }
         else {
+            // The preceding branch rejects file parts before the narrower subagent
+            // wire type is used; this array is not filtered or reordered.
+            const routedContent = content;
             const routed = await this.remote.subagents.prompt({
                 requestId: randomUUID(),
                 parentSessionId: this.address.parentSessionId,
                 childSessionId: this.address.childSessionId,
                 mode: 'continuable',
-                content,
+                delivery: mode,
+                content: routedContent,
                 clientTimeZone: resolvedClientTimeZone(),
             }, signal);
             result = routed.ok ? { ok: true, value: { accepted: true } } : routed;
@@ -553,29 +566,63 @@ export class Session {
     acceptEventChange(change) {
         switch (change.type) {
             case 'replace':
-                this.installWindow(change.entries, change.hasMore, change.page.projections === undefined ? undefined : projectionsBaseline(change.page.projections));
+                this.installWindow(change.entries, change.hasMore, change.page.projections === undefined ? undefined : projectionsBaseline(change.page.projections), change.page.assistantStream);
                 return;
             case 'prepend':
                 this.prependWindow(change.entries, change.hasMore);
                 return;
             case 'append':
-                if (this.appendLive(change.entry))
-                    this.notifier.markDirty();
+                this.publishAssistantEntry(this.assistantStream.acceptDurable(change.entry));
+                return;
+            case 'assistant-stream':
+                this.publishAssistantEntry(this.assistantStream.acceptFrame(change.frame));
         }
     }
     /** Replace the complete contiguous window and apply page-owned projection metadata. */
-    installWindow(entries, hasMore, projections) {
+    installWindow(entries, hasMore, projections, assistantStream) {
+        // A durable gap-repair page has no assistant baseline. Clearing transient
+        // attempts makes a held notification reopen follow once for an atomic
+        // page/baseline pair instead of applying it to an unrelated repair cut.
+        const visible = this.assistantStream.replace(entries, assistantStream);
         this.baseSeq = SessionLogOffset(entries[0]?.event.seq ?? 0);
         this.hasMore = hasMore;
-        if (entries.some(entry => entry.event.type === 'turn/start'))
+        if (visible.some(entry => entry.event.type === 'turn/start'))
             this.firstPromptPendingTurn = false;
         if (projections !== undefined)
             this.projections.seed(projections);
-        this.eventSource.replace(entries, hasMore);
-        for (const entry of entries)
+        this.eventSource.replace(visible, hasMore);
+        for (const entry of visible)
             this.observeSubmissionEvent(entry.event);
         this.notifier.markDirty();
     }
+    publishAssistantEntry(result) {
+        if (result?.type === 'rebaseline') {
+            const events = this.events;
+            queueMicrotask(() => {
+                if (events !== undefined && this.events === events)
+                    events.restart();
+            });
+            return;
+        }
+        if (result?.type === 'settlement') {
+            this.eventSource.settleAssistant(result.attemptId, result.entry);
+            this.observeSubmissionEvent(result.entry.event);
+            this.notifier.markDirty();
+            return;
+        }
+        if (result?.type === 'abandonment') {
+            this.eventSource.settleAssistant(result.attemptId);
+            this.notifier.markDirty();
+            return;
+        }
+        if (result?.type === 'publish' && this.appendLive(result.entry)) {
+            this.notifier.markDirty();
+        }
+        else if (result?.type === 'transient') {
+            this.eventSource.append(result.entry);
+            this.notifier.markDirty();
+        }
+    }
     /** Prepend one stream-validated history page. */
     prependWindow(entries, hasMore) {
         this.baseSeq = entries[0] === undefined ? this.baseSeq : SessionLogOffset(entries[0].event.seq);
@@ -607,7 +654,7 @@ export class Session {
         const source = data?.source;
         if (source?.kind !== 'user' || typeof source.rpcId !== 'string')
             return;
-        this.scheduleObservedRetirement(source.rpcId, imageRefsIn(data?.content));
+        this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(data?.content));
     }
     /** Retire echoes whose prompts landed in the host inbox instead of the log (running-turn submissions). */
     observeSubmissionQueue(items) {
@@ -615,7 +662,7 @@ export class Session {
             return;
         for (const item of items) {
             if (item.rpcId !== undefined) {
-                this.scheduleObservedRetirement(item.rpcId, imageRefsIn(item.message.content));
+                this.scheduleObservedRetirement(item.rpcId, attachmentRefsIn(item.message.content));
             }
         }
     }
@@ -702,8 +749,8 @@ function scheduleFrame(fn) {
     else
         setTimeout(fn, 0);
 }
-/** Image attachment references in one structurally-read content block list, in block order. */
-function imageRefsIn(content) {
+/** Attachment references in one structurally-read content block list, in block order. */
+function attachmentRefsIn(content) {
     if (!Array.isArray(content))
         return [];
     const refs = [];
@@ -711,7 +758,8 @@ function imageRefsIn(content) {
         if (typeof block !== 'object' || block === null)
             continue;
         const candidate = block;
-        if (candidate.type === 'image' && typeof candidate.attachment === 'object' && candidate.attachment !== null) {
+        if ((candidate.type === 'image' || candidate.type === 'file')
+            && typeof candidate.attachment === 'object' && candidate.attachment !== null) {
             refs.push(candidate.attachment);
         }
     }

package/lib/types/client/transport.d.ts

@@ -1,6 +1,6 @@
 /** Session-specific adapters for Gateway-owned Remote stream lifecycles. */
 import { RemoteJournalStream, RemoteSnapshotStream, RemoteStreamCarrierError, type ClientRemote, type RemoteJournalFrame } from '@deepseek-ai/dsh-api-gateway/client';
-import type { SessionAddress, SessionControlFrame, SessionHistoryRecord, SessionPage, SessionPageRequest, SessionProjectionBaseline } from '../types.ts';
+import type { SessionAddress, SessionAssistantStreamBaseline, SessionAssistantStreamFrame, SessionControlFrame, SessionHistoryRecord, SessionPage, SessionPageRequest, SessionProjectionBaseline } from '../types.ts';
 import type { SessionEventLikeEntry, SessionLiveEventEntry } from './contract/events.ts';
 import type { SessionRemotes } from './sessions/remotes.ts';
 export { SESSION_SEARCH_RESULT_LIMIT, SESSION_SEARCH_SNIPPET_MAX_CODE_POINTS, } from '../types.ts';
@@ -11,6 +11,7 @@ export type SessionRemote = ClientRemote['session'];
 /** Opening metadata carried only by a follow snapshot, never by loadOlder pages. */
 interface SessionJournalPage extends SessionPage {
     readonly projections?: SessionProjectionBaseline;
+    readonly assistantStream?: SessionAssistantStreamBaseline;
 }
 /** One complete publication from the Session journal stream. */
 export type SessionJournalChange = {
@@ -21,6 +22,9 @@ export type SessionJournalChange = {
 } | {
     readonly type: 'append';
     readonly entry: SessionLiveEventEntry;
+} | {
+    readonly type: 'assistant-stream';
+    readonly frame: SessionAssistantStreamFrame;
 };
 type SessionControlBaselineFrame = Extract<SessionControlFrame, {
     type: 'baseline';
@@ -54,7 +58,7 @@ export interface SessionEventStreamOptions {
  */
 export declare function createSessionControlStream(remote: SessionRemotes, options: SessionControlStreamOptions): SessionControlStream;
 /** Gateway-owned event journal bound to one ordinary or direct-subagent Session address. */
-export declare class SessionEventStream extends RemoteJournalStream<SessionJournalPage, SessionHistoryRecord, number, ClientSessionPageRequest> {
+export declare class SessionEventStream extends RemoteJournalStream<SessionJournalPage, SessionHistoryRecord, number, ClientSessionPageRequest, SessionAssistantStreamFrame> {
     private readonly remote;
     private readonly address;
     /**
@@ -64,7 +68,7 @@ export declare class SessionEventStream extends RemoteJournalStream<SessionJourn
      */
     constructor(remote: SessionRemotes, address: SessionAddress, options: SessionEventStreamOptions);
     /** @inheritdoc */
-    protected follow(request: ClientSessionPageRequest, signal: AbortSignal): AsyncIterable<RemoteJournalFrame<SessionHistoryRecord, number, SessionJournalPage>>;
+    protected follow(request: ClientSessionPageRequest, signal: AbortSignal): AsyncIterable<RemoteJournalFrame<SessionHistoryRecord, number, SessionJournalPage, SessionAssistantStreamFrame>>;
     /** @inheritdoc */
     protected readPage(request: ClientSessionPageRequest, throughSeq: number, signal: AbortSignal): Promise<SessionJournalPage>;
     /** @inheritdoc */

package/lib/types/client/transport.js

@@ -9,14 +9,13 @@ function toSessionJournalChange(change) {
         case 'prepend':
             return { ...change, entries: historyEntries(change.entries) };
         case 'append': {
-            if (change.entry.type !== 'event') {
-                throw new RemoteError('gateway/internal', 'session live stream emitted a packed history record', {});
-            }
             return {
                 type: 'append',
                 entry: change.entry,
             };
         }
+        case 'notification':
+            return { type: 'assistant-stream', frame: change.notification };
     }
 }
 /**
@@ -72,11 +71,17 @@ export class SessionEventStream extends RemoteJournalStream {
     }
     /** @inheritdoc */
     async *follow(request, signal) {
+        let assistantRevision;
         for await (const frame of this.remote.session.follow({
             address: this.address,
+            assistantStream: true,
             ...(request.maxMessages === undefined ? {} : { maxMessages: request.maxMessages }),
         }, signal)) {
             if (frame.type === 'snapshot') {
+                if (frame.assistantStream === undefined) {
+                    throw new RemoteError('gateway/internal', 'session assistant stream omitted its opted-in opening baseline', {});
+                }
+                assistantRevision = frame.assistantStream.revision;
                 yield {
                     type: 'opened',
                     cursor: frame.cursor,
@@ -84,10 +89,20 @@ export class SessionEventStream extends RemoteJournalStream {
                         records: frame.records,
                         hasMore: frame.hasMore,
                         projections: frame.projections,
+                        assistantStream: frame.assistantStream,
                     },
                 };
                 continue;
             }
+            if (frame.type === 'assistant-stream') {
+                const expected = (assistantRevision ?? 0) + 1;
+                if (frame.frame.revision !== expected) {
+                    throw new RemoteStreamCarrierError(`session assistant stream skipped revision ${String(expected)}`);
+                }
+                assistantRevision = frame.frame.revision;
+                yield { type: 'notification', notification: frame.frame };
+                continue;
+            }
             yield { type: 'entry', entry: frame };
         }
     }