@modelprofile.com/flexharness 11.0.1 → 11.1.1

package/ts/classes.flexharness.core.ts

@@ -26,6 +26,7 @@ import type {
   IFlexReversionSegment,
   IFlexPendingReversionRelease,
   IFlexResolvedScope,
+  IFlexResultLimits,
   IFlexScopeSnapshot,
   IFlexSession,
   IFlexSessionImportLimits,
@@ -59,6 +60,7 @@ import {
   resolveBoundedPositiveInteger,
   resolveCallbackLimits,
   resolvePromptQueueLimits,
+  resolveResultLimits,
   resolveReversionMaintenanceTimeoutMs,
   resolveReversionLimits,
   type INormalizedBuiltInTools,
@@ -153,6 +155,7 @@ export class FlexHarnessCore<TScope> {
   public readonly promptQueueLimits: Required<IFlexPromptQueueLimits>;
   public readonly reversionLimits: Required<IFlexReversionLimits>;
   public readonly sessionImportLimits: Required<IFlexSessionImportLimits>;
+  public readonly resultLimits: Required<IFlexResultLimits>;
   public readonly reversionMaintenanceTimeoutMs: number;
   public readonly turnReversionProvider: IFlexHarnessOptions<TScope>['turnReversionProvider'];
   public readonly reversionPolicy: TFlexReversionPolicy;
@@ -206,6 +209,7 @@ export class FlexHarnessCore<TScope> {
     this.promptQueueLimits = resolvePromptQueueLimits(options.promptQueueLimits);
     this.reversionLimits = resolveReversionLimits(options.reversionLimits);
     this.sessionImportLimits = resolveSessionImportLimits(options.sessionImportLimits);
+    this.resultLimits = resolveResultLimits(options.resultLimits, this.toolOutputLimits);
     this.reversionMaintenanceTimeoutMs = resolveReversionMaintenanceTimeoutMs(options);
     this.turnReversionProvider = options.turnReversionProvider;
     this.reversionPolicy = options.reversionPolicy ?? 'transcript-optional';
@@ -819,6 +823,7 @@ export class FlexHarnessCore<TScope> {
         onReasoningStart: (id) => this.callbacks.onReasoningStart(state, sessionId, id),
         onReasoningDelta: (id, delta) => this.callbacks.onReasoningDelta(state, sessionId, id, delta),
         onReasoningEnd: (id, text) => this.callbacks.onReasoningEnd(state, sessionId, id, text),
+        onStepCommitted: () => this.callbacks.onStepCommitted(state, sessionId),
         onToolCallStart: (event) => this.callbacks.onToolStart(state, sessionId, event),
         onToolCallUpdate: (event) => this.callbacks.onToolUpdate(state, sessionId, event),
         onToolCallFinish: (event) => this.callbacks.onToolFinish(state, sessionId, event),
@@ -1145,16 +1150,17 @@ export class FlexHarnessCore<TScope> {
     }]));
     const beforeTombstones = new Map([...state.tombstones].map(([id, value]) => [id, cloneSerializable(value)]));
     const beforeRetainedCleanups = new Map(state.retainedSessionCleanups);
-    const beforeSnapshot: IFlexScopeSnapshot = {
+    // The copies above stay untouched until a restore, so the scope as it was before the mutation
+    // is built from them only when a failed save has to be reconciled.
+    const beforeSnapshot = (): IFlexScopeSnapshot => ({
       schemaVersion: 1,
       revision: beforeRevision,
       sessions: [...beforeSessions.values()]
-        .map((entry) => cloneSerializable(entry.metadata))
+        .map((entry) => entry.metadata)
         .sort((left, right) => left.sessionId.localeCompare(right.sessionId)),
       tombstones: [...beforeTombstones.values()]
-        .map((value) => cloneSerializable(value))
         .sort((left, right) => left.sessionId.localeCompare(right.sessionId)),
-    };
+    });
     const restore = () => {
       state.revision = beforeRevision;
       state.sessions.clear();
@@ -1204,7 +1210,7 @@ export class FlexHarnessCore<TScope> {
       }
       if (
         (current === undefined && beforeRevision === 0)
-        || (current !== undefined && JSON.stringify(current) === JSON.stringify(beforeSnapshot))
+        || (current !== undefined && JSON.stringify(current) === JSON.stringify(beforeSnapshot()))
       ) {
         restore();
         throw error;
@@ -1240,19 +1246,19 @@ export class FlexHarnessCore<TScope> {
         ? undefined
         : cloneSerializable(stored.pendingReversion);
       const beforePendingReversionReleases = cloneSerializable(stored.pendingReversionReleases);
-      const beforeSnapshot: TFlexProjectionSnapshot = beforeBaseline ?? {
+      // The copies above stay untouched until a restore, so the projection as it was before the
+      // mutation is built from them only when a failed save has to be reconciled.
+      const beforeSnapshot = (): TFlexProjectionSnapshot => beforeBaseline ?? {
         schemaVersion: 3,
         revision: beforeRevision,
-        metrics: cloneSerializable(beforeMetrics),
-        messages: cloneSerializable(beforeMessages),
-        stagedTerminals: cloneSerializable(beforeStages),
-        reversionSegments: cloneSerializable(beforeSegments),
+        metrics: beforeMetrics,
+        messages: beforeMessages,
+        stagedTerminals: beforeStages,
+        reversionSegments: beforeSegments,
         revertCursor: beforeCursor,
-        excludedRunIds: cloneSerializable(beforeExcludedRunIds),
-        ...(beforePendingReversion === undefined
-          ? {}
-          : { pendingReversion: cloneSerializable(beforePendingReversion) }),
-        pendingReversionReleases: cloneSerializable(beforePendingReversionReleases),
+        excludedRunIds: beforeExcludedRunIds,
+        ...(beforePendingReversion === undefined ? {} : { pendingReversion: beforePendingReversion }),
+        pendingReversionReleases: beforePendingReversionReleases,
       };
       const restore = () => {
         stored.projectionSchemaVersion = beforeSchemaVersion;
@@ -1321,7 +1327,7 @@ export class FlexHarnessCore<TScope> {
         }
         if (
           (current === undefined && beforeRevision === 0)
-          || (current !== undefined && JSON.stringify(current) === JSON.stringify(beforeSnapshot))
+          || (current !== undefined && JSON.stringify(current) === JSON.stringify(beforeSnapshot()))
         ) {
           restore();
           throw error;

package/ts/classes.flexharness.results.ts

@@ -29,7 +29,7 @@ export class FlexHarnessResults<TScope> {
     if (!results || !run.toolCatalog) return normalizeJsonValue(output, this.core.toolOutputLimits);
     const stored = normalizeJsonValue(output, {
       ...this.core.toolOutputLimits,
-      maxBytes: Math.max(maxBytes, FLEX_RESULT_LIMITS.maxStoredBytes),
+      maxBytes: this.core.resultLimits.maxStoredBytes,
     });
     const bytes = jsonBytes(stored);
     if (bytes <= maxBytes) return stored;
@@ -53,7 +53,7 @@ export class FlexHarnessResults<TScope> {
       await results.save(storageKey, run.sessionId, handle, stored);
       // The session keeps its latest results; older ones are deleted.
       const handles = await results.list(storageKey, run.sessionId);
-      for (const old of handles.slice(0, Math.max(0, handles.length - FLEX_RESULT_LIMITS.maxResultsPerSession))) {
+      for (const old of handles.slice(0, Math.max(0, handles.length - this.core.resultLimits.maxResultsPerSession))) {
         await results.delete(storageKey, run.sessionId, old);
       }
     });
@@ -77,7 +77,7 @@ export class FlexHarnessResults<TScope> {
     const method = FLEX_RESULT_METHOD;
     const stored = await this.core.stores.results!.load(run.state.storageKey, run.sessionId, params.handle);
     if (stored === undefined) {
-      return { ok: false, error: { error: 'unknown_handle', method, handle: params.handle, hint: `A handle reads one of the latest ${FLEX_RESULT_LIMITS.maxResultsPerSession} results this session stored.` } };
+      return { ok: false, error: { error: 'unknown_handle', method, handle: params.handle, hint: `A handle reads one of the latest ${this.core.resultLimits.maxResultsPerSession} results this session stored.` } };
     }
     const path = params.path ?? '';
     const value = selectPath(stored, path);

package/ts/classes.flexharness.reversions.ts

@@ -997,38 +997,37 @@ export class FlexHarnessReversions<TScope> {
     run: IActiveRun,
     status: 'completed' | 'failed' | 'cancelled',
   ): Promise<void> {
-    if (run.stored.session.agent !== undefined) return;
+    const close = await this.prepareRunReversionClose(run, status);
+    if (close) await this.core.mutateProjection(run.state, run.stored, close, true);
+  }
+
+  /**
+   * Finalizes a run's workspace capture and returns the projection mutation that closes the run's
+   * reversion segment, so a completed run saves the close together with its staged terminal.
+   */
+  public async prepareRunReversionClose(
+    run: IActiveRun,
+    status: 'completed' | 'failed' | 'cancelled',
+  ): Promise<(() => void) | undefined> {
+    if (run.stored.session.agent !== undefined) return undefined;
     const segment = run.stored.reversionSegments.find((entry) => entry.runId === run.runId);
-    if (!segment) return;
-    const eventIds = run.stored.agentSession.getEvents()
-      .filter((event) => event.generationId === run.runId)
-      .map((event) => event.id);
+    if (!segment) return undefined;
     if (!this.core.turnReversionProvider || segment.provenance === 'transcript') {
-      await this.core.mutateProjection(run.state, run.stored, () => {
-        const wasCompleted = segment.status === 'completed';
-        segment.status = status;
-        segment.eventIds = eventIds;
-        if (!wasCompleted && status === 'completed') run.stored.revertCursor++;
-        else if (wasCompleted && status !== 'completed') run.stored.revertCursor--;
+      return () => {
+        this.closeRunReversionSegment(run, status);
         delete run.stored.pendingReversion;
         this.pruneReversionState(run.stored);
-      }, true);
-      return;
+      };
     }
     if (!segment.captureId) {
       throw new FlexHarnessValidationError('Workspace reversion segment has no capture ownership.');
     }
     const captureId = segment.captureId;
     if (segment.workspaceReference !== undefined) {
-      await this.core.mutateProjection(run.state, run.stored, () => {
-        const wasCompleted = segment.status === 'completed';
-        segment.status = status;
-        segment.eventIds = eventIds;
-        if (!wasCompleted && status === 'completed') run.stored.revertCursor++;
-        else if (wasCompleted && status !== 'completed') run.stored.revertCursor--;
+      return () => {
+        this.closeRunReversionSegment(run, status);
         delete run.stored.pendingReversion;
-      }, true);
-      return;
+      };
     }
     const pending = run.stored.pendingReversion;
     if (pending?.kind !== 'capture' || pending.runId !== run.runId) {
@@ -1059,28 +1058,40 @@ export class FlexHarnessReversions<TScope> {
       pending.state === 'prepared' ? 'finalizing' : pending.state,
     );
     if (outcome === undefined) {
-      await this.core.mutateProjection(run.state, run.stored, () => {
+      return () => {
         run.stored.reversionSegments = run.stored.reversionSegments.filter(
           (entry) => entry.runId !== run.runId,
         );
         delete run.stored.pendingReversion;
-      }, true);
-      return;
+      };
     }
-    await this.core.mutateProjection(run.state, run.stored, () => {
+    return () => {
       const current = run.stored.pendingReversion;
       if (current?.kind !== 'capture' || current.runId !== run.runId) {
         throw new FlexHarnessValidationError('Reversion capture intent changed before finalization.');
       }
-      const wasCompleted = segment.status === 'completed';
-      segment.status = status;
-      segment.eventIds = eventIds;
-      this.applyFinalizedReversionOutcome(run.stored, segment, outcome);
-      if (!wasCompleted && status === 'completed') run.stored.revertCursor++;
-      else if (wasCompleted && status !== 'completed') run.stored.revertCursor--;
+      const closed = this.closeRunReversionSegment(run, status);
+      this.applyFinalizedReversionOutcome(run.stored, closed, outcome);
       delete run.stored.pendingReversion;
       this.pruneReversionState(run.stored);
-    }, true);
+    };
+  }
+
+  /** Records a run's terminal status and events on its segment and moves the revert cursor. */
+  private closeRunReversionSegment(
+    run: IActiveRun,
+    status: 'completed' | 'failed' | 'cancelled',
+  ): IFlexReversionSegment {
+    const segment = run.stored.reversionSegments.find((entry) => entry.runId === run.runId);
+    if (!segment) throw new FlexHarnessValidationError('Reversion segment changed before finalization.');
+    const wasCompleted = segment.status === 'completed';
+    segment.status = status;
+    segment.eventIds = run.stored.agentSession.getEvents()
+      .filter((event) => event.generationId === run.runId)
+      .map((event) => event.id);
+    if (!wasCompleted && status === 'completed') run.stored.revertCursor++;
+    else if (wasCompleted && status !== 'completed') run.stored.revertCursor--;
+    return segment;
   }
 
   private applyFinalizedReversionOutcome(

package/ts/classes.flexharness.runs.ts

@@ -119,6 +119,7 @@ export class FlexHarnessRuns<TScope> {
         cacheWriteTokens: 0,
       },
       reasoningPartIds: new Map(),
+      completedTextPartIds: new Set(),
       toolPartIds: new Map(),
       trustedToolExecutionErrors: new Map(),
       unconfirmedToolCalls: new Map(),
@@ -158,11 +159,13 @@ export class FlexHarnessRuns<TScope> {
       if (run.controller.signal.aborted) throw run.controller.signal.reason;
       const result = normalizeRunResult(rawResult);
       if (!run.modelResolution) throw new FlexHarnessValidationError('Generation completed without a resolved model.');
-      await this.core.reversions.finalizeRunReversion(run, 'completed');
+      const closeReversion = await this.core.reversions.prepareRunReversionClose(run, 'completed');
       await this.core.admission.closeRunDelegatedRunAdmission(run);
       const terminal = this.buildTerminal(run, 'completed', result);
       try {
+        // The reversion segment closes in the save that stages the terminal.
         await this.core.mutateProjection(run.state, run.stored, () => {
+          closeReversion?.();
           this.replaceStagedTerminal(run.stored, terminal);
         }, true);
       } catch (error) {
@@ -808,6 +811,7 @@ export class FlexHarnessRuns<TScope> {
         run.reservedAssistantMessage = publicSnapshot(nextAssistant);
         run.callbackParts = [];
         run.reasoningPartIds.clear();
+        run.completedTextPartIds.clear();
         this.core.emitEvent(run.scopeId, run.stored.session, {
           type: 'message.updated',
           runId: run.runId,
@@ -1026,7 +1030,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'
+        ? callbackPart?.type === 'text' && !run.completedTextPartIds.has(part.partId)
         : part.type === 'reasoning'
           ? callbackPart?.type === 'reasoning' && callbackPart.status === 'running'
           : part.type === 'tool'

package/ts/classes.flexharness.tooldispatch.ts

@@ -329,7 +329,8 @@ export class FlexHarnessToolDispatch<TScope> {
    * (validation, `onCall`, the method's run with its permission requests, the output limits, error
    * projection) and recorded as a tool part of its own, named by the method, with the `run_code`
    * call as its parent. Proposals go to `onProposals` as one batch once the program finished; a
-   * program that fails proposes nothing.
+   * program that fails proposes nothing. The calls are recorded in the program's share of the run's
+   * callback limits; a call the share cannot hold stops the program at its `callbacks` limit.
    */
   private async runCatalogProgram(
     run: IActiveRun,
@@ -369,9 +370,24 @@ export class FlexHarnessToolDispatch<TScope> {
     let callNumber = 0;
     // Read-only calls run concurrently; any other call runs after every call the program made before it.
     const order = new plugins.AgentToolCallScheduler(abortSignal);
+    const share = this.core.callbacks.programCallbackShare(run.state, run.sessionId);
+    let recorded = 0;
+    /** Records the start of a call; false when the run cannot record it, and the program stops. */
+    const record = (id: string, method: string, input: unknown): boolean => {
+      if (!this.core.callbacks.onProgramCallStart(run.state, run.sessionId, share, {
+        toolCallId: id, toolName: method, input, parentToolCallId: toolCallId,
+      })) return false;
+      recorded += 1;
+      return true;
+    };
+    const unrecorded = (): TFlexCodeCallOutcome => ({
+      ok: false,
+      limit: 'callbacks',
+      message: `The run cannot record more than ${recorded} call${recorded === 1 ? '' : 's'} of this program.`,
+    });
     const finish = (id: string, method: string, input: unknown, outcome: { output: unknown } | { error: Error }) => {
       if ('error' in outcome) run.trustedToolExecutionErrors.set(id, outcome.error);
-      this.core.callbacks.onToolFinish(run.state, run.sessionId, 'error' in outcome
+      this.core.callbacks.onProgramCallFinish(run.state, run.sessionId, share, 'error' in outcome
         ? { toolCallId: id, toolName: method, input, success: false, error: outcome.error.message }
         : { toolCallId: id, toolName: method, input, success: true, output: outcome.output });
     };
@@ -385,7 +401,7 @@ export class FlexHarnessToolDispatch<TScope> {
       const call = await catalog.prepareCall(method, params);
       if (!call.success) {
         if (catalog.has(method)) {
-          this.core.callbacks.onToolStart(run.state, run.sessionId, { toolCallId: id, toolName: method, input: params ?? {}, parentToolCallId: toolCallId });
+          if (!record(id, method, params ?? {})) return unrecorded();
           finish(id, method, params, { error: this.catalogCallError(run, id, call.error) });
         }
         return { ok: false, error: call.error as unknown as TJsonValue };
@@ -396,9 +412,7 @@ export class FlexHarnessToolDispatch<TScope> {
         return stopped(call.method);
       }
       if (signal.aborted) return stopped(call.method);
-      this.core.callbacks.onToolStart(run.state, run.sessionId, {
-        toolCallId: id, toolName: call.method, input: call.params, parentToolCallId: toolCallId,
-      });
+      if (!record(id, call.method, call.params)) return unrecorded();
       if ('error' in classification) {
         finish(id, call.method, call.params, { error: classification.error });
         return { ok: false, error: { error: 'failed', method: call.method, message: classification.error.message } };
@@ -462,7 +476,9 @@ export class FlexHarnessToolDispatch<TScope> {
       },
     };
     const result = await run.codeSandbox!.run(code, host, catalog.codeMode!, abortSignal);
-    if (!result.ok) throw this.catalogCallError(run, toolCallId, result.failure);
+    if (!result.ok) {
+      throw this.catalogCallError(run, toolCallId, normalizeJsonValue(result.failure, this.core.toolOutputLimits));
+    }
     return {
       result: result.value,
       calls: result.calls,

package/ts/classes.stores.ts

@@ -37,15 +37,14 @@ import {
   assertFlexProjectManagementTombstone,
 } from './utils.projectmanagement.js';
 import {
+  assertFlexToolJobSnapshot,
   createAgentEventSnapshot,
   createToolJobSnapshot,
   normalizeJsonObjectUndefined,
   validateAgentEventArchive,
   validateAgentEventSnapshot,
-  validateToolJobSnapshot,
 } from './utils.storecodecs.js';
 import {
-  assertProjectionSession,
   assertProjectManagementSaveAdmitted,
   assertSameArchiveEvents,
   isProjectManagementTombstoneAdmitted,
@@ -100,8 +99,11 @@ class InMemoryProjectionStore implements IFlexProjectionStore {
     expectedRevision: number,
   ): Promise<void> {
     const key = providerKey(storageKey, sessionId);
-    const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexProjectionSnapshot);
-    assertProjectionSession(validated, sessionId);
+    const validated = validateSnapshotSave(
+      snapshot,
+      expectedRevision,
+      (value) => assertFlexProjectionSnapshot(value, sessionId),
+    );
     const actualRevision = this.snapshots.get(key)?.revision ?? 0;
     if (actualRevision !== expectedRevision) {
       throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
@@ -820,8 +822,7 @@ class JsonProjectionStore implements IFlexProjectionStore {
     const filePath = this.root.sessionPath('projections', storageKey, sessionId);
     return JsonFileRoot.inQueue(filePath, async () => {
       const snapshot = await this.root.read(filePath, (value) => {
-        assertFlexProjectionSnapshot(value);
-        assertProjectionSession(value, sessionId);
+        assertFlexProjectionSnapshot(value, sessionId);
         return value;
       });
       return snapshot ? cloneSerializable(snapshot) : undefined;
@@ -834,13 +835,15 @@ class JsonProjectionStore implements IFlexProjectionStore {
     snapshot: IFlexProjectionSnapshotV3,
     expectedRevision: number,
   ): Promise<void> {
-    const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexProjectionSnapshot);
-    assertProjectionSession(validated, sessionId);
+    const validated = validateSnapshotSave(
+      snapshot,
+      expectedRevision,
+      (value) => assertFlexProjectionSnapshot(value, sessionId),
+    );
     const filePath = this.root.sessionPath('projections', storageKey, sessionId);
     await JsonFileRoot.inQueue(filePath, async () => {
       const current = await this.root.read(filePath, (value) => {
-        assertFlexProjectionSnapshot(value);
-        assertProjectionSession(value, sessionId);
+        assertFlexProjectionSnapshot(value, sessionId);
         return value;
       });
       const actualRevision = current?.revision ?? 0;
@@ -1214,7 +1217,10 @@ class JsonToolJobStore implements plugins.IToolJobStore {
     const filePath = this.filePath();
     return JsonFileRoot.inQueue(filePath, async () => {
       abortSignal?.throwIfAborted();
-      const snapshot = await this.root.read(filePath, validateToolJobSnapshot);
+      const snapshot = await this.root.read(filePath, (value) => {
+        assertFlexToolJobSnapshot(value);
+        return value;
+      });
       abortSignal?.throwIfAborted();
       return snapshot ? cloneSerializable(snapshot) : undefined;
     });
@@ -1231,7 +1237,10 @@ class JsonToolJobStore implements plugins.IToolJobStore {
     const filePath = this.filePath();
     return JsonFileRoot.inQueue(filePath, async () => {
       abortSignal?.throwIfAborted();
-      const current = await this.root.read(filePath, validateToolJobSnapshot);
+      const current = await this.root.read(filePath, (value) => {
+        assertFlexToolJobSnapshot(value);
+        return value;
+      });
       const actualRevision = current?.revision ?? 0;
       if (actualRevision !== expectedRevision) {
         throw new plugins.ToolJobStoreConflictError(expectedRevision, actualRevision);

package/ts/errors.ts

@@ -217,6 +217,20 @@ export class FlexHarnessStoreCommitUncertainError extends FlexHarnessError {
   }
 }
 
+/** A record the store refused to create because a fenced purge removed its storage namespace. */
+export class FlexHarnessStorePurgedError extends FlexHarnessError {
+  public readonly path: string;
+
+  constructor(path: string) {
+    super(
+      'FLEX_STORE_PURGED',
+      `Store write at "${path}" was refused: a fenced purge removed its storage namespace.`,
+    );
+    this.name = 'FlexHarnessStorePurgedError';
+    this.path = path;
+  }
+}
+
 export class FlexHarnessRunError extends AggregateError {
   public readonly code = 'FLEX_RUN_FAILED';
 

package/ts/index.ts

@@ -9,13 +9,19 @@ export {
   type TFlexToolPermissionDecision,
   type TFlexToolPermissionRequester,
 } from './functions.toolpermissions.js';
-export { normalizeJsonValue } from './utils.json.js';
+export {
+  assertFlexPermissionSnapshot,
+  assertFlexProjectionSnapshot,
+  assertFlexScopeSnapshot,
+  normalizeJsonValue,
+} from './utils.json.js';
 export {
   assertFlexProjectManagementSnapshot,
   assertFlexProjectManagementRecord,
   assertFlexProjectManagementTombstone,
   createEmptyFlexProjectManagementSnapshot,
 } from './utils.projectmanagement.js';
+export { assertFlexToolJobSnapshot } from './utils.storecodecs.js';
 export {
   FLEX_SLASH_COMMAND_MAX_INPUT_BYTES,
   isReservedSlashCommandName,

package/ts/interfaces.flexharness.ts

@@ -224,6 +224,11 @@ export interface IActiveRun {
   usage: IFlexUsage;
   metricsOperation?: ISessionMetricsOperation;
   reasoningPartIds: Map<string, string>;
+  /**
+   * The text parts whose model step is committed. Each emitted its `part.completed`; text that
+   * follows starts a new part.
+   */
+  completedTextPartIds: Set<string>;
   toolPartIds: Map<string, string>;
   trustedToolExecutionErrors: Map<string, Error>;
   /**
@@ -281,6 +286,16 @@ export interface IRunReadCall {
   readonly output: Promise<unknown>;
 }
 
+/**
+ * What is left of the room a `run_code` program's calls may take in its run's callback limits:
+ * events, output bytes and parts.
+ */
+export interface IProgramCallbackShare {
+  events: number;
+  outputBytes: number;
+  parts: number;
+}
+
 /** The steers of a run: the input its generation takes in, and the prompts it accepted for it. */
 export interface IRunSteering {
   readonly input: plugins.AgentPendingInputQueue;

package/ts/interfaces.ts

@@ -706,10 +706,28 @@ export interface IFlexToolProvider<TScope> {
 /** The catalog method that reads stored results, reserved while a run stores results. */
 export const FLEX_RESULT_METHOD = 'results.get';
 
+/**
+ * Bounds what a session stores in the result store: at most `maxResultsPerSession` results of at
+ * most `maxStoredBytes` each.
+ */
+export interface IFlexResultLimits {
+  /**
+   * The most JSON bytes of one output a result stores; beyond it the stored value is truncated. At
+   * least `toolOutputLimits.maxBytes`. Defaults to `FLEX_RESULT_LIMITS.maxStoredBytes`, or to
+   * `toolOutputLimits.maxBytes` if that is larger.
+   */
+  maxStoredBytes?: number;
+  /**
+   * The results a session keeps; a new one beyond them deletes the oldest. Defaults to
+   * `FLEX_RESULT_LIMITS.maxResultsPerSession`.
+   */
+  maxResultsPerSession?: number;
+}
+
 export const FLEX_RESULT_LIMITS = Object.freeze({
-  /** The most of one output a result stores; beyond it the stored value is truncated. */
+  /** The default of `resultLimits.maxStoredBytes`. */
   maxStoredBytes: 8 * 1024 * 1024,
-  /** The results a session keeps; a new one beyond them deletes the oldest. */
+  /** The default of `resultLimits.maxResultsPerSession`. */
   maxResultsPerSession: 32,
   /** The size of the summary the model gets in place of the output. */
   summaryBytes: 2 * 1024,
@@ -1044,8 +1062,11 @@ export const FLEX_CODE_MODE_MAXIMUM_LIMITS: Readonly<IFlexCodeModeLimits> = Obje
 /** What `run_code` reports to the model, as JSON, when a program does not finish. */
 export interface IFlexCodeRunFailure {
   error: 'syntax_error' | 'program_error' | 'limit_exceeded' | 'aborted';
-  /** The limit that stopped the program, for `limit_exceeded`. */
-  limit?: 'source' | 'cpu' | 'wall' | 'memory' | 'stack' | 'calls';
+  /**
+   * The limit that stopped the program, for `limit_exceeded`; `callbacks` when its run could not
+   * record another of its calls.
+   */
+  limit?: 'source' | 'cpu' | 'wall' | 'memory' | 'stack' | 'calls' | 'callbacks';
   name?: string;
   message: string;
   /** The program's line, when known. */
@@ -1456,9 +1477,9 @@ export interface IFlexToolJobStoreProvider {
 /**
  * Tool outputs over the output budget, stored whole for the session that produced them. A result
  * is written once under its handle and read by `results.get`; FlexHarness keeps a session's latest
- * `FLEX_RESULT_LIMITS.maxResultsPerSession` results and deletes older ones. A FlexHarness writes a
- * session's results one operation at a time, so a store need not order concurrent writes of one
- * session.
+ * `resultLimits.maxResultsPerSession` results, each of at most `resultLimits.maxStoredBytes` JSON
+ * bytes, and deletes older ones. A FlexHarness writes a session's results one operation at a time,
+ * so a store need not order concurrent writes of one session.
  */
 export interface IFlexResultStore {
   save(storageKey: string, sessionId: string, handle: string, value: TJsonValue): Promise<void>;
@@ -1478,8 +1499,8 @@ export interface IFlexHarnessStores {
   jobs: IFlexToolJobStoreProvider;
   /**
    * Stores the outputs of a run with a tool catalog that exceed the output budget: the model gets a
-   * summary and a handle it reads with `results.get`. Without it, such outputs are truncated to
-   * the budget. The built-in stores provide it.
+   * summary and a handle it reads with `results.get`; `resultLimits` bounds what a session stores.
+   * Without it, such outputs are truncated to the budget. The built-in stores provide it.
    */
   results?: IFlexResultStore;
 }
@@ -1826,6 +1847,8 @@ export interface IFlexHarnessOptions<TScope> {
   promptQueueLimits?: IFlexPromptQueueLimits;
   reversionLimits?: IFlexReversionLimits;
   sessionImportLimits?: IFlexSessionImportLimits;
+  /** Bounds the outputs over the budget that a session stores; see `stores.results`. */
+  resultLimits?: IFlexResultLimits;
   /**
    * Bounds each turn-reversion maintenance operation. Falls back to
    * agentSessionPolicy.generationLeaseCleanupTimeoutMs, then 30 seconds.

package/ts/plugins.ts

@@ -3,8 +3,9 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { Worker } from 'node:worker_threads';
 
-export { AsyncLocalStorage, crypto, fs, path };
+export { AsyncLocalStorage, crypto, fs, path, Worker };
 
 // third party scope
 import { asSchema, jsonSchema } from 'ai';
@@ -70,23 +71,19 @@ export interface IAmaroError {
 }
 
 export interface ICodeSandboxEngine {
-  /** A new WebAssembly instance of QuickJS-ng, with a memory of its own. */
-  newModule(): Promise<IQuickJsModule>;
   /** Removes TypeScript type syntax, keeping every line where it was. */
   stripTypes(source: string): string;
 }
 
-/** Loads QuickJS and amaro, the optional peers code mode needs. */
+/**
+ * Loads amaro, and finds QuickJS: the optional peers code mode needs. Every program's worker loads
+ * QuickJS itself.
+ */
 export const importCodeSandboxEngine = async (): Promise<ICodeSandboxEngine> => {
-  const [core, variant, amaro] = await Promise.all([
-    import('quickjs-emscripten-core'),
-    import('@jitl/quickjs-ng-wasmfile-release-sync'),
-    import('amaro'),
-  ]);
-  // The variant's typings resolve as CommonJS; at run time the default export is the variant.
-  const quickjsVariant = (variant as { default: unknown }).default as Parameters<typeof core.newQuickJSWASMModuleFromVariant>[0];
+  import.meta.resolve('quickjs-emscripten-core');
+  import.meta.resolve('@jitl/quickjs-ng-wasmfile-release-sync');
+  const amaro = await import('amaro');
   return {
-    newModule: async () => await core.newQuickJSWASMModuleFromVariant(quickjsVariant) as unknown as IQuickJsModule,
     stripTypes: (source) => amaro.transformSync(source, { mode: 'strip-only' }).code,
   };
 };