agent-relay-runner 0.72.0 → 0.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.72.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.47"
+    "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.72.0",
+  "version": "0.73.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

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/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> {