agent-relay-runner 0.62.3 → 0.63.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.62.3",
+  "version": "0.63.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.40"
+    "agent-relay-sdk": "0.2.41"
   },
   "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.62.3",
+  "version": "0.63.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/busy-reconciler.ts

@@ -0,0 +1,84 @@
+type ProviderActivity = "busy" | "idle" | "unknown";
+
+const BUSY_RECONCILE_POLL_MS = 4_000;
+const BUSY_RECONCILE_IDLE_CONFIRM = 8;
+const BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY = 15;
+const INTERRUPT_RECONCILE_DELAY_MS = 1_500;
+
+interface BusyReconcilerDeps {
+  isStopped(): boolean;
+  hasProcess(): boolean;
+  currentStatus(): "idle" | "busy" | "offline" | "error";
+  isProviderBlocked(): boolean;
+  hasProviderTurn(): boolean;
+  canProbeActivity(): boolean;
+  probeActivity(): Promise<ProviderActivity> | undefined;
+  clearProviderTurn(reason: string): void;
+  sessionDebug(message: string): void;
+}
+
+export class BusyReconciler {
+  private idleStreak = 0;
+  private timer?: ReturnType<typeof setInterval>;
+  private sawBusy = false;
+
+  constructor(private readonly deps: BusyReconcilerDeps) {}
+
+  arm(): void {
+    if (this.timer || !this.deps.canProbeActivity()) return;
+    this.idleStreak = 0;
+    this.sawBusy = false;
+    this.timer = setInterval(() => { void this.run(); }, BUSY_RECONCILE_POLL_MS);
+  }
+
+  disarm(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+    this.idleStreak = 0;
+    this.sawBusy = false;
+  }
+
+  scheduleInterruptReconcile(): void {
+    setTimeout(() => {
+      if (this.deps.isStopped() || !this.deps.hasProcess()) return;
+      void (async () => {
+        if (this.deps.currentStatus() !== "busy" || this.deps.isProviderBlocked()) return;
+        const probe = this.deps.probeActivity();
+        let activity: ProviderActivity = "unknown";
+        try { if (probe) activity = await probe; } catch { return; }
+        this.deps.sessionDebug(`post-interrupt reconcile probe=${activity}`);
+        if (activity === "idle") this.deps.clearProviderTurn("post-interrupt");
+      })();
+    }, INTERRUPT_RECONCILE_DELAY_MS);
+  }
+
+  private async run(): Promise<void> {
+    const probe = this.deps.probeActivity();
+    if (this.deps.isStopped() || !this.deps.hasProcess() || !probe) {
+      this.disarm();
+      return;
+    }
+    if (this.deps.currentStatus() !== "busy" || this.deps.isProviderBlocked()) {
+      this.idleStreak = 0;
+      return;
+    }
+    if (!this.deps.hasProviderTurn()) {
+      this.disarm();
+      return;
+    }
+    let activity: ProviderActivity;
+    try { activity = await probe; } catch { return; }
+    if (activity === "busy") this.sawBusy = true;
+    if (activity !== "idle") {
+      this.idleStreak = 0;
+      this.deps.sessionDebug(`reconcile probe=${activity} sawBusy=${this.sawBusy} streak=${this.idleStreak}`);
+      return;
+    }
+    this.idleStreak += 1;
+    const confirm = this.sawBusy ? BUSY_RECONCILE_IDLE_CONFIRM : BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY;
+    this.deps.sessionDebug(`reconcile probe=idle sawBusy=${this.sawBusy} streak=${this.idleStreak}/${confirm}`);
+    if (this.idleStreak < confirm) return;
+    this.disarm();
+    this.deps.clearProviderTurn(this.sawBusy ? "backstop reconciler" : "backstop reconciler (no-busy-observed)");
+  }
+}

package/src/mcp-outbox.ts

@@ -0,0 +1,86 @@
+import type { SendMessageInput } from "agent-relay-sdk";
+import type { RelayHttpClient } from "agent-relay-sdk";
+import { relayMcpEndpoint } from "./relay-mcp";
+import type { OutboxRecord } from "./outbox";
+import { deliverContinuationArchiveRecord } from "./continuation-archive";
+import { logger } from "./logger";
+import { isHttpAuthError, isHttpStatusError } from "./runner-helpers";
+
+interface RunnerOutboxDelivery {
+  record: OutboxRecord;
+  http: RelayHttpClient;
+  relayUrl: string;
+  token?: string;
+  updatePayload(seq: number, payload: unknown): void;
+  sessionLog(message: string): void;
+  recoverRuntimeTokenAfterAuthFailure(source: string): void;
+}
+
+export async function deliverRunnerOutboxEvent(input: RunnerOutboxDelivery): Promise<void> {
+  const { record, http } = input;
+  try {
+    if (record.kind === "session-message") {
+      await http.sendMessage({
+        ...(record.payload as SendMessageInput),
+        occurredAt: record.occurredAt,
+        idempotencyKey: record.idempotencyKey,
+      });
+      return;
+    }
+    if (record.kind === "insight") {
+      await http.recordInsightObservation({
+        ...(record.payload as Parameters<RelayHttpClient["recordInsightObservation"]>[0]),
+        occurredAt: record.occurredAt,
+      });
+      return;
+    }
+    if (record.kind === "continuation-archive") {
+      await deliverContinuationArchiveRecord({
+        record,
+        http,
+        updatePayload: input.updatePayload,
+        sessionLog: input.sessionLog,
+      });
+      return;
+    }
+    if (record.kind === "mcp-tool-call") {
+      await deliverBufferedMcpCall(input);
+      return;
+    }
+    logger.warn("outbox", `dropping event with unknown kind: ${record.kind}`);
+  } catch (error) {
+    if (isHttpStatusError(error, 409)) return;
+    if (isHttpAuthError(error)) input.recoverRuntimeTokenAfterAuthFailure("outbox");
+    throw error;
+  }
+}
+
+export async function deliverBufferedMcpCall(input: {
+  record: OutboxRecord;
+  relayUrl: string;
+  token?: string;
+  recoverRuntimeTokenAfterAuthFailure(source: string): void;
+}): Promise<void> {
+  const payload = input.record.payload as { tool: string; arguments: Record<string, unknown> };
+  const headers: Record<string, string> = { "content-type": "application/json" };
+  if (input.token) headers.authorization = `Bearer ${input.token}`;
+  const response = await fetch(relayMcpEndpoint(input.relayUrl), {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: payload.tool, arguments: payload.arguments } }),
+  });
+  if (response.status === 401 || response.status === 403) {
+    input.recoverRuntimeTokenAfterAuthFailure("mcp-outbox");
+    throw new Error(`relay rejected buffered ${payload.tool} with ${response.status}`);
+  }
+  if (response.status >= 500) throw new Error(`relay ${response.status} on buffered ${payload.tool}`);
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.warn("mcp-outbox", `buffered ${payload.tool} permanently rejected (${response.status}); dropping: ${body.slice(0, 200)}`);
+    return;
+  }
+  const json = await response.json().catch(() => null) as { error?: { message?: string } } | null;
+  if (json?.error) {
+    logger.warn("mcp-outbox", `buffered ${payload.tool} returned a tool error; dropping: ${json.error.message ?? "(no detail)"}`);
+  }
+}

package/src/rate-limit.ts

@@ -14,7 +14,7 @@ export const RATE_LIMIT_BLOCK_REASON = "rate_limit";
 // fall back to the resume sweep's poll window.
 const MAX_RESET_AHEAD_MS = 7 * 24 * 60 * 60 * 1000;
 
-export interface RateLimitHoldInput {
+interface RateLimitHoldInput {
   errorType?: string;
   /** Unix ms the limit window resets, when known. */
   resetAt?: number;
@@ -58,7 +58,7 @@ const LIMIT_PHRASE_RE = /(?:hit (?:your|the)\s*(?:[\w-]+\s+)*limit|usage limit|\
 const RESET_AT_RE = /\bresets?\b(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\(([^)]+)\))?/i;
 const TRY_AGAIN_RE = /\btry again in\s+(\d+)\s*(second|minute|hour|day)s?/i;
 
-export interface PaneRateLimit {
+interface PaneRateLimit {
   /** The matched limit line, for the chat notice / observability. */
   message: string;
   /** Unix ms reset, when parseable from the pane (else undefined → resume falls back to poll). */