agentxchain 2.4.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/step.js

@@ -17,7 +17,7 @@
  *   - local_cli: implemented via subprocess dispatch + staged turn result
  *   - api_proxy: implemented for synchronous review-only turns and stages
  *     provider-backed JSON before validation/acceptance
- *   - mcp: implemented for synchronous MCP stdio tool dispatch
+ *   - mcp: implemented for synchronous MCP stdio or streamable_http tool dispatch
  */
 
 import chalk from 'chalk';
@@ -46,7 +46,7 @@ import {
   saveDispatchLogs,
   resolvePromptTransport,
 } from '../lib/adapters/local-cli-adapter.js';
-import { dispatchMcp } from '../lib/adapters/mcp-adapter.js';
+import { describeMcpRuntimeTarget, dispatchMcp, resolveMcpTransport } from '../lib/adapters/mcp-adapter.js';
 import {
   getDispatchAssignmentPath,
   getDispatchContextPath,
@@ -426,7 +426,8 @@ export async function stepCommand(opts) {
     }
     console.log('');
   } else if (runtimeType === 'mcp') {
-    console.log(chalk.cyan(`Dispatching to MCP stdio: ${runtime?.command || '(unknown)'}`));
+    const mcpTransport = resolveMcpTransport(runtime);
+    console.log(chalk.cyan(`Dispatching to MCP ${mcpTransport}: ${describeMcpRuntimeTarget(runtime)}`));
     console.log(chalk.dim(`Turn: ${turn.turn_id}  Role: ${roleId}  Phase: ${state.phase}  Tool: ${runtime?.tool_name || 'agentxchain_turn'}`));
 
     const mcpResult = await dispatchMcp(root, state, config, {

package/src/lib/adapters/mcp-adapter.js

@@ -2,6 +2,7 @@ import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import {
   getDispatchAssignmentPath,
   getDispatchContextPath,
@@ -13,12 +14,13 @@ import {
 import { verifyDispatchManifestForAdapter } from '../dispatch-manifest.js';
 
 export const DEFAULT_MCP_TOOL_NAME = 'agentxchain_turn';
+export const DEFAULT_MCP_TRANSPORT = 'stdio';
 
 /**
- * Dispatch a governed turn to an MCP server over stdio.
+ * Dispatch a governed turn to an MCP server.
  *
- * v1 scope:
- *   - stdio transport only
+ * Current scope:
+ *   - stdio or streamable_http transport
  *   - single tool call per turn
  *   - required governed-turn tool contract
  *   - synchronous dispatch/wait flow (like api_proxy)
@@ -55,7 +57,8 @@ export async function dispatchMcp(root, state, config, options = {}) {
   const prompt = readFileSync(promptPath, 'utf8');
   const context = existsSync(contextPath) ? readFileSync(contextPath, 'utf8') : '';
   const { command, args } = resolveMcpCommand(runtime);
-  if (!command) {
+  const transportType = resolveMcpTransport(runtime);
+  if (transportType === 'stdio' && !command) {
     return { ok: false, error: `Cannot resolve MCP command for runtime "${runtimeId}". Expected "command" field in runtime config.` };
   }
 
@@ -68,20 +71,16 @@ export async function dispatchMcp(root, state, config, options = {}) {
   const stagingDir = join(root, getTurnStagingDir(turn.turn_id));
   mkdirSync(stagingDir, { recursive: true });
 
-  const transport = new StdioClientTransport({
+  const transport = buildMcpClientTransport({
+    root,
+    runtime,
     command,
     args,
-    cwd: runtime.cwd ? join(root, runtime.cwd) : root,
-    env: buildTransportEnv(process.env),
-    stderr: 'pipe',
+    logs,
+    onStderr,
   });
-
-  if (transport.stderr) {
-    transport.stderr.on('data', (chunk) => {
-      const text = chunk.toString();
-      logs.push(`[stderr] ${text}`);
-      if (onStderr) onStderr(text);
-    });
+  if (!transport.ok) {
+    return { ok: false, error: transport.error, logs };
   }
 
   const client = new Client({
@@ -100,8 +99,8 @@ export async function dispatchMcp(root, state, config, options = {}) {
       return { ok: false, aborted: true, logs };
     }
 
-    onStatus?.(`Connecting to MCP stdio server (${command})`);
-    await client.connect(transport);
+    onStatus?.(`Connecting to MCP ${transportType} server (${describeMcpRuntimeTarget(runtime)})`);
+    await client.connect(transport.transport);
 
     if (signal?.aborted) {
       return { ok: false, aborted: true, logs };
@@ -182,7 +181,7 @@ export async function dispatchMcp(root, state, config, options = {}) {
       logs,
     };
   } finally {
-    await safeCloseClient(client, transport);
+    await safeCloseClient(client, transport.transport);
   }
 }
 
@@ -206,6 +205,18 @@ export function resolveMcpToolName(runtime) {
     : DEFAULT_MCP_TOOL_NAME;
 }
 
+export function resolveMcpTransport(runtime) {
+  return typeof runtime?.transport === 'string' && runtime.transport.trim()
+    ? runtime.transport.trim()
+    : DEFAULT_MCP_TRANSPORT;
+}
+
+export function describeMcpRuntimeTarget(runtime) {
+  return resolveMcpTransport(runtime) === 'streamable_http'
+    ? runtime?.url || '(unknown)'
+    : resolveMcpCommand(runtime).command || '(unknown)';
+}
+
 export function extractTurnResultFromMcpToolResult(toolResult) {
   const directCandidates = [
     toolResult?.structuredContent,
@@ -268,6 +279,58 @@ function buildTransportEnv(env) {
   return result;
 }
 
+function buildMcpClientTransport({ root, runtime, command, args, logs, onStderr }) {
+  if (resolveMcpTransport(runtime) === 'streamable_http') {
+    try {
+      const requestHeaders = buildRequestHeaders(runtime?.headers);
+      return {
+        ok: true,
+        transport: new StreamableHTTPClientTransport(new URL(runtime.url), {
+          requestInit: requestHeaders ? { headers: requestHeaders } : undefined,
+        }),
+      };
+    } catch (error) {
+      logs.push(`[transport-error] ${error.message}`);
+      return {
+        ok: false,
+        error: `Cannot resolve MCP streamable_http runtime: ${error.message}`,
+      };
+    }
+  }
+
+  const transport = new StdioClientTransport({
+    command,
+    args,
+    cwd: runtime.cwd ? join(root, runtime.cwd) : root,
+    env: buildTransportEnv(process.env),
+    stderr: 'pipe',
+  });
+
+  if (transport.stderr) {
+    transport.stderr.on('data', (chunk) => {
+      const text = chunk.toString();
+      logs.push(`[stderr] ${text}`);
+      if (onStderr) onStderr(text);
+    });
+  }
+
+  return { ok: true, transport };
+}
+
+function buildRequestHeaders(headers) {
+  if (!headers || typeof headers !== 'object' || Array.isArray(headers)) {
+    return null;
+  }
+
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === 'string') {
+      result[key] = value;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+
 function isPlainObject(value) {
   return !!value && typeof value === 'object' && !Array.isArray(value);
 }

package/src/lib/normalized-config.js

@@ -19,6 +19,7 @@ const VALID_WRITE_AUTHORITIES = ['authoritative', 'proposed', 'review_only'];
 const VALID_RUNTIME_TYPES = ['manual', 'local_cli', 'api_proxy', 'mcp'];
 const VALID_API_PROXY_PROVIDERS = ['anthropic', 'openai'];
 const VALID_PROMPT_TRANSPORTS = ['argv', 'stdin', 'dispatch_bundle_only'];
+const VALID_MCP_TRANSPORTS = ['stdio', 'streamable_http'];
 const VALID_PHASES = ['planning', 'implementation', 'qa'];
 const VALID_API_PROXY_RETRY_JITTER = ['none', 'full'];
 const VALID_API_PROXY_RETRY_CLASSES = [
@@ -47,8 +48,60 @@ const VALID_API_PROXY_PREFLIGHT_FIELDS = [
 ];
 
 function validateMcpRuntime(runtimeId, runtime, errors) {
+  const transport = typeof runtime?.transport === 'string' && runtime.transport.trim()
+    ? runtime.transport.trim()
+    : 'stdio';
   const command = runtime?.command;
 
+  if (!VALID_MCP_TRANSPORTS.includes(transport)) {
+    errors.push(`Runtime "${runtimeId}": mcp transport must be one of: ${VALID_MCP_TRANSPORTS.join(', ')}`);
+  }
+
+  if ('tool_name' in runtime && (typeof runtime.tool_name !== 'string' || !runtime.tool_name.trim())) {
+    errors.push(`Runtime "${runtimeId}": mcp tool_name must be a non-empty string`);
+  }
+
+  if (transport === 'streamable_http') {
+    if (typeof runtime?.url !== 'string' || !runtime.url.trim()) {
+      errors.push(`Runtime "${runtimeId}": mcp streamable_http requires "url"`);
+    } else {
+      try {
+        const parsed = new URL(runtime.url);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+          errors.push(`Runtime "${runtimeId}": mcp url must use http or https`);
+        }
+      } catch {
+        errors.push(`Runtime "${runtimeId}": mcp url must be a valid absolute URL`);
+      }
+    }
+
+    if ('headers' in runtime) {
+      if (!runtime.headers || typeof runtime.headers !== 'object' || Array.isArray(runtime.headers)) {
+        errors.push(`Runtime "${runtimeId}": mcp headers must be an object of string values`);
+      } else {
+        for (const [key, value] of Object.entries(runtime.headers)) {
+          if (typeof value !== 'string') {
+            errors.push(`Runtime "${runtimeId}": mcp headers["${key}"] must be a string`);
+          }
+        }
+      }
+    }
+
+    if ('command' in runtime) {
+      errors.push(`Runtime "${runtimeId}": mcp streamable_http does not accept "command"`);
+    }
+
+    if ('args' in runtime) {
+      errors.push(`Runtime "${runtimeId}": mcp streamable_http does not accept "args"`);
+    }
+
+    if ('cwd' in runtime) {
+      errors.push(`Runtime "${runtimeId}": mcp streamable_http does not accept "cwd"`);
+    }
+
+    return;
+  }
+
   if (typeof command === 'string') {
     if (!command.trim()) {
       errors.push(`Runtime "${runtimeId}": mcp command must be a non-empty string`);
@@ -67,13 +120,17 @@ function validateMcpRuntime(runtimeId, runtime, errors) {
     }
   }
 
-  if ('tool_name' in runtime && (typeof runtime.tool_name !== 'string' || !runtime.tool_name.trim())) {
-    errors.push(`Runtime "${runtimeId}": mcp tool_name must be a non-empty string`);
-  }
-
   if ('cwd' in runtime && (typeof runtime.cwd !== 'string' || !runtime.cwd.trim())) {
     errors.push(`Runtime "${runtimeId}": mcp cwd must be a non-empty string`);
   }
+
+  if ('url' in runtime) {
+    errors.push(`Runtime "${runtimeId}": mcp stdio does not accept "url"`);
+  }
+
+  if ('headers' in runtime) {
+    errors.push(`Runtime "${runtimeId}": mcp stdio does not accept "headers"`);
+  }
 }
 
 function validateApiProxyRetryPolicy(runtimeId, retryPolicy, errors) {