@modelprofile.com/flexharness 4.0.1 → 4.1.0

package/dist_ts/interfaces.d.ts

@@ -12,6 +12,7 @@ export type TFlexAgentModelMessage = ReturnType<plugins.IAgentSession['getModelM
 export type TFlexAgentToolSet = NonNullable<TFlexAgentSessionOptions['tools']>;
 export type TFlexAgentProviderOptions = TFlexAgentSessionOptions['providerOptions'];
 export type TFlexAgentCacheSetting = TFlexAgentSessionOptions['cache'];
+export type TFlexAgentToolCallUpdateEvent = Parameters<NonNullable<TFlexAgentSessionOptions['onToolCallUpdate']>>[0];
 export type TFlexAgentToolCallFinishEvent = Parameters<NonNullable<TFlexAgentSessionOptions['onToolCallFinish']>>[0];
 export interface IFlexTextPromptPart {
     type: 'text';
@@ -441,6 +442,10 @@ export interface IFlexPermissionSnapshot {
 }
 export declare const FLEX_PROJECT_MANAGEMENT_SCHEMA_VERSION: 1;
 export declare const FLEX_SESSION_GENERATION_ID_MAX_BYTES = 128;
+export interface IFlexSessionGeneration {
+    sessionGenerationId: string;
+    sessionGenerationSequence: number;
+}
 export declare const FLEX_PROJECT_MANAGEMENT_LIMITS: Readonly<{
     maxGoalBytes: number;
     maxScratchpadBytes: number;
@@ -485,7 +490,7 @@ export interface IFlexProjectManagementWriteContext {
     toolCallId?: string;
 }
 export interface IFlexProjectManagementStore {
-    load(storageKey: string, sessionId: string): Promise<TFlexProjectManagementRecord | undefined>;
+    load(storageKey: string, sessionId: string, sessionGeneration?: Readonly<IFlexSessionGeneration>): Promise<TFlexProjectManagementRecord | undefined>;
     save(storageKey: string, sessionId: string, snapshot: IFlexProjectManagementSnapshot, expectedRevision: number, writeContext: IFlexProjectManagementWriteContext): Promise<void>;
     tombstoneSession(storageKey: string, sessionId: string, tombstone: IFlexProjectManagementTombstone, expectedRevision: number): Promise<void>;
     purgeNamespace(storageKey: string): Promise<void>;

package/dist_ts/interfaces.js

@@ -26,4 +26,4 @@ export const FLEX_REVERSION_MAX_AFFECTED_WORKSPACES = 64;
 export const FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES = 512;
 export const FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES = 2048;
 export const FLEX_REVERSION_REASON_CODE_MAX_BYTES = 128;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBMGpCQSxNQUFNLENBQUMsTUFBTSxzQ0FBc0MsR0FBRyxDQUFVLENBQUM7QUFDakUsTUFBTSxDQUFDLE1BQU0sb0NBQW9DLEdBQUcsR0FBRyxDQUFDO0FBRXhELE1BQU0sQ0FBQyxNQUFNLDhCQUE4QixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDMUQsWUFBWSxFQUFFLENBQUMsR0FBRyxJQUFJO0lBQ3RCLGtCQUFrQixFQUFFLEdBQUcsR0FBRyxJQUFJO0lBQzlCLG1CQUFtQixFQUFFLENBQUMsR0FBRyxJQUFJO0lBQzdCLGNBQWMsRUFBRSxHQUFHO0lBQ25CLFFBQVEsRUFBRSxHQUFHO0lBQ2IsYUFBYSxFQUFFLElBQUk7SUFDbkIsZ0JBQWdCLEVBQUUsSUFBSSxHQUFHLElBQUk7Q0FDOUIsQ0FBQyxDQUFDO0FBeUxILE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDekQsaUJBQWlCLEVBQUUsR0FBRztJQUN0QixXQUFXLEVBQUUsR0FBRztJQUNoQixpQkFBaUIsRUFBRSxJQUFJO0lBQ3ZCLDJCQUEyQixFQUFFLElBQUk7Q0FDbEMsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUN6RCxpQkFBaUIsRUFBRSxJQUFJO0lBQ3ZCLFdBQVcsRUFBRSxJQUFJO0lBQ2pCLGlCQUFpQixFQUFFLE1BQU07SUFDekIsMkJBQTJCLEVBQUUsTUFBTTtDQUNwQyxDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsTUFBTSxrQ0FBa0MsR0FBRyxHQUFHLEdBQUcsSUFBSSxDQUFDO0FBQzdELE1BQU0sQ0FBQyxNQUFNLHNDQUFzQyxHQUFHLEVBQUUsQ0FBQztBQUN6RCxNQUFNLENBQUMsTUFBTSxxQ0FBcUMsR0FBRyxHQUFHLENBQUM7QUFDekQsTUFBTSxDQUFDLE1BQU0sd0NBQXdDLEdBQUcsSUFBSSxDQUFDO0FBQzdELE1BQU0sQ0FBQyxNQUFNLG9DQUFvQyxHQUFHLEdBQUcsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBNmpCQSxNQUFNLENBQUMsTUFBTSxzQ0FBc0MsR0FBRyxDQUFVLENBQUM7QUFDakUsTUFBTSxDQUFDLE1BQU0sb0NBQW9DLEdBQUcsR0FBRyxDQUFDO0FBT3hELE1BQU0sQ0FBQyxNQUFNLDhCQUE4QixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDMUQsWUFBWSxFQUFFLENBQUMsR0FBRyxJQUFJO0lBQ3RCLGtCQUFrQixFQUFFLEdBQUcsR0FBRyxJQUFJO0lBQzlCLG1CQUFtQixFQUFFLENBQUMsR0FBRyxJQUFJO0lBQzdCLGNBQWMsRUFBRSxHQUFHO0lBQ25CLFFBQVEsRUFBRSxHQUFHO0lBQ2IsYUFBYSxFQUFFLElBQUk7SUFDbkIsZ0JBQWdCLEVBQUUsSUFBSSxHQUFHLElBQUk7Q0FDOUIsQ0FBQyxDQUFDO0FBMExILE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDekQsaUJBQWlCLEVBQUUsR0FBRztJQUN0QixXQUFXLEVBQUUsR0FBRztJQUNoQixpQkFBaUIsRUFBRSxJQUFJO0lBQ3ZCLDJCQUEyQixFQUFFLElBQUk7Q0FDbEMsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUN6RCxpQkFBaUIsRUFBRSxJQUFJO0lBQ3ZCLFdBQVcsRUFBRSxJQUFJO0lBQ2pCLGlCQUFpQixFQUFFLE1BQU07SUFDekIsMkJBQTJCLEVBQUUsTUFBTTtDQUNwQyxDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsTUFBTSxrQ0FBa0MsR0FBRyxHQUFHLEdBQUcsSUFBSSxDQUFDO0FBQzdELE1BQU0sQ0FBQyxNQUFNLHNDQUFzQyxHQUFHLEVBQUUsQ0FBQztBQUN6RCxNQUFNLENBQUMsTUFBTSxxQ0FBcUMsR0FBRyxHQUFHLENBQUM7QUFDekQsTUFBTSxDQUFDLE1BQU0sd0NBQXdDLEdBQUcsSUFBSSxDQUFDO0FBQzdELE1BQU0sQ0FBQyxNQUFNLG9DQUFvQyxHQUFHLEdBQUcsQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -5,4 +5,4 @@ import * as path from 'node:path';
 export { AsyncLocalStorage, crypto, fs, path };
 import { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z } from '@push.rocks/smartagent';
 export { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, };
-export type { IAgentEventArchiveV2, IAgentContextCompactionOptions, IAgentEventSnapshotV2, IAgentEventStoreV2, IAgentGenerateResult, IAgentGenerationHandle, IAgentGenerationLease, IAgentRunResult, IAgentSession, IAgentSessionOptions, IAgentRuntimeEventPayload, IGenerationBegunEvent, IGenerationExecutionCompletedEvent, IGenerationExecutionStartedEvent, IGenerationOutcomeEvent, IToolExecutionContext, IToolExecutionIntentEvent, IToolJobSnapshot, IToolJobState, IToolJobStore, TAgentContextBuilder, TAgentContextCompactor, TAgentEvent, TAgentGenerationOutcome, TAgentToolCallFinishEvent, TAgentToolExecutionReconciliationOptions, } from '@push.rocks/smartagent';
+export type { IAgentEventArchiveV2, IAgentContextCompactionOptions, IAgentEventSnapshotV2, IAgentEventStoreV2, IAgentGenerateResult, IAgentGenerationHandle, IAgentGenerationLease, IAgentRunResult, IAgentSession, IAgentSessionOptions, IAgentToolCallUpdateEvent, IAgentRuntimeEventPayload, IGenerationBegunEvent, IGenerationExecutionCompletedEvent, IGenerationExecutionStartedEvent, IGenerationOutcomeEvent, IToolExecutionContext, IToolExecutionIntentEvent, IToolJobSnapshot, IToolJobState, IToolJobStore, TAgentContextBuilder, TAgentContextCompactor, TAgentEvent, TAgentGenerationOutcome, TAgentToolCallFinishEvent, TAgentToolExecutionReconciliationOptions, } from '@push.rocks/smartagent';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/flexharness",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "private": false,
   "description": "Provider-neutral model-session runtime with durable history, permissions, typed events, and pluggable local or remote tool execution.",
   "main": "dist_ts/index.js",
@@ -22,7 +22,7 @@
     "node": ">=24"
   },
   "dependencies": {
-    "@push.rocks/smartagent": "^4.6.0",
+    "@push.rocks/smartagent": "^5.0.0",
     "@types/json-schema": "7.0.15"
   },
   "devDependencies": {

package/readme.hints.md

@@ -38,6 +38,7 @@ Implementation findings for flexharness.
 ## Tool output boundary
 
 - Every tool `execute` result and every async-iterable yield is converted to bounded JSON before SmartAgent observes it. Thrown errors and iterator failures are not converted or swallowed.
+- SmartAgent preliminary tool outputs mutate only the run-local running tool part and emit cumulative `part.updated` snapshots. Terminal success replaces them with the authoritative final output; failure, cancellation, and callback overflow remove them before persistence.
 - JSON byte limits are propagated through traversal. Large strings never enter normalized output, and array/object traversal stops once the remaining allowance is reserved for deterministic truncation metadata.
 - Model callbacks use bounded synchronous run-local parts. Adjacent text/reasoning deltas coalesce; no per-delta snapshot is written. Callback event, byte, or part overflow aborts internally and is classified as failure, not owner cancellation.
 

package/readme.md

@@ -241,7 +241,7 @@ Public writes use `{ actor: 'application' }`. Tool writes use `{ actor: 'agent',
 
 `FLEX_PROJECT_MANAGEMENT_LIMITS` exports the hard UTF-8 and aggregate limits: goal 8 KiB, scratchpad 128 KiB, task content 8 KiB, task ID 512 bytes, title 2048 bytes, 512 tasks, and a 1 MiB serialized snapshot. The aggregate bound leaves room for worst-case JSON escaping of a controller-valid scratchpad. Loaded snapshots reject extra fields, duplicate IDs, invalid status/priority/timestamps, non-JSON data, wrong schema/revision, and every exceeded bound before use.
 
-`IFlexProjectManagementStore` is exact per `(storageKey, sessionId)`: `load`, CAS `save`, CAS `tombstoneSession`, and `purgeNamespace` must not collapse multiple sessions or storage namespaces. `load()` returns `TFlexProjectManagementRecord | undefined`. Same-generation live saves use normal revision CAS, and a same-generation tombstone permanently rejects later live saves. A higher `sessionGenerationSequence` with a different strong `sessionGenerationId` may replace only an older tombstone using expected revision `0`; it cannot replace a live record. This resets the PM revision for a recreated core session while stale saves and tombstones from older generations remain fenced. Deleting a recreated session that made no PM writes still replaces the prior-generation tombstone with a revision-1 tombstone for the new generation.
+`IFlexProjectManagementStore` is exact per `(storageKey, sessionId)`: `load`, CAS `save`, CAS `tombstoneSession`, and `purgeNamespace` must not collapse multiple sessions or storage namespaces. `load()` returns `TFlexProjectManagementRecord | undefined` and receives the current session generation as an optional third argument; FlexHarness always supplies it, while two-argument callers and stores remain compatible. Same-generation live saves use normal revision CAS, and a same-generation tombstone permanently rejects later live saves. A higher `sessionGenerationSequence` with a different strong `sessionGenerationId` may replace only an older tombstone using expected revision `0`; it cannot replace a live record. This resets the PM revision for a recreated core session while stale saves and tombstones from older generations remain fenced. Deleting a recreated session that made no PM writes still replaces the prior-generation tombstone with a revision-1 tombstone for the new generation.
 
 Every newly created core session exposes and persists a strong random `sessionGenerationId` plus its monotonic `sessionGenerationSequence`. A legacy scope session without those fields is assigned a deterministic bounded ID derived from its immutable `storageKey`, `sessionId`, and `createdAt`; FlexHarness persists the repaired scope snapshot before accepting work. Grouped core deletion tombstones retain both fields after live metadata is removed.
 
@@ -632,7 +632,7 @@ FlexHarness wraps every provided tool `execute` method before SmartAgent receive
 
 `toolOutputLimits` in the complete setup above bounds traversal depth and encoded bytes. The normalizer enforces its byte allowance incrementally: oversized strings are replaced before entering output, and arrays/objects stop reading entries once only truncation metadata fits.
 
-Streaming callbacks use run-local synchronous state rather than one persistence promise per delta. Adjacent text and reasoning deltas coalesce. `callbackLimits` bounds callback events, accumulated output bytes, and part count; overflow aborts internally with `FlexHarnessCallbackOverflowError` and the turn is recorded as failed. Reservation and terminal finalization are the normal persistence checkpoints, with permission state changes as explicit additional checkpoints.
+Streaming callbacks use run-local synchronous state rather than one persistence promise per delta. Adjacent text and reasoning deltas coalesce. Preliminary async-iterable tool outputs appear as bounded cumulative `part.updated` snapshots while the tool remains `running`; only the authoritative `part.completed` output enters the terminal projection, and failed or interrupted tools discard their preliminary output. `callbackLimits` bounds callback events, accumulated output bytes, and part count; overflow aborts internally with `FlexHarnessCallbackOverflowError` and the turn is recorded as failed. Reservation and terminal finalization are the normal persistence checkpoints, with permission state changes as explicit additional checkpoints.
 
 Model resolver, tool provider, AgentSession, tool execution, tool callback, tool cleanup, and run-persistence failures cross an untrusted error boundary. By default they become a fixed immutable `FlexHarnessExternalError` before completion rejection, persistence, events, or detached-cleanup reporting. Raw external messages and aggregate members are not retained. A failed `onToolCallFinish` callback stores and accounts for only the bounded projected message; it does not otherwise reject completion, although exceeding the configured callback limits still fails the run. Scope resolution and the initial store load happen before a run exists and remain outside this boundary.
 
@@ -685,7 +685,7 @@ const unsubscribe = harness.subscribe((event) => {
 unsubscribe();
 ```
 
-Events are discriminated, sequenced, deeply immutable snapshots. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. 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. 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. `part.updated` is cumulative metadata replacement rather than a text delta. `session.history.changed` carries `direction: 'undo' | 'redo' | 'branch'`; `runId` is present for undo and redo. Events contain public IDs and snapshots only; they do not expose prompt payloads, the resolved scope object, storage key, model object, provider options, or raw storage key.
+Events are discriminated, sequenced, deeply immutable snapshots. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. 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. 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. `part.updated` is 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 and snapshots only; they do not expose prompt payloads, the resolved scope object, storage key, model object, provider options, or raw storage key.
 
 ## Stores
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '4.0.1',
+  version: '4.1.0',
   description: 'Provider-neutral model-session runtime with durable history, permissions, typed events, and pluggable local or remote tool execution.'
 }

package/ts/classes.flexharness.ts

@@ -96,6 +96,7 @@ import type {
   IFlexUsage,
   IJsonObject,
   TFlexAgentRunResult,
+  TFlexAgentToolCallUpdateEvent,
   TFlexAgentToolCallFinishEvent,
   TFlexAgentToolSet,
   TFlexAttachmentSource,
@@ -556,7 +557,7 @@ function requireSessionGeneration(
 function isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {
   return Boolean(
     value
-    && typeof value === 'object'
+    && (typeof value === 'object' || typeof value === 'function')
     && typeof (value as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function',
   );
 }
@@ -601,6 +602,9 @@ function wrapToolSet(
         return Promise.resolve(output).then(
           (value) => {
             try {
+              if (isAsyncIterable(value)) {
+                return normalizeAsyncIterable(value, limits, projectError);
+              }
               return normalizeJsonValue(value, limits);
             } catch (error) {
               throw projectError(error);
@@ -4391,7 +4395,11 @@ export class FlexHarness<TScope = unknown> {
   ): Promise<IFlexProjectManagementSnapshot> {
     const store = this.stores.projectManagement;
     const generation = requireSessionGeneration(stored.session);
-    const record = await store.load(state.storageKey, stored.session.sessionId);
+    const record = await store.load(
+      state.storageKey,
+      stored.session.sessionId,
+      Object.freeze({ ...generation }),
+    );
     if (record === undefined) {
       return createEmptyFlexProjectManagementSnapshot(
         generation.sessionGenerationId,
@@ -5663,6 +5671,7 @@ export class FlexHarness<TScope = unknown> {
         part.status = status === 'completed' ? 'completed' : 'cancelled';
       } else if (part.type === 'tool' && part.status === 'running') {
         part.status = status === 'cancelled' ? 'cancelled' : 'failed';
+        delete part.output;
         part.error = status === 'cancelled'
           ? 'Tool execution was cancelled.'
           : 'Tool execution ended without a terminal event.';
@@ -6924,6 +6933,7 @@ export class FlexHarness<TScope = unknown> {
         part.output = output!;
       } else {
         part.status = 'failed';
+        delete part.output;
         part.error = projectedError!.message;
       }
       this.emitPartEvent(run, 'part.completed', part);
@@ -6932,6 +6942,31 @@ export class FlexHarness<TScope = unknown> {
     }
   }
 
+  private onToolUpdate(
+    state: IStorageState,
+    sessionId: string,
+    event: TFlexAgentToolCallUpdateEvent,
+  ): void {
+    let run = this.callbackRun(state, sessionId);
+    if (!run) return;
+    if (!run.toolPartIds.has(event.toolCallId)) {
+      this.onToolStart(state, sessionId, event);
+      run = this.callbackRun(state, sessionId);
+      if (!run) return;
+    }
+    const partId = run.toolPartIds.get(event.toolCallId);
+    const part = run.callbackParts.find((entry) => entry.partId === partId && entry.type === 'tool');
+    if (!part || part.type !== 'tool' || part.status !== 'running') return;
+    try {
+      const output = normalizeJsonValue(event.output, this.toolOutputLimits);
+      if (!this.reserveCallbackCapacity(run, 1, jsonBytes(output), 0)) return;
+      part.output = output;
+      this.emitPartEvent(run, 'part.updated', part);
+    } catch (error) {
+      this.failCallback(run, this.projectExternalError(run, error, 'toolCallback'));
+    }
+  }
+
   private callbackRun(state: IStorageState, sessionId: string): IActiveRun | undefined {
     const run = state.activeRuns.get(sessionId);
     return !run || run.callbacksClosed || run.callbackError ? undefined : run;
@@ -8096,6 +8131,7 @@ export class FlexHarness<TScope = unknown> {
         onReasoningDelta: (id, delta) => this.onReasoningDelta(state, sessionId, id, delta),
         onReasoningEnd: (id, text) => this.onReasoningEnd(state, sessionId, id, text),
         onToolCallStart: (event) => this.onToolStart(state, sessionId, event),
+        onToolCallUpdate: (event) => this.onToolUpdate(state, sessionId, event),
         onToolCallFinish: (event) => this.onToolFinish(state, sessionId, event),
       };
       stored.agentSession = await this.withCompactorContext(
@@ -8795,7 +8831,11 @@ export class FlexHarness<TScope = unknown> {
     const generation = requireSessionGeneration(sessionTombstone);
     let lastConflict: FlexHarnessStoreConflictError | undefined;
     for (let attempt = 0; attempt <= maxProjectManagementTombstoneConflicts; attempt++) {
-      const current = await store.load(storageKey, sessionId);
+      const current = await store.load(
+        storageKey,
+        sessionId,
+        Object.freeze({ ...generation }),
+      );
       if (current !== undefined) {
         assertFlexProjectManagementRecord(current);
         if (current.sessionGenerationId === generation.sessionGenerationId) {

package/ts/interfaces.ts

@@ -16,6 +16,9 @@ export type TFlexAgentModelMessage = ReturnType<plugins.IAgentSession['getModelM
 export type TFlexAgentToolSet = NonNullable<TFlexAgentSessionOptions['tools']>;
 export type TFlexAgentProviderOptions = TFlexAgentSessionOptions['providerOptions'];
 export type TFlexAgentCacheSetting = TFlexAgentSessionOptions['cache'];
+export type TFlexAgentToolCallUpdateEvent = Parameters<
+  NonNullable<TFlexAgentSessionOptions['onToolCallUpdate']>
+>[0];
 export type TFlexAgentToolCallFinishEvent = Parameters<
   NonNullable<TFlexAgentSessionOptions['onToolCallFinish']>
 >[0];
@@ -571,6 +574,11 @@ export interface IFlexPermissionSnapshot {
 export const FLEX_PROJECT_MANAGEMENT_SCHEMA_VERSION = 1 as const;
 export const FLEX_SESSION_GENERATION_ID_MAX_BYTES = 128;
 
+export interface IFlexSessionGeneration {
+  sessionGenerationId: string;
+  sessionGenerationSequence: number;
+}
+
 export const FLEX_PROJECT_MANAGEMENT_LIMITS = Object.freeze({
   maxGoalBytes: 8 * 1024,
   maxScratchpadBytes: 128 * 1024,
@@ -628,6 +636,7 @@ export interface IFlexProjectManagementStore {
   load(
     storageKey: string,
     sessionId: string,
+    sessionGeneration?: Readonly<IFlexSessionGeneration>,
   ): Promise<TFlexProjectManagementRecord | undefined>;
   save(
     storageKey: string,

package/ts/plugins.ts

@@ -47,6 +47,7 @@ export type {
   IAgentRunResult,
   IAgentSession,
   IAgentSessionOptions,
+  IAgentToolCallUpdateEvent,
   IAgentRuntimeEventPayload,
   IGenerationBegunEvent,
   IGenerationExecutionCompletedEvent,