agent-relay-runner 0.19.2 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.19.2",
+  "version": "0.20.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.10"
+    "agent-relay-sdk": "0.2.11"
   },
   "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.19.2",
+  "version": "0.20.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapter.ts

@@ -40,6 +40,8 @@ export interface ProviderSessionEvent {
   origin?: "chat" | "terminal" | "provider";
   turnId?: string;
   label?: string;
+  status?: "running" | "completed" | "failed";
+  streaming?: boolean;
 }
 
 export interface ProviderConfig {

package/src/adapters/claude.ts

@@ -7,6 +7,7 @@ import { tmuxCommand, tmuxHasSession } from "agent-relay-sdk/tmux-utils";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { profileAllowsRelayFeature, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderStatusUpdate, type RunnerSpawnConfig, type SemanticStatus, type SpawnArgs } from "../adapter";
 import { prepareClaudeProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
+import { relayMcpClaudeConfigArg } from "../relay-mcp";
 import { claudeProviderMessageText } from "./claude-delivery";
 
 export class ClaudeAdapter implements ProviderAdapter {
@@ -203,6 +204,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     const args = [
       ...rigPrefix,
       ...pluginDirs.flatMap((dir) => ["--plugin-dir", dir]),
+      ...(profileAllowsRelayFeature(config, "mcp") ? relayMcpClaudeConfigArg(config.relayUrl) : []),
       ...(profileAllowsRelayFeature(config, "statusLine") ? sessionStatusLineSettingsArgs(defaultArgs, config.providerArgs) : []),
       ...(config.systemPromptAppend ? ["--append-system-prompt", config.systemPromptAppend] : []),
       ...providerArgs,

package/src/adapters/codex.ts

@@ -6,6 +6,7 @@ import { isRecord, stringValue } from "agent-relay-sdk";
 import { isPidAlive, killPid, waitForPidsExit } from "agent-relay-sdk/process-utils";
 import { profileAllowsRelayFeature, providerMessageText, RELAY_CONTEXT, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderPermissionDecisionInput, type ProviderSessionEvent, type ProviderStatusUpdate, type RunnerSpawnConfig, type SpawnArgs, type TerminalAttachSpec } from "../adapter";
 import { workspaceDepsNoteFromEnv } from "../relay-instructions";
+import { relayMcpCodexConfigArgs, tomlString } from "../relay-mcp";
 import { logger } from "../logger";
 
 /** Relay context prepended to a Codex agent's first turn: the standard relay
@@ -36,6 +37,7 @@ export class CodexAdapter implements ProviderAdapter {
   // 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 itemTextBuffers = new Map<string, string>();
   private captureMode: "final" | "full" = "final";
 
   onStatusChange(cb: (status: ProviderStatusUpdate) => void): void {
@@ -257,6 +259,7 @@ export class CodexAdapter implements ProviderAdapter {
         ...codexModelConfigArgs(config.model, config.effort),
         ...codexApprovalConfigArgs(config.approvalMode),
         ...(profileAllowsRelayFeature(config, "skills") ? bundledSkillConfigArgs() : []),
+        ...(profileAllowsRelayFeature(config, "mcp") ? relayMcpCodexConfigArgs(config.relayUrl) : []),
         ...codexManagedConfigArgs(),
         "--listen",
         appServerUrl,
@@ -331,6 +334,7 @@ export class CodexAdapter implements ProviderAdapter {
         const turn = isRecord(params?.turn) ? params.turn : undefined;
         this.activeTurnId = stringValue(turn?.id);
         this.turnMessages = [];
+        this.itemTextBuffers.clear();
         this.statusCb({ status: "busy", reason: "provider-turn", id: this.activeTurnId });
       }
     }
@@ -347,6 +351,7 @@ export class CodexAdapter implements ProviderAdapter {
     if ((method.includes("item/completed") || method.includes("item.completed")) && !isSubagent) {
       this.handleCodexItem(isRecord(params?.item) ? params.item : undefined);
     }
+    if (!isSubagent) this.handleCodexItemDelta(method, params);
     if (method.includes("thread/status")) {
       const status = statusType(params?.status);
       if (threadId && this.subagentThreads.has(threadId)) {
@@ -366,9 +371,11 @@ export class CodexAdapter implements ProviderAdapter {
     if (!item) return;
     const type = stringValue(item.type);
     const turnId = this.activeTurnId;
+    const itemId = codexItemId(item);
     if (type === "agentMessage") {
-      const text = stringValue(item.text)?.trim();
+      const text = (stringValue(item.text) ?? (itemId ? this.itemTextBuffers.get(itemId) : undefined))?.trim();
       if (text) this.turnMessages.push(text);
+      if (itemId) this.itemTextBuffers.delete(itemId);
       return;
     }
     if (type === "userMessage") {
@@ -377,12 +384,39 @@ export class CodexAdapter implements ProviderAdapter {
       return;
     }
     if (type === "reasoning") {
-      const text = codexReasoningText(item);
+      const buffered = itemId ? this.itemTextBuffers.get(itemId) : undefined;
+      const text = (codexReasoningText(item) || buffered || "").trim();
       if (text) this.sessionEventCb({ type: "reasoning", origin: "provider", body: text, ...(turnId ? { turnId } : {}) });
+      if (itemId) this.itemTextBuffers.delete(itemId);
       return;
     }
     const tool = codexToolSummary(type, item);
-    if (tool) this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, ...(turnId ? { turnId } : {}) });
+    if (tool) this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, status: "completed", ...(turnId ? { turnId } : {}) });
+    if (itemId) this.itemTextBuffers.delete(itemId);
+  }
+
+  private handleCodexItemDelta(method: string, params: Record<string, unknown> | undefined): void {
+    if (!method.includes("item/") && !method.includes("item.")) return;
+    const item = isRecord(params?.item) ? params.item : undefined;
+    const itemId = codexItemId(params) ?? codexItemId(item);
+    const type = codexItemTypeFromMethod(method) ?? stringValue(item?.type);
+    const turnId = this.activeTurnId;
+
+    if (method.includes("/started") || method.includes(".started")) {
+      const tool = codexToolSummary(type, item ?? params ?? {});
+      if (tool) this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, status: "running", streaming: true, ...(turnId ? { turnId } : {}) });
+      return;
+    }
+
+    if (type === "agentMessage" || type === "reasoning" || type === "plan") {
+      const delta = codexDeltaText(params);
+      if (delta && itemId) this.itemTextBuffers.set(itemId, `${this.itemTextBuffers.get(itemId) ?? ""}${delta}`);
+      return;
+    }
+
+    // Raw stdout/stderr deltas can be huge. Surface the tool lifecycle via started/completed
+    // summaries only; never persist raw process output into the chat mirror.
+    if (method.includes("outputDelta") || method.includes("output_delta") || method.includes("progress")) return;
   }
 
   private flushTurnResponse(): void {
@@ -401,6 +435,25 @@ export class CodexAdapter implements ProviderAdapter {
   }
 }
 
+function codexItemId(item: Record<string, unknown> | undefined): string | undefined {
+  return stringValue(item?.itemId) ?? stringValue(item?.id);
+}
+
+function codexDeltaText(params: Record<string, unknown> | undefined): string {
+  const delta = params?.delta;
+  if (typeof delta === "string") return delta;
+  if (isRecord(delta)) {
+    const text = stringValue(delta.text) ?? stringValue(delta.value) ?? stringValue(delta.content);
+    if (text) return text;
+  }
+  return stringValue(params?.text) ?? stringValue(params?.chunk) ?? stringValue(params?.content) ?? "";
+}
+
+function codexItemTypeFromMethod(method: string): string | undefined {
+  const match = method.match(/item[/.]([^/.]+)[/.]/);
+  return match?.[1];
+}
+
 function codexApprovalFromServerRequest(message: { id: string | number; method: string; params?: unknown }): { pending: PendingCodexApproval; view: Record<string, unknown> } | null {
   if (!isRecord(message.params)) return null;
   const method = message.method;
@@ -841,6 +894,10 @@ export function bundledSkillConfigArgs(skillDirs = bundledCodexSkillDirs()): str
   return ["-c", `skills.config=[${skillsConfig}]`];
 }
 
+// tomlString now lives in ../relay-mcp (shared with the relay MCP injection args);
+// re-exported here so existing codex.ts consumers/tests keep their import path.
+export { tomlString };
+
 export function codexAppServerConfigArgs(...argLists: string[][]): string[] {
   const result: string[] = [];
   for (const args of argLists) {
@@ -860,9 +917,6 @@ export function codexAppServerConfigArgs(...argLists: string[][]): string[] {
   return result;
 }
 
-function tomlString(value: string): string {
-  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
 
 async function connectWithRetry(client: CodexAppClient, attempts = 40): Promise<void> {
   // Give the freshly-spawned app-server a moment to bind its socket before the

package/src/relay-mcp.ts

@@ -0,0 +1,50 @@
+// Single home for the relay HTTP MCP endpoint descriptor + per-provider injection
+// args. Both adapters (and Stage 2's proxy) import from here so the endpoint path,
+// server name, and token-handling rules live in exactly one place.
+//
+// Token handling: the bearer token is NEVER placed in argv (it would leak via `ps`
+// and the agent's own process inspection). Claude expands `${AGENT_RELAY_TOKEN}`
+// from the env at MCP-config parse time; Codex reads it from the named env var.
+
+export const RELAY_MCP_SERVER_NAME = "agent-relay";
+export const RELAY_MCP_PATH = "/api/mcp";
+
+export function relayMcpEndpoint(relayUrl: string): string {
+  return `${relayUrl.replace(/\/+$/, "")}${RELAY_MCP_PATH}`;
+}
+
+// Claude: additive `--mcp-config` JSON (NOT --strict-mcp-config, which would clobber
+// the user's own servers). HTTP transport, token via env-var expansion so it never
+// hits argv. Returns the full ["--mcp-config", "<json>"] arg pair.
+export function relayMcpClaudeConfigArg(relayUrl: string): string[] {
+  return [
+    "--mcp-config",
+    JSON.stringify({
+      mcpServers: {
+        [RELAY_MCP_SERVER_NAME]: {
+          type: "http",
+          url: relayMcpEndpoint(relayUrl),
+          headers: { Authorization: "Bearer ${AGENT_RELAY_TOKEN}" },
+        },
+      },
+    }),
+  ];
+}
+
+// Codex: `-c mcp_servers.<name>.*` overrides. `bearer_token_env_var` tells Codex to
+// read the token from the env var itself → transport resolves to streamable_http.
+export function relayMcpCodexConfigArgs(relayUrl: string): string[] {
+  const key = `mcp_servers.${RELAY_MCP_SERVER_NAME}`;
+  return [
+    "-c",
+    `${key}.url=${tomlString(relayMcpEndpoint(relayUrl))}`,
+    "-c",
+    `${key}.bearer_token_env_var=${tomlString("AGENT_RELAY_TOKEN")}`,
+  ];
+}
+
+// Shared TOML string escaper for Codex `-c key=value` overrides. One home; codex.ts
+// imports this rather than re-declaring it.
+export function tomlString(value: string): string {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}

package/src/runner.ts

@@ -1158,8 +1158,9 @@ export class AgentRunner {
       return;
     }
     if (event.type === "response") {
-      // If a relay message is awaiting the agent's own reply, let the agent answer
-      // it (Codex agents reply via their relay skills) instead of double-posting.
+      // Dashboard prompt injection is already answered by this captured App Server
+      // response. Other Relay inbox obligations still belong to the agent's explicit
+      // reply path, so those keep suppressing auto-capture to avoid duplicates.
       let replyToMessageId: number | undefined;
       const pendingPrompt = this.pendingPromptMessageId;
       if (pendingPrompt) {
@@ -1176,6 +1177,7 @@ export class AgentRunner {
         ...(replyToMessageId ? { replyTo: replyToMessageId } : {}),
         session: { type: "response", origin: event.origin ?? "provider", ...(turnId ? { turnId } : {}) },
       });
+      if (replyToMessageId) this.obligationCache.markDirty();
       return;
     }
     if (this.options.providerConfig.reasoningCapture === false) return;
@@ -1183,7 +1185,14 @@ export class AgentRunner {
       from: this.agentId,
       to: "user",
       body,
-      session: { type: event.type, origin: event.origin ?? "provider", ...(turnId ? { turnId } : {}), ...(event.label ? { label: event.label } : {}) },
+      session: {
+        type: event.type,
+        origin: event.origin ?? "provider",
+        ...(turnId ? { turnId } : {}),
+        ...(event.label ? { label: event.label } : {}),
+        ...(event.status ? { status: event.status } : {}),
+        ...(event.streaming !== undefined ? { streaming: event.streaming } : {}),
+      },
     });
   }