@rk0429/agentic-relay 0.1.0 → 0.2.0

package/README.md

@@ -199,10 +199,10 @@ sequenceDiagram
     User->>Parent: Task request
     Parent->>Relay: spawn_agent(codex, prompt)
     Note over Relay: RecursionGuard check<br>depth=1, calls=1
-    Relay->>Child: relay codex -p "prompt"<br>RELAY_DEPTH=1
+    Relay->>Child: Codex SDK thread.run("prompt")<br>RELAY_DEPTH=1
     Child->>Relay2: spawn_agent(gemini, sub-prompt)
     Note over Relay2: RecursionGuard check<br>depth=2, calls=1
-    Relay2->>Grandchild: relay gemini -p "sub-prompt"<br>RELAY_DEPTH=2
+    Relay2->>Grandchild: gemini -p "sub-prompt"<br>RELAY_DEPTH=2
     Grandchild-->>Relay2: Result
     Relay2-->>Child: Result
     Child-->>Relay: Result
@@ -229,6 +229,14 @@ graph TD
 
 Each backend CLI has different flags, output formats, and session handling. The adapter layer normalizes these differences behind a common `BackendAdapter` interface. Adding a new backend means implementing this interface and registering it with the `AdapterRegistry`.
 
+Non-interactive execution uses official SDKs where available:
+
+| Backend | Non-interactive (`-p`) | Interactive | Session listing |
+|---|---|---|---|
+| Claude Code | Agent SDK `query()` | CLI spawn | Agent SDK `listSessions()` |
+| Codex CLI | Codex SDK `thread.run()` | CLI spawn | -- |
+| Gemini CLI | CLI spawn | CLI spawn | CLI `--list-sessions` |
+
 ### Hooks Engine
 
 An event-driven hook system that executes external commands via stdin/stdout JSON pipes.
@@ -296,11 +304,12 @@ src/
 - **Package manager**: pnpm
 - **CLI framework**: citty
 - **Bundler**: tsup (esbuild-based)
+- **Backend SDKs**: @anthropic-ai/claude-agent-sdk, @openai/codex-sdk
 - **MCP**: @modelcontextprotocol/sdk
-- **Process management**: execa
+- **Process management**: execa (interactive modes, Gemini CLI)
 - **Validation**: zod
 - **Logging**: consola
-- **Testing**: vitest (274 tests across 18 files)
+- **Testing**: vitest (283 tests across 18 files)
 
 ## License
 

package/dist/relay.mjs

@@ -48,6 +48,7 @@ var ProcessManager = class {
       stdio: "inherit",
       cwd: options?.cwd,
       env: options?.env,
+      extendEnv: options?.env ? false : true,
       timeout: options?.timeout,
       reject: false
     };
@@ -61,10 +62,13 @@ var ProcessManager = class {
   }
   async execute(command, args, options) {
     logger.debug(`Executing: ${command} ${args.join(" ")}`);
+    const stdinMode = options?.stdinMode ?? "pipe";
+    const stdio = stdinMode === "pipe" ? "pipe" : [stdinMode, "pipe", "pipe"];
     const execaOptions = {
-      stdio: "pipe",
+      stdio,
       cwd: options?.cwd,
       env: options?.env,
+      extendEnv: options?.env ? false : true,
       timeout: options?.timeout,
       reject: false
     };
@@ -246,6 +250,15 @@ function mapCommonToNative(backendId, flags) {
 }
 
 // src/adapters/claude-adapter.ts
+import {
+  query,
+  listSessions
+} from "@anthropic-ai/claude-agent-sdk";
+var CLAUDE_NESTING_ENV_VARS = [
+  "CLAUDECODE",
+  "CLAUDE_CODE_SSE_PORT",
+  "CLAUDE_CODE_ENTRYPOINT"
+];
 var ClaudeAdapter = class extends BaseAdapter {
   id = "claude";
   command = "claude";
@@ -256,26 +269,91 @@ var ClaudeAdapter = class extends BaseAdapter {
   }
   async startInteractive(flags) {
     const { args } = this.mapFlags(flags);
-    await this.processManager.spawnInteractive(this.command, args);
+    await this.processManager.spawnInteractive(this.command, args, {
+      env: this.buildCleanEnv(flags)
+    });
   }
   async execute(flags) {
     if (!flags.prompt) {
       throw new Error("execute requires a prompt (-p flag)");
     }
-    const { args } = this.mapFlags(flags);
-    return this.processManager.execute(this.command, args);
+    const env = this.buildCleanEnv(flags);
+    try {
+      const q = query({
+        prompt: flags.prompt,
+        options: {
+          env,
+          cwd: process.cwd(),
+          ...flags.model ? { model: flags.model } : {},
+          ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {},
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true
+        }
+      });
+      let resultText = "";
+      let sessionId = "";
+      let isError = false;
+      let errorMessages = [];
+      for await (const message of q) {
+        if (message.type === "result") {
+          sessionId = message.session_id;
+          if (message.subtype === "success") {
+            resultText = message.result;
+          } else {
+            isError = true;
+            errorMessages = message.errors;
+          }
+        }
+      }
+      logger.debug(`Claude SDK session: ${sessionId}`);
+      return {
+        exitCode: isError ? 1 : 0,
+        stdout: resultText,
+        stderr: errorMessages.join("\n")
+      };
+    } catch (error) {
+      return {
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error)
+      };
+    }
   }
-  async resumeSession(sessionId, _flags) {
-    await this.processManager.spawnInteractive(this.command, [
-      "-r",
-      sessionId
-    ]);
+  async resumeSession(sessionId, flags) {
+    await this.processManager.spawnInteractive(
+      this.command,
+      ["-r", sessionId],
+      { env: this.buildCleanEnv(flags) }
+    );
+  }
+  buildCleanEnv(flags) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== void 0 && !CLAUDE_NESTING_ENV_VARS.includes(key)) {
+        env[key] = value;
+      }
+    }
+    if (flags.mcpContext) {
+      env.RELAY_TRACE_ID = flags.mcpContext.traceId;
+      env.RELAY_PARENT_SESSION_ID = flags.mcpContext.parentSessionId;
+      env.RELAY_DEPTH = String(flags.mcpContext.depth);
+    }
+    return env;
   }
   async listNativeSessions() {
-    logger.debug(
-      "listNativeSessions: claude --resume is interactive, returning empty array"
-    );
-    return [];
+    try {
+      const sessions = await listSessions({ limit: 20 });
+      return sessions.map((s) => ({
+        nativeId: s.sessionId,
+        startedAt: new Date(s.lastModified),
+        lastMessage: s.summary
+      }));
+    } catch (error) {
+      logger.debug(
+        `listNativeSessions failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return [];
+    }
   }
   async auth(action) {
     await this.processManager.spawnInteractive(this.command, ["auth", action]);
@@ -292,6 +370,7 @@ var ClaudeAdapter = class extends BaseAdapter {
 };
 
 // src/adapters/codex-adapter.ts
+import { Codex } from "@openai/codex-sdk";
 var CodexAdapter = class extends BaseAdapter {
   id = "codex";
   command = "codex";
@@ -321,15 +400,35 @@ var CodexAdapter = class extends BaseAdapter {
         `Codex CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
       );
     }
-    const args = [];
-    if (flags.model) {
-      args.push("--model", flags.model);
-    }
-    if (flags.outputFormat === "json") {
-      args.push("--json");
+    try {
+      const codexOptions = {};
+      if (flags.mcpContext) {
+        codexOptions.env = {
+          ...process.env,
+          RELAY_TRACE_ID: flags.mcpContext.traceId,
+          RELAY_PARENT_SESSION_ID: flags.mcpContext.parentSessionId,
+          RELAY_DEPTH: String(flags.mcpContext.depth)
+        };
+      }
+      const codex = new Codex(codexOptions);
+      const thread = codex.startThread({
+        ...flags.model ? { model: flags.model } : {},
+        workingDirectory: process.cwd(),
+        approvalPolicy: "never"
+      });
+      const result = await thread.run(flags.prompt);
+      return {
+        exitCode: 0,
+        stdout: result.finalResponse,
+        stderr: ""
+      };
+    } catch (error) {
+      return {
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error)
+      };
     }
-    args.push("exec", flags.prompt);
-    return this.processManager.execute(this.command, args);
   }
   async resumeSession(sessionId, flags) {
     const args = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rk0429/agentic-relay",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Unified CLI proxy for Claude Code, Codex CLI, and Gemini CLI with MCP-based multi-layer sub-agent orchestration",
   "type": "module",
   "license": "Apache-2.0",
@@ -46,7 +46,9 @@
     "node": ">=22"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.59",
     "@modelcontextprotocol/sdk": "^1.27.1",
+    "@openai/codex-sdk": "^0.105.0",
     "citty": "^0.1.6",
     "consola": "^3.4.0",
     "execa": "^9.5.2",