agent-relay-runner 0.19.3 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.19.3",
+  "version": "0.21.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.12"
   },
   "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.3",
+  "version": "0.21.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 {
@@ -157,7 +159,7 @@ export function profileAllowsRelayFeature(config: RunnerSpawnConfig, feature: ke
   return config.agentProfile?.relay?.[feature] !== false;
 }
 
-export const RELAY_CONTEXT = `[agent-relay] You are connected to Agent Relay, a real-time message bus between agents and users. When you receive a relay message: read it, do what it asks, and reply through the relay when a text response is needed. Use agent-relay /react <messageId> <emoji> for lightweight acknowledgement or approval. If Relay MCP tools are available, prefer relay_reply, relay_get_message, relay_get_thread, relay_send_message, relay_upload_artifact, relay_attach_artifact, relay_agent_status, relay_spawn_agent, and relay_shutdown_agent. CLI fallback: agent-relay /reply <messageId> --stdin < response.md; if a delivered message says it was truncated, fetch the full body with: agent-relay get-message <messageId>. For command details, run: agent-relay /guide`;
+export const RELAY_CONTEXT = `[agent-relay] You are connected to Agent Relay, a real-time message bus between agents and users. When you receive a relay message: read it, do what it asks, and reply through the relay when a text response is needed. Use agent-relay /react <messageId> <emoji> for lightweight acknowledgement or approval. If Relay MCP tools are available, prefer relay_reply, relay_get_message, relay_get_thread, relay_send_message, relay_upload_artifact, relay_attach_artifact, relay_agent_status, relay_find_agents, relay_spawn_agent, and relay_shutdown_agent. You never need to know or pass your own agent id — relay fills it from your token; use relay_whoami only if you need to reason about yourself. relay_spawn_agent / relay_shutdown_agent only appear if your profile grants spawning (a live-children quota); when present you can stand up long-living child agents and shut down your own — find them later with relay_find_agents spawnedBy:me. CLI fallback: agent-relay /reply <messageId> --stdin < response.md; if a delivered message says it was truncated, fetch the full body with: agent-relay get-message <messageId>. For command details, run: agent-relay /guide`;
 
 const PROVIDER_MESSAGE_BODY_PREVIEW_CHARS = 4000;
 

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
@@ -16,6 +17,8 @@ function codexRelayContextBlock(): string {
 import { prepareCodexProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
 import { CodexAppClient, type ClientEvent } from "./codex-client";
 
+export const DEFAULT_CODEX_TOOL_OUTPUT_TOKEN_LIMIT = 12_000;
+
 type PendingCodexApproval = {
   id: string;
   requestId: string | number;
@@ -36,6 +39,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 +261,8 @@ export class CodexAdapter implements ProviderAdapter {
         ...codexModelConfigArgs(config.model, config.effort),
         ...codexApprovalConfigArgs(config.approvalMode),
         ...(profileAllowsRelayFeature(config, "skills") ? bundledSkillConfigArgs() : []),
+        ...(profileAllowsRelayFeature(config, "mcp") ? relayMcpCodexConfigArgs(config.relayUrl) : []),
+        ...codexToolOutputTokenLimitConfigArgs(config),
         ...codexManagedConfigArgs(),
         "--listen",
         appServerUrl,
@@ -331,6 +337,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 +354,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 +374,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 +387,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 +438,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 +897,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,10 +920,22 @@ export function codexAppServerConfigArgs(...argLists: string[][]): string[] {
   return result;
 }
 
-function tomlString(value: string): string {
-  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+export function codexToolOutputTokenLimitConfigArgs(config: Pick<RunnerSpawnConfig, "agentProfile">): string[] {
+  const configured = codexToolOutputTokenLimit(config.agentProfile?.providerOptions);
+  if (configured === null) return [];
+  const limit = configured ?? DEFAULT_CODEX_TOOL_OUTPUT_TOKEN_LIMIT;
+  return ["-c", `tool_output_token_limit=${limit}`];
 }
 
+function codexToolOutputTokenLimit(providerOptions: unknown): number | null | undefined {
+  if (!isRecord(providerOptions)) return undefined;
+  const codex = providerOptions.codex;
+  if (!isRecord(codex)) return undefined;
+  const limit = codex.toolOutputTokenLimit;
+  return typeof limit === "number" || limit === null ? limit : undefined;
+}
+
+
 async function connectWithRetry(client: CodexAppClient, attempts = 40): Promise<void> {
   // Give the freshly-spawned app-server a moment to bind its socket before the
   // first attempt, so we don't spend the retry budget on guaranteed refusals.

package/src/outbox.ts

@@ -248,6 +248,10 @@ export class Outbox {
     }
   }
 
+  // Pure per-row delay calc: the attempt count lives in SQLite (one outbox row
+  // at a time may be due), so this stays a stateless function rather than the
+  // stateful SDK ReconnectionManager (single in-memory counter) used for the
+  // orchestrator/voice reconnect loops — different model, deliberately not shared.
   private backoff(attempts: number): number {
     const exp = Math.min(this.maxBackoffMs, this.baseBackoffMs * 2 ** (attempts - 1));
     return Math.round(exp / 2 + Math.random() * (exp / 2)); // full-ish jitter, never below half

package/src/relay-instructions.ts

@@ -58,7 +58,7 @@ export function workspaceLifecycleNote(input: { mode?: string | null; branch?: s
   const base = input.baseRef ? `\`${input.baseRef}\`` : "the base branch";
   return [
     `[agent-relay] Isolated workspace: you are in a git worktree on branch ${branch}, based on ${base} — NOT the main checkout. Other agents may work in parallel and land to ${base}, so ${base} will move under you. That is expected; don't fight it.`,
-    `Do NOT push this branch yourself — not with \`git push\`, not with \`tl push\` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, run \`agent-relay workspace ready\` — Relay rebases onto the latest ${base}, lands your work, and pushes for you. (\`agent-relay workspace status\` shows the current state.)`,
+    `Do NOT push this branch yourself — not with \`git push\`, not with \`tl push\` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, run \`agent-relay workspace ready\` — Relay rebases onto the latest ${base}, lands your work, and pushes for you. If the installed \`agent-relay\` binary is stale and says the workspace command is unknown, run the repo-local fallback: \`bun src/index.ts workspace ready\`. (\`agent-relay workspace status\` shows the current state.)`,
   ].join("\n");
 }
 

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 } : {}),
+      },
     });
   }