@deepseek-ai/dsh-api-session-controller 0.1.2-rc.1 → 0.1.5-alpha.1

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

@@ -2,6 +2,7 @@
 import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
 import { RemoteJournalStream, RemoteSnapshotStream, RemoteStreamCarrierError, } from '@deepseek-ai/dsh-api-gateway/client';
 import { historyEntries, historyRecordFirstSeq, historyRecordLastSeq, } from "./sessions/history-records.js";
+import { assertSessionWireEvent } from "./session-wire-event.js";
 export { SESSION_SEARCH_RESULT_LIMIT, SESSION_SEARCH_SNIPPET_MAX_CODE_POINTS, } from "../types.js";
 function toSessionJournalChange(change) {
     switch (change.type) {
@@ -9,14 +10,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 +72,19 @@ 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') {
+                for (const record of frame.records)
+                    assertSessionWireEvent(record.event);
+                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 +92,21 @@ 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;
+            }
+            assertSessionWireEvent(frame.event);
             yield { type: 'entry', entry: frame };
         }
     }
@@ -96,6 +115,8 @@ export class SessionEventStream extends RemoteJournalStream {
         const result = await this.remote.session.page({ address: this.address, throughSeq, ...request }, signal);
         if (!result.ok)
             throw result.error;
+        for (const record of result.value.records)
+            assertSessionWireEvent(record.event);
         return result.value;
     }
     /** @inheritdoc */

package/lib/types/commands.d.ts

@@ -38,7 +38,7 @@ export declare class SessionCommandController {
      */
     fork(request: SessionForkRequest): Promise<SessionForkValue>;
     /**
-     * Admit one browser prompt after explicit Agent resume and image validation.
+     * Reject empty content, then admit one prompt after Agent and attachment validation.
      * @param request - Session identity, prompt content, source metadata, and delivery mode.
      * @returns acknowledgement that the Agent accepted the prompt.
      */

package/lib/types/commands.js

@@ -53,14 +53,18 @@ 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";
+function hasPromptContent(content) {
+    return content.some(part => part.type !== 'text' || part.text.trim().length > 0);
+}
 /** Implements Session business commands delegated by the Session Controller Remote service. */
 export class SessionCommandController {
     ctx;
@@ -270,11 +274,14 @@ export class SessionCommandController {
         }
     }
     /**
-     * Admit one browser prompt after explicit Agent resume and image validation.
+     * Reject empty content, then admit one prompt after Agent and attachment validation.
      * @param request - Session identity, prompt content, source metadata, and delivery mode.
      * @returns acknowledgement that the Agent accepted the prompt.
      */
     async prompt(request) {
+        if (!hasPromptContent(request.content)) {
+            throw new RemoteError('gateway/bad-request', 'prompt content must include non-whitespace text or an attachment', {});
+        }
         const clientTimeZone = request.clientTimeZone === undefined
             ? undefined
             : canonicalClientTimeZone(request.clientTimeZone);
@@ -282,6 +289,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 +303,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)
@@ -360,17 +385,27 @@ export class SessionCommandController {
      * @returns acknowledgement that the queue mutation was applied.
      */
     updateQueue(request) {
-        if (request.action.kind === 'edit'
-            && request.action.content.some(block => block.type !== 'text')) {
-            throw new RemoteError('session/attachment-invalid', 'queue edits accept text content only', { reason: 'QUEUE_EDIT_NON_TEXT' });
+        if (request.action.kind === 'edit') {
+            if (request.action.content.some(block => block.type !== 'text')) {
+                throw new RemoteError('session/attachment-invalid', 'queue edits accept text content only', { reason: 'QUEUE_EDIT_NON_TEXT' });
+            }
+            if (!hasPromptContent(request.action.content)) {
+                throw new RemoteError('gateway/bad-request', 'queue edit content must include non-whitespace 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 +418,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 +509,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 +570,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/control.d.ts

@@ -15,7 +15,6 @@ export declare class SessionControlController {
     control(signal: AbortSignal): AsyncIterable<SessionControlFrame>;
     private baseline;
     private projectionBaseline;
-    private onSessionEvent;
     private onJobsChanged;
     private jobsFor;
     private broadcast;

package/lib/types/control.js

@@ -7,7 +7,6 @@ export class SessionControlController {
     /** @param ctx - Host context carrying live Agent, projection, and jobs services. */
     constructor(ctx) {
         this.ctx = ctx;
-        ctx.on('session/event', (session, event) => { this.onSessionEvent(session, event); });
         ctx.sessionProjections.onChanged((session, key, value, seq) => {
             this.broadcast({
                 type: 'projection',
@@ -16,6 +15,16 @@ export class SessionControlController {
                 value: value,
                 seq,
             });
+            if (key !== 'inbox')
+                return;
+            const agent = this.ctx.agents.get(session.id);
+            if (agent?.session !== session)
+                return;
+            this.broadcast({
+                type: 'queue',
+                sessionId: session.id,
+                items: queueItemsFromInbox(value),
+            });
         });
         ctx.inject(['jobs'], (jobsCtx) => {
             jobsCtx.jobs.onJobsChanged((owner) => { this.onJobsChanged(owner); });
@@ -76,18 +85,6 @@ export class SessionControlController {
         }
         return blocks;
     }
-    onSessionEvent(session, event) {
-        if (event.type !== 'agent/inbox/spliced')
-            return;
-        const agent = this.ctx.agents.get(session.id);
-        if (agent?.session !== session)
-            return;
-        this.broadcast({
-            type: 'queue',
-            sessionId: session.id,
-            items: queueItems(agent, event.data),
-        });
-    }
     onJobsChanged(owner) {
         if (owner !== undefined) {
             this.broadcast({ type: 'jobs', sessionId: owner.id, jobs: this.jobsFor(owner) });
@@ -151,21 +148,21 @@ class ControlQueue {
         }
     }
 }
-function queueItems(agent, splice) {
-    const project = (target) => {
-        const messages = target === 'next-turn' ? agent.inbox.nextTurn : agent.inbox.nextStep;
-        return splice?.target === target
-            ? messages.toSpliced(splice.start, splice.removedCount ?? 0, ...splice.inserted)
-            : messages;
-    };
+function queueItems(agent) {
+    return queueItemsFromInbox({
+        'next-turn': agent.inbox.nextTurn,
+        'next-step': agent.inbox.nextStep,
+    });
+}
+function queueItemsFromInbox(inbox) {
     return [
-        ...project('next-turn').map(message => ({
+        ...inbox['next-turn'].map(message => ({
             id: message.id,
             placement: 'queued',
             ...promptRpcId(message),
             message: { id: message.id, content: message.content },
         })),
-        ...project('next-step').map(message => ({
+        ...inbox['next-step'].map(message => ({
             id: message.id,
             placement: message.source.kind === 'user' ? 'steering' : 'context',
             ...promptRpcId(message),

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