Files
archie/internal/infrastructure/taskmcp/mcp_providers.go
T

191 lines
5.4 KiB
Go

package taskmcp
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/tools"
"github.com/samcharles93/archie-core/internal/tools/mcp"
toolprovider "github.com/samcharles93/archie-core/internal/tools/provider"
mcptoolprovider "github.com/samcharles93/archie-core/internal/tools/provider/mcp"
)
var errUnknownMCPTransport = errors.New("unknown MCP transport")
// Set holds the resources needed to clean up MCP providers.
type Set struct {
providers []toolprovider.Engine
Registry *tools.Registry
}
type mcpProviderBuilder func(config.MCPServer, mcp.SamplingHandler) (toolprovider.Engine, string, error)
// Start starts the configured MCP servers and registers their
// tools. sampling answers sampling requests when non-nil. Returns nil with
// no servers.
func Start(
ctx context.Context,
servers []config.MCPServer,
sampling mcp.SamplingHandler,
log *slog.Logger,
cacheDir string,
) (*Set, error) {
return startWith(ctx, servers, sampling, log, func(server config.MCPServer, sampling mcp.SamplingHandler) (toolprovider.Engine, string, error) {
return NewProvider(server, sampling, cacheDir)
})
}
func startWith(
ctx context.Context,
servers []config.MCPServer,
sampling mcp.SamplingHandler,
log *slog.Logger,
build mcpProviderBuilder,
) (*Set, error) {
if len(servers) == 0 {
return nil, nil
}
set := &Set{Registry: tools.NewRegistry()}
var firstErr error
for _, server := range servers {
name := strings.TrimSpace(server.Name)
if name == "" {
log.WarnContext(ctx, "mcp server skipped: empty name")
continue
}
provider, transportType, err := build(server, sampling)
if errors.Is(err, errUnknownMCPTransport) {
log.WarnContext(ctx, "mcp server skipped: unknown transport", "name", name, "transport", transportType)
continue
}
if err != nil {
log.WarnContext(ctx, "mcp server skipped", "name", name, "err", err)
firstErr = retainFirstError(firstErr, err)
continue
}
toolCount, err := startMCPProvider(ctx, name, provider, set.Registry, log)
if err != nil {
firstErr = retainFirstError(firstErr, err)
continue
}
set.providers = append(set.providers, provider)
log.InfoContext(ctx, "mcp provider started", "name", name, "transport", transportType, "tools", toolCount)
}
if len(set.providers) == 0 {
return nil, firstErr
}
return set, nil
}
// NewProvider builds the same transport and tool names for chat and tasks.
func NewProvider(server config.MCPServer, sampling mcp.SamplingHandler, cacheDir string) (toolprovider.Engine, string, error) {
name := strings.TrimSpace(server.Name)
transportType := strings.ToLower(strings.TrimSpace(server.Transport))
if transportType == "" {
transportType = "stdio"
}
if name == "" {
return nil, transportType, fmt.Errorf("MCP server name is required")
}
transport, err := mcpTransportForServer(name, transportType, server, cacheDir)
if err != nil {
return nil, transportType, err
}
return mcptoolprovider.New(name, transport, server.ParallelToolCalls, mcptoolprovider.WithSamplingHandler(sampling)), transportType, nil
}
func mcpTransportForServer(
name string,
transportType string,
server config.MCPServer,
cacheDir string,
) (mcptoolprovider.LifecycleTransport, error) {
switch transportType {
case "stdio":
command := strings.TrimSpace(server.Command)
if command == "" {
return nil, fmt.Errorf("MCP stdio server %q requires a command", name)
}
// Keep npx packages in the caller's cache.
return mcp.NewStdioTransport(mcp.StdioTransportConfig{
Command: command,
Args: append([]string(nil), server.Args...),
Dir: server.WorkDir,
Env: mcp.NpmCacheEnv(command, cacheDir),
}), nil
case "http", "streamablehttp":
url := strings.TrimSpace(server.URL)
if url == "" {
return nil, fmt.Errorf("MCP http server %q requires a url", name)
}
return mcp.NewHTTPTransport(mcp.HTTPTransportConfig{
Endpoint: url,
Headers: server.Headers,
}), nil
case "sse":
sseEndpoint := strings.TrimSpace(server.SSEEndpoint)
if sseEndpoint == "" {
return nil, fmt.Errorf("MCP sse server %q requires an sse_endpoint", name)
}
return mcp.NewSSETransport(mcp.SSETransportConfig{
SSEEndpoint: sseEndpoint,
MessageEndpoint: strings.TrimSpace(server.MessageEndpoint),
Headers: server.Headers,
}), nil
default:
return nil, fmt.Errorf("%w: %s", errUnknownMCPTransport, transportType)
}
}
func startMCPProvider(
ctx context.Context,
name string,
provider toolprovider.Engine,
registry *tools.Registry,
log *slog.Logger,
) (int, error) {
if err := provider.Start(ctx); err != nil {
log.WarnContext(ctx, "mcp provider start failed", "name", name, "err", err)
return 0, err
}
entries, err := provider.Discover(ctx)
if err != nil {
log.WarnContext(ctx, "mcp tool discovery failed", "name", name, "err", err)
_ = provider.Stop(ctx)
return 0, err
}
for _, entry := range entries {
if err := registry.Register(entry); err != nil {
log.WarnContext(ctx, "mcp tool registration failed", "tool", entry.Name, "err", err)
}
}
return len(entries), nil
}
func retainFirstError(firstErr, err error) error {
if firstErr != nil {
return firstErr
}
return err
}
func (s *Set) Close(ctx context.Context, log *slog.Logger) {
for _, provider := range s.providers {
if err := provider.Stop(ctx); err != nil {
log.WarnContext(ctx, "mcp provider stop failed", "err", err)
}
}
}