agent-relay-runner 0.73.0 → 0.74.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.48"
+    "agent-relay-sdk": "0.2.49"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/codex-agent-message-capture.ts

@@ -0,0 +1,56 @@
+type EmitAgentMessage = (body: string) => void;
+
+export class CodexAgentMessageCapture {
+  private segments: string[][] = [];
+  private currentSegment: string[] = [];
+  private readonly buffers = new Map<string, string>();
+  private readonly flushedLengths = new Map<string, number>();
+
+  reset(): void {
+    this.segments = [];
+    this.currentSegment = [];
+    this.buffers.clear();
+    this.flushedLengths.clear();
+  }
+
+  appendDelta(itemId: string | undefined, delta: string): void {
+    if (!itemId || !delta) return;
+    this.buffers.set(itemId, `${this.buffers.get(itemId) ?? ""}${delta}`);
+  }
+
+  completeItem(itemId: string | undefined, text: string | undefined, emit: EmitAgentMessage): void {
+    this.flushText(itemId, text ?? (itemId ? this.buffers.get(itemId) : undefined), emit);
+    if (!itemId) return;
+    this.buffers.delete(itemId);
+    this.flushedLengths.delete(itemId);
+  }
+
+  closeSegment(emit: EmitAgentMessage): void {
+    this.flushPending(emit);
+    if (!this.currentSegment.length) return;
+    this.segments.push(this.currentSegment);
+    this.currentSegment = [];
+  }
+
+  finish(emit: EmitAgentMessage): string | undefined {
+    this.closeSegment(emit);
+    const finalSegment = this.segments.at(-1);
+    this.segments = [];
+    return finalSegment?.length ? finalSegment.join("\n\n").trim() : undefined;
+  }
+
+  private flushPending(emit: EmitAgentMessage): void {
+    for (const [itemId, text] of [...this.buffers.entries()]) this.flushText(itemId, text, emit);
+  }
+
+  private flushText(itemId: string | undefined, text: string | undefined, emit: EmitAgentMessage): void {
+    if (!text) return;
+    const offset = itemId ? (this.flushedLengths.get(itemId) ?? 0) : 0;
+    const chunk = text.slice(offset);
+    if (itemId) this.flushedLengths.set(itemId, text.length);
+    const body = chunk.trim();
+    if (!body) return;
+    this.currentSegment.push(body);
+    emit(body);
+  }
+}

package/src/adapters/codex.ts

@@ -10,6 +10,7 @@ import { tomlString } from "../relay-mcp";
 import { assembleLaunch, bundledCodexSkillDirs, bundledSkillConfigArgs, materializeLaunchAssembly } from "../launch-assembly";
 import { logger } from "../logger";
 import type { SessionEvent } from "../session-insights";
+import { CodexAgentMessageCapture } from "./codex-agent-message-capture";
 
 /** Relay context prepended to a Codex agent's first turn: the standard relay
  * blurb plus, when running in an isolated workspace, the deps caveat (#159). */
@@ -49,12 +50,9 @@ export class CodexAdapter implements ProviderAdapter {
   // Active turn id for the main thread, captured from turn/started so an interrupt
   // can target the in-flight turn. Cleared on turn/completed.
   private activeTurnId?: string;
-  // Assistant message text accumulated across the current turn's agentMessage items,
-  // flushed as one session response on turn/completed (mirrors Claude's chatCaptureMode).
-  private turnMessages: string[] = [];
+  private readonly agentMessageCapture = new CodexAgentMessageCapture();
   private readonly itemTextBuffers = new Map<string, string>();
   private readonly itemTextBufferTypes = new Map<string, string>();
-  private captureMode: "final" | "full" = "final";
   // #183/#184: the normalized session-event log for the current process lifetime, fed
   // from the same completed-item stream that drives the chat mirror. The runner slices
   // this per-segment (since the last compact/clear/restart) via its own cursor, so we
@@ -81,7 +79,7 @@ export class CodexAdapter implements ProviderAdapter {
     this.subagentThreads.clear();
     this.pendingApprovals.clear();
     this.activeTurnId = undefined;
-    this.turnMessages = [];
+    this.agentMessageCapture.reset();
     this.itemTextBuffers.clear();
     this.itemTextBufferTypes.clear();
   }
@@ -133,7 +131,6 @@ export class CodexAdapter implements ProviderAdapter {
 
   async spawn(config: RunnerSpawnConfig): Promise<ManagedProcess> {
     this.resetProcessState();
-    this.captureMode = (config.providerConfig as ProviderConfig).chatCaptureMode ?? "final";
     const args = this.buildSpawnArgs(config, config.providerConfig as ProviderConfig);
     const appServer = Bun.spawn([args.command, ...args.args], {
       cwd: args.cwd,
@@ -459,8 +456,9 @@ export class CodexAdapter implements ProviderAdapter {
       } else {
         const turn = isRecord(params?.turn) ? params.turn : undefined;
         this.activeTurnId = stringValue(turn?.id);
-        this.turnMessages = [];
+        this.agentMessageCapture.reset();
         this.itemTextBuffers.clear();
+        this.itemTextBufferTypes.clear();
         this.statusCb({ status: "busy", reason: "provider-turn", id: this.activeTurnId });
       }
     }
@@ -492,29 +490,21 @@ export class CodexAdapter implements ProviderAdapter {
     }
   }
 
-  // Turn one completed Codex thread item into a session-mirror event. agentMessage
-  // text is accumulated and flushed as a single response on turn/completed; the rest
-  // (user prompt echo, reasoning, tool steps) is surfaced as it lands.
+  // Turn one completed Codex thread item into a session-mirror event. agentMessage text is
+  // mirrored as narration as it lands; only the final contiguous assistant segment is repeated
+  // as the turn-final response. The rest (user prompt echo, reasoning, tool steps) is surfaced
+  // as it lands.
   private handleCodexItem(item: Record<string, unknown> | undefined): void {
     if (!item) return;
     const type = stringValue(item.type);
     const turnId = this.activeTurnId;
     const itemId = codexItemId(item);
+    if (type !== "agentMessage") this.agentMessageCapture.closeSegment((body) => this.emitAgentNarration(body));
     // A completed non-reasoning item ends the reasoning segment that preceded it — flush the
     // buffered reasoning first so it lands in transcript order, ahead of this tool/message.
     if (type !== "reasoning") this.flushBufferedReasoning();
     if (type === "agentMessage") {
-      const text = (stringValue(item.text) ?? (itemId ? this.itemTextBuffers.get(itemId) : undefined))?.trim();
-      if (text) {
-        this.turnMessages.push(text);
-        this.recordInsightEvent({ type: "turn" }); // a substantive assistant turn
-        // Stream the assistant text into the trace as narration (Claude parity). The closing
-        // response bubble at turn end repeats the final block; the dashboard suppresses the
-        // matching narration so it isn't shown twice.
-        this.sessionEventCb({ type: "narration", origin: "provider", body: text, ...(turnId ? { turnId } : {}) });
-      }
-      if (itemId) this.itemTextBuffers.delete(itemId);
-      if (itemId) this.itemTextBufferTypes.delete(itemId);
+      this.agentMessageCapture.completeItem(itemId, stringValue(item.text), (body) => this.emitAgentNarration(body));
       return;
     }
     if (type === "userMessage") {
@@ -549,6 +539,14 @@ export class CodexAdapter implements ProviderAdapter {
     if (itemId) this.itemTextBufferTypes.delete(itemId);
   }
 
+  private emitAgentNarration(body: string): void {
+    this.recordInsightEvent({ type: "turn" }); // a substantive assistant turn
+    // Stream the assistant text into the trace as narration (Claude parity). The closing
+    // response bubble at turn end repeats the final block; the dashboard suppresses the
+    // matching narration so it isn't shown twice.
+    this.sessionEventCb({ type: "narration", origin: "provider", body, ...(this.activeTurnId ? { turnId: this.activeTurnId } : {}) });
+  }
+
   // Emit any buffered reasoning as discrete trace blocks (appended, in transcript order). Codex
   // streams reasoning as deltas with no reliable completion event, so we flush coarsely at item
   // and turn boundaries — the signal the Claude reasoning tail uses — never a codex-only timer.
@@ -588,6 +586,7 @@ export class CodexAdapter implements ProviderAdapter {
     const turnId = this.activeTurnId;
 
     if (method.includes("/started") || method.includes(".started")) {
+      if (type !== "agentMessage") this.agentMessageCapture.closeSegment((body) => this.emitAgentNarration(body));
       // A new item starting ends the prior reasoning segment — flush it ahead of this step.
       this.flushBufferedReasoning();
       const tool = codexToolSummary(type, item ?? params ?? {});
@@ -596,7 +595,14 @@ export class CodexAdapter implements ProviderAdapter {
       return;
     }
 
-    if (type === "agentMessage" || type === "reasoning" || type === "plan") {
+    if (type === "agentMessage") {
+      const delta = codexDeltaText(params);
+      if (delta) this.agentMessageCapture.appendDelta(itemId, delta);
+      return;
+    }
+
+    if (type === "reasoning" || type === "plan") {
+      this.agentMessageCapture.closeSegment((body) => this.emitAgentNarration(body));
       const delta = codexDeltaText(params);
       if (delta && itemId) {
         this.itemTextBuffers.set(itemId, `${this.itemTextBuffers.get(itemId) ?? ""}${delta}`);
@@ -611,15 +617,7 @@ export class CodexAdapter implements ProviderAdapter {
   }
 
   private flushTurnResponse(): void {
-    const pendingAgentMessages = [...this.itemTextBuffers.entries()]
-      .filter(([itemId]) => this.itemTextBufferTypes.get(itemId) === "agentMessage")
-      .map(([, text]) => text.trim())
-      .filter(Boolean);
-    const messages = [...this.turnMessages, ...pendingAgentMessages];
-    if (!messages.length) return;
-    const joined = this.captureMode === "full" ? messages.join("\n\n") : messages[messages.length - 1]!;
-    this.turnMessages = [];
-    const text = joined.trim();
+    const text = this.agentMessageCapture.finish((body) => this.emitAgentNarration(body));
     if (text) this.sessionEventCb({ type: "response", origin: "provider", body: text, final: true, ...(this.activeTurnId ? { turnId: this.activeTurnId } : {}) });
   }
 
@@ -631,6 +629,7 @@ export class CodexAdapter implements ProviderAdapter {
     this.pendingApprovals.clear();
     this.itemTextBuffers.clear();
     this.itemTextBufferTypes.clear();
+    this.agentMessageCapture.reset();
     this.statusCb({ status: "idle", reason: "provider-turn", id: turnId });
   }