Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

21.4 KB
Raw Blame
package runtime

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/url"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	goruntime "runtime"
	"strings"
	"time"

	"agentflow/internal/domain"
	"agentflow/internal/mcpclient"
)

const (
	mcpCallConfigEnv = "AGENTFLOW_MCP_CONFIG"
	mcpCallBinEnv    = "AGENTFLOW_BIN"
)

type mcpCallConfigFile struct {
	Servers []mcpCallServer `json:"servers"`
}

type mcpCallServer struct {
	ID             string            `json:"id"`
	Name           string            `json:"name"`
	MarketID       string            `json:"marketId,omitempty"`
	URL            string            `json:"url"`
	Command        string            `json:"command,omitempty"`
	Args           []string          `json:"args,omitempty"`
	CWD            string            `json:"cwd,omitempty"`
	Environment    map[string]string `json:"environment,omitempty"`
	Transport      string            `json:"transport"`
	AuthType       string            `json:"authType,omitempty"`
	CredentialKind string            `json:"credentialKind,omitempty"`
	Headers        map[string]string `json:"headers,omitempty"`
	TimeoutSec     int               `json:"timeoutSec,omitempty"`
	Aliases        []string          `json:"aliases,omitempty"`
}

func mcpCallHostDir(workspace string) string {
	return filepath.Join(workspace, ".agentflow", "runtime")
}

func mcpCallGuestPath(rel string) string {
	return filepath.ToSlash(path.Join("/workspace", ".agentflow", "runtime", rel))
}

// PrepareMCPCall writes the script-node helper (`agentflow mcp call`) and bound
// MCP server list into the workspace. Tokens stay in a 0600 file; they are not
// exported as environment variables.
func PrepareMCPCall(sandbox Sandbox, workspace string, servers []domain.MCPServerDefinition) (map[string]string, error) {
	hostRoot := mcpCallHostDir(workspace)
	hostBin := filepath.Join(hostRoot, "bin")
	if _, err := EnsureControlDirectory(workspace, "runtime", "bin"); err != nil {
		return nil, fmt.Errorf("create mcp call dir: %w", err)
	}
	driver := sandboxDriver(sandbox)
	runtimeServers := prepareMCPServersForDriver(servers, driver)
	for i := range runtimeServers {
		if managedMCPProcessRuntime(servers[i], driver) {
			runtimeServers[i].Command = filepath.Join(workspace, filepath.FromSlash(runtimeServers[i].Command))
		}
	}
	cfg := mcpCallConfigFile{Servers: mcpCallConfigServers(runtimeServers)}
	raw, err := json.MarshalIndent(cfg, "", "  ")
	if err != nil {
		return nil, err
	}
	configHost := filepath.Join(hostRoot, "mcp-servers.json")
	if err := writeManagedFile(workspace, configHost, raw, 0o600); err != nil {
		return nil, fmt.Errorf("write mcp call config: %w", err)
	}
	helperHost := filepath.Join(hostBin, "agentflow-helper")
	if err := installMCPCallHelperForSandbox(sandbox, workspace, helperHost); err != nil {
		return nil, err
	}
	wrapperHost := filepath.Join(hostBin, "agentflow")
	self, _ := os.Executable()
	helperExec := helperHost
	configEnv := configHost
	wrapperEnv := wrapperHost
	fallback := strings.TrimSpace(self)
	if sandboxDriver(sandbox) == "docker" {
		// The container only bind-mounts the workspace. The host platform
		// binary (AGENTFLOW_BIN on the CVM) is not on that filesystem.
		helperExec = mcpCallGuestPath("bin/agentflow-helper")
		configEnv = mcpCallGuestPath("mcp-servers.json")
		wrapperEnv = mcpCallGuestPath("bin/agentflow")
		fallback = ""
	}
	if err := writeManagedFile(workspace, wrapperHost, []byte(mcpCallWrapperScript(helperExec, fallback)), 0o700); err != nil {
		return nil, fmt.Errorf("write mcp call wrapper: %w", err)
	}
	return map[string]string{
		mcpCallConfigEnv: configEnv,
		mcpCallBinEnv:    wrapperEnv,
	}, nil
}

// mcpCallConfigServers converts runtime MCP server definitions into the
// entries written to mcp-servers.json. The transport defaults to stdio, and
// servers missing the URL (http) or command (stdio) they need are skipped.
func mcpCallConfigServers(servers []domain.MCPServerDefinition) []mcpCallServer {
	out := make([]mcpCallServer, 0, len(servers))
	for _, server := range servers {
		transport := strings.ToLower(strings.TrimSpace(server.Transport))
		if transport == "" {
			transport = "stdio"
		}
		if transport == "http" && strings.TrimSpace(server.URL) == "" {
			continue
		}
		if transport == "stdio" && strings.TrimSpace(server.Command) == "" {
			continue
		}
		out = append(out, mcpCallServer{
			ID:             server.ID,
			Name:           server.Name,
			MarketID:       server.MarketID,
			URL:            server.URL,
			Transport:      transport,
			Command:        server.Command,
			Args:           append([]string(nil), server.Args...),
			CWD:            MCPRuntimeWorkingDirectory(server),
			Environment:    resolveMap(server.Environment),
			AuthType:       server.AuthType,
			CredentialKind: server.CredentialKind,
			Headers:        cloneHeaders(server.Headers),
			TimeoutSec:     server.TimeoutSec,
			Aliases:        mcpCallAliases(server),
		})
	}
	return out
}

func mcpCallWrapperScript(helperPath, fallback string) string {
	var b strings.Builder
	b.WriteString("#!/bin/sh\n")
	if strings.TrimSpace(helperPath) != "" {
		b.WriteString("if [ -x " + shellSingleQuote(helperPath) + " ]; then\n")
		b.WriteString("  exec " + shellSingleQuote(helperPath) + " \"$@\"\n")
		b.WriteString("fi\n")
	}
	if strings.TrimSpace(fallback) != "" {
		b.WriteString("if [ -x " + shellSingleQuote(fallback) + " ]; then\n")
		b.WriteString("  exec " + shellSingleQuote(fallback) + " \"$@\"\n")
		b.WriteString("fi\n")
	}
	b.WriteString("echo \"agentflow: mcp helper is not available in this sandbox\" >&2\n")
	b.WriteString("exit 127\n")
	return b.String()
}

func installMCPCallHelper(workspace, dest string) error {
	src, err := os.Executable()
	if err != nil {
		return err
	}
	return installMCPCallHelperFrom(workspace, src, dest)
}

func installMCPCallHelperForSandbox(sandbox Sandbox, workspace, dest string) error {
	if sandboxDriver(sandbox) != "docker" || goruntime.GOOS == "linux" {
		return installMCPCallHelper(workspace, dest)
	}
	self, err := os.Executable()
	if err != nil {
		return err
	}
	pattern := strings.TrimSpace(os.Getenv("AGENTFLOW_RUNNER_BINARY"))
	if !strings.Contains(pattern, "{os}") {
		pattern = filepath.Join(filepath.Dir(self), "agentflow-runner-{os}-{arch}")
	}
	src := strings.NewReplacer("{os}", "linux", "{arch}", goruntime.GOARCH).Replace(pattern)
	if _, err := os.Stat(src); err != nil {
		return fmt.Errorf("Docker Git/MCP helper requires a Linux runner binary: set AGENTFLOW_RUNNER_BINARY with {os} and {arch}: %w", err)
	}
	return installMCPCallHelperFrom(workspace, src, dest)
}

func installMCPCallHelperFrom(workspace, src, dest string) error {
	srcInfo, err := os.Stat(src)
	if err != nil {
		return err
	}
	root, rel, err := openWorkspacePath(workspace, dest)
	if err != nil {
		return err
	}
	defer root.Close()
	if dstInfo, err := root.Stat(rel); err == nil {
		if !dstInfo.Mode().IsRegular() {
			return fmt.Errorf("MCP helper is not a regular file")
		}
		if dstInfo.Size() == srcInfo.Size() && !srcInfo.ModTime().After(dstInfo.ModTime()) {
			return nil
		}
	} else if !os.IsNotExist(err) {
		return err
	}
	return copyFileMode(workspace, src, dest, 0o755)
}

func copyFileMode(workspace, src, dest string, mode os.FileMode) error {
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()
	return writeManagedReader(workspace, dest, in, mode)
}

func mcpCallAliases(server domain.MCPServerDefinition) []string {
	seen := map[string]bool{}
	var out []string
	add := func(v string) {
		v = strings.TrimSpace(v)
		if v == "" || seen[strings.ToLower(v)] {
			return
		}
		seen[strings.ToLower(v)] = true
		out = append(out, v)
	}
	add(server.ID)
	add(server.MarketID)
	add(server.Name)
	if parsed, err := url.Parse(server.URL); err == nil {
		add(path.Base(strings.TrimRight(parsed.Path, "/")))
	}
	if strings.HasPrefix(server.ID, "mcp-") {
		parts := strings.Split(server.ID, "-")
		if len(parts) >= 2 {
			add(parts[1])
		}
	}
	return out
}

func bindMCPCallEnvironment(sandbox Sandbox, workspace string, environment map[string]string, servers []domain.MCPServerDefinition) error {
	prepared, err := PrepareMCPCall(sandbox, workspace, servers)
	if err != nil {
		return err
	}
	for key, value := range prepared {
		if key == "PATH" {
			continue
		}
		environment[key] = value
	}
	return nil
}

func sandboxIsolatesProcess(sb Sandbox) bool {
	switch sandboxDriver(sb) {
	case "docker", "bwrap", "seatbelt":
		return true
	default:
		return false
	}
}

const localMCPCallPreamble = `agentflow() {
  if [ -z "${AGENTFLOW_BIN-}" ] || [ ! -x "$AGENTFLOW_BIN" ]; then
    echo "agentflow: mcp helper is not available in this sandbox" >&2
    return 127
  fi
  command "$AGENTFLOW_BIN" "$@"
}
`

const isolatedMCPCallPreamble = `if [ -n "${AGENTFLOW_BIN-}" ] && [ -x "$AGENTFLOW_BIN" ]; then
  PATH="$(dirname "$AGENTFLOW_BIN"):$PATH"
  export PATH
fi
`

// BindMCPCallArgv points script/gate shells at the workspace `agentflow` bin.
// Isolated sandboxes prepend that directory after login-shell PATH reset.
// Local unisolated processes never rewrite PATH (the user's execution machine
// would inherit it); they get a shell function instead.
func BindMCPCallArgv(sandbox Sandbox, argv []string) []string {
	if sandboxDriver(sandbox) == "docker" {
		return argv
	}
	if sandboxIsolatesProcess(sandbox) {
		if out, ok := injectShellPreamble(argv, isolatedMCPCallPreamble); ok {
			return out
		}
		return wrapIsolatedMCPCallExec(argv)
	}
	if out, ok := injectShellPreamble(argv, localMCPCallPreamble); ok {
		return out
	}
	return argv
}

func injectShellPreamble(argv []string, preamble string) ([]string, bool) {
	if len(argv) < 3 || strings.TrimSpace(preamble) == "" {
		return argv, false
	}
	// -c also means configuration in Codex and source code in Python. Only
	// shell command strings can receive shell functions; touching a provider's
	// -c value can silently discard its model gateway/credential configuration.
	switch filepath.Base(argv[0]) {
	case "sh", "bash", "zsh", "dash", "ksh", "ash":
	default:
		return argv, false
	}
	out := append([]string{}, argv...)
	for i := 1; i < len(out)-1; i++ {
		switch out[i] {
		case "-c", "-lc", "-cl":
			out[i+1] = preamble + out[i+1]
			return out, true
		}
	}
	return argv, false
}

func wrapIsolatedMCPCallExec(argv []string) []string {
	if len(argv) == 0 {
		return argv
	}
	return append([]string{"sh", "-c", isolatedMCPCallPreamble + `exec "$0" "$@"`}, argv...)
}

// ScriptMCPEnvironment materializes agentflow mcp call and returns AGENTFLOW_BIN
// plus the config path. It does not rewrite PATH for local/unisolated processes.
func ScriptMCPEnvironment(sandbox Sandbox, workspace string, servers []domain.MCPServerDefinition) (map[string]string, error) {
	env := map[string]string{}
	if err := bindMCPCallEnvironment(sandbox, workspace, env, servers); err != nil {
		return nil, err
	}
	return env, nil
}

func loadMCPCallConfig() (mcpCallConfigFile, error) {
	path := strings.TrimSpace(os.Getenv(mcpCallConfigEnv))
	if path == "" {
		return mcpCallConfigFile{}, fmt.Errorf("未注入 MCP:agentflow mcp call 只在脚本、门禁或 Hook 里可用")
	}
	raw, err := os.ReadFile(path)
	if err != nil {
		return mcpCallConfigFile{}, fmt.Errorf("read mcp config: %w", err)
	}
	var cfg mcpCallConfigFile
	if err := json.Unmarshal(raw, &cfg); err != nil {
		return mcpCallConfigFile{}, fmt.Errorf("decode mcp config: %w", err)
	}
	return cfg, nil
}

func matchMCPCallServer(servers []mcpCallServer, query string) (mcpCallServer, error) {
	query = strings.TrimSpace(query)
	if query == "" {
		return mcpCallServer{}, fmt.Errorf("请指定要调用的 MCP")
	}
	lower := strings.ToLower(query)
	var matches []mcpCallServer
	for _, server := range servers {
		if mcpCallServerMatches(server, lower) {
			matches = append(matches, server)
		}
	}
	if len(matches) == 1 {
		return matches[0], nil
	}
	if len(matches) > 1 {
		names := make([]string, 0, len(matches))
		for _, server := range matches {
			names = append(names, server.Name+" ("+server.ID+")")
		}
		return mcpCallServer{}, fmt.Errorf("MCP %q 匹配到多个:%s", query, strings.Join(names, "、"))
	}
	return mcpCallServer{}, fmt.Errorf("当前任务没有 MCP %q", query)
}

func mcpCallServerMatches(server mcpCallServer, lower string) bool {
	if strings.ToLower(server.ID) == lower || strings.ToLower(server.MarketID) == lower || strings.ToLower(server.Name) == lower {
		return true
	}
	for _, alias := range server.Aliases {
		if strings.ToLower(strings.TrimSpace(alias)) == lower {
			return true
		}
	}
	return false
}

func authorizationHeader(headers map[string]string) string {
	for key, value := range headers {
		if strings.EqualFold(strings.TrimSpace(key), "authorization") {
			return strings.TrimSpace(value)
		}
	}
	return ""
}

// RunMCPCallCLI handles `agentflow mcp …` (and the same argv on agentflow-runner).
// It returns false when the process should continue with its normal entrypoint.
func RunMCPCallCLI(args []string) bool {
	if len(args) == 0 || args[0] != "mcp" {
		return false
	}
	os.Exit(mcpCallMain(args[1:]))
	return true
}

func mcpCallMain(args []string) int {
	if len(args) == 0 {
		fmt.Fprintln(os.Stderr, mcpCallUsage)
		return 2
	}
	switch args[0] {
	case "call":
		if err := mcpCallInvoke(args[1:]); err != nil {
			fmt.Fprintln(os.Stderr, err.Error())
			return 1
		}
		return 0
	case "tools":
		if err := mcpCallTools(args[1:]); err != nil {
			fmt.Fprintln(os.Stderr, err.Error())
			return 1
		}
		return 0
	case "list":
		if err := mcpCallList(); err != nil {
			fmt.Fprintln(os.Stderr, err.Error())
			return 1
		}
		return 0
	default:
		fmt.Fprintln(os.Stderr, mcpCallUsage)
		return 2
	}
}

const mcpCallUsage = `用法:
  agentflow mcp call <server> <tool> [json-args]
  agentflow mcp tools <server>
  agentflow mcp list`

func mcpCallInvoke(args []string) error {
	if len(args) < 2 {
		return fmt.Errorf("%s", mcpCallUsage)
	}
	cfg, err := loadMCPCallConfig()
	if err != nil {
		return err
	}
	server, err := matchMCPCallServer(cfg.Servers, args[0])
	if err != nil {
		return err
	}
	if strings.EqualFold(strings.TrimSpace(server.Transport), "http") && strings.TrimSpace(server.AuthType) != "" && authorizationHeader(server.Headers) == "" {
		if strings.EqualFold(strings.TrimSpace(server.AuthType), MCPAuthCredential) {
			return fmt.Errorf("MCP %s 需要凭证 %q:请先在个人凭证中配置", server.Name, server.CredentialKind)
		}
		return fmt.Errorf("MCP %s 需要 GitHub Git Token:请先在个人凭证中配置", server.Name)
	}
	tool := strings.TrimSpace(args[1])
	if tool == "" {
		return fmt.Errorf("请指定 MCP 工具名")
	}
	rawArgs := "{}"
	if len(args) >= 3 {
		rawArgs = strings.TrimSpace(args[2])
	}
	if rawArgs == "" {
		rawArgs = "{}"
	}
	var parsed map[string]any
	if err := json.Unmarshal([]byte(rawArgs), &parsed); err != nil {
		return fmt.Errorf("工具参数必须是 JSON 对象: %w", err)
	}
	var text string
	if strings.EqualFold(strings.TrimSpace(server.Transport), "http") {
		client := mcpclient.New(server.URL, server.Headers)
		if server.TimeoutSec > 0 {
			client = client.WithTimeout(time.Duration(server.TimeoutSec) * time.Second)
		}
		text, err = client.CallTool(tool, parsed)
	} else {
		text, err = stdioMCPCall(server, tool, parsed)
	}
	if err != nil {
		return err
	}
	_, _ = fmt.Fprintln(os.Stdout, text)
	return nil
}

func mcpCallList() error {
	cfg, err := loadMCPCallConfig()
	if err != nil {
		return err
	}
	type row struct {
		ID        string   `json:"id"`
		Name      string   `json:"name"`
		MarketID  string   `json:"marketId,omitempty"`
		Transport string   `json:"transport"`
		URL       string   `json:"url,omitempty"`
		Command   string   `json:"command,omitempty"`
		Aliases   []string `json:"aliases,omitempty"`
	}
	out := make([]row, 0, len(cfg.Servers))
	for _, server := range cfg.Servers {
		out = append(out, row{ID: server.ID, Name: server.Name, MarketID: server.MarketID, Transport: server.Transport, URL: server.URL, Command: server.Command, Aliases: server.Aliases})
	}
	raw, err := json.MarshalIndent(out, "", "  ")
	if err != nil {
		return err
	}
	_, _ = fmt.Fprintln(os.Stdout, string(raw))
	return nil
}

func mcpCallTools(args []string) error {
	if len(args) < 1 {
		return fmt.Errorf("%s", mcpCallUsage)
	}
	cfg, err := loadMCPCallConfig()
	if err != nil {
		return err
	}
	server, err := matchMCPCallServer(cfg.Servers, args[0])
	if err != nil {
		return err
	}
	if strings.EqualFold(strings.TrimSpace(server.Transport), "http") && strings.TrimSpace(server.AuthType) != "" && authorizationHeader(server.Headers) == "" {
		if strings.EqualFold(strings.TrimSpace(server.AuthType), MCPAuthCredential) {
			return fmt.Errorf("MCP %s 需要凭证 %q:请先在个人凭证中配置", server.Name, server.CredentialKind)
		}
		return fmt.Errorf("MCP %s 需要 GitHub Git Token:请先在个人凭证中配置", server.Name)
	}
	var names []string
	if strings.EqualFold(strings.TrimSpace(server.Transport), "http") {
		client := mcpclient.New(server.URL, server.Headers)
		if server.TimeoutSec > 0 {
			client = client.WithTimeout(time.Duration(server.TimeoutSec) * time.Second)
		}
		tools, listErr := client.ListTools()
		err = listErr
		for _, tool := range tools {
			if strings.TrimSpace(tool.Name) != "" {
				names = append(names, tool.Name)
			}
		}
	} else {
		names, err = stdioMCPTools(server)
	}
	if err != nil {
		return err
	}
	raw, err := json.MarshalIndent(names, "", "  ")
	if err != nil {
		return err
	}
	_, _ = fmt.Fprintln(os.Stdout, string(raw))
	return nil
}

type stdioRPCResponse struct {
	ID     int64           `json:"id"`
	Result json.RawMessage `json:"result,omitempty"`
	Error  *struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
	} `json:"error,omitempty"`
}

func stdioMCPCall(server mcpCallServer, tool string, args map[string]any) (string, error) {
	raw, err := runStdioMCP(server, "tools/call", map[string]any{"name": tool, "arguments": args})
	if err != nil {
		return "", err
	}
	var result struct {
		Content []struct {
			Type string `json:"type"`
			Text string `json:"text"`
		} `json:"content"`
		IsError bool `json:"isError"`
	}
	if json.Unmarshal(raw, &result) != nil {
		return strings.TrimSpace(string(raw)), nil
	}
	var blocks []string
	for _, b := range result.Content {
		if b.Type == "text" && b.Text != "" {
			blocks = append(blocks, b.Text)
		}
	}
	if result.IsError {
		return "", fmt.Errorf("mcp tool %s: %s", tool, strings.Join(blocks, "\n"))
	}
	return strings.Join(blocks, "\n"), nil
}

func stdioMCPTools(server mcpCallServer) ([]string, error) {
	raw, err := runStdioMCP(server, "tools/list", map[string]any{})
	if err != nil {
		return nil, err
	}
	var result struct {
		Tools []struct {
			Name string `json:"name"`
		} `json:"tools"`
	}
	if err := json.Unmarshal(raw, &result); err != nil {
		return nil, err
	}
	out := make([]string, 0, len(result.Tools))
	for _, tool := range result.Tools {
		if strings.TrimSpace(tool.Name) != "" {
			out = append(out, tool.Name)
		}
	}
	return out, nil
}

func runStdioMCP(server mcpCallServer, method string, params any) (json.RawMessage, error) {
	timeout := time.Duration(server.TimeoutSec) * time.Second
	if timeout <= 0 {
		timeout = 60 * time.Second
	}
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()
	cmd := exec.CommandContext(ctx, server.Command, server.Args...)
	if server.CWD != "" {
		root := filepath.Dir(filepath.Dir(filepath.Dir(strings.TrimSpace(os.Getenv(mcpCallConfigEnv)))))
		cmd.Dir = filepath.Join(root, filepath.FromSlash(server.CWD))
	}
	cmd.Env = appendEnvironment(os.Environ(), server.Environment)
	stdin, err := cmd.StdinPipe()
	if err != nil {
		return nil, err
	}
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return nil, err
	}
	var stderr bytes.Buffer
	cmd.Stderr = &stderr
	if err := cmd.Start(); err != nil {
		return nil, fmt.Errorf("start stdio MCP %s: %w", server.Name, err)
	}
	defer func() {
		_ = stdin.Close()
		if cmd.Process != nil {
			_ = cmd.Process.Kill()
		}
		_ = cmd.Wait()
	}()
	scanner := bufio.NewScanner(stdout)
	scanner.Buffer(make([]byte, 64<<10), 4<<20)
	if err := writeStdioRPC(stdin, map[string]any{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": map[string]any{"protocolVersion": "2024-11-05", "capabilities": map[string]any{}, "clientInfo": map[string]any{"name": "agentflow-script", "version": "1"}}}); err != nil {
		return nil, err
	}
	if _, err := readStdioRPCResult(ctx, scanner, &stderr, 1); err != nil {
		return nil, fmt.Errorf("mcp init: %w", err)
	}
	if err := writeStdioRPC(stdin, map[string]any{"jsonrpc": "2.0", "method": "notifications/initialized", "params": map[string]any{}}); err != nil {
		return nil, err
	}
	if err := writeStdioRPC(stdin, map[string]any{"jsonrpc": "2.0", "id": 2, "method": method, "params": params}); err != nil {
		return nil, err
	}
	return readStdioRPCResult(ctx, scanner, &stderr, 2)
}

// writeStdioRPC writes one newline-delimited JSON-RPC message.
func writeStdioRPC(w io.Writer, value any) error {
	raw, err := json.Marshal(value)
	if err != nil {
		return err
	}
	_, err = fmt.Fprintf(w, "%s\n", raw)
	return err
}

// readStdioRPCResult scans stdout lines until the response with id arrives,
// skipping notifications, unparsable lines and responses to other requests.
func readStdioRPCResult(ctx context.Context, scanner *bufio.Scanner, stderr *bytes.Buffer, id int64) (json.RawMessage, error) {
	for scanner.Scan() {
		var resp stdioRPCResponse
		if json.Unmarshal(scanner.Bytes(), &resp) != nil || resp.ID != id {
			continue
		}
		if resp.Error != nil {
			return nil, fmt.Errorf("mcp error [%d]: %s", resp.Error.Code, resp.Error.Message)
		}
		return resp.Result, nil
	}
	if ctx.Err() != nil {
		return nil, ctx.Err()
	}
	return nil, fmt.Errorf("stdio MCP exited before response: %s", strings.TrimSpace(stderr.String()))
}