agent-relay-runner 0.37.0 → 0.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.22"
+    "agent-relay-sdk": "0.2.24"
   },
   "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.37.0",
+  "version": "0.39.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/claude.ts

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import type { Message } from "agent-relay-sdk";
+import { extractClaudeModelUnavailableMessage, type Message } from "agent-relay-sdk";
 import { shellEscape as shellQuote } from "agent-relay-sdk/shell-utils";
 import { tmuxCommand, tmuxHasSession } from "agent-relay-sdk/tmux-utils";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
@@ -21,6 +21,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   private statusCb: (status: ProviderStatusUpdate) => void = () => {};
   private tmuxWatcher?: Timer;
   private turnWatcher?: Timer;
+  private modelUnavailableReported = false;
 
   onStatusChange(cb: (status: ProviderStatusUpdate) => void): void {
     this.statusCb = cb;
@@ -285,6 +286,7 @@ export class ClaudeAdapter implements ProviderAdapter {
 
   private async spawnHeadless(config: RunnerSpawnConfig, spawnArgs: SpawnArgs): Promise<ManagedProcess> {
     const { sessionName, socketName, args: tmuxArgs } = this.buildTmuxArgs(config, spawnArgs);
+    this.modelUnavailableReported = false;
 
     Bun.spawnSync(tmuxCommand(socketName, "kill-session", "-t", sessionName), {
       stdin: "ignore", stdout: "ignore", stderr: "ignore",
@@ -332,6 +334,19 @@ export class ClaudeAdapter implements ProviderAdapter {
         clearInterval(this.tmuxWatcher!);
         this.tmuxWatcher = undefined;
         this.statusCb("offline");
+        return;
+      }
+      if (this.modelUnavailableReported) return;
+      let pane = "";
+      try {
+        pane = captureTmuxPane(sessionName, socketName);
+      } catch {
+        return;
+      }
+      const status = claudeModelUnavailableStatus(pane, sessionName);
+      if (status) {
+        this.modelUnavailableReported = true;
+        this.statusCb(status);
       }
     }, 2000);
   }
@@ -505,6 +520,43 @@ export function claudePaneIsBusy(text: string): boolean {
   return CLAUDE_BUSY_SPINNER_RE.test(text) || text.includes("esc to interrupt");
 }
 
+export function claudeModelUnavailableStatus(text: string, sessionName?: string): ProviderStatusUpdate | null {
+  const message = extractClaudeModelUnavailableMessage(text);
+  if (!message) return null;
+  return {
+    status: "error",
+    clear: ["provider-turn", "subagent"],
+    providerState: {
+      state: "failed",
+      reason: "model-unavailable",
+      message,
+      source: "claude-pane",
+      terminal: true,
+      ...(sessionName ? { sessionName } : {}),
+      recommendedAction: "Choose a different Claude model before restarting this agent.",
+    },
+    metadata: {
+      terminalFailureReason: "model-unavailable",
+      terminalFailureMessage: message,
+    },
+    timeline: {
+      status: "provider.restart_decision",
+      id: `provider-model-unavailable-${Date.now()}`,
+      timestamp: Date.now(),
+      title: "Provider restart skipped",
+      body: message,
+      icon: "ti-player-stop",
+      metadata: {
+        eventType: "provider.restart_decision",
+        decision: "stop-surface",
+        reason: "model-unavailable",
+        modelUnavailable: true,
+        modelUnavailableMessage: message,
+      },
+    },
+  };
+}
+
 async function waitForClaudeInputReady(sessionName: string, timeoutMs = CLAUDE_TMUX_READY_TIMEOUT_MS, socketName?: string): Promise<void> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {

package/src/runner.ts

@@ -250,6 +250,7 @@ export class AgentRunner {
   // Session-mirror: a synthesized id grouping a turn's reasoning/tool steps and
   // its final response. Set when a provider-turn starts, cleared when it ends.
   private currentTurnId?: string;
+  private currentTurnStartedAt?: number;
   // Prompt-echo dedup: a short, time-bounded queue of prompts the runner itself
   // injected (chat box or initial prompt) that are still awaiting their matching
   // UserPromptSubmit echo. A single slot dropped earlier entries when several prompts
@@ -268,6 +269,7 @@ export class AgentRunner {
   // Tracks whether the provider is in a legitimate blocked/approval state, so the
   // busy reconciler doesn't mistake a permission prompt for a stuck-busy turn.
   private providerBlocked = false;
+  private terminalFailure?: { reason: string; message: string; providerState?: Record<string, unknown> };
   // Reasoning tailer (item 5): streams the in-flight turn's reasoning/tool steps
   // from the Claude transcript into chat as discreet session events.
   private reasoningTail?: { timer: ReturnType<typeof setInterval>; seen: Set<string> };
@@ -1091,15 +1093,36 @@ export class AgentRunner {
     } else if (status === "idle") {
       this.providerBlocked = false;
     }
+    if (typeof update !== "string" && status === "error") {
+      const terminalReason = typeof update.metadata?.terminalFailureReason === "string"
+        ? update.metadata.terminalFailureReason
+        : typeof update.providerState?.reason === "string"
+          ? update.providerState.reason
+          : "provider-error";
+      const terminalMessage = typeof update.metadata?.terminalFailureMessage === "string"
+        ? update.metadata.terminalFailureMessage
+        : typeof update.providerState?.message === "string"
+          ? update.providerState.message
+          : "Provider reported an unrecoverable error.";
+      this.terminalFailure = {
+        reason: terminalReason,
+        message: terminalMessage,
+        ...(update.providerState ? { providerState: update.providerState } : {}),
+      };
+    } else if (status === "idle" || status === "busy") {
+      this.terminalFailure = undefined;
+    }
     if (status === "busy" && reason === "provider-turn") {
       if (!this.currentTurnId) {
         this.currentTurnId = typeof update !== "string" && update.id ? update.id : crypto.randomUUID();
+        this.currentTurnStartedAt = Date.now();
         this.sessionLog(`turn started (turn ${this.currentTurnId})`);
       }
       this.armBusyReconciler();
     } else if (status === "idle" && reason === "provider-turn") {
       if (this.currentTurnId) this.sessionLog(`turn ended via provider idle (turn ${this.currentTurnId})`);
       this.currentTurnId = undefined;
+      this.currentTurnStartedAt = undefined;
       this.disarmBusyReconciler();
       this.stopReasoningTail();
     }
@@ -1324,7 +1347,10 @@ export class AgentRunner {
   // deliveries) so those aren't double-posted.
   private async handleUserPrompt(input: { prompt: string; transcriptPath?: string }): Promise<void> {
     if (input.transcriptPath) this.lastTranscriptPath = input.transcriptPath;
-    if (!this.currentTurnId) this.currentTurnId = crypto.randomUUID();
+    if (!this.currentTurnId) {
+      this.currentTurnId = crypto.randomUUID();
+      this.currentTurnStartedAt = Date.now();
+    }
     const text = input.prompt.trim();
     if (text && !this.isRunnerInjectedPrompt(text)) {
       this.sessionLog(`prompt echoed from terminal (${text.length} chars)`);
@@ -1482,7 +1508,7 @@ export class AgentRunner {
       if (pendingPrompt) {
         replyToMessageId = pendingPrompt;
         this.pendingPromptMessageId = undefined;
-      } else if (this.obligationCache.get().some((o) => o.from === "user")) {
+      } else if (this.obligationCache.get().some((o) => o.from === "user" && this.obligationPredatesCurrentTurn(o))) {
         // The agent will answer the relay obligation itself — don't double-post (#196).
         return;
       }
@@ -1534,6 +1560,10 @@ export class AgentRunner {
     return false;
   }
 
+  private obligationPredatesCurrentTurn(obligation: { createdAt: number }): boolean {
+    return this.currentTurnStartedAt === undefined || obligation.createdAt <= this.currentTurnStartedAt;
+  }
+
   // --- Busy-state reconciler (item 2) -------------------------------------------------
   // A safety net for turns that end out of band (interrupted from the web terminal,
   // a hook that never fired) where the runner would otherwise stay stuck "busy".
@@ -1668,11 +1698,13 @@ export class AgentRunner {
   }
 
   private publishStatus(): void {
+    this.claims.expire();
     const status = this.claims.currentStatus();
     const agentStatus = runnerAgentStatus(status);
     const activeWork = this.claims.activeWork();
     const activeSubagents = activeWork.filter((item) => item.kind === "subagent");
-    const providerState = providerStateFromActiveWork(activeWork);
+    const terminalFailure = this.terminalFailure;
+    const providerState = terminalFailure?.providerState ?? providerStateFromActiveWork(activeWork);
     this.bus.setSemanticStatus(status === "offline" || status === "error" ? "idle" : status);
     const timelineEvent = this.pendingTimelineEvent;
     this.pendingTimelineEvent = undefined;
@@ -1693,6 +1725,11 @@ export class AgentRunner {
         lifecycleAction: this.lifecycleAction ?? null,
         profile: this.options.profile ?? null,
         ...(status === "error" ? { terminalStatus: "error" } : {}),
+        ...(terminalFailure ? {
+          lastError: terminalFailure.message,
+          terminalFailureReason: terminalFailure.reason,
+          terminalFailureMessage: terminalFailure.message,
+        } : {}),
         busyReasons: this.claims.reasons(),
         activeWork,
         activeSubagents,