mcp

type Client ¶

type Client struct {
	Name   string
	Config ServerConfig
	// contains filtered or unexported fields
}

Client wraps one SDK ClientSession with the lifecycle policy this phase needs: lazy re-connect on session-expired, lock-protected swap of the underlying session, and a small set of convenience methods the dynamic tool factories call.

func (c *Client) CallTool(ctx context.Context, name string, args map[string]any) (*mcpsdk.CallToolResult, error)

func (c *Client) ListTools(ctx context.Context) ([]*mcpsdk.Tool, error)

func (c *Client) Status() ServerStatus

type Config ¶

type Config struct {
	Servers []ServerConfig
}

Config is the merged + normalized server list ready for Open.

type ConfigScope ¶

type ConfigScope string

ConfigScope identifies where a server config was loaded from. Mirrors hooks/skills sourcing — workdir overrides user.

const (
	ScopeUser    ConfigScope = "user"    // <APP_HOME>/settings.json
	ScopeProject ConfigScope = "project" // <workdir>/.evva/settings.json
)

type Manager ¶

type Manager struct {
	// contains filtered or unexported fields
}

Manager holds every Client and is the seam internal/agent threads through ToolState. Safe for concurrent use.

func NewManager(opts OpenOptions) *Manager

func (m *Manager) Client(name string) *Client

func (m *Manager) DiscoveredToolNames() []string

func (m *Manager) RegisterFactories(reg *pubtoolset.Registry)

func (m *Manager) SetOnToolsChanged(fn func())

func (m *Manager) Shutdown()

func (m *Manager) Status() []ServerState

type OAuthHandler ¶

type OAuthHandler struct {
	// contains filtered or unexported fields
}

OAuthHandler wraps the SDK's auth.AuthorizationCodeHandler with one piece of evva-specific glue: the URL the SDK derives from the server's OAuth metadata is routed through promptFn so a human (or any other prompt sink the host chose) can confirm completion. A local HTTP listener captures the authorization-code redirect out of band, as the SDK's AuthorizationCodeFetcher contract requires.

func NewOAuthHandler(server string, logger *slog.Logger, promptFn OAuthPromptFn) *OAuthHandler

func (h *OAuthHandler) SDKHandler() (auth.OAuthHandler, error)

type OAuthPrompt ¶

type OAuthPrompt struct {
	Server  string // MCP server name from settings.json
	AuthURL string // URL the user must open in their browser
}

OAuthPrompt is the data an MCP-driven OAuth flow needs to surface to the end user. The host receives this struct via OAuthPromptFn, shows it to the user however it sees fit (TUI dialog, ask_user_question, custom UI, headless allow-list), and returns whether the user completed the in-browser flow or cancelled.

pkg/mcp deliberately does NOT import internal/question. Callers adapt the OAuthPromptFn signature into whatever question/broker shape their host uses; the bundled cmd/evva does this in internal/agent/mcp_wiring.go.

type OAuthPromptFn ¶

type OAuthPromptFn func(ctx context.Context, prompt OAuthPrompt) (OAuthPromptResult, error)

OAuthPromptFn is the seam the host installs to surface auth URLs to the user. Returning OAuthCancelled aborts the auth. Returning a non-nil error is treated as a transport failure — the connect fails and the server's status moves to failed/needs-auth.

type OAuthPromptResult ¶

type OAuthPromptResult int

OAuthPromptResult is the user's decision after seeing an OAuthPrompt.

const (
	// OAuthCompleted means the user reports the browser flow finished; the
	// local callback listener has captured the code+state.
	OAuthCompleted OAuthPromptResult = iota
	// OAuthCancelled aborts the connect — the server stays needs-auth until
	// the user retries via the per-server authenticate tool.
	OAuthCancelled
)

type OpenOptions ¶

type OpenOptions struct {
	// Logger receives mcp.* slog entries. nil yields a discard logger.
	Logger *slog.Logger

	// EvvaHome is the resolved per-user home dir used for binary-blob
	// persistence under <EvvaHome>/mcp-blobs. Empty disables blob writes.
	EvvaHome string

	// OAuthPrompt is called when an HTTP MCP server requires OAuth. nil
	// disables the interactive flow — needs-auth servers surface a clear
	// error if their authenticate tool is invoked.
	OAuthPrompt OAuthPromptFn
}

OpenOptions carries the host-supplied dependencies the Manager needs at construction time. Every field is optional with a defined nil/zero behavior so Open's signature stays stable as the option set grows.

type ServerConfig ¶

type ServerConfig struct {
	Name     string // map key from settings.json
	Type     TransportType
	Disabled bool // "disabled": true skips connect

	// Stdio fields
	Command string // required when Type == TransportStdio
	Args    []string
	Env     map[string]string // ${VAR} / ${VAR:-default} expansion happens at Load

	// HTTP fields
	URL     string // required when Type == TransportStreamableHTTP
	Headers map[string]string

	// Common
	Timeout time.Duration // connect timeout; default 30s; max 600s
	Scope   ConfigScope   // Project | User — for telemetry/logging only
}

ServerConfig is the parsed shape of one entry under mcpServers. Mirrors ref/src/services/mcp/types.ts McpStdioServerConfigSchema + McpHTTPServerConfigSchema, simplified to the two transports v1.6 ships.

type ServerState ¶

type ServerState struct {
	Name          string
	Config        ServerConfig
	Status        ServerStatus
	Error         string    // populated for StatusFailed / StatusNeedsAuth
	ToolCount     int       // number of tools discovered (0 unless Connected)
	ResourceCount int       // 0 unless server advertises resources/list capability
	ConnectedAt   time.Time // zero unless Connected
}

ServerState is what Manager.Status() returns per server.

type ServerStatus ¶

type ServerStatus string

ServerStatus is the live runtime state of one server's connection.

const (
	StatusConnected ServerStatus = "connected"
	StatusPending   ServerStatus = "pending"    // Connect in flight
	StatusFailed    ServerStatus = "failed"     // Connect returned err; tools=0
	StatusNeedsAuth ServerStatus = "needs-auth" // HTTP 401; auth tool offered
	StatusDisabled  ServerStatus = "disabled"
)

type ToolNameInfo ¶

type ToolNameInfo struct {
	Server string
	Tool   string
}

ToolNameInfo is the parsed shape: server + tool.

func ParseToolName(name string) *ToolNameInfo

type TransportType ¶

type TransportType string

TransportType is the wire-level transport kind.

const (
	TransportStdio          TransportType = "stdio"
	TransportStreamableHTTP TransportType = "http"
)

type Warning ¶

type Warning struct {
	Path string
	Err  error
}

Warning is a non-fatal load issue. Mirrors hooks.Warning shape so callers surface MCP warnings the same way they surface hook ones.

func (w Warning) Error() string