191 lines
5.4 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|