agent-relay-runner 0.71.0 → 0.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.71.0",
+  "version": "0.73.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.46"
+    "agent-relay-sdk": "0.2.48"
   },
   "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.71.0",
+  "version": "0.73.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapter.ts

@@ -41,6 +41,8 @@ export interface ProviderSessionEvent {
   body: string;
   origin?: "chat" | "terminal" | "provider";
   turnId?: string;
+  /** True only when this response is the completed provider turn, not an intermediate flush. */
+  final?: boolean;
   label?: string;
   status?: "running" | "completed" | "failed";
   streaming?: boolean;
@@ -267,9 +269,13 @@ export function isNotificationMessage(message: Message): boolean {
   return isPersistedRelayMessage(message) && message.replyExpected === false;
 }
 
+function isSpawnObligationMessage(message: Message): boolean {
+  return isRecord(message.payload) && message.payload.source === "spawn-obligation";
+}
+
 function latestReplyableMessage(messages: Message[]): Message | undefined {
   return messages
-    .filter((message) => isPersistedRelayMessage(message) && !isMemoryInjection(message) && !isReactionNotification(message) && message.replyExpected !== false)
+    .filter((message) => isPersistedRelayMessage(message) && !isMemoryInjection(message) && !isReactionNotification(message) && !isSpawnObligationMessage(message) && message.replyExpected !== false)
     .at(-1);
 }
 

package/src/adapters/claude-delivery.ts

@@ -39,6 +39,10 @@ function isReactionNotification(message: Message): boolean {
   return message.payload?.reactionNotification === true || event?.type === "message.reaction";
 }
 
+function isSpawnObligationMessage(message: Message): boolean {
+  return isRecord(message.payload) && message.payload.source === "spawn-obligation";
+}
+
 function isPersistedRelayMessage(message: Message): boolean {
   return Number.isSafeInteger(message.id) && message.id > 0;
 }
@@ -60,7 +64,7 @@ function shouldShowReplyReminder(deliveryCount: number): boolean {
 
 function latestReplyableMessage(messages: Message[]): Message | undefined {
   return messages
-    .filter((message) => isPersistedRelayMessage(message) && !isMemoryInjection(message) && !isReactionNotification(message) && message.replyExpected !== false)
+    .filter((message) => isPersistedRelayMessage(message) && !isMemoryInjection(message) && !isReactionNotification(message) && !isSpawnObligationMessage(message) && message.replyExpected !== false)
     .at(-1);
 }
 

package/src/adapters/codex.ts

@@ -620,7 +620,7 @@ export class CodexAdapter implements ProviderAdapter {
     const joined = this.captureMode === "full" ? messages.join("\n\n") : messages[messages.length - 1]!;
     this.turnMessages = [];
     const text = joined.trim();
-    if (text) this.sessionEventCb({ type: "response", origin: "provider", body: text, ...(this.activeTurnId ? { turnId: this.activeTurnId } : {}) });
+    if (text) this.sessionEventCb({ type: "response", origin: "provider", body: text, final: true, ...(this.activeTurnId ? { turnId: this.activeTurnId } : {}) });
   }
 
   private finishMainTurn(): void {

package/src/config.ts

@@ -111,6 +111,10 @@ export function workspaceJsonFromEnv(): string | undefined {
   return process.env.AGENT_RELAY_WORKSPACE_JSON;
 }
 
+export function relayInjectionEventsJsonFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_INJECTION_EVENTS_JSON;
+}
+
 export function tmuxSessionFromEnv(): string | undefined {
   return process.env.AGENT_RELAY_TMUX_SESSION;
 }

package/src/index.ts

@@ -12,6 +12,7 @@ import {
   loadGlobalConfig,
   loadProviderConfigFromRelay,
   policyNameFromEnv,
+  relayInjectionEventsJsonFromEnv,
   resolveCwd,
   runnerId,
   runtimeTokenExpiresAtFromEnv,
@@ -23,8 +24,9 @@ import {
 } from "./config";
 import { createProviderAdapter } from "./providers";
 import { VERSION } from "./version";
-import type { AgentProfile, SpawnProvider, WorkspaceMetadata } from "agent-relay-sdk";
-import { errMessage, normalizeAgentLifecycle, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import type { AgentProfile, RelayInjectionCategory, SpawnProvider, WorkspaceMetadata } from "agent-relay-sdk";
+import { errMessage, isRecord, normalizeAgentLifecycle, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import type { RunnerRelayInjectionEvent } from "./relay-injection-events";
 
 interface CliOptions {
   provider: SpawnProvider;
@@ -42,6 +44,7 @@ interface CliOptions {
   agentId?: string;
   prompt?: string;
   systemPromptAppend?: string;
+  relayInjectionEvents?: RunnerRelayInjectionEvent[];
   tags: string[];
   caps: string[];
   providerArgs: string[];
@@ -106,6 +109,7 @@ export async function main(argv = process.argv): Promise<void> {
     workspace: parseWorkspaceEnv(workspaceJsonFromEnv()),
     prompt: opts.prompt,
     systemPromptAppend: opts.systemPromptAppend,
+    relayInjectionEvents: parseRelayInjectionEventsEnv(relayInjectionEventsJsonFromEnv()),
     tmuxSession: tmuxSessionFromEnv(),
     tags: opts.tags,
     capabilities: opts.caps,
@@ -306,6 +310,23 @@ function parseWorkspaceEnv(raw: string | undefined): WorkspaceMetadata | undefin
   }
 }
 
+function parseRelayInjectionEventsEnv(raw: string | undefined): RunnerRelayInjectionEvent[] | undefined {
+  if (!raw) return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return undefined;
+    const categories = new Set(["memory", "instructions", "tools", "comms", "knowledge", "context"]);
+    const events = parsed.flatMap((item): RunnerRelayInjectionEvent[] => {
+      if (!isRecord(item) || typeof item.summary !== "string" || !categories.has(String(item.category))) return [];
+      const detail = isRecord(item.detail) ? item.detail : {};
+      return [{ category: item.category as RelayInjectionCategory, summary: item.summary, detail }];
+    });
+    return events.length ? events : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 function printHelp(provider: string): void {
   console.log(`${provider}-relay [--headless] [--model ALIAS] [--effort LEVEL] [--rig NAME] [--profile NAME] [--cwd PATH] [--relay-url URL] [--approval MODE] [--label NAME] [--agent-id ID] [--prompt TEXT] [--system-prompt-append TEXT] [--tags a,b] [--caps x,y] [-- provider-args...]`);
 }

package/src/relay-injection-events.ts

@@ -0,0 +1,97 @@
+import type { MessageSessionMeta, RelayInjectionCategory, SpawnProvider } from "agent-relay-sdk";
+import type { ProviderConfig, RunnerSpawnConfig } from "./adapter";
+import { assembleLaunch } from "./launch-assembly";
+
+export interface RunnerRelayInjectionEvent {
+  category: RelayInjectionCategory;
+  summary: string;
+  detail: Record<string, unknown>;
+}
+
+interface RunnerRelayInjectionSessionEvent {
+  from: string;
+  to: string;
+  body: string;
+  session: MessageSessionMeta;
+}
+
+interface KeyedRelayInjectionEvent {
+  key: string;
+  event: RunnerRelayInjectionEvent;
+}
+
+interface RunnerLaunchInjectionInput {
+  carried?: RunnerRelayInjectionEvent[];
+  provider: string;
+  config: RunnerSpawnConfig;
+  providerConfig: ProviderConfig;
+  agentId: string;
+  providerSessionId: string;
+  timestamp?: number;
+}
+
+function supportsLaunchAssembly(provider: string): provider is SpawnProvider {
+  return provider === "claude" || provider === "codex";
+}
+
+function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInjectionEvent[] {
+  const events: KeyedRelayInjectionEvent[] = (input.carried ?? []).map((event, index) => ({ key: `spawn-${index}`, event }));
+  if (!supportsLaunchAssembly(input.provider)) return events;
+  const assembled = assembleLaunch(input.provider, input.config, input.providerConfig);
+  const toolCount = assembled.skills.length + assembled.plugins.length + assembled.mcp.servers.length
+    + (assembled.relaySkills ? 1 : 0)
+    + (assembled.relayPlugin ? 1 : 0)
+    + (assembled.mcp.relayEndpoint ? 1 : 0)
+    + (assembled.statusLine ? 1 : 0);
+  if (toolCount === 0) return events;
+  const parts = [
+    assembled.relaySkills ? "relay skills" : "",
+    assembled.relayPlugin ? "relay plugin" : "",
+    assembled.statusLine ? "status line" : "",
+    assembled.mcp.relayEndpoint ? "relay MCP" : "",
+    assembled.skills.length ? `${assembled.skills.length} skill${assembled.skills.length === 1 ? "" : "s"}` : "",
+    assembled.plugins.length ? `${assembled.plugins.length} plugin${assembled.plugins.length === 1 ? "" : "s"}` : "",
+    assembled.mcp.servers.length ? `${assembled.mcp.servers.length} MCP server${assembled.mcp.servers.length === 1 ? "" : "s"}` : "",
+  ].filter(Boolean);
+  events.push({
+    key: "tools",
+    event: {
+      category: "tools",
+      summary: `provisioned ${parts.join(", ")}`,
+      detail: {
+        source: "launch-assembly",
+        provider: assembled.provider,
+        base: assembled.base,
+        vanilla: assembled.vanilla,
+        relayContext: assembled.relayContext,
+        relaySkills: assembled.relaySkills,
+        relayPlugin: assembled.relayPlugin,
+        statusLine: assembled.statusLine,
+        skills: assembled.skills,
+        plugins: assembled.plugins,
+        mcp: assembled.mcp,
+      },
+    },
+  });
+  return events;
+}
+
+export function runnerLaunchInjectionSessionEvents(input: RunnerLaunchInjectionInput): RunnerRelayInjectionSessionEvent[] {
+  const timestamp = input.timestamp ?? Date.now();
+  return launchInjectionEvents(input).map(({ event, key }) => ({
+    from: input.agentId,
+    to: "user",
+    body: event.summary,
+    session: {
+      type: "relay-injection",
+      stepId: `relay-injection:${input.providerSessionId}:${key}`,
+      relayInjection: {
+        category: event.category,
+        summary: event.summary,
+        detail: event.detail,
+        agentId: input.agentId,
+        timestamp,
+      },
+    },
+  }));
+}

package/src/reply-obligation-cache.ts

@@ -24,6 +24,7 @@ import { logger } from "./logger";
 // both the Claude Stop-hook nag (control-server) and the non-claude re-injection (runner)
 // gate on it, so the rule must not drift between them.
 export function obligationRequiresExplicitReply(obligation: ReplyObligation): boolean {
+  if (obligation.source === "spawn-obligation") return false;
   return obligation.from !== "user";
 }
 

package/src/response-capture-report.ts

@@ -12,6 +12,10 @@ type SessionPublisher = (input: {
   replyTo?: number;
 }) => void | Promise<void>;
 
+function finalSession(session: MessageSessionMeta): MessageSessionMeta {
+  return { ...session, final: true };
+}
+
 export async function publishCapturedResponse(input: {
   publishSessionEvent: SessionPublisher;
   outbox: ReportOutbox;
@@ -27,7 +31,7 @@ export async function publishCapturedResponse(input: {
     to: input.to,
     body: input.body,
     ...(input.replyTo ? { replyTo: input.replyTo } : {}),
-    session: input.session,
+    session: finalSession(input.session),
   });
   enqueueCapturedResponseReport(input);
 }
@@ -53,7 +57,7 @@ export function enqueueCapturedResponseReport(input: {
       kind: "chat",
       body: input.body,
       replyExpected: false,
-      payload: { responseCapture: { provider: input.provider, ...input.session } },
+      payload: { responseCapture: { provider: input.provider, ...finalSession(input.session) } },
     },
   });
 }

package/src/runner-core.ts

@@ -23,6 +23,7 @@ import { deliverBufferedMcpCall as deliverBufferedMcpOutboxCall, deliverRunnerOu
 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 {
   appliedAgentProfileMetadata,
@@ -115,6 +116,7 @@ interface RunnerOptions {
   agentProfile?: AgentProfile;
   prompt?: string;
   systemPromptAppend?: string;
+  relayInjectionEvents?: RunnerRelayInjectionEvent[];
   tags: string[];
   capabilities: string[];
   providerArgs: string[];
@@ -601,7 +603,12 @@ export class AgentRunner {
       },
     };
     const launchSeededPrompt = this.options.adapter.seedsInitialPromptAtLaunch ? this.options.prompt?.trim() : ""; if (launchSeededPrompt) this.recordInjectedPrompt(launchSeededPrompt);
-    return this.options.adapter.spawn(config);
+    const managedProcess = await this.options.adapter.spawn(config);
+    const injectionEvents = runnerLaunchInjectionSessionEvents({ carried: this.options.relayInjectionEvents, provider: this.options.provider, config, providerConfig: this.options.providerConfig, agentId: this.agentId, providerSessionId: this.providerSessionId });
+    for (const event of injectionEvents) {
+      this.publishSessionEvent(event);
+    }
+    return managedProcess;
   }
 
   private async terminalAttachSpec(): Promise<TerminalAttachSpec> {
@@ -1391,7 +1398,7 @@ export class AgentRunner {
     }
 
     this.sessionLog(`response captured for turn ${turnId ?? "?"} (${body.length} chars${replyToMessageId ? `, replyTo #${replyToMessageId}` : ", no replyTo"})`);
-    await publishCapturedResponse({ publishSessionEvent: (event) => this.publishSessionEvent(event), outbox: this.sessionOutbox, provider: this.options.provider, from: this.agentId, to: replyTarget, body, replyTo: replyToMessageId, session: { type: "response", origin: "provider", ...(turnId ? { turnId } : {}) } });
+    await publishCapturedResponse({ publishSessionEvent: (event) => this.publishSessionEvent(event), outbox: this.sessionOutbox, provider: this.options.provider, from: this.agentId, to: replyTarget, body, replyTo: replyToMessageId, session: { type: "response", origin: "provider", final: true, ...(turnId ? { turnId } : {}) } });
     // The agent's reply may have cleared an obligation — refresh the snapshot so the next
     // turn-end doesn't re-prompt for a message already answered (#196).
     if (replyToMessageId) this.obligationCache.markDirty();
@@ -1625,6 +1632,7 @@ export class AgentRunner {
         ...(event.status ? { status: event.status } : {}),
         ...(event.streaming !== undefined ? { streaming: event.streaming } : {}),
         ...(event.stepId ? { stepId: event.stepId } : {}),
+        ...(event.final ? { final: true } : {}),
       },
     });
   }