agent-relay-runner 0.78.6 → 0.78.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.78.6",
+  "version": "0.78.8",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.56"
+    "agent-relay-sdk": "0.2.58"
   },
   "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.78.6",
+  "version": "0.78.8",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

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

@@ -1,16 +1,20 @@
 type EmitAgentMessage = (body: string) => void;
+type ResponseEntry = { itemId?: string; body: string };
+type CompleteItemOptions = { includeInResponse?: boolean; phase?: unknown };
 
 export class CodexAgentMessageCapture {
-  private segments: string[][] = [];
-  private currentSegment: string[] = [];
+  private segments: ResponseEntry[][] = [];
+  private currentSegment: ResponseEntry[] = [];
   private readonly buffers = new Map<string, string>();
   private readonly flushedLengths = new Map<string, number>();
+  private readonly responseRecordedLengths = new Map<string, number>();
 
   reset(): void {
     this.segments = [];
     this.currentSegment = [];
     this.buffers.clear();
     this.flushedLengths.clear();
+    this.responseRecordedLengths.clear();
   }
 
   appendDelta(itemId: string | undefined, delta: string): void {
@@ -18,8 +22,14 @@ export class CodexAgentMessageCapture {
     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);
+  completeItem(itemId: string | undefined, text: string | undefined, emit: EmitAgentMessage, options: CompleteItemOptions = {}): void {
+    const fullText = text ?? (itemId ? this.buffers.get(itemId) : undefined);
+    this.flushText(itemId, fullText, emit);
+    if (options.includeInResponse === false || options.phase === "commentary") {
+      this.forgetResponseItem(itemId);
+    } else {
+      this.recordResponseText(itemId, fullText);
+    }
     if (!itemId) return;
     this.buffers.delete(itemId);
     this.flushedLengths.delete(itemId);
@@ -36,11 +46,14 @@ export class CodexAgentMessageCapture {
     this.closeSegment(emit);
     const finalSegment = this.segments.at(-1);
     this.segments = [];
-    return finalSegment?.length ? finalSegment.join("\n\n").trim() : undefined;
+    return finalSegment?.length ? finalSegment.map((entry) => entry.body).join("\n\n").trim() : undefined;
   }
 
   private flushPending(emit: EmitAgentMessage): void {
-    for (const [itemId, text] of [...this.buffers.entries()]) this.flushText(itemId, text, emit);
+    for (const [itemId, text] of [...this.buffers.entries()]) {
+      this.flushText(itemId, text, emit);
+      this.recordResponseText(itemId, text);
+    }
   }
 
   private flushText(itemId: string | undefined, text: string | undefined, emit: EmitAgentMessage): void {
@@ -50,7 +63,30 @@ export class CodexAgentMessageCapture {
     if (itemId) this.flushedLengths.set(itemId, text.length);
     const body = chunk.trim();
     if (!body) return;
-    this.currentSegment.push(body);
     emit(body);
   }
+
+  private recordResponseText(itemId: string | undefined, text: string | undefined): void {
+    if (!text) return;
+    const body = text.trim();
+    if (!body) return;
+    if (itemId) {
+      const offset = this.responseRecordedLengths.get(itemId) ?? 0;
+      const chunk = text.slice(offset).trim();
+      this.responseRecordedLengths.set(itemId, text.length);
+      if (!chunk) return;
+      this.currentSegment.push({ itemId, body: chunk });
+      return;
+    }
+    this.currentSegment.push({ body });
+  }
+
+  private forgetResponseItem(itemId: string | undefined): void {
+    if (!itemId) return;
+    this.responseRecordedLengths.delete(itemId);
+    this.currentSegment = this.currentSegment.filter((entry) => entry.itemId !== itemId);
+    this.segments = this.segments
+      .map((segment) => segment.filter((entry) => entry.itemId !== itemId))
+      .filter((segment) => segment.length > 0);
+  }
 }

package/src/adapters/codex.ts

@@ -504,7 +504,7 @@ export class CodexAdapter implements ProviderAdapter {
     // buffered reasoning first so it lands in transcript order, ahead of this tool/message.
     if (type !== "reasoning") this.flushBufferedReasoning();
     if (type === "agentMessage") {
-      this.agentMessageCapture.completeItem(itemId, stringValue(item.text), (body) => this.emitAgentNarration(body));
+      this.agentMessageCapture.completeItem(itemId, stringValue(item.text), (body) => this.emitAgentNarration(body), { phase: item.phase });
       return;
     }
     if (type === "userMessage") {

package/src/claude-quota-harvest.ts

@@ -0,0 +1,57 @@
+import type { RelayHttpClient } from "agent-relay-sdk";
+import { quotaStateFromProbeMetrics } from "agent-relay-sdk/context-probe";
+import { readRunnerContextProbeState } from "./context-probe-state";
+import { DEFAULT_PROVIDER_QUOTA_CONFIG, normalizeProviderQuotaConfig, resolveClaudeStatuslineQuotaIdentity } from "./quota";
+
+const PASSIVE_QUOTA_CONFIG_REFRESH_MS = 60_000;
+
+interface ClaudeQuotaHarvestOptions {
+  agentId: string;
+  provider: string;
+  http: () => Pick<RelayHttpClient, "getProviderQuotaConfig" | "upsertProviderQuota">;
+}
+
+export class ClaudeQuotaHarvest {
+  private config = { ...DEFAULT_PROVIDER_QUOTA_CONFIG };
+  private configRefreshAt = 0;
+  private lastReportAt?: number;
+
+  constructor(private readonly options: ClaudeQuotaHarvestOptions) {}
+
+  async publish(): Promise<void> {
+    if (this.options.provider !== "claude") return;
+    const probeMetrics = readRunnerContextProbeState(this.options.agentId);
+    const quota = probeMetrics ? quotaStateFromProbeMetrics(probeMetrics) : undefined;
+    if (!quota) return;
+    const config = await this.refreshConfig();
+    if (!config.enabled) return;
+    const now = Date.now();
+    if (this.lastReportAt !== undefined && now - this.lastReportAt < config.pollIntervalMs) return;
+    const identity = await resolveClaudeStatuslineQuotaIdentity({ env: process.env });
+    if (!identity) return;
+    await this.options.http().upsertProviderQuota({
+      provider: "claude",
+      accountKey: identity.accountKey,
+      quota,
+      lastAttemptAt: quota.updatedAt,
+      sourceAgentId: this.options.agentId,
+    });
+    this.lastReportAt = now;
+  }
+
+  private async refreshConfig() {
+    const now = Date.now();
+    if (now < this.configRefreshAt) return this.config;
+    this.configRefreshAt = now + PASSIVE_QUOTA_CONFIG_REFRESH_MS;
+    try {
+      const map = await this.options.http().getProviderQuotaConfig();
+      this.config = map.claude
+        ? normalizeProviderQuotaConfig(map.claude)
+        : { ...DEFAULT_PROVIDER_QUOTA_CONFIG };
+    } catch {
+      // Keep the previous config; defaults preserve collection if the relay is older
+      // or temporarily unreachable during a liveness tick.
+    }
+    return this.config;
+  }
+}

package/src/context-probe-state.ts

@@ -0,0 +1,6 @@
+import { readContextProbeState } from "agent-relay-sdk/context-probe";
+import { contextStateDirFromEnv } from "./config";
+
+export function readRunnerContextProbeState(agentId: string) {
+  return readContextProbeState(agentId, contextStateDirFromEnv());
+}

package/src/process-meta.ts

@@ -0,0 +1,9 @@
+import type { ManagedProcess } from "./adapter";
+
+export function providerTerminalSession(process?: ManagedProcess): string | undefined {
+  return typeof process?.meta?.tmuxSession === "string" ? process.meta.tmuxSession : undefined;
+}
+
+export function providerTerminalSocket(process?: ManagedProcess): string | undefined {
+  return typeof process?.meta?.tmuxSocket === "string" ? process.meta.tmuxSocket : undefined;
+}

package/src/quota.ts

@@ -4,6 +4,7 @@ export {
   CLAUDE_MESSAGES_URL,
   CLAUDE_QUOTA_PROBE_MODEL,
   CLAUDE_USAGE_URL,
+  DEFAULT_PROVIDER_QUOTA_CONFIG,
   QUOTA_FAILURE_LOG_INTERVAL_MS,
   QUOTA_FAST_RETRY_MS,
   QUOTA_POLL_INTERVAL_MS,
@@ -20,11 +21,13 @@ export {
   defaultClaudeConfigDir,
   defaultClaudeCredentialsPath,
   hostProviderAccountKey,
+  normalizeProviderQuotaConfig,
   providerPayloadAccountKey,
   providerQuotaErrorFromCollectorError,
   quotaRetryAfterMs,
   readClaudeOAuthAccessToken,
   resolveClaudeQuotaIdentity,
+  resolveClaudeStatuslineQuotaIdentity,
   resolveCodexQuotaIdentity,
   resolveCodexQuotaIdentityFromHome,
   resolveStableClaudeQuotaIdentity,

package/src/runner-core.ts

@@ -4,11 +4,13 @@ import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import type { AgentLifecycle, AgentProfile, ContextState, Message, MessageSessionMeta, SendMessageInput, TaskStatusInput, WorkspaceMetadata } from "agent-relay-sdk";
 import { errMessage, RelayBusClient, RelayHttpClient } from "agent-relay-sdk";
-import { contextStateFromProbeMetrics, quotaStateFromProbeMetrics, readContextProbeState } from "agent-relay-sdk/context-probe";
+import { contextStateFromProbeMetrics, quotaStateFromProbeMetrics } from "agent-relay-sdk/context-probe";
 import { providerAttachmentText, providerMessageText } from "./adapter";
 import type { ManagedProcess, ProviderAdapter, ProviderConfig, ProviderPermissionDecision, ProviderPermissionDecisionInput, ProviderSessionEvent, ProviderStatusUpdate, RunnerSpawnConfig, SemanticStatus, TerminalAttachSpec } from "./adapter";
 import { messagesWithCachedAttachments } from "./attachment-cache";
 import { ClaimTracker } from "./claim-tracker";
+import { ClaudeQuotaHarvest } from "./claude-quota-harvest";
+import { readRunnerContextProbeState } from "./context-probe-state";
 import { startControlServer, type ControlServer } from "./control-server";
 import { ReplyObligationCache, obligationRequiresExplicitReply, responseCaptureReplyRoute } from "./reply-obligation-cache";
 import { Outbox, type OutboxRecord } from "./outbox";
@@ -24,7 +26,8 @@ import { RunnerInsights } from "./runner-insights";
 import { BusyReconciler } from "./busy-reconciler";
 import { publishCapturedResponse } from "./response-capture-report";
 import { runnerLaunchInjectionSessionEvents, type RunnerRelayInjectionEvent } from "./relay-injection-events";
-import { capsFromEnv, contextStateDirFromEnv, logLevelFromEnv, mcpProxyEnabledFromEnv, orchestratorBaseDirFromEnv, orchestratorUrlFromEnv, registrationTimeoutMsFromEnv, runnerInfoFileFromEnv, runnerLogFileFromEnv, runnerOutboxDirWithInfoFallback, sessionDebugEnabled, tagsFromEnv, workspaceModeFromEnv } from "./config";
+import { providerTerminalSession, providerTerminalSocket } from "./process-meta";
+import { capsFromEnv, logLevelFromEnv, mcpProxyEnabledFromEnv, orchestratorBaseDirFromEnv, orchestratorUrlFromEnv, registrationTimeoutMsFromEnv, runnerInfoFileFromEnv, runnerLogFileFromEnv, runnerOutboxDirWithInfoFallback, sessionDebugEnabled, tagsFromEnv, workspaceModeFromEnv } from "./config";
 import {
   appliedAgentProfileMetadata,
   commandTimeoutMs,
@@ -204,6 +207,7 @@ export class AgentRunner {
   private readonly sessionOutbox: Outbox;
   private readonly insights: RunnerInsights;
   private readonly busyReconciler: BusyReconciler;
+  private readonly claudeQuotaHarvest: ClaudeQuotaHarvest;
   private currentToken?: string;
   private currentTokenJti?: string;
   private currentTokenProfileId?: string;
@@ -314,6 +318,7 @@ export class AgentRunner {
     this.mcpProxySecret = crypto.randomUUID();
     const runtime = runtimeMetadata(options.provider);
     this.http = new RelayHttpClient({ baseUrl: options.relayUrl, token: this.currentToken });
+    this.claudeQuotaHarvest = new ClaudeQuotaHarvest({ agentId: this.agentId, provider: options.provider, http: () => this.http });
     this.obligationCache = new ReplyObligationCache({ fetch: () => this.http.listReplyObligations(this.agentId) });
     // Co-locate the durable outbox with the runner's runtime state (survives reboot) when the
     // orchestrator told us where that is; otherwise the Outbox falls back to a temp dir.
@@ -386,8 +391,8 @@ export class AgentRunner {
         agentProfile: options.agentProfile ? appliedAgentProfileMetadata(options.provider, options.agentProfile, { ...options, agentId: this.agentId, env: {}, controlPort: 0 } as RunnerSpawnConfig, options.providerConfig) : null,
         runnerId: options.runnerId,
         startedAt: options.startedAt,
-        tmuxSession: this.providerTerminalSession() ?? options.tmuxSession ?? null,
-        tmuxSocket: this.providerTerminalSocket() ?? null,
+        tmuxSession: providerTerminalSession(this.process) ?? options.tmuxSession ?? null,
+        tmuxSocket: providerTerminalSocket(this.process) ?? null,
         policyName: options.policyName ?? null,
         spawnRequestId: options.spawnRequestId ?? null,
         automationId: options.automationId ?? null,
@@ -628,8 +633,8 @@ export class AgentRunner {
         provider: this.options.provider,
         controlUrl: this.control.url,
         pid: process.pid,
-        ...(this.providerTerminalSession() ? { tmuxSession: this.providerTerminalSession() } : {}),
-        ...(this.providerTerminalSocket() ? { tmuxSocket: this.providerTerminalSocket() } : {}),
+        ...(providerTerminalSession(this.process) ? { tmuxSession: providerTerminalSession(this.process) } : {}),
+        ...(providerTerminalSocket(this.process) ? { tmuxSocket: providerTerminalSocket(this.process) } : {}),
         startedAt: this.options.startedAt,
       }, null, 2) + "\n", { mode: 0o600 });
     } catch (error) {
@@ -1807,8 +1812,8 @@ export class AgentRunner {
       meta: {
         runnerId: this.options.runnerId,
         startedAt: this.options.startedAt,
-        tmuxSession: this.providerTerminalSession() ?? this.options.tmuxSession ?? null,
-        tmuxSocket: this.providerTerminalSocket() ?? null,
+        tmuxSession: providerTerminalSession(this.process) ?? this.options.tmuxSession ?? null,
+        tmuxSocket: providerTerminalSocket(this.process) ?? null,
         policyName: this.options.policyName ?? null,
         spawnRequestId: this.options.spawnRequestId ?? null,
         automationId: this.options.automationId ?? null,
@@ -1857,6 +1862,7 @@ export class AgentRunner {
       await this.http.setStatus(this.agentId, agentStatus, this.options.instanceId);
       await this.http.setReady(this.agentId, agentStatus !== "offline", this.options.instanceId);
       await this.http.heartbeat(this.agentId, this.options.instanceId);
+      await this.claudeQuotaHarvest.publish().catch((error) => this.logRunnerDiagnostic(`passive Claude quota publish failed: ${errMessage(error)}`));
       await this.bootstrapUnreadMessages();
     } catch (error) {
       if (!this.stopped) this.handleHttpLivenessFailure(error);
@@ -2111,8 +2117,8 @@ export class AgentRunner {
     const probeContext = probeMetrics ? contextStateFromProbeMetrics(probeMetrics) : undefined;
     const context = processContext ?? probeContext;
     const quota = probeMetrics ? quotaStateFromProbeMetrics(probeMetrics) : undefined;
-    const terminalSession = this.providerTerminalSession();
-    const terminalSocket = this.providerTerminalSocket();
+    const terminalSession = providerTerminalSession(this.process);
+    const terminalSocket = providerTerminalSocket(this.process);
     const probeModel: ProbeModelInfo | undefined = probeMetrics?.model || probeMetrics?.effort
       ? { model: probeMetrics.model, effort: probeMetrics.effort }
       : undefined;
@@ -2125,14 +2131,6 @@ export class AgentRunner {
     return meta;
   }
 
-  private providerTerminalSession(): string | undefined {
-    return typeof this.process?.meta?.tmuxSession === "string" ? this.process.meta.tmuxSession : undefined;
-  }
-
-  private providerTerminalSocket(): string | undefined {
-    return typeof this.process?.meta?.tmuxSocket === "string" ? this.process.meta.tmuxSocket : undefined;
-  }
-
   private latestProcessContext(): ContextState | undefined {
     const getContext = this.process?.meta?.getContext;
     if (typeof getContext === "function") {
@@ -2144,8 +2142,7 @@ export class AgentRunner {
   }
 
   private latestProbeMetrics() {
-    const stateDir = contextStateDirFromEnv();
-    return readContextProbeState(this.agentId, stateDir);
+    return readRunnerContextProbeState(this.agentId);
   }
 
   private matchesMessage(message: Message): boolean {