Address review comments

Author: RadCod3

langchain-interpreter/src/afm_cli/__init__.py

@@ -106,7 +106,6 @@
 from .tools import (
     MCPClient,
     MCPManager,
-    build_auth_headers,
     filter_tools,
 )
 from .variables import (
@@ -195,7 +194,6 @@
     # MCP Classes
     "MCPClient",
     "MCPManager",
-    "build_auth_headers",
     "filter_tools",
     # Interface Functions
     "get_interfaces",

langchain-interpreter/src/afm_cli/interfaces/web_chat.py

@@ -182,17 +182,22 @@ async def chat_string(
 
             except HTTPException:
                 raise
-            except json.JSONDecodeError:
+            except json.JSONDecodeError as e:
                 raise HTTPException(
                     status_code=400,
                     detail="Invalid JSON in request body",
-                )
+                ) from e
+            except UnicodeDecodeError as e:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Request body must be valid UTF-8",
+                ) from e
             except Exception as e:
                 logger.exception(f"Error in chat_string for session {session_id}: {e}")
                 raise HTTPException(
                     status_code=500,
                     detail="Internal server error",
-                )
+                ) from e
 
     else:
         # Complex schema-based chat
@@ -255,17 +260,17 @@ async def chat_object(
 
             except HTTPException:
                 raise
-            except json.JSONDecodeError:
+            except json.JSONDecodeError as e:
                 raise HTTPException(
                     status_code=400,
                     detail="Invalid JSON in request body",
-                )
+                ) from e
             except Exception as e:
                 logger.exception(f"Error in chat_object for session {session_id}: {e}")
                 raise HTTPException(
                     status_code=500,
                     detail="Internal server error",
-                )
+                ) from e
 
     return router
 

langchain-interpreter/src/afm_cli/models.py

@@ -41,7 +41,7 @@ class ClientAuthentication(BaseModel):
     @model_validator(mode="after")
     def validate_type_fields(self) -> Self:
         """Validate that the required fields for each type are present."""
-        match self.type:
+        match self.type.lower():
             case "bearer":
                 if self.token is None:
                     raise ValueError("type 'bearer' requires 'token' field")

langchain-interpreter/src/afm_cli/tools/__init__.py

@@ -10,13 +10,11 @@
 from .mcp import (
     MCPClient,
     MCPManager,
-    build_auth_headers,
     filter_tools,
 )
 
 __all__ = [
     "MCPClient",
     "MCPManager",
-    "build_auth_headers",
     "filter_tools",
 ]

langchain-interpreter/src/afm_cli/tools/mcp.py

@@ -5,7 +5,6 @@
 
 from __future__ import annotations
 
-import base64
 import logging
 from typing import Any
 
@@ -52,42 +51,6 @@ def auth_flow(self, request: httpx.Request):
         yield request
 
 
-def build_auth_headers(auth: ClientAuthentication | None) -> dict[str, str]:
-    """Build HTTP headers from authentication configuration."""
-    if auth is None:
-        return {}
-
-    auth_type = auth.type.lower()
-
-    if auth_type == "bearer":
-        if auth.token is None:
-            raise MCPAuthenticationError("Bearer auth requires 'token' field")
-        return {"Authorization": f"Bearer {auth.token}"}
-
-    elif auth_type == "basic":
-        if auth.username is None or auth.password is None:
-            raise MCPAuthenticationError(
-                "Basic auth requires 'username' and 'password' fields"
-            )
-        credentials = base64.b64encode(
-            f"{auth.username}:{auth.password}".encode()
-        ).decode()
-        return {"Authorization": f"Basic {credentials}"}
-
-    elif auth_type == "api-key":
-        if auth.api_key is None:
-            raise MCPAuthenticationError("API key auth requires 'api_key' field")
-        return {"Authorization": auth.api_key}
-
-    elif auth_type in ("oauth2", "jwt"):
-        raise MCPAuthenticationError(
-            f"Authentication type '{auth_type}' not yet supported"
-        )
-
-    else:
-        raise MCPAuthenticationError(f"Unsupported authentication type: {auth_type}")
-
-
 def build_httpx_auth(auth: ClientAuthentication | None) -> httpx.Auth | None:
     """Build httpx Auth instance from authentication configuration."""
     if auth is None:

langchain-interpreter/tests/test_mcp.py

@@ -21,8 +21,6 @@
     MCPServer,
     ToolFilter,
     Tools,
-    Transport,
-    build_auth_headers,
     filter_tools,
 )
 from afm_cli.tools.mcp import (
@@ -97,89 +95,6 @@ class MockArgsSchema(BaseModel):
 # =============================================================================
 
 
-class TestBuildAuthHeaders:
-    """Tests for build_auth_headers function."""
-
-    def test_none_auth_returns_empty_dict(self):
-        """No auth returns empty headers."""
-        result = build_auth_headers(None)
-        assert result == {}
-
-    def test_bearer_auth_returns_bearer_header(self):
-        """Bearer auth returns Authorization: Bearer header."""
-        auth = ClientAuthentication(type="bearer", token="my-token")
-        result = build_auth_headers(auth)
-        assert result == {"Authorization": "Bearer my-token"}
-
-    def test_basic_auth_returns_basic_header(self):
-        """Basic auth returns base64-encoded Authorization header."""
-        auth = ClientAuthentication(type="basic", username="user", password="pass")
-        result = build_auth_headers(auth)
-        # "user:pass" -> base64 "dXNlcjpwYXNz"
-        assert result == {"Authorization": "Basic dXNlcjpwYXNz"}
-
-    def test_api_key_auth_returns_api_key_header(self):
-        """API key auth returns Authorization header with raw key."""
-        auth = ClientAuthentication(type="api-key", api_key="my-api-key")
-        result = build_auth_headers(auth)
-        assert result == {"Authorization": "my-api-key"}
-
-    def test_bearer_auth_missing_token_raises_pydantic_error(self):
-        """Bearer auth without token raises Pydantic ValidationError at model creation."""
-        # Pydantic validates at model creation time, not at build_auth_headers
-        from pydantic import ValidationError
-
-        with pytest.raises(ValidationError, match="requires 'token' field"):
-            ClientAuthentication(type="bearer")
-
-    def test_basic_auth_missing_username_raises_pydantic_error(self):
-        """Basic auth without username raises Pydantic ValidationError at model creation."""
-        from pydantic import ValidationError
-
-        with pytest.raises(ValidationError, match="requires 'username' and 'password'"):
-            ClientAuthentication(type="basic", password="pass")
-
-    def test_basic_auth_missing_password_raises_pydantic_error(self):
-        """Basic auth without password raises Pydantic ValidationError at model creation."""
-        from pydantic import ValidationError
-
-        with pytest.raises(ValidationError, match="requires 'username' and 'password'"):
-            ClientAuthentication(type="basic", username="user")
-
-    def test_api_key_auth_missing_key_raises_pydantic_error(self):
-        """API key auth without key raises Pydantic ValidationError at model creation."""
-        from pydantic import ValidationError
-
-        with pytest.raises(ValidationError, match="requires 'api_key' field"):
-            ClientAuthentication(type="api-key")
-
-    def test_oauth2_auth_not_supported(self):
-        """OAuth2 auth raises not supported error."""
-        auth = ClientAuthentication(type="oauth2")
-        with pytest.raises(MCPAuthenticationError, match="not yet supported"):
-            build_auth_headers(auth)
-
-    def test_jwt_auth_not_supported(self):
-        """JWT auth raises not supported error."""
-        auth = ClientAuthentication(type="jwt")
-        with pytest.raises(MCPAuthenticationError, match="not yet supported"):
-            build_auth_headers(auth)
-
-    def test_unknown_auth_type_raises_error(self):
-        """Unknown auth type raises MCPAuthenticationError."""
-        auth = ClientAuthentication(type="unknown")
-        with pytest.raises(
-            MCPAuthenticationError, match="Unsupported authentication type"
-        ):
-            build_auth_headers(auth)
-
-    def test_auth_type_is_case_insensitive(self):
-        """Auth type matching is case-insensitive."""
-        auth = ClientAuthentication(type="BEARER", token="my-token")
-        result = build_auth_headers(auth)
-        assert result == {"Authorization": "Bearer my-token"}
-
-
 class TestBuildHttpxAuth:
     """Tests for build_httpx_auth function."""
 
@@ -385,7 +300,7 @@ def test_build_connection_config_with_auth(self):
         config = client._build_connection_config()
 
         assert "auth" in config
-        assert isinstance(config["auth"], BearerAuth)
+        assert isinstance(config.get("auth"), BearerAuth)
 
     @pytest.mark.asyncio
     async def test_get_tools_calls_mcp_client(self):