@modelprofile.com/flexharness 15.0.0 → 16.0.1

package/ts/classes.flexharness.prompts.ts

@@ -13,6 +13,8 @@ import {
 } from './errors.js';
 import type {
   IFlexAgentContextInvocation,
+  IFlexContinuePromptOptions,
+  IFlexContinuePromptResult,
   IFlexEnqueuePromptOptions,
   IFlexSteerAdmission,
   IFlexSteerInput,
@@ -24,6 +26,7 @@ import type {
   IFlexScheduledPromptAdmission,
   IFlexSchedulePromptOptions,
   TFlexPrompt,
+  TFlexAgentPrompt,
 } from './interfaces.js';
 import { cloneSerializable } from './utils.json.js';
 import { normalizeFlexPrompt, type INormalizedFlexPrompt } from './utils.prompt.js';
@@ -71,13 +74,15 @@ export class FlexHarnessPromptQueue<TScope> {
   constructor(private readonly core: FlexHarnessCore<TScope>) {}
 
   public promptAdmissionByteSize(
-    prompt: TFlexPrompt,
+    prompt: TFlexPrompt | undefined,
     options: IFlexPromptOptions,
     scheduleKey?: string,
     debounceMs?: number,
   ): number {
     return jsonBytes({
-      prompt: normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols),
+      ...(prompt === undefined
+        ? {}
+        : { prompt: normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols) }),
       options: cloneSerializable(options),
       scheduleKey,
       debounceMs,
@@ -100,12 +105,52 @@ export class FlexHarnessPromptQueue<TScope> {
     return admission.completion;
   }
 
+  public async continuePrompt(
+    scopeId: string,
+    sessionId: string,
+    options: IFlexContinuePromptOptions = {},
+  ): Promise<IFlexPromptQueueAdmission<IFlexContinuePromptResult>> {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+      throw new FlexHarnessValidationError('Continuation options must be a plain object.');
+    }
+    const { scheduleKey, debounceMs, ...enqueueOptions } = options;
+    if ('promptId' in enqueueOptions) {
+      throw new FlexHarnessValidationError('A continuation has no new prompt to identify.');
+    }
+    const admitted = this.splitEnqueueOptions(enqueueOptions);
+    if (scheduleKey === undefined && debounceMs !== undefined) {
+      throw new FlexHarnessValidationError('debounceMs requires scheduleKey.');
+    }
+    if (scheduleKey !== undefined) {
+      validateIdentifier(scheduleKey, 'scheduleKey');
+      requireTransferIdentifier(scheduleKey, 'scheduleKey');
+      this.validateScheduleDebounce(debounceMs ?? 50);
+    }
+    const queued = await this.enqueuePromptInternal(
+      scopeId, sessionId, undefined, admitted.options,
+      scheduleKey, scheduleKey === undefined ? undefined : debounceMs ?? 50,
+      undefined, undefined, false, false, admitted.steers,
+    );
+    return queued.admission;
+  }
+
+  private validateScheduleDebounce(debounceMs: number): void {
+    if (!Number.isSafeInteger(debounceMs) || debounceMs < 0 || debounceMs > maxScheduleDebounceMs) {
+      throw new FlexHarnessValidationError(
+        `debounceMs must be an integer from 0 through ${maxScheduleDebounceMs}.`,
+      );
+    }
+  }
+
   public async startPrompt(
     scopeId: string,
     sessionId: string,
     prompt: TFlexPrompt,
     options: IFlexEnqueuePromptOptions = {},
   ): Promise<IFlexPromptAdmission> {
+    if (prompt === undefined) {
+      throw new FlexHarnessValidationError('prompt must be a string or a non-empty array of parts.');
+    }
     const admitted = this.splitEnqueueOptions(options);
     const queued = await this.enqueuePromptInternal(
       scopeId, sessionId, prompt, admitted.options,
@@ -120,6 +165,9 @@ export class FlexHarnessPromptQueue<TScope> {
     prompt: TFlexPrompt,
     options: IFlexEnqueuePromptOptions = {},
   ): Promise<IFlexPromptQueueAdmission> {
+    if (prompt === undefined) {
+      throw new FlexHarnessValidationError('prompt must be a string or a non-empty array of parts.');
+    }
     const admitted = this.splitEnqueueOptions(options);
     const queued = await this.enqueuePromptInternal(
       scopeId, sessionId, prompt, admitted.options,
@@ -166,15 +214,14 @@ export class FlexHarnessPromptQueue<TScope> {
     prompt: TFlexPrompt,
     options: IFlexSchedulePromptOptions = {},
   ): Promise<IFlexScheduledPromptAdmission> {
+    if (prompt === undefined) {
+      throw new FlexHarnessValidationError('prompt must be a string or a non-empty array of parts.');
+    }
     validateIdentifier(scheduleKey, 'scheduleKey');
     requireTransferIdentifier(scheduleKey, 'scheduleKey');
     validatePromptOptions(options, true);
     const debounceMs = options.debounceMs ?? 50;
-    if (!Number.isSafeInteger(debounceMs) || debounceMs < 0 || debounceMs > maxScheduleDebounceMs) {
-      throw new FlexHarnessValidationError(
-        `debounceMs must be an integer from 0 through ${maxScheduleDebounceMs}.`,
-      );
-    }
+    this.validateScheduleDebounce(debounceMs);
     const queued = await this.enqueuePromptInternal(
       scopeId,
       sessionId,
@@ -331,9 +378,7 @@ export class FlexHarnessPromptQueue<TScope> {
     try {
       steering.input.add({
         inputId: steer.steerId,
-        content: cloneSerializable(prompt.modelMessage.content) as Parameters<
-          plugins.IAgentSession['beginGeneration']
-        >[0],
+        content: cloneSerializable(prompt.modelMessage.content) as TFlexAgentPrompt,
       });
     } catch (error) {
       if (error instanceof plugins.AgentPendingInputRejectedError) {
@@ -355,10 +400,10 @@ export class FlexHarnessPromptQueue<TScope> {
     return { steerId: steer.steerId, queueId: run.queueId, runId: run.runId };
   }
 
-  public async enqueuePromptInternal(
+  public async enqueuePromptInternal<TPrompt extends TFlexPrompt | undefined>(
     scopeId: string,
     sessionId: string,
-    prompt: TFlexPrompt,
+    prompt: TPrompt,
     options: IFlexPromptOptions,
     scheduleKey?: string,
     debounceMs?: number,
@@ -368,13 +413,15 @@ export class FlexHarnessPromptQueue<TScope> {
     cacheWarm = false,
     steers: readonly IAdmittedSteer[] = [],
   ): Promise<{
-    admission: IFlexPromptQueueAdmission;
-    started: Promise<IFlexPromptAdmission>;
+    admission: IFlexPromptQueueAdmission<TPrompt extends undefined ? IFlexContinuePromptResult : IFlexPromptResult>;
+    started: Promise<IFlexPromptAdmission<TPrompt extends undefined ? IFlexContinuePromptResult : IFlexPromptResult>>;
     queued?: IQueuedPrompt;
   }> {
     this.core.assertOpen();
     if (options.promptId !== undefined) requireTransferIdentifier(options.promptId, 'promptId');
-    const normalizedPrompt = normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols);
+    const normalizedPrompt = prompt === undefined
+      ? undefined
+      : normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols);
     const normalizedOptions = cloneSerializable(options);
     const byteSize = this.promptAdmissionByteSize(prompt, options, scheduleKey, debounceMs);
     const steerBytes = steers.reduce((sum, steer) => sum + steer.byteSize, 0);
@@ -467,16 +514,16 @@ export class FlexHarnessPromptQueue<TScope> {
       ) {
         throw new FlexHarnessDuplicatePromptError(options.promptId);
       }
-      let resolveCompletion!: (result: IFlexPromptResult) => void;
+      let resolveCompletion!: (result: IFlexContinuePromptResult) => void;
       let rejectCompletion!: (error: unknown) => void;
-      const completion = new Promise<IFlexPromptResult>((resolve, reject) => {
+      const completion = new Promise<IFlexContinuePromptResult>((resolve, reject) => {
         resolveCompletion = resolve;
         rejectCompletion = reject;
       });
       void completion.catch(() => undefined);
-      let resolveStarted!: (admission: IFlexPromptAdmission) => void;
+      let resolveStarted!: (admission: IFlexPromptAdmission<IFlexContinuePromptResult>) => void;
       let rejectStarted!: (error: unknown) => void;
-      const started = new Promise<IFlexPromptAdmission>((resolve, reject) => {
+      const started = new Promise<IFlexPromptAdmission<IFlexContinuePromptResult>>((resolve, reject) => {
         resolveStarted = resolve;
         rejectStarted = reject;
       });
@@ -494,7 +541,7 @@ export class FlexHarnessPromptQueue<TScope> {
         ...(scheduleKey === undefined ? {} : { scheduleKey, debounceMs }),
         ...(cacheWarm ? { cacheWarm: true as const } : {}),
         ...(options.promptId === undefined ? {} : { promptId: options.promptId }),
-        prompt: normalizedPrompt,
+        ...(normalizedPrompt === undefined ? { continuation: true as const } : { prompt: normalizedPrompt }),
         options: normalizedOptions,
         ...(delegationSeed === undefined ? {} : { delegationSeed }),
         byteSize,
@@ -517,8 +564,13 @@ export class FlexHarnessPromptQueue<TScope> {
       this.emitPromptQueueEvent(queued, 'prompt.queued');
       this.schedulePromptQueueDrain(state, stored);
       return {
-        admission: Object.freeze({ queueId: queued.queueId, completion }),
-        started,
+        // The input determines whether the completed run has a user message.
+        admission: Object.freeze({ queueId: queued.queueId, completion }) as IFlexPromptQueueAdmission<
+          TPrompt extends undefined ? IFlexContinuePromptResult : IFlexPromptResult
+        >,
+        started: started as Promise<IFlexPromptAdmission<
+          TPrompt extends undefined ? IFlexContinuePromptResult : IFlexPromptResult
+        >>,
         queued,
       };
     } finally {
@@ -625,8 +677,28 @@ export class FlexHarnessPromptQueue<TScope> {
     }
   }
 
+  /** Check the actual model context at the FIFO boundary, before any durable run claim. */
+  private assertContinuableContext(stored: IStoredSessionState): void {
+    const visibleEvents = this.core.reversions.filterReversionContextEvents(stored, stored.agentSession.getEvents());
+    const retainedRunIds = new Set(plugins.filterModelVisibleAgentEvents(visibleEvents)
+      .map((event) => event.generationId));
+    const lastTurnMessage = [...this.core.visibleMessages(stored)].reverse().find((message) =>
+      !message.cacheWarm && (message.status === 'completed'
+        || message.keptInContext === true || retainedRunIds.has(message.runId)));
+    // A summary or runtime update can look like a user message even after a completed answer.
+    const answered = !lastTurnMessage || (lastTurnMessage.role === 'assistant'
+      && lastTurnMessage.status === 'completed');
+    const last = answered ? undefined : stored.agentSession.getModelMessages().at(-1);
+    if (last?.role === 'user' || last?.role === 'tool') return;
+    if (last?.role === 'assistant' && Array.isArray(last.content)
+      && last.content.some((part) => part.type === 'tool-call')) return;
+    throw this.core.trustInternalError(new FlexHarnessValidationError(
+      'The conversation has no unanswered turn to continue.',
+    ));
+  }
+
   private async promoteQueuedPrompt(queued: IQueuedPrompt, run: IActiveRun): Promise<void> {
-    const prompt = queued.prompt!;
+    const prompt = queued.prompt;
     const options = queued.options!;
     let projectionReserved = false;
     // Open from the reservation until its messages are announced or rolled back.
@@ -636,18 +708,18 @@ export class FlexHarnessPromptQueue<TScope> {
         this.assertPromptPromotion(queued, run);
         await this.core.admission.acquireDelegatedRunAdmission(queued, run);
         this.assertPromptPromotion(queued, run);
+        if (queued.continuation) this.assertContinuableContext(run.stored);
         await this.core.reversions.commitRevertedBranch(run.state, run.stored, run.scopeId, run.scope as TScope);
         this.assertPromptPromotion(queued, run);
-        const generationPrompt = cloneSerializable(prompt.modelMessage.content) as Parameters<
-          plugins.IAgentSession['beginGeneration']
-        >[0];
+        const generationPrompt = prompt === undefined
+          ? undefined
+          : cloneSerializable(prompt.modelMessage.content) as TFlexAgentPrompt;
         this.assertPromptPromotion(queued, run);
         run.transaction = await this.core.compaction.withRunCompactorContext(
           run,
-          () => run.stored.agentSession.beginGeneration(
-            generationPrompt,
-            { generationId: run.runId },
-          ),
+          () => generationPrompt === undefined
+            ? run.stored.agentSession.beginContinuation({ generationId: run.runId })
+            : run.stored.agentSession.beginGeneration(generationPrompt, { generationId: run.runId }),
         );
         this.assertPromptPromotion(queued, run);
         const reservation = this.core.runs.createReservation(run, prompt, queued.promptId);
@@ -658,7 +730,8 @@ export class FlexHarnessPromptQueue<TScope> {
             throw new Error('Session metrics already owns a generation.');
           }
           run.stored.metrics.pendingGenerationId = run.runId;
-          run.stored.messages.push(reservation.userMessage, reservation.assistantMessage);
+          if (reservation.userMessage) run.stored.messages.push(reservation.userMessage);
+          run.stored.messages.push(reservation.assistantMessage);
           // A cache-warm turn is no turn of the user's: it gets no reversion segment of its own.
           if (run.stored.session.agent === undefined && !run.cacheWarm) {
             this.core.reversions.pruneReversionState(run.stored, true);
@@ -668,7 +741,7 @@ export class FlexHarnessPromptQueue<TScope> {
             const protocolVersion = this.core.reversions.reversionProviderProtocolVersion() ?? 1;
             run.stored.reversionSegments.push({
               runId: run.runId,
-              userMessageId: reservation.userMessage.messageId,
+              ...(reservation.userMessage ? { userMessageId: reservation.userMessage.messageId } : {}),
               status: 'capturing',
               contextAvailable: true,
               eventIds: [],
@@ -690,7 +763,7 @@ export class FlexHarnessPromptQueue<TScope> {
           }
         });
         projectionReserved = true;
-        run.reservedUserMessage = publicSnapshot(reservation.userMessage);
+        if (reservation.userMessage) run.reservedUserMessage = publicSnapshot(reservation.userMessage);
         run.reservedAssistantMessage = publicSnapshot(reservation.assistantMessage);
         this.assertPromptPromotion(queued, run);
         await this.core.mutateScope(run.state, () => {
@@ -707,9 +780,9 @@ export class FlexHarnessPromptQueue<TScope> {
           run.stored.session.activity = {
             runId: run.runId,
             status: run.scheduleKey ? 'scheduled' : 'running',
-            startedAt: reservation.userMessage.createdAt,
+            startedAt: reservation.assistantMessage.createdAt,
           };
-          run.stored.session.updatedAt = reservation.userMessage.createdAt;
+          run.stored.session.updatedAt = reservation.assistantMessage.createdAt;
           const preview = run.stored.session.preview ?? sessionPreview(run.stored.messages);
           if (preview !== undefined) run.stored.session.preview = preview;
         });
@@ -751,11 +824,12 @@ export class FlexHarnessPromptQueue<TScope> {
       this.core.emitEvent(run.scopeId, run.stored.session, {
         type: runType,
         runId: run.runId,
-        messageId: run.userMessageId,
+        messageId: run.userMessageId ?? run.assistantMessageId,
         session: publicSnapshot(run.stored.session),
         ...(run.cacheWarm ? { cacheWarm: true } : {}),
       });
-      for (const message of [run.reservedUserMessage!, run.reservedAssistantMessage!]) {
+      for (const message of [run.reservedUserMessage, run.reservedAssistantMessage!]) {
+        if (!message) continue;
         this.core.emitEvent(run.scopeId, run.stored.session, {
           type: 'message.created',
           runId: run.runId,
@@ -828,6 +902,7 @@ export class FlexHarnessPromptQueue<TScope> {
       queuedAt: queued.queuedAt,
       ...(queued.runId ? { runId: queued.runId } : {}),
       ...(queued.promptId === undefined ? {} : { promptId: queued.promptId }),
+      ...(queued.continuation ? { continuation: true as const } : {}),
       ...(queued.scheduleKey ? { scheduleKey: queued.scheduleKey } : {}),
       ...(queued.cacheWarm ? { cacheWarm: true } : {}),
       ...(queued.startedAt ? { startedAt: queued.startedAt } : {}),
@@ -861,7 +936,7 @@ export class FlexHarnessPromptQueue<TScope> {
     queued: IQueuedPrompt,
     status: 'completed' | 'failed' | 'cancelled',
     error?: unknown,
-    result?: IFlexPromptResult,
+    result?: IFlexContinuePromptResult,
   ): void {
     const stored = queued.stored;
     if (stored.outstandingPromptsById.get(queued.queueId) !== queued) return;

package/ts/classes.flexharness.runs.ts

@@ -16,7 +16,8 @@ import {
   type IFlexMessage,
   type IFlexPermissionRequestInput,
   type IFlexPromptOptions,
-  type IFlexPromptResult,
+  type IFlexContinuePromptResult,
+  type TFlexAgentPrompt,
   type IFlexResolvedModel,
   type IFlexRunFinishedEvent,
   type IFlexSession,
@@ -94,9 +95,7 @@ export class FlexHarnessRuns<TScope> {
     for (const steer of steers) {
       steering.input.add({
         inputId: steer.steerId,
-        content: cloneSerializable(steer.prompt.modelMessage.content) as Parameters<
-          plugins.IAgentSession['beginGeneration']
-        >[0],
+        content: cloneSerializable(steer.prompt.modelMessage.content) as TFlexAgentPrompt,
       });
       steering.accepted.set(steer.steerId, { prompt: steer.prompt, byteSize: steer.byteSize });
     }
@@ -123,7 +122,7 @@ export class FlexHarnessRuns<TScope> {
       sessionId: queued.sessionId,
       queueId: queued.queueId,
       runId: queued.runId!,
-      userMessageId: plugins.crypto.randomUUID(),
+      ...(queued.continuation ? { continuation: true as const } : { userMessageId: plugins.crypto.randomUUID() }),
       assistantMessageId: plugins.crypto.randomUUID(),
       controller: new AbortController(),
       ...(queued.scheduleKey === undefined
@@ -162,7 +161,7 @@ export class FlexHarnessRuns<TScope> {
   public async executeRun(
     run: IActiveRun,
     generation: Promise<plugins.IAgentGenerateResult>,
-  ): Promise<IFlexPromptResult> {
+  ): Promise<IFlexContinuePromptResult> {
     let generated = false;
     try {
       // The transactional generation settles only after its model calls are reported, so
@@ -236,7 +235,7 @@ export class FlexHarnessRuns<TScope> {
       return {
         runId: run.runId,
         sessionId: run.sessionId,
-        userMessage: publicSnapshot(terminal.userMessage),
+        ...(terminal.userMessage ? { userMessage: publicSnapshot(terminal.userMessage) } : {}),
         assistantMessage: publicSnapshot(terminal.assistantMessage),
         model: publicSnapshot(terminal.model!),
         usage: publicSnapshot(terminal.usage!),
@@ -729,12 +728,12 @@ export class FlexHarnessRuns<TScope> {
 
   public createReservation(
     run: IActiveRun,
-    prompt: INormalizedFlexPrompt,
+    prompt: INormalizedFlexPrompt | undefined,
     promptId?: string,
-  ): { userMessage: IFlexMessage; assistantMessage: IFlexMessage } {
+  ): { userMessage?: IFlexMessage; assistantMessage: IFlexMessage } {
     const timestamp = new Date().toISOString();
-    const userMessage: IFlexMessage = {
-      messageId: run.userMessageId,
+    const userMessage: IFlexMessage | undefined = prompt === undefined ? undefined : {
+      messageId: run.userMessageId!,
       sessionId: run.sessionId,
       runId: run.runId,
       role: 'user',
@@ -754,7 +753,7 @@ export class FlexHarnessRuns<TScope> {
       parts: [],
       ...(run.cacheWarm ? { cacheWarm: true as const } : {}),
     };
-    return { userMessage, assistantMessage };
+    return { ...(userMessage ? { userMessage } : {}), assistantMessage };
   }
 
   private userMessageParts(prompt: INormalizedFlexPrompt): TFlexMessagePart[] {
@@ -915,11 +914,11 @@ export class FlexHarnessRuns<TScope> {
     error?: Error,
   ): IFlexTerminalProjection {
     const timestamp = new Date().toISOString();
-    const userMessage: IFlexMessage = cloneSerializable(
+    const userMessage = run.continuation ? undefined : cloneSerializable(
       run.reservedUserMessage
       ?? run.stored.messages.find((message) => message.messageId === run.userMessageId)
       ?? {
-        messageId: run.userMessageId,
+        messageId: run.userMessageId!,
         sessionId: run.sessionId,
         runId: run.runId,
         role: 'user',
@@ -957,11 +956,13 @@ export class FlexHarnessRuns<TScope> {
       }
     }
     if (run.cacheWarm) {
-      userMessage.cacheWarm = true;
+      if (userMessage) userMessage.cacheWarm = true;
       assistantMessage.cacheWarm = true;
     }
-    userMessage.status = status;
-    userMessage.completedAt = timestamp;
+    if (userMessage) {
+      userMessage.status = status;
+      userMessage.completedAt = timestamp;
+    }
     assistantMessage.status = status;
     assistantMessage.completedAt = timestamp;
     if (run.modelResolution) assistantMessage.model = cloneSerializable(run.modelResolution.identity);
@@ -984,6 +985,7 @@ export class FlexHarnessRuns<TScope> {
       // A failed turn fails its prompt too. A stopped turn is no fault of its prompt, so the prompt
       // stays an ordinary user message and only the answer it stopped carries the stop.
       for (const failedMessage of status === 'cancelled' ? [assistantMessage] : [userMessage, assistantMessage]) {
+        if (!failedMessage) continue;
         failedMessage.error = message;
         if (limit) failedMessage.limit = cloneSerializable(limit);
         if (rejectedPermissionId) failedMessage.rejectedPermissionId = rejectedPermissionId;
@@ -992,7 +994,7 @@ export class FlexHarnessRuns<TScope> {
     return {
       runId: run.runId,
       status,
-      userMessage,
+      ...(userMessage ? { userMessage } : {}),
       assistantMessage,
       ...(run.modelResolution ? { model: cloneSerializable(run.modelResolution.identity) } : {}),
       ...(status === 'completed' && result
@@ -1060,7 +1062,9 @@ export class FlexHarnessRuns<TScope> {
    * the steers it took in in the model context. `replaceVisibleRun()` writes it onto the steers.
    */
   public withKeptInContext(terminal: IFlexTerminalProjection, keptInContext: boolean): IFlexTerminalProjection {
-    return { ...terminal, userMessage: { ...terminal.userMessage, keptInContext } };
+    return terminal.userMessage
+      ? { ...terminal, userMessage: { ...terminal.userMessage, keptInContext } }
+      : terminal;
   }
 
   private replaceStagedTerminal(stored: IStoredSessionState, terminal: IFlexTerminalProjection): void {
@@ -1076,11 +1080,13 @@ export class FlexHarnessRuns<TScope> {
    */
   public replaceVisibleRun(stored: IStoredSessionState, terminal: IFlexTerminalProjection): void {
     const replacements = new Map([
-      [terminal.userMessage.messageId, terminal.userMessage],
+      ...(terminal.userMessage ? [[terminal.userMessage.messageId, terminal.userMessage] as const] : []),
       [terminal.assistantMessage.messageId, terminal.assistantMessage],
     ]);
     const placed = new Set<string>();
-    const keptInContext = terminal.userMessage.keptInContext;
+    const keptInContext = terminal.userMessage?.keptInContext
+      ?? (terminal.status === 'completed'
+        || plugins.isGenerationInModelContext(stored.agentSession.getEvents(), terminal.runId));
     stored.messages = stored.messages.map((message) => {
       const replacement = message.runId === terminal.runId
         ? replacements.get(message.messageId)
@@ -1096,7 +1102,7 @@ export class FlexHarnessRuns<TScope> {
       return cloneSerializable(replacement);
     });
     const firstIndex = stored.messages.findIndex((message) => message.runId === terminal.runId);
-    if (!placed.has(terminal.userMessage.messageId)) {
+    if (terminal.userMessage && !placed.has(terminal.userMessage.messageId)) {
       stored.messages.splice(
         firstIndex < 0 ? stored.messages.length : firstIndex,
         0,
@@ -1130,10 +1136,14 @@ export class FlexHarnessRuns<TScope> {
         this.core.emitPartEvent(run, 'part.completed', part);
       }
     }
-    const steerMessages = terminal.userMessage.keptInContext === undefined
-      ? []
-      : run.stored.messages.filter((message) => message.runId === run.runId && message.steerId !== undefined);
+    const retentionKnown = terminal.userMessage
+      ? terminal.userMessage.keptInContext !== undefined
+      : run.steering.keptInContext !== undefined;
+    const steerMessages = retentionKnown
+      ? run.stored.messages.filter((message) => message.runId === run.runId && message.steerId !== undefined)
+      : [];
     for (const message of [terminal.userMessage, ...steerMessages, terminal.assistantMessage]) {
+      if (!message) continue;
       this.core.emitEvent(run.scopeId, run.stored.session, {
         type: 'message.updated',
         runId: run.runId,

package/ts/classes.flexharness.subagents.ts

@@ -13,6 +13,7 @@ import type {
   IFlexSteerAdmission,
   IFlexSteerInput,
   IFlexPromptAdmission,
+  IFlexContinuePromptResult,
   IFlexPromptOptions,
   IFlexSession,
   IFlexSubagentDefinition,
@@ -378,7 +379,7 @@ export class FlexHarnessSubagents<TScope> {
     let child: IStoredSessionState | undefined;
     let childCreated = false;
     let queued: Awaited<ReturnType<typeof this.core.prompts.enqueuePromptInternal>> | undefined;
-    let admission: IFlexPromptAdmission | undefined;
+    let admission: IFlexPromptAdmission<IFlexContinuePromptResult> | undefined;
     const abortChild = () => {
       const reason = delegatedCancellation(run.controller.signal.reason)
         ?? this.core.trustInternalError(new FlexHarnessAbortError('The parent run was aborted.'));

package/ts/classes.flexharness.ts

@@ -4,6 +4,8 @@ import type {
   IFlexCacheWarmInput,
   IFlexCacheWarmState,
   IFlexCompactSessionOptions,
+  IFlexContinuePromptOptions,
+  IFlexContinuePromptResult,
   IFlexCreateProjectTaskInput,
   IFlexCreateSessionOptions,
   IFlexDeleteSessionGenerationCohortInput,
@@ -320,6 +322,14 @@ export class FlexHarness<TScope = unknown> {
     return this.core.prompts.prompt(scopeId, sessionId, prompt, options);
   }
 
+  public continuePrompt(
+    scopeId: string,
+    sessionId: string,
+    options: IFlexContinuePromptOptions = {},
+  ): Promise<IFlexPromptQueueAdmission<IFlexContinuePromptResult>> {
+    return this.core.prompts.continuePrompt(scopeId, sessionId, options);
+  }
+
   public startPrompt(
     scopeId: string,
     sessionId: string,

package/ts/interfaces.flexharness.ts

@@ -15,7 +15,7 @@ import type {
   IFlexPromptAdmission,
   IFlexPromptQueueEntry,
   IFlexPromptOptions,
-  IFlexPromptResult,
+  IFlexContinuePromptResult,
   IFlexReversionSegment,
   IFlexPendingReversionRelease,
   IFlexResolvedModel,
@@ -88,7 +88,7 @@ export interface IStoredSessionState {
   permissionRevision: number;
   permissionQueue: Promise<void>;
   eventStore: plugins.IAgentEventStore;
-  agentSession: plugins.IAgentSession;
+  agentSession: plugins.IAgentContinuationSession;
   agentSessionAbortCompleted: boolean;
   agentSessionCloseCompleted: boolean;
   agentEventStoreReleased: boolean;
@@ -226,7 +226,8 @@ export interface IActiveRun {
   sessionId: string;
   queueId: string;
   runId: string;
-  userMessageId: string;
+  userMessageId?: string;
+  continuation?: true;
   assistantMessageId: string;
   controller: AbortController;
   transaction?: plugins.IAgentGenerationHandle;
@@ -292,7 +293,7 @@ export interface IActiveRun {
   permissionPolicy?: IFlexResolvedSessionConfiguration<unknown>['permissionPolicy'];
   delegatedRunAdmissionOwner?: IDelegatedRunAdmissionOwner;
   delegatedRunAdmissionClose?: Promise<void>;
-  completion: Promise<IFlexPromptResult>;
+  completion: Promise<IFlexContinuePromptResult>;
   steering: IRunSteering;
   /** Stops the run's generation for its owner, so what the model produced stays in context. */
   stop: AbortController;
@@ -415,6 +416,7 @@ export interface IQueuedPrompt {
   /** The prompt's `promptId`; kept after its payload is released. */
   promptId?: string;
   startedAt?: string;
+  continuation?: true;
   prompt?: INormalizedFlexPrompt;
   options?: IFlexPromptOptions;
   delegationSeed?: IDelegatedRunAdmissionSeed;
@@ -426,11 +428,11 @@ export interface IQueuedPrompt {
   steering?: IRunSteering;
   /** The steers admitted with the prompt, in their given order. */
   admittedSteerIds?: readonly string[];
-  completion: Promise<IFlexPromptResult>;
-  resolveCompletion: (result: IFlexPromptResult) => void;
+  completion: Promise<IFlexContinuePromptResult>;
+  resolveCompletion: (result: IFlexContinuePromptResult) => void;
   rejectCompletion: (error: unknown) => void;
-  started: Promise<IFlexPromptAdmission>;
-  resolveStarted: (admission: IFlexPromptAdmission) => void;
+  started: Promise<IFlexPromptAdmission<IFlexContinuePromptResult>>;
+  resolveStarted: (admission: IFlexPromptAdmission<IFlexContinuePromptResult>) => void;
   rejectStarted: (error: unknown) => void;
 }