@springbrand/agent-runtime 0.3.0-alpha.18 → 0.3.0-alpha.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springbrand/agent-runtime",
-  "version": "0.3.0-alpha.18",
+  "version": "0.3.0-alpha.19",
   "type": "module",
   "files": [
     "src",

package/src/adapter/cloudflare/agent.ts

@@ -1072,7 +1072,7 @@ export abstract class AgentRuntimeKernel<
   /** Start the native resume handshake from Pi's current lane snapshot. */
   async onConnect(connection: Connection): Promise<void> {
     this.conversation.disconnect(connection);
-    await this.conversation.resume(connection);
+    await this.conversation.connect(connection);
   }
 
   async onClose(connection: Connection, code: number, reason: string, wasClean: boolean): Promise<void> {

package/src/conversation/harness-resume.ts

@@ -54,21 +54,28 @@ export class HarnessConversationBridge {
       await this.send(session.connection, { type: MessageType.CF_AGENT_USE_CHAT_RESPONSE, id: session.source.requestId, body: JSON.stringify(chunk), done: false, ...(replay ? { replay: true, continuation: false } : {}) });
     }
   }
-  async resume(connection: Connection, probeId?: string): Promise<void> {
+  /**
+   * A socket just opened: offer the live stream if one exists, otherwise only
+   * sync messages. Like Cloudflare's AIChatAgent, an idle connect sends no
+   * STREAM_RESUME_NONE. The client answers its own resume probe from the
+   * reply that carries its probeId; an unsolicited, probe-less "none" arriving
+   * first consumes that pending probe without clearing the client's
+   * server-streaming state, which leaves a reconnected Chat stuck streaming
+   * after a Turn that ended while it was offline.
+   */
+  connect(connection: Connection): Promise<void> {
+    return this.resume(connection, undefined, false);
+  }
+  /** Answer a client's stream-resume request; `announceIdle` is false only for {@link connect}. */
+  async resume(connection: Connection, probeId?: string, announceIdle = true): Promise<void> {
     this.disconnect(connection);
     const source = this.active;
-    if (!source) {
-      await this.send(connection, { type: MessageType.CF_AGENT_CHAT_MESSAGES, messages: await this.host.history.browserMessages() });
-      await this.send(connection, { type: MessageType.CF_AGENT_STREAM_RESUME_NONE, reason: STREAM_RESUME_NONE_REASONS.IDLE, ...(probeId ? { probeId } : {}) });
-      return;
-    }
+    if (!source) return this.idle(connection, probeId, announceIdle);
     const watch = await source.runtime.watch(BACKGROUND_CONTEXT);
-    if (this.active !== source) { await watch.stop(); return this.resume(connection, probeId); }
+    if (this.active !== source) { await watch.stop(); return this.resume(connection, probeId, announceIdle); }
     if (!watch.snapshot.run) {
       await watch.stop();
-      await this.send(connection, { type: MessageType.CF_AGENT_CHAT_MESSAGES, messages: await this.host.history.browserMessages() });
-      await this.send(connection, { type: MessageType.CF_AGENT_STREAM_RESUME_NONE, reason: STREAM_RESUME_NONE_REASONS.IDLE, ...(probeId ? { probeId } : {}) });
-      return;
+      return this.idle(connection, probeId, announceIdle);
     }
     const messages = await this.host.history.browserSnapshot(watch.snapshot, source.submissionId);
     const replay = this.replayMessage(messages, source.submissionId);
@@ -77,6 +84,15 @@ export class HarnessConversationBridge {
     await this.send(connection, { type: MessageType.CF_AGENT_CHAT_MESSAGES, messages: replay ? messages.filter((message) => message.id !== replay.id) : messages });
     await this.send(connection, { type: MessageType.CF_AGENT_STREAM_RESUMING, id: source.requestId, ...(probeId ? { probeId } : {}) });
   }
+  /**
+   * No Turn is running. "None" goes first: while the client still observes the
+   * stream it lost, it keeps its own partial answer over any snapshot that has
+   * no more parts, so the settled answer must arrive after it stops observing.
+   */
+  private async idle(connection: Connection, probeId: string | undefined, announceIdle: boolean): Promise<void> {
+    if (announceIdle) await this.send(connection, { type: MessageType.CF_AGENT_STREAM_RESUME_NONE, reason: STREAM_RESUME_NONE_REASONS.IDLE, ...(probeId ? { probeId } : {}) });
+    await this.send(connection, { type: MessageType.CF_AGENT_CHAT_MESSAGES, messages: await this.host.history.browserMessages() });
+  }
   async acknowledge(connection: Connection, requestId: string): Promise<void> {
     const session = this.connections.get(connection.id);
     if (!session || session.source.requestId !== requestId || session.started) return;

package/src/conversation/message/projection.ts

@@ -595,6 +595,12 @@ export class PiChunkEncoder {
           turnDurationMs: Math.max(0, message.timestamp - this.startedAt),
           turnStatus: terminal.turnStatus,
           ...(this.turnId ? { turnId: this.turnId } : {}),
+          // The browser keeps this stream copy over a history snapshot that
+          // arrives while it still observes the stream, so it must carry the
+          // user-stop marker the snapshot projects from `turn-aborted`.
+          ...(terminal.outcome === "aborted" && message.errorMessage === USER_STOP_REASON
+            ? { interruptedByUser: true }
+            : {}),
           ...((publicError ?? terminal.message) &&
               (terminal.outcome !== "aborted" ||
                 message.errorMessage !== USER_STOP_REASON)

package/src/submission/finalization.ts

@@ -13,7 +13,7 @@ import type { SteerRepository } from "./steer-repository";
 
 /** Commits the Submission outcome and human/Host facts after accepted steering is preserved. */
 export class SubmissionFinalizer {
-  /** User-stop markers appended after their terminal commit; `finish()` awaits its own. */
+  /** User-stop markers appended after their terminal commit; every `finish()` of that Turn awaits it. */
   private readonly stopMarkers = new Map<string, Promise<unknown>>();
   constructor(private readonly options: {
     submissions: SubmissionRepository;
@@ -36,7 +36,12 @@ export class SubmissionFinalizer {
     message?: string,
   ): Promise<StoredSubmission> {
     const initial = this.read(submissionId);
-    if (isTerminalSubmissionStatus(initial.status)) return initial;
+    if (isTerminalSubmissionStatus(initial.status)) {
+      // A stop RPC and the ending harness finish the same Turn; whichever loses
+      // still waits for the stop marker, so its history broadcast carries it.
+      await this.stopMarkers.get(submissionId);
+      return initial;
+    }
     const aborted = Boolean(initial.abortReason) || outcome === "aborted";
     if (aborted) await this.options.releaseAbortedHarness();
     await finishPendingSteers({
@@ -58,8 +63,8 @@ export class SubmissionFinalizer {
     const completed = this.commit(submissionId, outcome, message, output?.role === "assistant" ? output : undefined);
     const marker = this.stopMarkers.get(submissionId);
     if (marker) {
-      this.stopMarkers.delete(submissionId);
       await marker;
+      this.stopMarkers.delete(submissionId);
     }
     return completed;
   }