@modelprofile.com/flexharness 11.1.0 → 11.2.0

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.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;
+  }
 }