feat(mcp-hosts): let hatch manage mistral vibe configs

Add the adapter, strategy, model wiring, and core validations needed to treat Mistral Vibe as a first-class MCP host inside the shared host-configuration layer.

Author: LittleCoinCoin

hatch/mcp_host_config/adapters/__init__.py

@@ -12,6 +12,7 @@
 from hatch.mcp_host_config.adapters.gemini import GeminiAdapter
 from hatch.mcp_host_config.adapters.kiro import KiroAdapter
 from hatch.mcp_host_config.adapters.lmstudio import LMStudioAdapter
+from hatch.mcp_host_config.adapters.mistral_vibe import MistralVibeAdapter
 from hatch.mcp_host_config.adapters.opencode import OpenCodeAdapter
 from hatch.mcp_host_config.adapters.registry import (
     AdapterRegistry,
@@ -36,6 +37,7 @@
     "GeminiAdapter",
     "KiroAdapter",
     "LMStudioAdapter",
+    "MistralVibeAdapter",
     "OpenCodeAdapter",
     "VSCodeAdapter",
 ]

hatch/mcp_host_config/adapters/mistral_vibe.py

@@ -0,0 +1,116 @@
+"""Mistral Vibe adapter for MCP host configuration.
+
+Mistral Vibe uses TOML `[[mcp_servers]]` entries with an explicit `transport`
+field instead of the Claude-style `type` discriminator.
+"""
+
+from typing import Any, Dict, FrozenSet
+
+from hatch.mcp_host_config.adapters.base import AdapterValidationError, BaseAdapter
+from hatch.mcp_host_config.fields import MISTRAL_VIBE_FIELDS
+from hatch.mcp_host_config.models import MCPServerConfig
+
+
+class MistralVibeAdapter(BaseAdapter):
+    """Adapter for Mistral Vibe MCP server configuration."""
+
+    @property
+    def host_name(self) -> str:
+        """Return the host identifier."""
+        return "mistral-vibe"
+
+    def get_supported_fields(self) -> FrozenSet[str]:
+        """Return fields supported by Mistral Vibe."""
+        return MISTRAL_VIBE_FIELDS
+
+    def validate(self, config: MCPServerConfig) -> None:
+        """Deprecated compatibility wrapper for legacy adapter tests."""
+        self.validate_filtered(self.filter_fields(config))
+
+    def validate_filtered(self, filtered: Dict[str, Any]) -> None:
+        """Validate Mistral Vibe transport rules on filtered fields."""
+        has_command = "command" in filtered
+        has_url = "url" in filtered
+        transport_count = sum([has_command, has_url])
+
+        if transport_count == 0:
+            raise AdapterValidationError(
+                "Either 'command' or 'url' must be specified",
+                host_name=self.host_name,
+            )
+
+        if transport_count > 1:
+            raise AdapterValidationError(
+                "Cannot specify multiple transports - choose exactly one of 'command' or 'url'",
+                host_name=self.host_name,
+            )
+
+        transport = filtered.get("transport")
+        if transport == "stdio" and not has_command:
+            raise AdapterValidationError(
+                "transport='stdio' requires 'command' field",
+                field="transport",
+                host_name=self.host_name,
+            )
+        if transport in ("http", "streamable-http") and not has_url:
+            raise AdapterValidationError(
+                f"transport='{transport}' requires 'url' field",
+                field="transport",
+                host_name=self.host_name,
+            )
+
+    def apply_transformations(
+        self, filtered: Dict[str, Any], transport_hint: str | None = None
+    ) -> Dict[str, Any]:
+        """Apply Mistral Vibe field/value transformations."""
+        result = dict(filtered)
+
+        transport = (
+            result.get("transport") or transport_hint or self._infer_transport(result)
+        )
+        result["transport"] = transport
+
+        return result
+
+    def serialize(self, config: MCPServerConfig) -> Dict[str, Any]:
+        """Serialize configuration for Mistral Vibe format."""
+        filtered = self.filter_fields(config)
+
+        # Support cross-host sync hints without advertising these as native fields.
+        if (
+            "command" not in filtered
+            and "url" not in filtered
+            and config.httpUrl is not None
+        ):
+            filtered["url"] = config.httpUrl
+
+        transport_hint = self._infer_transport(filtered, config=config)
+        if transport_hint is not None:
+            filtered["transport"] = transport_hint
+
+        self.validate_filtered(filtered)
+        return self.apply_transformations(filtered)
+
+    def _infer_transport(
+        self, filtered: Dict[str, Any], config: MCPServerConfig | None = None
+    ) -> str | None:
+        """Infer Vibe transport from canonical MCP fields."""
+        if "transport" in filtered:
+            return filtered["transport"]
+        if "command" in filtered:
+            return "stdio"
+
+        config_type = config.type if config is not None else None
+        if config_type == "stdio":
+            return "stdio"
+        if config_type == "http":
+            return "http"
+        if config_type == "sse":
+            return "streamable-http"
+
+        if config is not None and config.httpUrl is not None:
+            return "http"
+        if "url" in filtered:
+            return "streamable-http"
+
+        return None

hatch/mcp_host_config/adapters/registry.py

@@ -14,6 +14,7 @@
 from hatch.mcp_host_config.adapters.gemini import GeminiAdapter
 from hatch.mcp_host_config.adapters.kiro import KiroAdapter
 from hatch.mcp_host_config.adapters.lmstudio import LMStudioAdapter
+from hatch.mcp_host_config.adapters.mistral_vibe import MistralVibeAdapter
 from hatch.mcp_host_config.adapters.opencode import OpenCodeAdapter
 from hatch.mcp_host_config.adapters.vscode import VSCodeAdapter
 
@@ -34,7 +35,7 @@ class AdapterRegistry:
         'claude-desktop'
 
         >>> registry.get_supported_hosts()
-        ['augment', 'claude-code', 'claude-desktop', 'codex', 'cursor', 'gemini', 'kiro', 'lmstudio', 'opencode', 'vscode']
+        ['augment', 'claude-code', 'claude-desktop', 'codex', 'cursor', 'gemini', 'kiro', 'lmstudio', 'mistral-vibe', 'opencode', 'vscode']
     """
 
     def __init__(self):
@@ -55,6 +56,7 @@ def _register_defaults(self) -> None:
         self.register(GeminiAdapter())
         self.register(KiroAdapter())
         self.register(CodexAdapter())
+        self.register(MistralVibeAdapter())
         self.register(OpenCodeAdapter())
         self.register(AugmentAdapter())
 

hatch/mcp_host_config/backup.py

@@ -48,6 +48,7 @@ def validate_hostname(cls, v):
             "gemini",
             "kiro",
             "codex",
+            "mistral-vibe",
             "opencode",
             "augment",
         }

hatch/mcp_host_config/fields.py

@@ -27,7 +27,7 @@
 # ============================================================================
 
 # Hosts that support the 'type' discriminator field (stdio/sse/http)
-# Note: Gemini, Kiro, Codex do NOT support this field
+# Note: Gemini, Kiro, Codex, and Mistral Vibe do NOT support this field
 TYPE_SUPPORTING_HOSTS: FrozenSet[str] = frozenset(
     {
         "claude-desktop",
@@ -117,6 +117,21 @@
 )
 
 
+# Fields supported by Mistral Vibe (TOML array-of-tables with explicit transport)
+MISTRAL_VIBE_FIELDS: FrozenSet[str] = UNIVERSAL_FIELDS | frozenset(
+    {
+        "transport",  # Vibe transport discriminator: stdio/http/streamable-http
+        "prompt",  # Optional per-server prompt override
+        "sampling_enabled",  # Enable model sampling for tool calls
+        "api_key_env",  # Env var containing API key for remote servers
+        "api_key_header",  # Header name for API key injection
+        "api_key_format",  # Header formatting template for API key injection
+        "startup_timeout_sec",  # Server startup timeout
+        "tool_timeout_sec",  # Tool execution timeout
+    }
+)
+
+
 # Fields supported by Augment Code (auggie CLI + extensions); same as Claude fields
 # Config: ~/.augment/settings.json, key: mcpServers
 AUGMENT_FIELDS: FrozenSet[str] = CLAUDE_FIELDS

hatch/mcp_host_config/host_management.py

@@ -30,6 +30,7 @@ class MCPHostRegistry:
     _family_mappings: Dict[str, List[MCPHostType]] = {
         "claude": [MCPHostType.CLAUDE_DESKTOP, MCPHostType.CLAUDE_CODE],
         "cursor": [MCPHostType.CURSOR, MCPHostType.LMSTUDIO],
+        "mistral": [MCPHostType.MISTRAL_VIBE],
     }
 
     @classmethod

hatch/mcp_host_config/models.py

@@ -30,6 +30,7 @@ class MCPHostType(str, Enum):
     GEMINI = "gemini"
     KIRO = "kiro"
     CODEX = "codex"
+    MISTRAL_VIBE = "mistral-vibe"
     OPENCODE = "opencode"
     AUGMENT = "augment"
 
@@ -62,6 +63,10 @@ class MCPServerConfig(BaseModel):
     type: Optional[Literal["stdio", "sse", "http"]] = Field(
         None, description="Transport type (stdio for local, sse/http for remote)"
     )
+    transport: Optional[Literal["stdio", "http", "streamable-http"]] = Field(
+        None,
+        description="Host-native transport discriminator (e.g. Mistral Vibe)",
+    )
 
     # stdio transport (local server)
     command: Optional[str] = Field(
@@ -138,15 +143,15 @@ class MCPServerConfig(BaseModel):
     disabledTools: Optional[List[str]] = Field(None, description="Disabled tool names")
 
     # ========================================================================
-    # Codex-Specific Fields
+    # Codex / Mistral Vibe-Specific Fields
     # ========================================================================
     env_vars: Optional[List[str]] = Field(
         None, description="Environment variables to whitelist/forward"
     )
-    startup_timeout_sec: Optional[int] = Field(
+    startup_timeout_sec: Optional[float] = Field(
         None, description="Server startup timeout in seconds"
     )
-    tool_timeout_sec: Optional[int] = Field(
+    tool_timeout_sec: Optional[float] = Field(
         None, description="Tool execution timeout in seconds"
     )
     enabled: Optional[bool] = Field(
@@ -167,6 +172,19 @@ class MCPServerConfig(BaseModel):
     env_http_headers: Optional[Dict[str, str]] = Field(
         None, description="Header names to env var names"
     )
+    prompt: Optional[str] = Field(None, description="Per-server prompt override")
+    sampling_enabled: Optional[bool] = Field(
+        None, description="Whether sampling is enabled for tool calls"
+    )
+    api_key_env: Optional[str] = Field(
+        None, description="Env var containing API key for remote server auth"
+    )
+    api_key_header: Optional[str] = Field(
+        None, description="HTTP header name used for API key injection"
+    )
+    api_key_format: Optional[str] = Field(
+        None, description="Formatting template for API key header values"
+    )
 
     # ========================================================================
     # OpenCode-Specific Fields
@@ -239,6 +257,8 @@ def is_stdio(self) -> bool:
             1. Explicit type="stdio" field takes precedence
             2. Otherwise, presence of 'command' field indicates stdio
         """
+        if self.transport is not None:
+            return self.transport == "stdio"
         if self.type is not None:
             return self.type == "stdio"
         return self.command is not None
@@ -253,6 +273,8 @@ def is_sse(self) -> bool:
             1. Explicit type="sse" field takes precedence
             2. Otherwise, presence of 'url' field indicates SSE
         """
+        if self.transport is not None:
+            return False
         if self.type is not None:
             return self.type == "sse"
         return self.url is not None
@@ -267,6 +289,8 @@ def is_http(self) -> bool:
             1. Explicit type="http" field takes precedence
             2. Otherwise, presence of 'httpUrl' field indicates HTTP streaming
         """
+        if self.transport is not None:
+            return self.transport in ("http", "streamable-http")
         if self.type is not None:
             return self.type == "http"
         return self.httpUrl is not None
@@ -278,8 +302,12 @@ def get_transport_type(self) -> Optional[str]:
             "stdio" for command-based local servers
             "sse" for URL-based remote servers (SSE transport)
             "http" for httpUrl-based remote servers (Gemini HTTP streaming)
+            "streamable-http" for hosts that expose that transport natively
             None if transport cannot be determined
         """
+        if self.transport is not None:
+            return self.transport
+
         # Explicit type takes precedence
         if self.type is not None:
             return self.type
@@ -367,6 +395,7 @@ def validate_host_names(cls, v):
             "gemini",
             "kiro",
             "codex",
+            "mistral-vibe",
             "opencode",
             "augment",
         }

hatch/mcp_host_config/reporting.py

@@ -73,6 +73,7 @@ def _get_adapter_host_name(host_type: MCPHostType) -> str:
         MCPHostType.GEMINI: "gemini",
         MCPHostType.KIRO: "kiro",
         MCPHostType.CODEX: "codex",
+        MCPHostType.MISTRAL_VIBE: "mistral-vibe",
         MCPHostType.OPENCODE: "opencode",
         MCPHostType.AUGMENT: "augment",
     }