@modelprofile.com/flexharness 11.1.1 → 11.3.0

package/ts/classes.codesandbox.worker.ts

@@ -1,8 +1,9 @@
 /**
- * The QuickJS side of a `run_code` program. `FlexCodeSandbox` runs every program in a worker thread of
- * its own with this module, and ends it by terminating the worker, which frees its WebAssembly instance
- * too: a native operation that never reaches QuickJS's interrupt handler cannot outlast its limits, and
- * a program never blocks the host's event loop.
+ * The QuickJS side of `run_code` programs. A worker thread of `FlexCodeSandbox` loads QuickJS once and
+ * runs one program at a time, each in a QuickJS runtime and context of its own, which it frees once the
+ * program ended by itself. A program stopped at a limit ends with its worker: terminating the worker
+ * frees its WebAssembly instance too, so a native operation that never reaches QuickJS's interrupt
+ * handler cannot outlast its limits, and a program never blocks the host's event loop.
  *
  * Written in erasable TypeScript that imports nothing of the package at run time, so the module loads
  * uncompiled as well.
@@ -29,10 +30,13 @@ export type TCodeWorkerRequest =
 /**
  * What a program's worker reports. `ready` comes once QuickJS is loaded; every `start` and `answer`
  * ends in `idle`, with the milliseconds computed so far, unless the program stopped. `done` counts the
- * calls the program had no answer to when it returned.
+ * calls the program had no answer to when it returned. `released` follows a program that ended by
+ * itself (`done`, or `failed` short of a limit): its runtime is freed, and the worker's WebAssembly
+ * memory, which never shrinks, has `memoryBytes`.
  */
 export type TCodeWorkerReport =
   | { kind: 'ready' }
+  | { kind: 'released'; memoryBytes: number }
   | { kind: 'call'; id: number; method: string; params: string }
   | { kind: 'log'; text: string }
   | { kind: 'idle'; cpuMs: number }
@@ -134,7 +138,8 @@ const prelude = `'use strict';
 /**
  * One program in its QuickJS runtime. It enforces the limits QuickJS can see: memory, stack, console
  * output, and computing time at every interrupt point. The host enforces the rest, and ends the worker
- * when the program computes past its time between two interrupt points.
+ * when the program computes past its time between two interrupt points. Once the program's outcome is
+ * reported, nothing more of it runs: work it left pending is interrupted and dropped with its runtime.
  */
 class CodeWorkerRun {
   private readonly report: (report: TCodeWorkerReport) => void;
@@ -177,6 +182,19 @@ class CodeWorkerRun {
     this.idle();
   }
 
+  /** The program ended by itself, so its runtime can be freed and the worker run the next program. */
+  public get finished(): boolean {
+    return this.ended && this.stopped === undefined;
+  }
+
+  /** Frees the program's runtime with everything in it, and the calls it left unanswered. */
+  public release(): void {
+    for (const deferred of this.deferreds.values()) deferred.dispose();
+    this.deferreds.clear();
+    this.vm.dispose();
+    this.runtime.dispose();
+  }
+
   /** Settles a call of the program with the host's outcome, and runs what it unblocked. */
   public answer(id: number, text: string): void {
     const deferred = this.deferreds.get(id);
@@ -233,7 +251,7 @@ class CodeWorkerRun {
       return false;
     }
     result.value.dispose();
-    return true;
+    return !this.ended;
   }
 
   /** Runs the program's pending jobs after a call settled or the program started. */
@@ -259,6 +277,11 @@ class CodeWorkerRun {
   }
 
   private failWith(handle: plugins.IQuickJsHandle, phase: TCodeWorkerPhase): void {
+    if (this.ended) {
+      // The interruption of work the program left pending once its outcome was out.
+      handle.dispose();
+      return;
+    }
     let dumped: unknown;
     // Reading the thrown value can run program code, such as a toJSON: it counts as computing.
     this.enter();
@@ -268,6 +291,7 @@ class CodeWorkerRun {
       dumped = undefined;
     } finally {
       this.leave();
+      handle.dispose();
     }
     if (this.stopped) {
       this.stop(this.stopped);
@@ -313,7 +337,7 @@ class CodeWorkerRun {
   }
 
   private interrupted(): boolean {
-    if (this.stopped) return true;
+    if (this.stopped || this.ended) return true;
     if (this.enteredAt !== undefined && this.cpuMs + performance.now() - this.enteredAt > this.limits.cpuMs) {
       this.stopped = 'cpu';
       return true;
@@ -340,6 +364,12 @@ if (port) {
     } else {
       run?.answer(request.id, request.text);
     }
+    // A failure to free the runtime throws: the worker fails, and the host ends it.
+    if (run?.finished) {
+      run.release();
+      run = undefined;
+      report({ kind: 'released', memoryBytes: module.getWasmMemory().buffer.byteLength });
+    }
   });
   report({ kind: 'ready' });
 }

package/ts/classes.flexharness.callbacks.ts

@@ -39,7 +39,7 @@ export class FlexHarnessRunCallbacks<TScope> {
     const run = this.callbackRun(state, sessionId);
     if (!run || !delta) return;
     const lastPart = run.callbackParts.at(-1);
-    const openPart = lastPart?.type === 'text' && !run.completedTextPartIds.has(lastPart.partId)
+    const openPart = lastPart?.type === 'text' && run.stepPartIds.has(lastPart.partId)
       ? lastPart
       : undefined;
     const created = !openPart;
@@ -54,6 +54,7 @@ export class FlexHarnessRunCallbacks<TScope> {
     )) return;
     if (created) {
       run.callbackParts.push(part);
+      run.stepPartIds.add(part.partId);
       run.partTextUtf8Bytes.set(part.partId, 0);
       this.core.emitPartEvent(run, 'part.started', part);
     }
@@ -75,6 +76,7 @@ export class FlexHarnessRunCallbacks<TScope> {
     };
     run.reasoningPartIds.set(id, part.partId);
     run.callbackParts.push(part);
+    run.stepPartIds.add(part.partId);
     run.partTextUtf8Bytes.set(part.partId, 0);
     this.core.emitPartEvent(run, 'part.started', part);
   }
@@ -115,6 +117,9 @@ export class FlexHarnessRunCallbacks<TScope> {
     }
     part.status = 'completed';
     part.completedAt = new Date().toISOString();
+    // Model calls number their reasoning summaries afresh, so a later call's summary with the
+    // same ID is another one.
+    run.reasoningPartIds.delete(id);
     this.core.emitPartEvent(run, 'part.completed', part);
   }
 
@@ -128,10 +133,10 @@ export class FlexHarnessRunCallbacks<TScope> {
     const run = this.callbackRun(state, sessionId);
     if (!run) return;
     for (const part of run.callbackParts) {
-      if (part.type !== 'text' || run.completedTextPartIds.has(part.partId)) continue;
-      run.completedTextPartIds.add(part.partId);
+      if (part.type !== 'text' || !run.stepPartIds.has(part.partId)) continue;
       this.core.emitPartEvent(run, 'part.completed', part);
     }
+    run.stepPartIds.clear();
   }
 
   private textAppendAccounting(
@@ -372,9 +377,23 @@ export class FlexHarnessRunCallbacks<TScope> {
     }
   }
 
+  /**
+   * Announces a retry. The failed model call's text and reasoning are not in the session, so their
+   * parts are removed first, last part first, each with a `part.removed` event; its tool calls
+   * stay. The removals are outside the callback limits, like completions: their number is bounded
+   * by the run's parts. What the removed parts took of the limits stays taken.
+   */
   public onRetry(state: IStorageState, sessionId: string, retry: plugins.IAgentRetryEvent): void {
     const run = this.callbackRun(state, sessionId);
     if (!run || !this.reserveCallbackCapacity(run, 1, 0, 0)) return;
+    for (let partIndex = run.callbackParts.length - 1; partIndex >= 0; partIndex--) {
+      const part = run.callbackParts[partIndex]!;
+      if (!run.stepPartIds.has(part.partId)) continue;
+      this.core.emitPartRemovedEvent(run, part);
+      run.callbackParts.splice(partIndex, 1);
+      run.partTextUtf8Bytes.delete(part.partId);
+    }
+    run.stepPartIds.clear();
     this.core.emitEvent(run.scopeId, run.stored.session, {
       type: 'run.retrying',
       runId: run.runId,

package/ts/classes.flexharness.core.ts

@@ -43,6 +43,7 @@ import type {
   TFlexReversionPolicy,
 } from './interfaces.js';
 import { InMemoryFlexHarnessStores } from './classes.stores.js';
+import { FlexCodeSandbox } from './classes.codesandbox.js';
 import {
   assertJsonSerializable,
   cloneSerializable,
@@ -172,6 +173,7 @@ export class FlexHarnessCore<TScope> {
   public readonly trustedInternalErrors = new WeakSet<object>();
   public sequence = 0;
   public closed = false;
+  private codeSandbox?: Promise<FlexCodeSandbox>;
   public readonly results = new FlexHarnessResults<TScope>(this);
   public readonly toolDispatch = new FlexHarnessToolDispatch<TScope>(this);
   public readonly providers = new FlexHarnessToolProviders<TScope>(this);
@@ -1716,6 +1718,19 @@ export class FlexHarnessCore<TScope> {
     });
   }
 
+  /** Announces that `part` leaves the run's parts; call it while the part is still among them. */
+  public emitPartRemovedEvent(run: IActiveRun, part: TFlexMessagePart): void {
+    const { messageIndex, partIndex } = this.partEventCoordinates(run, part.partId);
+    this.emitEvent(run.scopeId, run.stored.session, {
+      type: 'part.removed',
+      runId: run.runId,
+      messageId: run.assistantMessageId,
+      messageIndex,
+      partId: part.partId,
+      partIndex,
+    });
+  }
+
   private partEventCoordinates(
     run: IActiveRun,
     partId: string,
@@ -1833,4 +1848,20 @@ export class FlexHarnessCore<TScope> {
   public assertOpen(): void {
     if (this.closed) throw new FlexHarnessClosedError();
   }
+
+  /** The harness's code mode sandbox, loaded with its first code mode run; its workers are the harness's. */
+  public loadCodeSandbox(): Promise<FlexCodeSandbox> {
+    this.assertOpen();
+    this.codeSandbox ??= FlexCodeSandbox.load().catch((error: unknown) => {
+      this.codeSandbox = undefined;
+      throw error;
+    });
+    return this.codeSandbox;
+  }
+
+  /** Stops the code mode programs still running and ends every worker of the sandbox. */
+  public async disposeCodeSandbox(): Promise<void> {
+    const sandbox = await this.codeSandbox?.catch(() => undefined);
+    await sandbox?.dispose();
+  }
 }

package/ts/classes.flexharness.lifecycle.ts

@@ -771,6 +771,11 @@ export class FlexHarnessLifecycle<TScope> {
         errors.push(...await this.closeOrphanedResources(storageKey));
       }
     }
+    try {
+      await this.core.disposeCodeSandbox();
+    } catch (error) {
+      this.core.appendUnexpectedErrors(errors, error);
+    }
     this.core.listeners.clear();
     if (errors.length > 0) throw combineErrors(errors);
     this.core.compaction.compactorInvocationContext.disable();

package/ts/classes.flexharness.runs.ts

@@ -26,7 +26,6 @@ import {
   type TFlexMessagePart,
 } from './interfaces.js';
 import { FlexToolCatalog, assertNoCatalogCollisions } from './classes.toolcatalog.js';
-import { FlexCodeSandbox } from './classes.codesandbox.js';
 import { cloneSerializable } from './utils.json.js';
 import type { INormalizedFlexPrompt } from './utils.prompt.js';
 import {
@@ -119,7 +118,7 @@ export class FlexHarnessRuns<TScope> {
         cacheWriteTokens: 0,
       },
       reasoningPartIds: new Map(),
-      completedTextPartIds: new Set(),
+      stepPartIds: new Set(),
       toolPartIds: new Map(),
       trustedToolExecutionErrors: new Map(),
       unconfirmedToolCalls: new Map(),
@@ -495,7 +494,11 @@ export class FlexHarnessRuns<TScope> {
           catalog = await FlexToolCatalog.create(toolHandle.catalog, this.core.toolCatalogOptions, {
             results: this.core.stores.results !== undefined,
           });
-          if (catalog.codeMode) run.codeSandbox = await FlexCodeSandbox.load();
+          if (catalog.codeMode) {
+            run.codeSandbox = await this.core.loadCodeSandbox();
+            // The worker loads QuickJS while the model writes the program.
+            run.codeSandbox.prewarm(run.scopeId);
+          }
         } catch (error) {
           throw this.core.projectExternalError(run, error, 'toolProvider');
         }
@@ -811,7 +814,7 @@ export class FlexHarnessRuns<TScope> {
         run.reservedAssistantMessage = publicSnapshot(nextAssistant);
         run.callbackParts = [];
         run.reasoningPartIds.clear();
-        run.completedTextPartIds.clear();
+        run.stepPartIds.clear();
         this.core.emitEvent(run.scopeId, run.stored.session, {
           type: 'message.updated',
           runId: run.runId,
@@ -1030,7 +1033,7 @@ export class FlexHarnessRuns<TScope> {
     for (const part of terminal.assistantMessage.parts) {
       const callbackPart = run.callbackParts.find((entry) => entry.partId === part.partId);
       const shouldComplete = part.type === 'text'
-        ? callbackPart?.type === 'text' && !run.completedTextPartIds.has(part.partId)
+        ? callbackPart?.type === 'text' && run.stepPartIds.has(part.partId)
         : part.type === 'reasoning'
           ? callbackPart?.type === 'reasoning' && callbackPart.status === 'running'
           : part.type === 'tool'

package/ts/classes.flexharness.tooldispatch.ts

@@ -475,7 +475,7 @@ export class FlexHarnessToolDispatch<TScope> {
         }
       },
     };
-    const result = await run.codeSandbox!.run(code, host, catalog.codeMode!, abortSignal);
+    const result = await run.codeSandbox!.run(code, host, catalog.codeMode!, abortSignal, run.scopeId);
     if (!result.ok) {
       throw this.catalogCallError(run, toolCallId, normalizeJsonValue(result.failure, this.core.toolOutputLimits));
     }

package/ts/interfaces.flexharness.ts

@@ -223,12 +223,14 @@ export interface IActiveRun {
   /** The usage the provider reported for the run's model calls so far. */
   usage: IFlexUsage;
   metricsOperation?: ISessionMetricsOperation;
+  /** The part of each reasoning summary in progress, by the model's reasoning ID. */
   reasoningPartIds: Map<string, string>;
   /**
-   * The text parts whose model step is committed. Each emitted its `part.completed`; text that
-   * follows starts a new part.
+   * The text and reasoning parts the model step in progress streamed. When the step commits, its
+   * text parts complete and text that follows starts a new part; when its model call is retried,
+   * they are removed.
    */
-  completedTextPartIds: Set<string>;
+  stepPartIds: Set<string>;
   toolPartIds: Map<string, string>;
   trustedToolExecutionErrors: Map<string, Error>;
   /**

package/ts/interfaces.ts

@@ -1962,7 +1962,16 @@ export interface IFlexPartDeltaEvent extends IFlexPartEventBase {
   readonly textUtf8Bytes: number;
 }
 
-export type TFlexPartEvent = IFlexPartSnapshotEvent | IFlexPartDeltaEvent;
+/**
+ * A streamed part left its message: the model call that streamed it failed and is retried, and
+ * the retry streams its own parts. `partIndex` is the part's position before it left; the parts
+ * after it move up by one.
+ */
+export interface IFlexPartRemovedEvent extends IFlexPartEventBase {
+  readonly type: 'part.removed';
+}
+
+export type TFlexPartEvent = IFlexPartSnapshotEvent | IFlexPartDeltaEvent | IFlexPartRemovedEvent;
 
 export interface IFlexPermissionRequestedEvent extends IFlexEventBase {
   readonly type: 'permission.requested';

package/ts/plugins.ts

@@ -61,6 +61,8 @@ export interface IQuickJsRuntime {
 
 export interface IQuickJsModule {
   newRuntime(): IQuickJsRuntime;
+  /** The module's WebAssembly memory, shared by all its runtimes; it grows and never shrinks. */
+  getWasmMemory(): WebAssembly.Memory;
 }
 
 /** A failed strip, as amaro reports it. */
@@ -76,7 +78,7 @@ export interface ICodeSandboxEngine {
 }
 
 /**
- * Loads amaro, and finds QuickJS: the optional peers code mode needs. Every program's worker loads
+ * Loads amaro, and finds QuickJS: the optional peers code mode needs. Every code mode worker loads
  * QuickJS itself.
  */
 export const importCodeSandboxEngine = async (): Promise<ICodeSandboxEngine> => {

package/ts/readme.md

@@ -1065,6 +1065,9 @@ const unsubscribe = harness.subscribe((event) => {
         event.textUtf8Bytes,
       );
       break;
+    case 'part.removed':
+      removePart(event.sessionId, event.messageIndex, event.partIndex);
+      break;
     case 'permission.requested':
       showPermission(event.request);
       break;
@@ -1100,13 +1103,13 @@ const unsubscribe = harness.subscribe((event) => {
 unsubscribe();
 ```
 
-Events are discriminated, deeply immutable values with one global sequence within each `FlexHarness` instance. Every `IFlexEventBase` carries the exact source `sessionGenerationId` and `sessionGenerationSequence`; `session.deleted` retains the deleted generation after live metadata is removed. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Every accepted steer emits `prompt.steer.accepted`, and `prompt.steer.applied`, after the `message.*` events of its user message, once the run took it in; `run.finished` lists it in `unappliedSteerIds` unless it is in the model context of later turns. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part emits exactly one `part.completed` event before the corresponding `run.finished` event: once the model step that streamed it is committed, so its text is final and saved, or with the run's terminal projection when that step did not commit. Text a later model step streams starts a new part. Every `part.started`, `part.delta`, `part.updated`, and `part.completed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences.
+Events are discriminated, deeply immutable values with one global sequence within each `FlexHarness` instance. Every `IFlexEventBase` carries the exact source `sessionGenerationId` and `sessionGenerationSequence`; `session.deleted` retains the deleted generation after live metadata is removed. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Every accepted steer emits `prompt.steer.accepted`, and `prompt.steer.applied`, after the `message.*` events of its user message, once the run took it in; `run.finished` lists it in `unappliedSteerIds` unless it is in the model context of later turns. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part that stays in its message emits exactly one `part.completed` event before the corresponding `run.finished` event: once the model step that streamed it is committed, so its text is final and saved, or with the run's terminal projection when that step did not commit. Text a later model step streams starts a new part. When a model call fails and is retried, the text and reasoning parts it streamed are not in the session: `part.removed` takes each of them out of its message, last part first, and the retry streams its own parts. Its `partIndex` is the part's position before it left; the parts after it move up by one. A removed part has no further events, and `part.removed` does not count against `callbackLimits`. The tool parts of calls the failed model call executed stay. Every `part.started`, `part.delta`, `part.updated`, `part.completed`, and `part.removed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences.
 
 `getSessionView(scopeId, sessionId)` reads a session's metadata, visible messages and pending permission requests in one step, together with the instance's event `sequence` they include. The messages include what a running turn has streamed so far, so a consumer that applies every event of the instance with a greater `sequence` follows the session exactly from the view on; events up to `sequence` are already in it. The read waits while a queued write or a change that emits events for the session is in progress; a session that keeps changing through 64 consecutive waits is refused with `FlexHarnessSessionBusyError`, and the read can be repeated. Session metadata is current: status changes such as `waiting_permission` emit no event. A permission request its run leaves unanswered leaves `pendingPermissions` without an event of its own; the run's `run.finished` follows.
 
 `part.started`, `part.updated`, and `part.completed` are snapshot events with a complete immutable `part`. Tool and reasoning parts carry `startedAt` (ISO time the call or reasoning began) and, once they reach a terminal status, `completedAt`; parts recorded by earlier versions have neither, so a consumer falls back to the message times for them. A newly streamed text part emits `part.started` with empty text before its first delta; reasoning parts also start empty. `part.delta` is a separate delta-only event: it has no cumulative `part`, and carries `partType`, the required exact source `delta`, and `baseTextUtf8Bytes`/`textUtf8Bytes` for the cumulative text before and after that delta. The counters remain correct when a UTF-16 surrogate pair is split across callbacks. Exact deltas are never truncated, including a single delta above the 96 KiB message-transfer text limit. `part.updated` remains a cumulative replacement snapshot for running tool output or metadata, not a text delta. `session.history.changed` carries `direction: 'undo' | 'redo' | 'branch'`; `runId` is present for undo and redo. Events contain public IDs, exact delta payloads, and public snapshots only; they do not expose prompt payloads, the resolved scope object, storage key, model object, provider options, or raw storage key.
 
-Part events narrow through the exported `TFlexPartEvent` union. `IFlexPartEventBase` contains their shared coordinates, `IFlexPartSnapshotEvent` owns snapshot events and their complete `part`, and `IFlexPartDeltaEvent` owns exact delta-only events and their UTF-8 counters.
+Part events narrow through the exported `TFlexPartEvent` union. `IFlexPartEventBase` contains their shared coordinates, `IFlexPartSnapshotEvent` owns snapshot events and their complete `part`, `IFlexPartDeltaEvent` owns exact delta-only events and their UTF-8 counters, and `IFlexPartRemovedEvent` is `part.removed`, which carries only the coordinates.
 
 ### Migrating Part Events to 5.x
 

package/ts_chat_harness/classes.chatclient.ts

@@ -44,10 +44,13 @@ export interface IFlexHarnessChatClientListener {
   permissions?(permissions: plugins.IHarnessPermissionRequest[]): void;
   history?(history: IFlexHarnessChatHistoryState): void;
   steer?(outcome: IFlexHarnessChatSteerOutcome): void;
-  /** the open conversation could not be followed again and was closed; the message says why */
-  closed?(message: string): void;
-  /** attaching again after a reconnect failed; the message says why */
-  error?(message: string): void;
+  /**
+   * the open conversation could not be followed again and was closed; the message says why, and
+   * the error is what the transport failed with, for a view that words its own refusals
+   */
+  closed?(message: string, error: unknown): void;
+  /** attaching again after a reconnect failed; the message says why, and the error is the transport's */
+  error?(message: string, error: unknown): void;
 }
 
 /** Runs one tool of a turn in this tab and answers with what the model reads. */
@@ -104,7 +107,7 @@ export class FlexHarnessChatClient {
     });
     this.stopWatchingReconnects = this.transport.onReconnect(() => {
       void this.attach().catch((error) =>
-        this.listener?.error?.(errorText(error, 'The conversation could not be reattached after a reconnect.')),
+        this.listener?.error?.(errorText(error, 'The conversation could not be reattached after a reconnect.'), error),
       );
     });
   }
@@ -267,7 +270,7 @@ export class FlexHarnessChatClient {
       // another conversation was opened or a new one started meanwhile: that one stays
       if (this.openEpoch !== epoch) return;
       this.clear();
-      this.listener?.closed?.(errorText(error, 'The conversation could not be opened again.'));
+      this.listener?.closed?.(errorText(error, 'The conversation could not be opened again.'), error);
     }
   }
 

package/ts_chat_harness/classes.transcript.ts

@@ -250,6 +250,9 @@ export class FlexHarnessTranscript {
       case 'part.delta':
         this.applyPartDelta(change, event);
         break;
+      case 'part.removed':
+        this.removePart(change, event);
+        break;
       case 'permission.requested':
         this.addPermission(event.request);
         change.permissions = true;
@@ -396,4 +399,20 @@ export class FlexHarnessTranscript {
       ? { type: 'text', messageId: rowId, delta: event.delta }
       : { type: 'reasoning', messageId: rowId, partId: event.partId, delta: event.delta });
   }
+
+  private removePart(
+    change: IFlexHarnessTranscriptChange,
+    event: Extract<TFlexHarnessEvent, { type: 'part.removed' }>,
+  ): void {
+    const message = this.flexMessages.find((entry) => entry.messageId === event.messageId);
+    if (!message || message.parts[event.partIndex]?.partId !== event.partId) {
+      change.reload = true;
+      return;
+    }
+    message.parts.splice(event.partIndex, 1);
+    const key = flexPartTimingKey(event.messageId, event.partId);
+    this.timings.delete(key);
+    this.partBytes.delete(key);
+    change.messages = true;
+  }
 }

package/ts_chat_harness_server/classes.chathub.ts

@@ -38,6 +38,7 @@ export const defaultFlexHarnessChatLimits: Readonly<IFlexHarnessChatLimits> = Ob
   admissionWaitMs: 30 * 1000,
   toolTimeoutMs: 2 * 60 * 1000,
   maxPendingDeltas: 2_000,
+  minUpdateIntervalMs: 100,
   maxMessageChars: 100_000,
   maxAttachments: 16,
   maxAttachmentChars: 8 * 1024 * 1024,

package/ts_chat_harness_server/classes.chatsubscription.ts

@@ -26,6 +26,12 @@ const emptyPending = (): IPendingUpdate => ({
   steers: [],
 });
 
+/** Resolves after the time; its timer keeps no process alive. */
+const delay = (msArg: number): Promise<void> =>
+  new Promise<void>((resolve) => {
+    setTimeout(resolve, msArg).unref?.();
+  });
+
 const hasPending = (pendingArg: IPendingUpdate): boolean =>
   pendingArg.reset
   || pendingArg.rows
@@ -58,8 +64,9 @@ export interface IFlexHarnessChatSubscriptionOptions {
 
 /**
  * One tab following one conversation. A `FlexHarnessTranscript` takes every event of the harness
- * instance; what changed reaches the tab as numbered updates, one at a time. A transcript that
- * loses track, or an update the tab does not acknowledge, makes the next update a `reset`.
+ * instance; what changed reaches the tab as numbered updates, one at a time and at most one per
+ * `minUpdateIntervalMs`. A transcript that loses track, or an update the tab does not acknowledge,
+ * makes the next update a `reset`.
  */
 export class FlexHarnessChatSubscription {
   public readonly id: string;
@@ -80,6 +87,8 @@ export class FlexHarnessChatSubscription {
   private sentRows = new Map<string, string>();
   private pending: IPendingUpdate = emptyPending();
   private sending = false;
+  /** when the last update was taken to be sent, by `performance.now()` */
+  private lastUpdateAt = Number.NEGATIVE_INFINITY;
   private closed = false;
 
   constructor(optionsArg: IFlexHarnessChatSubscriptionOptions) {
@@ -176,13 +185,19 @@ export class FlexHarnessChatSubscription {
     }
   }
 
-  /** Sends what is pending, one update at a time, in seq order. */
+  /** Sends what is pending, one update at a time, in seq order, `minUpdateIntervalMs` apart. */
   private async pump(): Promise<void> {
     if (this.sending) return;
     this.sending = true;
     let inFlight: TUpdate | null = null;
     try {
       while (!this.closed && this.state === 'live' && hasPending(this.pending)) {
+        const wait = this.lastUpdateAt + this.limits.minUpdateIntervalMs - performance.now();
+        if (wait > 0) {
+          // what changes meanwhile goes into this update
+          await delay(wait);
+          continue;
+        }
         const peer = await this.peers.find(this.tab);
         if (!peer) {
           this.closeSelf();
@@ -190,6 +205,7 @@ export class FlexHarnessChatSubscription {
         }
         if (this.closed || this.state !== 'live') return;
         inFlight = await this.takeUpdate();
+        this.lastUpdateAt = performance.now();
         await peer.update(inFlight);
         inFlight = null;
       }

package/ts_chat_harness_server/interfaces.ts

@@ -75,6 +75,12 @@ export interface IFlexHarnessChatLimits {
   toolTimeoutMs: number;
   /** Deltas one update may carry; a tab further behind gets the changed rows. Default: 2000. */
   maxPendingDeltas: number;
+  /**
+   * The least time between two updates of one subscription; what changes meanwhile goes into the
+   * next. It bounds the requests a streaming turn costs a transport that answers every update with
+   * one, as TypedSocket pulls do. Default: 100 ms.
+   */
+  minUpdateIntervalMs: number;
   /** Characters of a message's text. Default: 100 000. */
   maxMessageChars: number;
   /** Attachments of one message. Default: 16. */

package/ts_chat_harness_server/readme.md

@@ -47,7 +47,7 @@ The host keeps its harness, models, system prompt, tools and scopes. It authenti
 ## Conversations
 
 - `attach(caller)` lists the tab's conversations, newest first, and forgets what the tab followed. A tab attaches after loading and after every reconnect; conversations created, renamed or deleted afterwards reach it as list pushes (`IFlexHarnessChatPeer.sessions`, an `IFlexHarnessChatSessionsPush`).
-- `open(caller, { sessionId, subscriptionId })` follows a conversation. Its state reaches the tab as numbered `IFlexHarnessChatUpdate` pushes, starting with a `reset`: changed rows, streamed deltas, status, usage, pending permissions, undo and redo availability, and what became of steers. A tab follows one conversation at a time. An update the tab does not acknowledge makes the next change a `reset`; a tab that sees a gap in `seq` opens the conversation again.
+- `open(caller, { sessionId, subscriptionId })` follows a conversation. Its state reaches the tab as numbered `IFlexHarnessChatUpdate` pushes, starting with a `reset`: changed rows, streamed deltas, status, usage, pending permissions, undo and redo availability, and what became of steers. Updates go one at a time and at most one per `limits.minUpdateIntervalMs` (100 ms by default); what changes meanwhile goes into the next. A transport that answers every update with a request, as TypedSocket pulls do, so makes at most one request per interval for a streaming turn. A tab follows one conversation at a time. An update the tab does not acknowledge makes the next change a `reset`; a tab that sees a gap in `seq` opens the conversation again.
 - `send(caller, { sessionId?, send, context })` starts a conversation without `sessionId`. While a turn runs, the message steers it; one the turn no longer takes waits up to `admissionWaitMs` for the ending turn and starts the next one. `readContext` checks the context the message is sent with; the turn carries it. The composer's model, account and effort choices are not used: the host's model resolver decides from the context.
 - `abort`, `respondToPermission`, `moveHistory` (FlexHarness undo and redo), `renameSession` and `deleteSession` act on a conversation the caller reaches. An imported conversation can be read, not continued.