refactor: rename resolve_config to get_mcp_config

Per user feedback, 'get' is more accurate since the value may already
be resolved/cached, and 'mcp' in the name makes it clearer what we're doing.

Changes:
- Renamed public function resolve_config -> get_mcp_config
- Renamed internal method MCPServerConfig.resolve_config -> get_config
- Updated all test function names and calls
- Updated module docstring examples
- Updated README examples and API reference
- Updated __init__.py exports

Co-Authored-By: AJ Steers <aj@airbyte.io>

Author: devin-ai-integration[bot]

README.md

@@ -52,9 +52,9 @@ app = mcp_server(
 )
 
 # Server info resource is automatically registered at {name}://server/info
-# Resolve credentials from HTTP headers or environment variables
-from fastmcp_extensions import resolve_config
-api_key = resolve_config(app, "api_key")
+# Get credentials from HTTP headers or environment variables
+from fastmcp_extensions import get_mcp_config
+api_key = get_mcp_config(app, "api_key")
 ```
 
 ### Using Annotation Constants
@@ -168,7 +168,7 @@ cmd = "python bin/measure_mcp_tool_list.py"
 
 - `mcp_server` - Create a FastMCP instance with built-in server info resource
 - `MCPServerConfigArg` - Configuration for credential resolution
-- `resolve_config` - Resolve a credential from HTTP headers or environment variables
+- `get_mcp_config` - Get a credential from HTTP headers or environment variables
 
 ### Annotations
 

src/fastmcp_extensions/__init__.py

@@ -36,8 +36,8 @@
 from fastmcp_extensions.server import (
     MCPServerConfig,
     MCPServerConfigArg,
+    get_mcp_config,
     mcp_server,
-    resolve_config,
 )
 
 __all__ = [
@@ -50,6 +50,7 @@
     "PromptDef",
     "ResourceDef",
     "clear_registrations",
+    "get_mcp_config",
     "get_registered_prompts",
     "get_registered_resources",
     "get_registered_tools",
@@ -60,5 +61,4 @@
     "register_mcp_prompts",
     "register_mcp_resources",
     "register_mcp_tools",
-    "resolve_config",
 ]

src/fastmcp_extensions/server.py

@@ -10,7 +10,7 @@
 - `mcp_server`: Factory function to create a FastMCP instance with built-in features
 - `MCPServerConfigArg`: Dataclass for defining credential resolution configuration
 - `MCPServerConfig`: Dataclass storing server configuration (attached to the app)
-- `resolve_config`: Helper function to resolve credentials at runtime
+- `get_mcp_config`: Helper function to get credentials at runtime
 
 ## Basic Usage
 
@@ -30,7 +30,7 @@
 Define credentials that resolve from HTTP headers, environment variables, or defaults:
 
 ```py
-from fastmcp_extensions import mcp_server, MCPServerConfigArg, resolve_config
+from fastmcp_extensions import mcp_server, MCPServerConfigArg, get_mcp_config
 
 app = mcp_server(
     name="my-server",
@@ -44,8 +44,8 @@
     ],
 )
 
-# Later, resolve the credential (checks header -> env var -> default)
-api_key = resolve_config(app, "api_key")
+# Later, get the credential (checks header -> env var -> default)
+api_key = get_mcp_config(app, "api_key")
 ```
 
 ## MCP Module Auto-Discovery
@@ -128,15 +128,16 @@ def __post_init__(self) -> None:
         """Build lookup dict for config args by name."""
         self._config_args_by_name = {arg.name: arg for arg in self.config_args}
 
-    def resolve_config(self, name: str) -> str:
-        """Resolve a configuration value by name.
+    def get_config(self, name: str) -> str:
+        """Get a configuration value by name.
 
         Resolution order:
         1. HTTP headers (case-insensitive)
         2. Environment variables
+        3. Default value
 
         Args:
-            name: The name of the config argument to resolve.
+            name: The name of the config argument to get.
 
         Returns:
             The resolved value as a string.
@@ -442,10 +443,10 @@ def mcp_server(
     return app
 
 
-def resolve_config(ctx_or_app: Context | FastMCP, name: str) -> str:
-    """Resolve a configuration value from an MCP server.
+def get_mcp_config(ctx_or_app: Context | FastMCP, name: str) -> str:
+    """Get a configuration value from an MCP server.
 
-    This is a convenience function to resolve config values from a FastMCP
+    This is a convenience function to get config values from a FastMCP
     app created with mcp_server(). It accepts either a Context object (preferred
     for use in MCP tools) or a FastMCP app instance directly.
 
@@ -455,7 +456,7 @@ def resolve_config(ctx_or_app: Context | FastMCP, name: str) -> str:
     Args:
         ctx_or_app: Either a FastMCP Context object (from tool/resource functions)
             or a FastMCP application instance (created with mcp_server()).
-        name: The name of the config argument to resolve.
+        name: The name of the config argument to get.
 
     Returns:
         The resolved value as a string.
@@ -469,12 +470,12 @@ def resolve_config(ctx_or_app: Context | FastMCP, name: str) -> str:
         ```python
         @mcp_tool(...)
         def my_tool(ctx: Context, ...) -> str:
-            api_key = resolve_config(ctx, "api_key")
+            api_key = get_mcp_config(ctx, "api_key")
             ...
         ```
     """
     # Extract the FastMCP app from Context if needed
     app = ctx_or_app.fastmcp if isinstance(ctx_or_app, Context) else ctx_or_app
 
     config: MCPServerConfig = app.x_mcp_server_config  # type: ignore[attr-defined]
-    return config.resolve_config(name)
+    return config.get_config(name)

tests/test_server.py

@@ -10,8 +10,8 @@
 from fastmcp_extensions import (
     MCPServerConfig,
     MCPServerConfigArg,
+    get_mcp_config,
     mcp_server,
-    resolve_config,
 )
 
 
@@ -112,7 +112,7 @@ def test_mcp_server_config_arg_attributes(
 
 
 @pytest.mark.unit
-def test_resolve_config_from_env_var() -> None:
+def test_get_mcp_config_from_env_var() -> None:
     """Test resolving config from environment variable."""
     config_args = [
         MCPServerConfigArg(
@@ -125,12 +125,12 @@ def test_resolve_config_from_env_var() -> None:
     app = mcp_server("test-server", server_config_args=config_args)
 
     with patch.dict(os.environ, {"TEST_API_KEY": "secret-key-123"}):
-        value = resolve_config(app, "api_key")
+        value = get_mcp_config(app, "api_key")
         assert value == "secret-key-123"
 
 
 @pytest.mark.unit
-def test_resolve_config_from_http_header() -> None:
+def test_get_mcp_config_from_http_header() -> None:
     """Test resolving config from HTTP header (takes precedence over env var)."""
     config_args = [
         MCPServerConfigArg(
@@ -146,12 +146,12 @@ def test_resolve_config_from_http_header() -> None:
         "fastmcp_extensions.server.get_http_headers",
         return_value={"X-API-Key": "header-key"},
     ):
-        value = resolve_config(app, "api_key")
+        value = get_mcp_config(app, "api_key")
         assert value == "header-key"
 
 
 @pytest.mark.unit
-def test_resolve_config_header_case_insensitive() -> None:
+def test_get_mcp_config_header_case_insensitive() -> None:
     """Test that HTTP header resolution is case-insensitive."""
     config_args = [
         MCPServerConfigArg(
@@ -167,21 +167,21 @@ def test_resolve_config_header_case_insensitive() -> None:
         "fastmcp_extensions.server.get_http_headers",
         return_value={"x-api-key": "lowercase-header-key"},
     ):
-        value = resolve_config(app, "api_key")
+        value = get_mcp_config(app, "api_key")
         assert value == "lowercase-header-key"
 
 
 @pytest.mark.unit
-def test_resolve_config_unknown_name_raises_key_error() -> None:
+def test_get_mcp_config_unknown_name_raises_key_error() -> None:
     """Test that resolving unknown config name raises KeyError."""
     app = mcp_server("test-server")
 
     with pytest.raises(KeyError, match="Unknown config argument"):
-        resolve_config(app, "nonexistent")
+        get_mcp_config(app, "nonexistent")
 
 
 @pytest.mark.unit
-def test_resolve_config_required_missing_raises_value_error() -> None:
+def test_get_mcp_config_required_missing_raises_value_error() -> None:
     """Test that missing required config raises ValueError."""
     config_args = [
         MCPServerConfigArg(
@@ -197,11 +197,11 @@ def test_resolve_config_required_missing_raises_value_error() -> None:
         "fastmcp_extensions.server.get_http_headers", return_value=None
     )
     with mock_headers, pytest.raises(ValueError, match="Required config"):
-        resolve_config(app, "api_key")
+        get_mcp_config(app, "api_key")
 
 
 @pytest.mark.unit
-def test_resolve_config_optional_missing_returns_empty_string() -> None:
+def test_get_mcp_config_optional_missing_returns_empty_string() -> None:
     """Test that missing optional config returns empty string."""
     config_args = [
         MCPServerConfigArg(
@@ -214,7 +214,7 @@ def test_resolve_config_optional_missing_returns_empty_string() -> None:
     app = mcp_server("test-server", server_config_args=config_args)
 
     with patch("fastmcp_extensions.server.get_http_headers", return_value=None):
-        value = resolve_config(app, "optional_key")
+        value = get_mcp_config(app, "optional_key")
         assert value == ""
 
 
@@ -237,7 +237,7 @@ def test_mcp_server_config_default_values() -> None:
 
 
 @pytest.mark.unit
-def test_resolve_config_with_string_default() -> None:
+def test_get_mcp_config_with_string_default() -> None:
     """Test resolving config with a string default value."""
     config_args = [
         MCPServerConfigArg(
@@ -250,12 +250,12 @@ def test_resolve_config_with_string_default() -> None:
     app = mcp_server("test-server", server_config_args=config_args)
 
     with patch("fastmcp_extensions.server.get_http_headers", return_value=None):
-        value = resolve_config(app, "api_key")
+        value = get_mcp_config(app, "api_key")
         assert value == "default-value"
 
 
 @pytest.mark.unit
-def test_resolve_config_with_callable_default() -> None:
+def test_get_mcp_config_with_callable_default() -> None:
     """Test resolving config with a callable default value."""
     config_args = [
         MCPServerConfigArg(
@@ -268,12 +268,12 @@ def test_resolve_config_with_callable_default() -> None:
     app = mcp_server("test-server", server_config_args=config_args)
 
     with patch("fastmcp_extensions.server.get_http_headers", return_value=None):
-        value = resolve_config(app, "api_key")
+        value = get_mcp_config(app, "api_key")
         assert value == "callable-default"
 
 
 @pytest.mark.unit
-def test_resolve_config_env_var_takes_precedence_over_default() -> None:
+def test_get_mcp_config_env_var_takes_precedence_over_default() -> None:
     """Test that env var takes precedence over default value."""
     config_args = [
         MCPServerConfigArg(
@@ -286,12 +286,12 @@ def test_resolve_config_env_var_takes_precedence_over_default() -> None:
     app = mcp_server("test-server", server_config_args=config_args)
 
     with patch.dict(os.environ, {"TEST_API_KEY": "env-value"}):
-        value = resolve_config(app, "api_key")
+        value = get_mcp_config(app, "api_key")
         assert value == "env-value"
 
 
 @pytest.mark.unit
-def test_resolve_config_with_only_env_var() -> None:
+def test_get_mcp_config_with_only_env_var() -> None:
     """Test resolving config with only env_var set (no http_header_key)."""
     config_args = [
         MCPServerConfigArg(
@@ -303,12 +303,12 @@ def test_resolve_config_with_only_env_var() -> None:
     app = mcp_server("test-server", server_config_args=config_args)
 
     with patch.dict(os.environ, {"TEST_API_KEY": "env-only-value"}):
-        value = resolve_config(app, "api_key")
+        value = get_mcp_config(app, "api_key")
         assert value == "env-only-value"
 
 
 @pytest.mark.unit
-def test_resolve_config_with_only_http_header() -> None:
+def test_get_mcp_config_with_only_http_header() -> None:
     """Test resolving config with only http_header_key set (no env_var)."""
     config_args = [
         MCPServerConfigArg(
@@ -323,5 +323,5 @@ def test_resolve_config_with_only_http_header() -> None:
         "fastmcp_extensions.server.get_http_headers",
         return_value={"X-API-Key": "header-only-value"},
     ):
-        value = resolve_config(app, "api_key")
+        value = get_mcp_config(app, "api_key")
         assert value == "header-only-value"