agent-relay-runner 0.10.24 → 0.10.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.10.24",
+  "version": "0.10.26",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

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.10.24",
+  "version": "0.10.26",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/plugins/claude/hooks/relay-status.sh

@@ -41,12 +41,16 @@ relay_post_session_turn() {
   # the captured turn clears the reply obligation before the stop decision check
   # below, so the agent is not nagged to /reply (and does not re-emit).
   local transcript_path="${1:-}"
+  local last_assistant_message="${2:-}"
   local port="${AGENT_RELAY_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   [ -z "$transcript_path" ] && return 0
+  local body="{\"transcriptPath\":\"$(relay_json_escape "$transcript_path")\""
+  [ -n "$last_assistant_message" ] && body="${body},\"lastAssistantMessage\":${last_assistant_message}"
+  body="${body}}"
   curl -fsS -X POST "http://127.0.0.1:${port}/session-turn" \
     -H 'Content-Type: application/json' \
-    -d "{\"transcriptPath\":\"$(relay_json_escape "$transcript_path")\"}" >/dev/null 2>&1 || true
+    -d "$body" >/dev/null 2>&1 || true
 }
 
 relay_pending_reply_stop_decision() {

package/plugins/claude/hooks/stop.sh

@@ -5,7 +5,8 @@ source "${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}/
 payload="$(cat || true)"
 stop_hook_active="$(relay_json_bool_field stop_hook_active "$payload")"
 if [ "$stop_hook_active" != "true" ]; then
-  relay_post_session_turn "$(relay_json_string_field transcript_path "$payload")"
+  last_assistant_msg="$(echo "$payload" | jq -c '.last_assistant_message // empty' 2>/dev/null || true)"
+  relay_post_session_turn "$(relay_json_string_field transcript_path "$payload")" "$last_assistant_msg"
   stop_decision="$(relay_pending_reply_stop_decision)"
   if [ -n "$stop_decision" ]; then
     printf '%s\n' "$stop_decision"

package/src/adapter.ts

@@ -31,6 +31,7 @@ export interface ProviderConfig {
   defaultCapabilities: string[];
   defaultApprovalMode: string;
   defaultTags: string[];
+  chatCaptureMode: "final" | "full";
   headless: {
     tmuxPrefix: string;
     shutdownTimeoutMs: number;

package/src/adapters/claude-transcript.ts

@@ -96,3 +96,50 @@ export function extractLastAssistantTurn(jsonl: string): string {
   }
   return collected.join("\n\n").trim();
 }
+
+/**
+ * Returns only the text from the LAST assistant entry in the current turn.
+ * Unlike extractLastAssistantTurn which collects all intermediate text between
+ * tool calls, this returns just the final response — what the user sees as the
+ * concluding message.
+ */
+export function extractFinalAssistantMessage(jsonl: string): string {
+  const lines = jsonl.split("\n");
+  let lastText = "";
+  let pastLastUserPrompt = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry: TranscriptEntry;
+    try {
+      entry = JSON.parse(trimmed) as TranscriptEntry;
+    } catch {
+      continue;
+    }
+    if (isRealUserPrompt(entry)) {
+      pastLastUserPrompt = true;
+      lastText = "";
+      continue;
+    }
+    if (!pastLastUserPrompt) continue;
+    const text = assistantText(entry);
+    if (text) lastText = text;
+  }
+  return lastText.trim();
+}
+
+/**
+ * Extract text from the `last_assistant_message` field in the Stop hook
+ * payload. This is the content of the final assistant message — either a plain
+ * string or an array of content blocks (same shape as transcript entries).
+ * Thinking and tool_use blocks are dropped, matching extractLastAssistantTurn.
+ */
+export function extractHookAssistantMessage(content: unknown): string {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return (content as TranscriptBlock[])
+    .filter((b) => b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text!.trim())
+    .filter(Boolean)
+    .join("\n\n");
+}

package/src/config.ts

@@ -33,6 +33,7 @@ export function defaultProviderConfig(provider: string): ProviderConfig {
     defaultCapabilities: ["chat", "code", "review"],
     defaultApprovalMode: "guarded",
     defaultTags: [],
+    chatCaptureMode: "final",
     headless: {
       tmuxPrefix: `${provider}-relay`,
       shutdownTimeoutMs: 10_000,
@@ -63,6 +64,7 @@ export function loadProviderConfig(provider: string, home = agentRelayHome()): L
     defaultCapabilities: stringArray(raw.defaultCapabilities) ?? defaults.defaultCapabilities,
     defaultApprovalMode: stringValue(raw.defaultApprovalMode) ?? defaults.defaultApprovalMode,
     defaultTags: stringArray(raw.defaultTags) ?? defaults.defaultTags,
+    chatCaptureMode: enumValue(raw.chatCaptureMode, ["final", "full"]) ?? defaults.chatCaptureMode,
     headless: {
       tmuxPrefix: stringValue(recordValue(raw.headless).tmuxPrefix) ?? defaults.headless.tmuxPrefix,
       shutdownTimeoutMs: positiveInteger(recordValue(raw.headless).shutdownTimeoutMs) ?? defaults.headless.shutdownTimeoutMs,
@@ -88,6 +90,7 @@ export function providerConfigPublic(config: LoadedProviderConfig): Record<strin
     defaultCapabilities: config.defaultCapabilities,
     defaultApprovalMode: config.defaultApprovalMode,
     defaultTags: config.defaultTags,
+    chatCaptureMode: config.chatCaptureMode,
     headless: config.headless,
   };
 }
@@ -120,6 +123,10 @@ function positiveInteger(value: unknown): number | undefined {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
 
+function enumValue<T extends string>(value: unknown, allowed: T[]): T | undefined {
+  return typeof value === "string" && allowed.includes(value as T) ? (value as T) : undefined;
+}
+
 function stringArray(value: unknown): string[] | undefined {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined;
 }

package/src/control-server.ts

@@ -23,7 +23,7 @@ interface ControlServerOptions {
   // Phase 1 live-session lane: a provider Stop hook hands over its transcript
   // path so the runner can capture the assistant turn and surface it in the
   // dashboard chat without the agent re-emitting it via /reply.
-  onSessionTurn?(input: { transcriptPath: string }): Promise<void>;
+  onSessionTurn?(input: { transcriptPath: string; lastAssistantMessage?: unknown }): Promise<void>;
 }
 
 export function startControlServer(options: ControlServerOptions): ControlServer {
@@ -253,11 +253,12 @@ async function handleSessionTurn(req: Request, options: ControlServerOptions): P
   const body = await req.json().catch(() => null);
   const transcriptPath = isRecord(body) && typeof body.transcriptPath === "string" ? body.transcriptPath : "";
   if (!transcriptPath) return Response.json({ ok: false, reason: "transcriptPath required" }, { status: 400 });
+  const lastAssistantMessage = isRecord(body) ? body.lastAssistantMessage : undefined;
   // Awaited on purpose: the Stop hook posts this synchronously before its
   // reply-obligation check, so the captured turn must be persisted (and the
   // obligation cleared) before this response returns.
   try {
-    await options.onSessionTurn({ transcriptPath });
+    await options.onSessionTurn({ transcriptPath, lastAssistantMessage });
     return Response.json({ ok: true });
   } catch (error) {
     return Response.json({ ok: false, reason: error instanceof Error ? error.message : String(error) }, { status: 500 });

package/src/runner.ts

@@ -9,7 +9,7 @@ import type { ManagedProcess, ProviderAdapter, ProviderConfig, ProviderPermissio
 import { messagesWithCachedAttachments } from "./attachment-cache";
 import { ClaimTracker } from "./claim-tracker";
 import { startControlServer, type ControlServer } from "./control-server";
-import { extractLastAssistantTurn, transcriptLooksComplete } from "./adapters/claude-transcript";
+import { extractLastAssistantTurn, extractFinalAssistantMessage, extractHookAssistantMessage, transcriptLooksComplete } from "./adapters/claude-transcript";
 import { agentProfileProjectionReport } from "./profile-projection";
 import { profileUsesHostProviderGlobals } from "./profile-home";
 import { runtimeMetadata } from "./version";
@@ -665,7 +665,7 @@ export class AgentRunner {
   // dashboard chat with zero agent tokens. Posting it as a reply to the
   // triggering message also clears the reply obligation, so the Stop hook no
   // longer nags the agent to /reply — which is what made it re-emit before.
-  private async publishSessionTurn(input: { transcriptPath: string }): Promise<void> {
+  private async publishSessionTurn(input: { transcriptPath: string; lastAssistantMessage?: unknown }): Promise<void> {
     // Find the triggering message to reply to: either a pending prompt injection
     // (Phase 2 direct lane) or a reply obligation from the dashboard human.
     let replyToMessageId: number | undefined;
@@ -691,12 +691,27 @@ export class AgentRunner {
       return;
     }
     // The Stop hook can fire before the final assistant entry is flushed to
-    // disk. Retry a few times with a short delay to catch the race.
-    for (let attempt = 0; attempt < 3 && !transcriptLooksComplete(jsonl); attempt++) {
-      await new Promise((r) => setTimeout(r, 100));
-      try { jsonl = await readFile(input.transcriptPath, "utf8"); } catch { return; }
+    // disk. Claude Code writes thinking and text as separate entries (both with
+    // end_turn), so the transcript can "look complete" while the text entry is
+    // still pending. Retry until both the transcript has an end_turn AND the
+    // extraction yields non-empty text.
+    let body = "";
+    for (let attempt = 0; attempt < 5; attempt++) {
+      if (attempt > 0) {
+        await new Promise((r) => setTimeout(r, 100));
+        try { jsonl = await readFile(input.transcriptPath, "utf8"); } catch { return; }
+      }
+      if (!transcriptLooksComplete(jsonl)) continue;
+      const extract = this.options.providerConfig.chatCaptureMode === "full" ? extractLastAssistantTurn : extractFinalAssistantMessage;
+      body = extract(jsonl);
+      if (body) break;
+    }
+    // Fallback: use last_assistant_message from the Stop hook payload directly.
+    // This bypasses the transcript file race entirely — Claude Code provides the
+    // content in-memory before the hook even fires.
+    if (!body && input.lastAssistantMessage) {
+      body = extractHookAssistantMessage(input.lastAssistantMessage);
     }
-    const body = extractLastAssistantTurn(jsonl);
     if (!body) return;
 
     try {