agl 22.0.3 → 23.0.0

package/ts/classes.controller.ts

@@ -12,6 +12,7 @@ import {
   controllerBuiltinCommands,
   controllerMaxToolEventBytes,
   controllerMaxLiveMessageEventBytes,
+  controllerLiveMessageDeltaTargetBytes,
   controllerInitialMessageBundleLimit,
   controllerMaximumTranscriptBytes,
   controllerLiveToolPayloadNotice,
@@ -26,8 +27,11 @@ import {
   type IControllerMessagePage,
   type IControllerMessageStreamCursor,
   type IControllerPendingPrompt,
+  type IControllerReasoningDelta,
   type IControllerReasoningUpdate,
+  type IControllerTextDelta,
   type IControllerTextUpdate,
+  type IControllerTodo,
   type TControllerModelChoice,
   type IControllerModelRefreshJob,
   type IControllerPermission,
@@ -539,15 +543,24 @@ interface ILatestToolExecution {
 interface ILatestReasoningUpdate {
   projectId: string;
   update: IControllerReasoningUpdate;
+  textUtf8Bytes: number;
   bytes?: number;
 }
 
 interface ILatestTextUpdate {
   projectId: string;
   update: IControllerTextUpdate;
+  textUtf8Bytes: number;
   bytes?: number;
 }
 
+type TControllerMessageDelta = IControllerReasoningDelta | IControllerTextDelta;
+
+interface IControllerTextDeltaFragment {
+  delta: string;
+  utf8Bytes: number;
+}
+
 type TControllerToolExecutionSnapshot = Omit<
   IControllerToolExecution,
   'revision' | 'streamEpoch'
@@ -557,6 +570,103 @@ const historyLimitedNotice = '[earlier message content omitted: this transcript
 const historyLimitedDigestPrefix = 'history-limited:';
 const liveToolExecutionBytes = controllerMaxToolEventBytes - (8 * 1024);
 
+const controllerEventMessageDelta = (
+  eventArg: IControllerEvent,
+): TControllerMessageDelta | undefined => eventArg.reasoningDelta ?? eventArg.textDelta;
+
+const controllerTextAfterAppendUtf8Bytes = (
+  textArg: string,
+  textUtf8BytesArg: number,
+  deltaArg: string,
+): number | undefined => {
+  // Separately encoded surrogate halves cost six bytes; after append the pair costs four.
+  const boundaryCorrection = (
+    textArg.length > 0
+    && deltaArg.length > 0
+    && textArg.charCodeAt(textArg.length - 1) >= 0xD800
+    && textArg.charCodeAt(textArg.length - 1) <= 0xDBFF
+    && deltaArg.charCodeAt(0) >= 0xDC00
+    && deltaArg.charCodeAt(0) <= 0xDFFF
+  ) ? -2 : 0;
+  const result = textUtf8BytesArg + Buffer.byteLength(deltaArg, 'utf8') + boundaryCorrection;
+  return Number.isSafeInteger(result) && result >= 0 ? result : undefined;
+};
+
+const fragmentControllerTextDelta = (valueArg: string): IControllerTextDeltaFragment[] => {
+  const fragments: IControllerTextDeltaFragment[] = [];
+  let delta = '';
+  let utf8Bytes = 0;
+  for (const codePoint of valueArg) {
+    const codePointBytes = Buffer.byteLength(codePoint, 'utf8');
+    if (
+      delta !== ''
+      && utf8Bytes + codePointBytes > controllerLiveMessageDeltaTargetBytes
+    ) {
+      fragments.push({ delta, utf8Bytes });
+      delta = '';
+      utf8Bytes = 0;
+    }
+    delta += codePoint;
+    utf8Bytes += codePointBytes;
+  }
+  if (delta !== '') fragments.push({ delta, utf8Bytes });
+  return fragments;
+};
+
+const controllerMessageDeltaPendingKey = (eventArg: IControllerEvent): string | undefined => {
+  const delta = controllerEventMessageDelta(eventArg);
+  if (!delta) return undefined;
+  return JSON.stringify([
+    eventArg.type,
+    eventArg.harnessId ?? null,
+    eventArg.projectId ?? null,
+    controllerRuntimeIdKey(delta.sessionId),
+    controllerRuntimeIdKey(delta.partId),
+  ]);
+};
+
+const controllerMessageDeltaEventsAreContiguous = (
+  previousEventArg: IControllerEvent,
+  eventArg: IControllerEvent,
+): boolean => {
+  const previous = controllerEventMessageDelta(previousEventArg);
+  const delta = controllerEventMessageDelta(eventArg);
+  if (!previous || !delta) return false;
+  return previousEventArg.type === eventArg.type
+    && previousEventArg.harnessId === eventArg.harnessId
+    && previousEventArg.projectId === eventArg.projectId
+    && (previousEventArg.sessionId
+      ? eventArg.sessionId !== undefined
+        && controllerRuntimeIdKey(previousEventArg.sessionId)
+          === controllerRuntimeIdKey(eventArg.sessionId)
+      : eventArg.sessionId === undefined)
+    && controllerRuntimeIdKey(previous.sessionId) === controllerRuntimeIdKey(delta.sessionId)
+    && controllerRuntimeIdKey(previous.messageId) === controllerRuntimeIdKey(delta.messageId)
+    && controllerRuntimeIdKey(previous.partId) === controllerRuntimeIdKey(delta.partId)
+    && previous.streamEpoch === delta.streamEpoch
+    && previous.order?.messageIndex === delta.order?.messageIndex
+    && previous.order?.partIndex === delta.order?.partIndex
+    && previous.textUtf8Bytes === delta.baseTextUtf8Bytes
+    && delta.revision > previous.revision;
+};
+
+const mergeControllerMessageDeltaEvents = (
+  previousEventArg: IControllerEvent,
+  eventArg: IControllerEvent,
+): IControllerEvent | undefined => {
+  if (!controllerMessageDeltaEventsAreContiguous(previousEventArg, eventArg)) return undefined;
+  const previous = controllerEventMessageDelta(previousEventArg)!;
+  const delta = controllerEventMessageDelta(eventArg)!;
+  const mergedDelta = {
+    ...delta,
+    delta: `${previous.delta}${delta.delta}`,
+    baseTextUtf8Bytes: previous.baseTextUtf8Bytes,
+  };
+  return eventArg.reasoningDelta
+    ? { ...eventArg, reasoningDelta: mergedDelta }
+    : { ...eventArg, textDelta: mergedDelta };
+};
+
 const markHistoryLimitedDigest = (digestArg: string): string => (
   digestArg.startsWith(historyLimitedDigestPrefix)
     ? digestArg
@@ -8978,14 +9088,36 @@ export class OpenCodeController {
     messagePage: IControllerMessagePage;
     permissions: IControllerPermission[];
     questions: IControllerQuestion[];
-    todos: [];
+    todos: IControllerTodo[];
     model?: string;
     effort?: string;
   }> {
     const reader = this.requireFlexProjectionReader();
     const supervisor = this.flexSupervisor;
-    const [session, messagePage, permissionResult] = await Promise.all([
-      reader.getSession(projectIdArg, sessionIdArg, signalArg),
+    const sessionPromise = reader.getSession(projectIdArg, sessionIdArg, signalArg);
+    const todosPromise: Promise<IControllerTodo[]> = sessionPromise.then(async (session) => {
+      if (
+        session.sessionGenerationId === undefined
+        || session.sessionGenerationSequence === undefined
+      ) return [];
+      signalArg?.throwIfAborted();
+      const tasks = await this.requireAuthStore().readFlexProjectTasks(
+        projectIdArg,
+        sessionIdArg,
+        {
+          sessionGenerationId: session.sessionGenerationId,
+          sessionGenerationSequence: session.sessionGenerationSequence,
+        },
+      );
+      signalArg?.throwIfAborted();
+      return tasks.map((task) => ({
+        id: flexRuntimeId(task.id),
+        content: task.content,
+        status: task.status,
+      }));
+    });
+    const [session, messagePage, permissionResult, todos] = await Promise.all([
+      sessionPromise,
       reader.listMessagePage(projectIdArg, sessionIdArg, {
         limit: controllerInitialMessageBundleLimit,
       }, signalArg),
@@ -8995,6 +9127,7 @@ export class OpenCodeController {
             familyRootSessionId: sessionIdArg,
           }, signalArg).catch(() => ({ permissions: [] as TFlexPermissionRequest[] }))
         : Promise.resolve({ permissions: [] as TFlexPermissionRequest[] }),
+      todosPromise,
     ]);
     const bundles = messagePage.messages.map((message) => this.toFlexMessageBundle(message));
     const messages = bundles.flatMap((bundle) => bundle.messages);
@@ -9016,7 +9149,7 @@ export class OpenCodeController {
       }),
       permissions: permissionResult.permissions.map((permission) => this.toFlexPermission(permission)),
       questions: [],
-      todos: [],
+      todos,
       ...(model === undefined ? {} : { model }),
       ...(effort === undefined ? {} : { effort }),
     };
@@ -9968,6 +10101,10 @@ export class OpenCodeController {
       this.handleFlexTextUpdate(eventArg);
       return;
     }
+    if (eventArg.type === 'part.delta') {
+      this.handleFlexPartDelta(eventArg);
+      return;
+    }
     if (eventArg.type === 'permissions.changed') {
       if (this.autoAcceptPermissions || this.hasFlexYoloSessions()) {
         this.queueFlexAutoAcceptSweep(eventArg.scopeId, eventArg.sessionId);
@@ -10389,7 +10526,12 @@ export class OpenCodeController {
     const bytes = Buffer.byteLength(JSON.stringify(eventArg), 'utf8');
     return {
       tool: eventArg.toolExecution ? bytes : 0,
-      message: eventArg.reasoningUpdate || eventArg.textUpdate ? bytes : 0,
+      message: eventArg.reasoningUpdate
+        || eventArg.reasoningDelta
+        || eventArg.textUpdate
+        || eventArg.textDelta
+        ? bytes
+        : 0,
     };
   }
 
@@ -10549,7 +10691,12 @@ export class OpenCodeController {
     this.latestFlexTextUpdates.clear();
     this.latestFlexMessageUpdateBytes = 0;
     for (const [key, event] of this.pendingFlexControllerEvents) {
-      if (event.reasoningUpdate || event.textUpdate) this.deletePendingFlexControllerEvent(key);
+      if (
+        event.reasoningUpdate
+        || event.reasoningDelta
+        || event.textUpdate
+        || event.textDelta
+      ) this.deletePendingFlexControllerEvent(key);
     }
     const timestamp = Date.now();
     const barrier: IControllerEvent = {
@@ -10635,11 +10782,19 @@ export class OpenCodeController {
     for (const [key, event] of this.pendingFlexControllerEvents) {
       if (
         event.projectId === projectIdArg
-        && (event.toolExecution || event.reasoningUpdate || event.textUpdate)
+        && (
+          event.toolExecution
+          || event.reasoningUpdate
+          || event.reasoningDelta
+          || event.textUpdate
+          || event.textDelta
+        )
         && controllerRuntimeIdKey(
           event.toolExecution?.sessionId
             ?? event.reasoningUpdate?.sessionId
-            ?? event.textUpdate!.sessionId,
+            ?? event.reasoningDelta?.sessionId
+            ?? event.textUpdate?.sessionId
+            ?? event.textDelta!.sessionId,
         ) === sessionKey
       ) this.deletePendingFlexControllerEvent(key);
     }
@@ -10705,7 +10860,13 @@ export class OpenCodeController {
     for (const [key, event] of this.pendingFlexControllerEvents) {
       if (
         event.projectId === projectIdArg
-        && (event.toolExecution || event.reasoningUpdate || event.textUpdate)
+        && (
+          event.toolExecution
+          || event.reasoningUpdate
+          || event.reasoningDelta
+          || event.textUpdate
+          || event.textDelta
+        )
       ) {
         this.deletePendingFlexControllerEvent(key);
       }
@@ -10862,7 +11023,11 @@ export class OpenCodeController {
     }
     this.setLatestFlexReasoningUpdate(
       key,
-      { projectId: eventArg.scopeId, update },
+      {
+        projectId: eventArg.scopeId,
+        update,
+        textUtf8Bytes: Buffer.byteLength(update.text, 'utf8'),
+      },
       eventBytes,
     );
     this.queueFlexControllerEvent(controllerEvent);
@@ -10922,12 +11087,169 @@ export class OpenCodeController {
     }
     this.setLatestFlexTextUpdate(
       key,
-      { projectId: eventArg.scopeId, update },
+      {
+        projectId: eventArg.scopeId,
+        update,
+        textUtf8Bytes: Buffer.byteLength(update.text, 'utf8'),
+      },
       eventBytes,
     );
     this.queueFlexControllerEvent(controllerEvent);
   }
 
+  private handleFlexPartDelta(
+    eventArg: Extract<TFlexChildEvent, { type: 'part.delta' }>,
+  ): void {
+    if (this.lifecycleState !== 'starting' && this.lifecycleState !== 'ready') return;
+    const sourceUpdatedAt = Date.parse(eventArg.timestamp);
+    if (!Number.isFinite(sourceUpdatedAt)) {
+      this.advanceFlexMessageStreamEpoch(true);
+      return;
+    }
+    const sessionId = flexRuntimeId(eventArg.sessionId);
+    const messageId = flexRuntimeId(eventArg.messageId);
+    const partId = flexRuntimeId(eventArg.partId);
+    const order = { messageIndex: eventArg.messageIndex, partIndex: eventArg.partIndex };
+    const key = this.openCodeToolExecutionKey(eventArg.scopeId, { sessionId, partId });
+    const cache = eventArg.partType === 'reasoning'
+      ? this.latestFlexReasoningUpdates
+      : this.latestFlexTextUpdates;
+    const entry = cache.get(key);
+    const previous = entry?.update;
+    if (
+      !entry
+      || !previous
+      || this.flexMessageStreamEpoch === 0
+      || entry.projectId !== eventArg.scopeId
+      || previous.status !== 'running'
+      || previous.streamEpoch !== this.flexMessageStreamEpoch
+      || previous.revision > this.flexMessageStreamRevision
+      || controllerRuntimeIdKey(previous.sessionId) !== controllerRuntimeIdKey(sessionId)
+      || controllerRuntimeIdKey(previous.messageId) !== controllerRuntimeIdKey(messageId)
+      || controllerRuntimeIdKey(previous.partId) !== controllerRuntimeIdKey(partId)
+      || previous.order?.messageIndex !== order.messageIndex
+      || previous.order.partIndex !== order.partIndex
+      || sourceUpdatedAt < previous.sourceUpdatedAt
+      || entry.textUtf8Bytes !== eventArg.baseTextUtf8Bytes
+    ) {
+      this.advanceFlexMessageStreamEpoch(true);
+      return;
+    }
+    const textUtf8Bytes = controllerTextAfterAppendUtf8Bytes(
+      previous.text,
+      entry.textUtf8Bytes,
+      eventArg.delta,
+    );
+    if (
+      textUtf8Bytes === undefined
+      || textUtf8Bytes <= entry.textUtf8Bytes
+      || textUtf8Bytes !== eventArg.textUtf8Bytes
+    ) {
+      this.advanceFlexMessageStreamEpoch(true);
+      return;
+    }
+
+    const revision = this.flexMessageStreamRevision + 1;
+    const update = {
+      ...previous,
+      text: `${previous.text}${eventArg.delta}`,
+      sourceUpdatedAt,
+      revision,
+      streamEpoch: this.flexMessageStreamEpoch,
+    } as IControllerReasoningUpdate | IControllerTextUpdate;
+    const controllerEvent: IControllerEvent = eventArg.partType === 'reasoning'
+      ? {
+          type: 'session.reasoning.delta',
+          harnessId: 'flex',
+          projectId: eventArg.scopeId,
+          sessionId,
+          reasoningDelta: {
+            sessionId,
+            messageId,
+            partId,
+            delta: eventArg.delta,
+            baseTextUtf8Bytes: eventArg.baseTextUtf8Bytes,
+            textUtf8Bytes,
+            order,
+            sourceUpdatedAt,
+            revision,
+            streamEpoch: this.flexMessageStreamEpoch,
+          },
+          timestamp: sourceUpdatedAt,
+        }
+      : {
+          type: 'session.text.delta',
+          harnessId: 'flex',
+          projectId: eventArg.scopeId,
+          sessionId,
+          textDelta: {
+            sessionId,
+            messageId,
+            partId,
+            delta: eventArg.delta,
+            baseTextUtf8Bytes: eventArg.baseTextUtf8Bytes,
+            textUtf8Bytes,
+            order,
+            sourceUpdatedAt,
+            revision,
+            streamEpoch: this.flexMessageStreamEpoch,
+          },
+          timestamp: sourceUpdatedAt,
+        };
+    const snapshotEvent: IControllerEvent = eventArg.partType === 'reasoning'
+      ? {
+          type: 'session.reasoning.updated',
+          harnessId: 'flex',
+          projectId: eventArg.scopeId,
+          sessionId,
+          reasoningUpdate: update as IControllerReasoningUpdate,
+          timestamp: sourceUpdatedAt,
+        }
+      : {
+          type: 'session.text.updated',
+          harnessId: 'flex',
+          projectId: eventArg.scopeId,
+          sessionId,
+          textUpdate: update as IControllerTextUpdate,
+          timestamp: sourceUpdatedAt,
+        };
+    const eventBytes = Buffer.byteLength(JSON.stringify(controllerEvent), 'utf8');
+    const snapshotBytes = Buffer.byteLength(JSON.stringify(snapshotEvent), 'utf8');
+    if (
+      eventBytes > controllerMaxLiveMessageEventBytes
+      || snapshotBytes > controllerMaxLiveMessageEventBytes
+      || this.latestFlexMessageUpdateBytes - (entry.bytes ?? 0) + snapshotBytes
+        > maxLatestFlexMessageUpdateBytes
+    ) {
+      this.advanceFlexMessageStreamEpoch(true);
+      return;
+    }
+
+    this.flexMessageStreamRevision = revision;
+    if (eventArg.partType === 'reasoning') {
+      this.setLatestFlexReasoningUpdate(
+        key,
+        {
+          projectId: eventArg.scopeId,
+          update: update as IControllerReasoningUpdate,
+          textUtf8Bytes,
+        },
+        snapshotBytes,
+      );
+    } else {
+      this.setLatestFlexTextUpdate(
+        key,
+        {
+          projectId: eventArg.scopeId,
+          update: update as IControllerTextUpdate,
+          textUtf8Bytes,
+        },
+        snapshotBytes,
+      );
+    }
+    this.queueFlexControllerEvent(controllerEvent);
+  }
+
   private getOpenCodeToolStreamCursor(): IControllerToolStreamCursor {
     return {
       streamEpoch: this.openCodeToolStreamEpoch,
@@ -11051,12 +11373,25 @@ export class OpenCodeController {
 
   private advanceOpenCodeMessageStreamEpoch(includeSessionsChangedArg: boolean): void {
     if (this.lifecycleState !== 'starting' && this.lifecycleState !== 'ready') return;
+    const pendingEntries = includeSessionsChangedArg ? 2 : 1;
+    if (
+      this.pendingOpenCodeControllerEvents.size
+      > maxPendingOpenCodeControllerEvents - pendingEntries
+    ) {
+      this.advanceOpenCodeStreams(includeSessionsChangedArg);
+      return;
+    }
     this.openCodeMessageStreamEpoch += 1;
     this.openCodeMessageStreamRevision = 0;
     this.latestOpenCodeReasoningUpdates.clear();
     this.latestOpenCodeTextUpdates.clear();
     for (const [key, event] of this.pendingOpenCodeControllerEvents) {
-      if (event.reasoningUpdate || event.textUpdate) this.pendingOpenCodeControllerEvents.delete(key);
+      if (
+        event.reasoningUpdate
+        || event.reasoningDelta
+        || event.textUpdate
+        || event.textDelta
+      ) this.pendingOpenCodeControllerEvents.delete(key);
     }
     const timestamp = Date.now();
     const barrier: IControllerEvent = {
@@ -11143,6 +11478,143 @@ export class OpenCodeController {
     if (!cache.has(key) && cache.size >= maxLatestOpenCodeMessageUpdates) {
       this.advanceOpenCodeMessageStreamEpoch(true);
     }
+    const previousEntry = cache.get(key);
+    const previous = previousEntry?.update;
+    if (
+      previousEntry !== undefined
+      && previous !== undefined
+      && previousEntry.projectId === projectId
+      && previous.streamEpoch === this.openCodeMessageStreamEpoch
+      && previous.revision <= this.openCodeMessageStreamRevision
+      && controllerRuntimeIdKey(previous.sessionId) === controllerRuntimeIdKey(updateArg.sessionId)
+      && controllerRuntimeIdKey(previous.messageId) === controllerRuntimeIdKey(updateArg.messageId)
+      && controllerRuntimeIdKey(previous.partId) === controllerRuntimeIdKey(updateArg.partId)
+      && previous.status === 'running'
+      && updateArg.status === 'running'
+      && updateArg.text.length > previous.text.length
+      && updateArg.text.startsWith(previous.text)
+      && Number.isSafeInteger(previousEntry.textUtf8Bytes)
+    ) {
+      const deltaText = updateArg.text.slice(previous.text.length);
+      const fragments = fragmentControllerTextDelta(deltaText);
+      const textUtf8Bytes = controllerTextAfterAppendUtf8Bytes(
+        previous.text,
+        previousEntry.textUtf8Bytes,
+        deltaText,
+      );
+      const finalRevision = this.openCodeMessageStreamRevision + fragments.length;
+      if (
+        fragments.length === 0
+        || textUtf8Bytes === undefined
+        || textUtf8Bytes <= previousEntry.textUtf8Bytes
+        || !Number.isSafeInteger(finalRevision)
+      ) {
+        this.advanceOpenCodeMessageStreamEpoch(true);
+        return;
+      }
+      const update = {
+        ...updateArg,
+        revision: finalRevision,
+        streamEpoch: this.openCodeMessageStreamEpoch,
+      } as IControllerReasoningUpdate | IControllerTextUpdate;
+      const snapshotEvent: IControllerEvent = typeArg === 'reasoning'
+        ? {
+            type: 'session.reasoning.updated',
+            harnessId: 'opencode',
+            projectId,
+            sessionId: update.sessionId,
+            reasoningUpdate: update as IControllerReasoningUpdate,
+            timestamp: update.sourceUpdatedAt,
+          }
+        : {
+            type: 'session.text.updated',
+            harnessId: 'opencode',
+            projectId,
+            sessionId: update.sessionId,
+            textUpdate: update as IControllerTextUpdate,
+            timestamp: update.sourceUpdatedAt,
+          };
+      const snapshotBytes = Buffer.byteLength(JSON.stringify(snapshotEvent), 'utf8');
+      if (snapshotBytes > controllerMaxLiveMessageEventBytes) {
+        this.advanceOpenCodeMessageStreamEpoch(true);
+        return;
+      }
+
+      const events: IControllerEvent[] = [];
+      let baseTextUtf8Bytes = previousEntry.textUtf8Bytes;
+      for (const [index, fragment] of fragments.entries()) {
+        const fragmentTextUtf8Bytes = index === 0
+          ? controllerTextAfterAppendUtf8Bytes(
+              previous.text,
+              baseTextUtf8Bytes,
+              fragment.delta,
+            )
+          : baseTextUtf8Bytes + fragment.utf8Bytes;
+        if (
+          fragmentTextUtf8Bytes === undefined
+          || !Number.isSafeInteger(fragmentTextUtf8Bytes)
+          || fragmentTextUtf8Bytes <= baseTextUtf8Bytes
+        ) {
+          this.advanceOpenCodeMessageStreamEpoch(true);
+          return;
+        }
+        const revision = this.openCodeMessageStreamRevision + index + 1;
+        const commonDelta = {
+          sessionId: update.sessionId,
+          messageId: update.messageId,
+          partId: update.partId,
+          delta: fragment.delta,
+          baseTextUtf8Bytes,
+          textUtf8Bytes: fragmentTextUtf8Bytes,
+          sourceUpdatedAt: update.sourceUpdatedAt,
+          revision,
+          streamEpoch: this.openCodeMessageStreamEpoch,
+        };
+        const event: IControllerEvent = typeArg === 'reasoning'
+          ? {
+              type: 'session.reasoning.delta',
+              harnessId: 'opencode',
+              projectId,
+              sessionId: update.sessionId,
+              reasoningDelta: commonDelta,
+              timestamp: update.sourceUpdatedAt,
+            }
+          : {
+              type: 'session.text.delta',
+              harnessId: 'opencode',
+              projectId,
+              sessionId: update.sessionId,
+              textDelta: commonDelta,
+              timestamp: update.sourceUpdatedAt,
+            };
+        if (Buffer.byteLength(JSON.stringify(event), 'utf8') > controllerMaxLiveMessageEventBytes) {
+          this.advanceOpenCodeMessageStreamEpoch(true);
+          return;
+        }
+        events.push(event);
+        baseTextUtf8Bytes = fragmentTextUtf8Bytes;
+      }
+      if (baseTextUtf8Bytes !== textUtf8Bytes) {
+        this.advanceOpenCodeMessageStreamEpoch(true);
+        return;
+      }
+
+      this.openCodeMessageStreamRevision = finalRevision;
+      cache.delete(key);
+      cache.set(key, {
+        projectId,
+        update,
+        textUtf8Bytes,
+        bytes: snapshotBytes,
+      } as ILatestReasoningUpdate & ILatestTextUpdate);
+      const streamEpoch = this.openCodeMessageStreamEpoch;
+      for (const event of events) {
+        this.queueOpenCodeControllerEvent(event);
+        if (this.openCodeMessageStreamEpoch !== streamEpoch) return;
+      }
+      return;
+    }
+
     this.openCodeMessageStreamRevision += 1;
     const update = {
       ...updateArg,
@@ -11166,12 +11638,18 @@ export class OpenCodeController {
           textUpdate: update as IControllerTextUpdate,
           timestamp: update.sourceUpdatedAt,
         };
-    if (Buffer.byteLength(JSON.stringify(event), 'utf8') > controllerMaxLiveMessageEventBytes) {
+    const eventBytes = Buffer.byteLength(JSON.stringify(event), 'utf8');
+    if (eventBytes > controllerMaxLiveMessageEventBytes) {
       this.advanceOpenCodeMessageStreamEpoch(true);
       return;
     }
     cache.delete(key);
-    cache.set(key, { projectId, update } as ILatestReasoningUpdate & ILatestTextUpdate);
+    cache.set(key, {
+      projectId,
+      update,
+      textUtf8Bytes: Buffer.byteLength(update.text, 'utf8'),
+      bytes: eventBytes,
+    } as ILatestReasoningUpdate & ILatestTextUpdate);
     this.queueOpenCodeControllerEvent(event);
   }
 
@@ -11218,6 +11696,7 @@ export class OpenCodeController {
   }
 
   private controllerEventKey(eventArg: IControllerEvent): string {
+    const delta = controllerEventMessageDelta(eventArg);
     return JSON.stringify([
       eventArg.type,
       eventArg.harnessId ?? null,
@@ -11232,6 +11711,18 @@ export class OpenCodeController {
       eventArg.textUpdate
         ? controllerRuntimeIdKey(eventArg.textUpdate.partId)
         : null,
+      delta
+        ? [
+            controllerRuntimeIdKey(delta.messageId),
+            controllerRuntimeIdKey(delta.partId),
+            delta.streamEpoch,
+            delta.order?.messageIndex ?? null,
+            delta.order?.partIndex ?? null,
+            delta.baseTextUtf8Bytes,
+            delta.textUtf8Bytes,
+            delta.revision,
+          ]
+        : null,
       eventArg.toolExecution
         ? eventArg.toolExecution.status === 'completed' || eventArg.toolExecution.status === 'error'
           ? 'terminal'
@@ -11248,15 +11739,59 @@ export class OpenCodeController {
     ]);
   }
 
-  private queueOpenCodeControllerEvent(eventArg: IControllerEvent): void {
-    if (this.lifecycleState !== 'starting' && this.lifecycleState !== 'ready') return;
+  private latestPendingControllerDelta(
+    queueArg: Map<string, IControllerEvent>,
+    eventArg: IControllerEvent,
+  ): { key: string; event: IControllerEvent } | undefined {
+    const pendingKey = controllerMessageDeltaPendingKey(eventArg);
+    if (!pendingKey) return undefined;
+    let tail: [string, IControllerEvent] | undefined;
+    for (const entry of queueArg) tail = entry;
+    if (!tail || controllerMessageDeltaPendingKey(tail[1]) !== pendingKey) return undefined;
+    return { key: tail[0], event: tail[1] };
+  }
+
+  private queueOpenCodeControllerEvent(eventArg: IControllerEvent): boolean {
+    if (this.lifecycleState !== 'starting' && this.lifecycleState !== 'ready') return false;
+    const delta = controllerEventMessageDelta(eventArg);
+    if (delta) {
+      if (Buffer.byteLength(JSON.stringify(eventArg), 'utf8') > controllerMaxLiveMessageEventBytes) {
+        this.advanceOpenCodeMessageStreamEpoch(true);
+        return false;
+      }
+      const pending = this.latestPendingControllerDelta(
+        this.pendingOpenCodeControllerEvents,
+        eventArg,
+      );
+      if (pending) {
+        const merged = mergeControllerMessageDeltaEvents(pending.event, eventArg);
+        if (!merged) {
+          this.advanceOpenCodeMessageStreamEpoch(true);
+          return false;
+        }
+        if (
+          Buffer.byteLength(JSON.stringify(merged), 'utf8')
+            <= controllerMaxLiveMessageEventBytes
+        ) {
+          this.pendingOpenCodeControllerEvents.set(pending.key, merged);
+          this.startOpenCodeControllerEventDrain();
+          return true;
+        }
+      }
+    }
     const key = this.controllerEventKey(eventArg);
-    if (this.pendingOpenCodeControllerEvents.has(key)) {
+    if (delta && this.pendingOpenCodeControllerEvents.has(key)) {
+      this.advanceOpenCodeMessageStreamEpoch(true);
+      return false;
+    }
+    if (!delta && this.pendingOpenCodeControllerEvents.has(key)) {
       this.pendingOpenCodeControllerEvents.delete(key);
     } else if (
       this.pendingOpenCodeControllerEvents.size >= maxPendingOpenCodeControllerEvents
     ) {
-      if (eventArg.reasoningUpdate || eventArg.textUpdate) {
+      if (delta) {
+        this.advanceOpenCodeStreams(true);
+      } else if (eventArg.reasoningUpdate || eventArg.textUpdate) {
         this.advanceOpenCodeMessageStreamEpoch(true);
       } else if (eventArg.toolExecution) {
         this.advanceOpenCodeToolStreamEpoch(true);
@@ -11288,10 +11823,11 @@ export class OpenCodeController {
           rebasedEvent,
         );
       }
-      return;
+      return false;
     }
     this.pendingOpenCodeControllerEvents.set(key, eventArg);
     this.startOpenCodeControllerEventDrain();
+    return true;
   }
 
   private startOpenCodeControllerEventDrain(): void {
@@ -11358,7 +11894,11 @@ export class OpenCodeController {
       };
       this.setLatestFlexReasoningUpdate(
         this.openCodeToolExecutionKey(eventArg.projectId, update),
-        { projectId: eventArg.projectId, update },
+        {
+          projectId: eventArg.projectId,
+          update,
+          textUtf8Bytes: Buffer.byteLength(update.text, 'utf8'),
+        },
         Buffer.byteLength(JSON.stringify(event), 'utf8'),
       );
       return event;
@@ -11377,7 +11917,11 @@ export class OpenCodeController {
       };
       this.setLatestFlexTextUpdate(
         this.openCodeToolExecutionKey(eventArg.projectId, update),
-        { projectId: eventArg.projectId, update },
+        {
+          projectId: eventArg.projectId,
+          update,
+          textUtf8Bytes: Buffer.byteLength(update.text, 'utf8'),
+        },
         Buffer.byteLength(JSON.stringify(event), 'utf8'),
       );
       return event;
@@ -11385,10 +11929,51 @@ export class OpenCodeController {
     return eventArg;
   }
 
-  private queueFlexControllerEvent(eventArg: IControllerEvent): void {
-    if (this.lifecycleState !== 'starting' && this.lifecycleState !== 'ready') return;
+  private queueFlexControllerEvent(eventArg: IControllerEvent): boolean {
+    if (this.lifecycleState !== 'starting' && this.lifecycleState !== 'ready') return false;
+    const delta = controllerEventMessageDelta(eventArg);
+    if (delta) {
+      if (Buffer.byteLength(JSON.stringify(eventArg), 'utf8') > controllerMaxLiveMessageEventBytes) {
+        this.advanceFlexMessageStreamEpoch(true);
+        return false;
+      }
+      const pending = this.latestPendingControllerDelta(
+        this.pendingFlexControllerEvents,
+        eventArg,
+      );
+      if (pending) {
+        const merged = mergeControllerMessageDeltaEvents(pending.event, eventArg);
+        if (!merged) {
+          this.advanceFlexMessageStreamEpoch(true);
+          return false;
+        }
+        const mergedBytes = this.flexControllerEventLiveBytes(merged);
+        if (
+          mergedBytes.message <= controllerMaxLiveMessageEventBytes
+        ) {
+          const pendingBytes = this.flexControllerEventLiveBytes(pending.event);
+          if (
+            this.latestFlexMessageUpdateBytes
+              + this.pendingFlexMessageEventBytes
+              - pendingBytes.message
+              + mergedBytes.message
+            > maxLatestFlexMessageUpdateBytes
+          ) {
+            this.advanceFlexMessageStreamEpoch(true);
+            return false;
+          }
+          this.setPendingFlexControllerEvent(pending.key, merged);
+          this.startFlexControllerEventDrain();
+          return true;
+        }
+      }
+    }
     const key = this.controllerEventKey(eventArg);
-    this.deletePendingFlexControllerEvent(key);
+    if (delta && this.pendingFlexControllerEvents.has(key)) {
+      this.advanceFlexMessageStreamEpoch(true);
+      return false;
+    }
+    if (!delta) this.deletePendingFlexControllerEvent(key);
     const liveBytes = this.flexControllerEventLiveBytes(eventArg);
     const exceedsCountBound = this.pendingFlexControllerEvents.size >= maxPendingFlexControllerEvents;
     const exceedsPendingBound = exceedsCountBound
@@ -11403,7 +11988,12 @@ export class OpenCodeController {
         || this.pendingFlexControllerEvents.size > maxPendingFlexControllerEvents - 3;
       if (requiresCountCollapse) {
         this.advanceFlexStreams(true);
-      } else if (eventArg.reasoningUpdate || eventArg.textUpdate) {
+      } else if (
+        eventArg.reasoningUpdate
+        || eventArg.reasoningDelta
+        || eventArg.textUpdate
+        || eventArg.textDelta
+      ) {
         this.advanceFlexMessageStreamEpoch(true);
       } else if (eventArg.toolExecution) {
         this.advanceFlexToolStreamEpoch(true);
@@ -11421,10 +12011,11 @@ export class OpenCodeController {
         this.setPendingFlexControllerEvent(this.controllerEventKey(rebasedEvent), rebasedEvent);
       }
       this.startFlexControllerEventDrain();
-      return;
+      return false;
     }
     this.setPendingFlexControllerEvent(key, eventArg);
     this.startFlexControllerEventDrain();
+    return true;
   }
 
   private startFlexControllerEventDrain(): void {