mcp-agents 0.5.4 → 0.5.6

package/README.md

@@ -37,7 +37,9 @@ mcp-agents
 # Specific provider
 mcp-agents --provider claude
 mcp-agents --provider gemini
-mcp-agents --provider gemini --sandbox false
+
+# Optional: enable Gemini sandbox mode
+mcp-agents --provider gemini --sandbox true
 ```
 
 The server speaks [JSON-RPC over stdio](https://modelcontextprotocol.io/docs/concepts/transports#stdio). It prints `[mcp-agents] ready (provider: <name>)` to stderr when it's listening.
@@ -48,7 +50,7 @@ Each `--provider` flag maps to a single exposed tool:
 
 | Provider | Tool name | CLI command |
 |----------|-----------|-------------|
-| `claude` | `claude_code` | `claude -p <prompt>` |
+| `claude` | `claude_code` | `claude -p --output-format json` |
 | `gemini` | `gemini` | `gemini [-s] -p <prompt>` |
 | `codex` | *(pass-through)* | `codex mcp-server` |
 
@@ -61,6 +63,8 @@ Each `--provider` flag maps to a single exposed tool:
 
 Any additional `tools/call` arguments are ignored (for example `model` or `model_reasoning_effort`).
 
+Claude calls run with `--output-format json`; the server parses the JSON payload and returns the assistant `result` text (or an MCP error if `is_error=true`).
+
 ### `gemini` parameters
 
 | Parameter | Type | Required | Description |
@@ -96,7 +100,20 @@ Add entries to your project's `.mcp.json` (requires `npm i -g mcp-agents`):
     },
     "gemini": {
       "command": "mcp-agents",
-      "args": ["--provider", "gemini", "--sandbox", "false"]
+      "args": ["--provider", "gemini"]
+    }
+  }
+}
+```
+
+Optional Gemini sandbox mode in `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "gemini": {
+      "command": "mcp-agents",
+      "args": ["--provider", "gemini", "--sandbox", "true"]
     }
   }
 }
@@ -136,16 +153,28 @@ Override codex defaults at server startup (not via `tools/call` arguments):
 
 ## Integration with OpenAI Codex
 
-Add two entries to `~/.codex/config.toml` — one per provider you want available:
+Add two entries to `~/.codex/config.toml` — one per provider you want available.
+Set `tool_timeout_sec = 300` to avoid Codex MCP's default 60s per-tool timeout:
 
 ```toml
 [mcp_servers.claude-code]
 command = "mcp-agents"
 args = ["--provider", "claude"]
+tool_timeout_sec = 300
 
 [mcp_servers.gemini]
 command = "mcp-agents"
-args = ["--provider", "gemini", "--sandbox", "false"]
+args = ["--provider", "gemini"]
+tool_timeout_sec = 300
+```
+
+Optional Gemini sandbox mode in Codex config:
+
+```toml
+[mcp_servers.gemini]
+command = "mcp-agents"
+args = ["--provider", "gemini", "--sandbox", "true"]
+tool_timeout_sec = 300
 ```
 
 Then in a Codex session you can call the `claude_code` or `gemini` tools, which shell out to the respective CLIs.
@@ -165,7 +194,7 @@ After `npm link`, any edits to `server.js` take effect immediately — no reinst
 2. The server reads `--provider <name>` from its argv (defaults to `codex`)
 3. It registers a single tool matching that provider's CLI
 4. Client calls `tools/call` with the tool name and a `prompt`
-5. The server runs the CLI as a child process and returns stdout (or stderr) as the tool result
+5. The server runs the CLI as a child process and returns tool text (Claude JSON `result`, or stdout/stderr for other providers)
 
 The server includes a keepalive timer to prevent Node.js from exiting prematurely when stdin reaches EOF before the async subprocess registers an active handle.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-agents",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "MCP server that wraps AI CLI tools (Claude Code, Gemini CLI, Codex CLI) for use by any MCP client",
   "type": "module",
   "bin": {

package/server.js

@@ -20,6 +20,7 @@ const VERSION = JSON.parse(
 
 const DEFAULT_TIMEOUT_MS = 300_000;
 const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+const CLAUDE_EMPTY_OUTPUT_MAX_ATTEMPTS = 2;
 
 // ---------------------------------------------------------------------------
 // CLI Backend Definitions
@@ -32,7 +33,7 @@ const CLI_BACKENDS = {
     description:
       "Run Claude Code CLI with a prompt (via stdin). Supports prompt + optional timeout_ms only; other arguments are ignored.",
     stdinPrompt: true,
-    buildArgs: () => ["--no-session-persistence", "-p"],
+    buildArgs: () => ["--no-session-persistence", "-p", "--output-format", "json"],
     extraProperties: {},
   },
   gemini: {
@@ -83,6 +84,33 @@ function toStringArg(value) {
   return String(value);
 }
 
+/**
+ * Normalize provider output and parse Claude's JSON print format when present.
+ * @param {string} provider
+ * @param {string} output
+ * @returns {{ text: string, isError: boolean }}
+ */
+function normalizeToolOutput(provider, output) {
+  if (provider !== "claude") return { text: output, isError: false };
+
+  const trimmed = output.trim();
+  if (!trimmed) return { text: "", isError: false };
+
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && parsed.type === "result") {
+      return {
+        text: toStringArg(parsed.result),
+        isError: parsed.is_error === true,
+      };
+    }
+  } catch {
+    // Fall back to raw text if output shape changes or isn't JSON.
+  }
+
+  return { text: output, isError: false };
+}
+
 /**
  * Print usage information to stdout.
  */
@@ -186,11 +214,12 @@ function parseArgs() {
  * @param {string} command
  * @param {string[]} args
  * @param {{ timeoutMs?: number, stdinData?: string }} [opts]
- * @returns {Promise<string>}
+ * @returns {Promise<{ output: string, stdoutBytes: number, stderrBytes: number, durationMs: number }>}
  */
 function runCli(command, args, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const stdinData = opts.stdinData;
+  const startedAt = Date.now();
 
   return new Promise((resolve, reject) => {
     let stdout = "";
@@ -221,7 +250,12 @@ function runCli(command, args, opts = {}) {
       clearTimeout(timer);
       if (settled) return;
       settled = true;
-      err ? reject(err) : resolve((stdout || stderr || "").trimEnd());
+      err ? reject(err) : resolve({
+        output: (stdout || stderr || "").trimEnd(),
+        stdoutBytes: stdoutLen,
+        stderrBytes: stderrLen,
+        durationMs: Date.now() - startedAt,
+      });
     };
 
     child.stdout.on("data", (chunk) => {
@@ -450,16 +484,90 @@ async function main() {
     const cliArgs = backend.stdinPrompt
       ? backend.buildArgs(extraOpts)
       : backend.buildArgs(prompt, extraOpts);
-    const cliOpts = backend.stdinPrompt
-      ? { timeoutMs, stdinData: prompt }
-      : { timeoutMs };
+    const buildCliOpts = (attemptTimeoutMs) => (
+      backend.stdinPrompt
+        ? { timeoutMs: attemptTimeoutMs, stdinData: prompt }
+        : { timeoutMs: attemptTimeoutMs }
+    );
 
     logErr(`[mcp-agents] tools/call: running ${backend.command} …`);
     try {
-      const output = await runCli(backend.command, cliArgs, cliOpts);
-      logErr("[mcp-agents] tools/call: done");
+      const startedAt = Date.now();
+      const maxAttempts = providerName === "claude"
+        ? CLAUDE_EMPTY_OUTPUT_MAX_ATTEMPTS
+        : 1;
+      let lastResult;
+      let lastNormalized = { text: "", isError: false };
+
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const elapsedMs = Date.now() - startedAt;
+        const remainingMs = timeoutMs - elapsedMs;
+
+        if (remainingMs <= 0) break;
+
+        const result = await runCli(
+          backend.command,
+          cliArgs,
+          buildCliOpts(remainingMs),
+        );
+        lastResult = result;
+        const normalized = normalizeToolOutput(providerName, result.output);
+        lastNormalized = normalized;
+
+        if (normalized.isError) {
+          const msg = normalized.text.trim() || `${backend.command} returned is_error=true`;
+          logErr(
+            `[mcp-agents] tools/call: provider returned error payload (provider=${providerName})`,
+          );
+          return {
+            content: [{ type: "text", text: msg }],
+            isError: true,
+          };
+        }
+
+        if (normalized.text.trim()) {
+          logErr("[mcp-agents] tools/call: done");
+          return {
+            content: [{ type: "text", text: normalized.text }],
+          };
+        }
+
+        if (attempt < maxAttempts) {
+          logErr(
+            "[mcp-agents] tools/call: empty output; retrying " +
+              `(provider=${providerName}, attempt=${attempt}/${maxAttempts}, ` +
+              `duration_ms=${result.durationMs}, timeout_ms=${timeoutMs}, ` +
+              `stdout_bytes=${result.stdoutBytes}, stderr_bytes=${result.stderrBytes})`,
+          );
+        }
+      }
+
+      if (lastResult && !lastNormalized.text.trim()) {
+        const elapsedMs = Date.now() - startedAt;
+        const emptyMsg = providerName === "claude"
+          ? "claude returned empty output twice (exit 0); treated as failure"
+          : `${backend.command} returned empty output (exit 0); treated as failure`;
+
+        logErr(
+          "[mcp-agents] tools/call: empty output after retries " +
+            `(provider=${providerName}, attempts=${maxAttempts}, ` +
+            `elapsed_ms=${elapsedMs}, timeout_ms=${timeoutMs}, ` +
+            `stdout_bytes=${lastResult.stdoutBytes}, stderr_bytes=${lastResult.stderrBytes})`,
+        );
+        return {
+          content: [{ type: "text", text: emptyMsg }],
+          isError: true,
+        };
+      }
+
+      const timeoutMsg = `${backend.command} failed: timeout budget exhausted before retry`;
+      logErr(
+        "[mcp-agents] tools/call: timeout budget exhausted " +
+          `(provider=${providerName}, timeout_ms=${timeoutMs})`,
+      );
       return {
-        content: [{ type: "text", text: output || "" }],
+        content: [{ type: "text", text: timeoutMsg }],
+        isError: true,
       };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);