mcpproxy

type CallHistory struct {
	ToolCalls     []*ToolCall
	ResourceReads []*ResourceRead
	PromptGets    []*PromptGet
}

type CallRecord struct {
	ServerName string    `json:"serverName"`
	Timestamp  time.Time `json:"timestamp"`
	Success    bool      `json:"success"`
	Error      string    `json:"error,omitempty"`
}

type HeaderRoundTripper struct {
	// Headers is the map of headers to add to each request
	Headers map[string]string
	// Transport is the underlying RoundTripper to use for the actual request
	Transport http.RoundTripper
}

type MCPConfig struct {
	MCPServers map[string]*ServerConfig `json:"mcpServers" yaml:"mcpServers"`
}

type PromptGet struct {
	CallRecord
	Name    string                `json:"name"` // this is copies to the top level struct for convenience
	Request *mcp.GetPromptRequest `json:"request"`
	Result  *mcp.GetPromptResult  `json:"result"`
}

type Recorder interface {
	RecordToolCall(req *mcp.CallToolRequest, res *mcp.CallToolResult, err error, start time.Time)
	RecordResourceRead(req *mcp.ReadResourceRequest, res *mcp.ReadResourceResult, err error, start time.Time)
	RecordPromptGet(req *mcp.GetPromptRequest, res *mcp.GetPromptResult, err error, start time.Time)
	GetHistory() CallHistory
}

type ResourceRead struct {
	CallRecord
	URI     string                   `json:"uri"` // this is copied to the top level struct for convenience
	Request *mcp.ReadResourceRequest `json:"request"`
	Result  *mcp.ReadResourceResult  `json:"result"`
}

type Server interface {
	Run(ctx context.Context) error
	GetConfig() (*ServerConfig, error)
	GetName() string
	GetAllowedToolNames() []string
	Close() error
	GetCallHistory() CallHistory
	// WaitReady blocks until the server has initialized and is ready to serve
	WaitReady(ctx context.Context) error
}

type ServerConfig struct {
	// Type specifies the server type: "stdio" or "http"
	// If not specified, will be inferred from URL (http) or Command (stdio)
	Type string `json:"type,omitempty"`

	// Command is the executable to run (e.g., "node", "python", "npx")
	// Used for stdio servers
	Command string `json:"command,omitempty"`

	// Args are the command-line arguments to pass to the command
	// Used for stdio servers
	Args []string `json:"args,omitempty"`

	// Env contains environment variables to set for the server process
	// Used for stdio servers
	Env map[string]string `json:"env,omitempty"`

	// URL is the HTTP endpoint for the MCP server
	// Used for http servers. May contain environment variable references
	// like ${VAR} or ${VAR:-default}
	URL string `json:"url,omitempty"`

	// Headers are HTTP headers to send with requests
	// Used for http servers. Values may contain environment variable references
	Headers map[string]string `json:"headers,omitempty"`

	// Disabled indicates whether this server should be skipped
	Disabled bool `json:"disabled,omitempty"`

	// AlwaysAllow is a list of tools/resources that should always be allowed
	AlwaysAllow []string `json:"alwaysAllow,omitempty"`

	// EnableAllTools sets all tools to be allowed
	EnableAllTools bool `json:"enableAllTools"`
}

type ServerManager interface {
	GetMcpServerFiles() ([]string, error)
	GetMcpServers() []Server
	// Start is non-blocking. Caller must ensure this is only called once, and called before Close
	Start(ctx context.Context) error
	// Close closes associated server resources. Caller must ensure this is only called once, and called after Start
	Close() error

	// aggregate call tracking
	GetAllCallHistory() *CallHistory
	GetCallHistoryForServer(serverName string) (CallHistory, bool)
}

type ToolCall struct {
	CallRecord
	ToolName string               `json:"name"` // this is copied to the top level struct for convenience
	Request  *mcp.CallToolRequest `json:"request,omitempty"`
	Result   *mcp.CallToolResult  `json:"result,omitempty"`
}