auto-coder-web 0.1.60__py3-none-any.whl → 0.1.62__py3-none-any.whl

auto_coder_web/routers/editable_preview_router.py

@@ -0,0 +1,202 @@
+import logging
+from pydantic import BaseModel
+import requests
+from fastapi import APIRouter, HTTPException, Request, Query, Body
+from fastapi.responses import HTMLResponse
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin, urlparse
+import aiofiles
+from pathlib import Path
+import json
+from datetime import datetime
+import uuid
+from loguru import logger as global_logger
+
+logger = global_logger.bind(name="editable_preview")
+router = APIRouter()
+
+# --- Configuration ---
+BRIDGE_SCRIPT_PATH = "/bridge.js"  # Path where the frontend serves bridge.js
+SAVED_PREVIEWS_DIR = Path(".auto-coder/auto-coder.web/editable-previews")
+SAVED_PREVIEWS_DIR.mkdir(parents=True, exist_ok=True)
+# --- End Configuration ---
+
+
+def resolve_url(base_url: str, relative_url: str) -> str:
+    """Resolves a relative URL against a base URL."""
+    try:
+        return urljoin(base_url, relative_url)
+    except ValueError:
+        # Handle cases where relative_url might be invalid
+        return relative_url
+
+def rewrite_html_resources(soup: BeautifulSoup, base_url: str, proxy_base: str):
+    """Rewrites relative URLs in common HTML tags to absolute URLs or proxy URLs."""
+    tags_attributes = {
+        'a': 'href',
+        'link': 'href',
+        'script': 'src',
+        'img': 'src',
+        'iframe': 'src',
+        'form': 'action',
+        # Add other tags/attributes as needed
+    }
+
+    for tag_name, attr_name in tags_attributes.items():
+        for tag in soup.find_all(tag_name):
+            attr_value = tag.get(attr_name)
+            if attr_value:
+                # Resolve relative URLs relative to the original page's base URL
+                absolute_url = resolve_url(base_url, attr_value)
+                
+                # Optionally, rewrite to go through proxy (more complex, might break things)
+                # For simplicity now, just make them absolute to original domain
+                # proxy_url = f"{proxy_base}?url={absolute_url}" # Example proxy rewrite
+                # tag[attr_name] = proxy_url
+                tag[attr_name] = absolute_url # Keep original absolute for now
+
+    # Special handling for inline styles with url()
+    for tag in soup.find_all(style=True):
+        # Basic url() rewriting - might need a more robust CSS parser for complex cases
+        style_content = tag['style']
+        # This regex is basic, might need refinement
+        import re
+        def replace_url(match):
+            url = match.group(1).strip("'\"")
+            absolute_url = resolve_url(base_url, url)
+            return f"url('{absolute_url}')"
+
+        tag['style'] = re.sub(r"url\((.*?)\)", replace_url, style_content)
+
+    # Consider rewriting srcset for images as well if needed
+
+@router.get("/api/editable-preview/proxy", response_class=HTMLResponse)
+async def proxy_external_url(request: Request, url: str = Query(...)):
+    """
+    Fetches an external URL, injects a bridge script, and returns the HTML.
+    Handles basic resource URL rewriting.
+    """
+    if not url or not url.startswith(('http://', 'https://')):
+        raise HTTPException(status_code=400, detail="Invalid or missing URL parameter")
+
+    try:
+        headers = {
+            # Mimic a browser request
+            'User-Agent': request.headers.get('user-agent', 'Mozilla/5.0'),
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Referer': urlparse(url).scheme + "://" + urlparse(url).netloc # Set referer to target domain
+        }
+        response = requests.get(url, headers=headers, timeout=15, allow_redirects=True)
+        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+
+        # Check content type
+        content_type = response.headers.get('content-type', '').lower()
+        if 'text/html' not in content_type:
+            logger.warning(f"Proxied URL {url} returned non-HTML content-type: {content_type}")
+            # Return as is if not HTML, or raise error? Decide based on desired behavior.
+            # For now, let's try parsing anyway, but log a warning.
+            # raise HTTPException(status_code=400, detail=f"URL did not return HTML content. Content-Type: {content_type}")
+
+        # Parse HTML content
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # --- Inject Bridge Script ---
+        bridge_script_tag = soup.new_tag("script")
+        bridge_script_tag["src"] = BRIDGE_SCRIPT_PATH
+        bridge_script_tag["defer"] = True # Load after HTML parsing but before DOMContentLoaded
+
+        # Try injecting into <head>, fallback to <body>
+        head = soup.find('head')
+        if head:
+            head.append(bridge_script_tag)
+        else:
+            body = soup.find('body')
+            if body:
+                body.append(bridge_script_tag)
+            else:
+                # If no head or body, append to the root (less ideal)
+                soup.append(bridge_script_tag)
+        # --- End Injection ---
+
+        # --- Rewrite Resource URLs ---
+        # Get the final URL after potential redirects
+        final_url = response.url
+        # Define the base for our proxy endpoint (needed if we decide to proxy resources)
+        proxy_base_url = str(request.base_url) + "api/editable-preview/proxy"
+        rewrite_html_resources(soup, final_url, proxy_base_url)
+        # --- End Rewriting ---
+
+        # Return modified HTML
+        modified_html = str(soup)
+
+        # Prepare response, try to remove X-Frame-Options
+        resp_headers = dict(response.headers)
+        # Remove security headers that prevent framing (use with caution)
+        resp_headers.pop('X-Frame-Options', None)
+        resp_headers.pop('Content-Security-Policy', None)
+        # Remove Content-Length header
+        resp_headers.pop('Content-Length', None)
+        # Ensure correct content type
+        resp_headers['Content-Type'] = 'text/html; charset=utf-8' # Force UTF-8
+
+        return HTMLResponse(content=modified_html, headers=resp_headers)
+
+    except requests.exceptions.Timeout:
+        raise HTTPException(status_code=504, detail=f"Timeout while fetching URL: {url}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error fetching URL {url}: {e}")
+        raise HTTPException(status_code=502, detail=f"Failed to fetch URL: {url}. Error: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error processing proxy request for {url}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Internal server error processing URL: {url}")
+
+
+class SavePreviewRequest(BaseModel):
+    url: str
+    html_content: str
+
+@router.post("/api/editable-preview/save")
+async def save_edited_preview(payload: SavePreviewRequest = Body(...)):
+    """Saves the edited HTML content for a given URL."""
+    try:
+        url = payload.url
+        html_content = payload.html_content
+
+        if not url or not html_content:
+            raise HTTPException(status_code=400, detail="Missing URL or HTML content")
+
+        # Generate a unique filename or use a hash of the URL
+        parsed_url = urlparse(url)
+        # Sanitize filename (basic example)
+        filename_base = f"{parsed_url.netloc}_{parsed_url.path}".replace('/', '_').replace('.', '_')
+        filename_base = "".join(c for c in filename_base if c.isalnum() or c in ('_', '-')).rstrip('_')[:100] # Limit length
+        
+        save_id = str(uuid.uuid4())
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{filename_base}_{timestamp}_{save_id}.html"
+        filepath = SAVED_PREVIEWS_DIR / filename
+
+        metadata = {
+            "original_url": url,
+            "saved_at": datetime.now().isoformat(),
+            "save_id": save_id,
+            "filename": filename
+        }
+        meta_filepath = SAVED_PREVIEWS_DIR / f"{filename}.meta.json"
+
+
+        async with aiofiles.open(filepath, mode='w', encoding='utf-8') as f:
+            await f.write(html_content)
+
+        async with aiofiles.open(meta_filepath, mode='w', encoding='utf-8') as f:
+            await f.write(json.dumps(metadata, indent=2))
+
+        logger.info(f"Saved edited preview for URL '{url}' to '{filepath}'")
+        return {"status": "success", "save_id": save_id, "filename": filename}
+
+    except HTTPException:
+        raise # Re-raise HTTP exceptions
+    except Exception as e:
+        logger.error(f"Error saving edited preview for URL '{payload.url}': {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Failed to save edited preview")

auto_coder_web/routers/mcp_router.py

@@ -4,94 +4,277 @@ import os
 from fastapi import APIRouter, HTTPException, Request, Depends
 from pydantic import BaseModel, Field
 from typing import Dict, Any, Optional, List
-from autocoder.common.mcp_server import (
-    get_mcp_server, 
-    McpInstallRequest, 
-    McpRemoveRequest, 
-    McpListRequest, 
-    McpListRunningRequest, 
-    McpRefreshRequest, 
+from autocoder.common.mcp_server_types import (
+    McpInstallRequest,
+    McpRemoveRequest,
+    McpListRequest,
+    McpListRunningRequest,
+    McpRefreshRequest,
     McpServerInfoRequest,
-    McpResponse
+    McpResponse,
+    InstallResult,
+    RemoveResult,
+    ListResult,
+    ListRunningResult,
+    RefreshResult,
+    QueryResult,
+    ErrorResult,
+    ServerInfo,
+    ExternalServerInfo,
+    ServerConfig,  # Added for InstallResult
+    MarketplaceAddRequest,
+    MarketplaceAddResult,
+    MarketplaceUpdateRequest,  # Added for update endpoint
+    MarketplaceUpdateResult,  # Added for update endpoint
 )
-from autocoder.common.printer import Printer # For messages
-from autocoder.chat_auto_coder_lang import get_message_with_format # For formatted messages
+from autocoder.common.mcp_server import get_mcp_server
+from autocoder.common.printer import Printer  # For messages
+from autocoder.chat_auto_coder_lang import (
+    get_message_with_format,
+    get_message,
+)  # For formatted messages
 from loguru import logger
-from byzerllm.utils.langutil import asyncfy_with_semaphore
-
-# Use asyncfy_with_semaphore to wrap the synchronous send_request method
-async_send_request = asyncfy_with_semaphore(get_mcp_server().send_request, max_workers=5) 
 
 router = APIRouter()
-printer = Printer() # Initialize printer for messages
+printer = Printer()  # Initialize printer for messages
+
+
+# Helper function to run the synchronous send_request in a thread
+async def send_mcp_request_async(*args, **kwargs) -> McpResponse:
+    """Runs the synchronous MCP send_request in a separate thread."""
+    return await asyncio.to_thread(get_mcp_server().send_request, *args, **kwargs)
+
 
 # --- Pydantic Models for Requests ---
 
-class McpAddRequest(BaseModel):
-    server_config: str = Field(..., description="Server configuration string (command-line style or JSON)")
+
+class McpInstallRequestModel(BaseModel):
+    server_config: str = Field(
+        ..., description="Server configuration string (command-line style or JSON)"
+    )
+
+
+# Model for the new /api/mcp/add endpoint
+class MarketplaceAddRequestModel(BaseModel):
+    name: str = Field(
+        ..., description="Name of the MCP server to add to the marketplace"
+    )
+    description: Optional[str] = Field("", description="Description of the MCP server")
+    mcp_type: str = Field(
+        "command", description="Type of MCP server (e.g., 'command', 'sse')"
+    )
+    command: Optional[str] = Field(
+        None, description="Command to run the server (if type is 'command')"
+    )  # Allow None
+    args: Optional[List[str]] = Field(None, description="Arguments for the command")
+    env: Optional[Dict[str, str]] = Field(
+        None, description="Environment variables for the command"
+    )
+    url: Optional[str] = Field(
+        None, description="URL endpoint for the server (if type is 'sse')"
+    )  # Allow None
+
+
+# Model for the /api/mcp/update endpoint
+class MarketplaceUpdateRequestModel(BaseModel):
+    name: str = Field(
+        ..., description="Name of the MCP server to update (used as identifier)"
+    )
+    description: Optional[str] = Field(
+        None, description="Updated description of the MCP server"
+    )
+    mcp_type: Optional[str] = Field(
+        None, description="Updated type of MCP server"
+    )  # Allow None if not changing
+    command: Optional[str] = Field(None, description="Updated command")
+    args: Optional[List[str]] = Field(None, description="Updated arguments")
+    env: Optional[Dict[str, str]] = Field(
+        None, description="Updated environment variables (replaces existing)"
+    )
+    url: Optional[str] = Field(None, description="Updated URL endpoint")
+
 
 class McpRemoveRequestModel(BaseModel):
     server_name: str = Field(..., description="Name of the MCP server to remove")
 
+
 class McpRefreshRequestModel(BaseModel):
-    server_name: Optional[str] = Field(None, description="Name of the MCP server to refresh (optional, refreshes all if None)")
+    server_name: Optional[str] = Field(
+        None,
+        description="Name of the MCP server to refresh (optional, refreshes all if None)",
+    )
+
 
 class McpInfoRequestModel(BaseModel):
     # Assuming model and product_mode might come from global config or request context later
     # For now, let's make them optional or derive them if possible
     model: Optional[str] = None
-    product_mode: Optional[str] = None # Example: "lite", "pro"
+    product_mode: Optional[str] = None  # Example: "lite", "pro"
+
 
 # --- Helper Function to Handle MCP Responses ---
 
-async def handle_mcp_response(request: Any, success_key: str, error_key: str, **kwargs) -> Dict[str, Any]:
+
+async def handle_mcp_response(
+    request: Any, success_key: str, error_key: str, **kwargs
+) -> Dict[str, Any]:
     """Handles sending request to MCP server and formatting the response."""
     try:
-        response: McpResponse = await async_send_request(request)
+        response: McpResponse = await send_mcp_request_async(request)
         if response.error:
             logger.error(f"MCP Error ({error_key}): {response.error}")
             # Use get_message_with_format if available, otherwise use the raw error
             error_message = response.error
             try:
                 # Attempt to format the error message if a key is provided
-                formatted_error = get_message_with_format(error_key, error=response.error)
-                if formatted_error: # Check if formatting was successful
+                formatted_error = get_message_with_format(
+                    error_key, error=response.error
+                )
+                if formatted_error:  # Check if formatting was successful
                     error_message = formatted_error
-            except Exception: # Catch potential errors during formatting
-                pass # Stick with the original error message
+            except Exception:  # Catch potential errors during formatting
+                pass  # Stick with the original error message
             raise HTTPException(status_code=400, detail=error_message)
         else:
             # Use get_message_with_format for success message if available
             success_message = response.result
             try:
-                formatted_success = get_message_with_format(success_key, result=response.result, **kwargs)
-                if formatted_success: # Check if formatting was successful
+                formatted_success = get_message_with_format(
+                    success_key, result=response.result, **kwargs
+                )
+                if formatted_success:  # Check if formatting was successful
                     success_message = formatted_success
             except Exception:
-                 pass # Stick with the original result message
-            return {"status": "success", "message": success_message, "data": response.result} # Include raw data too
+                pass  # Stick with the original result message
+            # Return the formatted message and the raw Pydantic model result
+            return {
+                "status": "success",
+                "message": success_message,
+                "raw_result": response.raw_result,
+            }
     except HTTPException as http_exc:
-        raise http_exc # Re-raise HTTPException
+        raise http_exc  # Re-raise HTTPException
     except Exception as e:
         logger.error(f"Unexpected error during MCP request ({error_key}): {str(e)}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
+
 # --- API Endpoints ---
 
+
+@router.post("/api/mcp/install")
+async def install_mcp_server(request: McpInstallRequestModel):
+    """
+    Installs or updates an MCP server configuration based on name, JSON, or command-line args.
+    Handles built-in, external, and custom server installations.
+    """
+    # First, try to find the server in the marketplace list via McpListRequest
+    try:
+        list_request = McpListRequest()
+        list_response: McpResponse = await send_mcp_request_async(list_request)
+
+        marketplace_item = None
+        if list_response.raw_result and isinstance(
+            list_response.raw_result, ListResult
+        ):
+            # Combine all server lists for searching
+            all_servers = list_response.raw_result.marketplace_items
+            for item in all_servers:
+                if item.name == request.server_config:
+                    marketplace_item = item
+                    break
+
+        if marketplace_item:
+            # If found in any list, create install request with the item
+            mcp_request = McpInstallRequest(market_install_item=marketplace_item)
+            logger.info(
+                f"Found '{request.server_config}' in available server lists. Installing using item. {marketplace_item}"
+            )
+        else:
+            # If not found in any list, assume it's a direct config string or an unknown name
+            mcp_request = McpInstallRequest(server_name_or_config=request.server_config)
+            logger.info(
+                f"'{request.server_config}' not found in available server lists. Installing using name/config string."
+            )
+
+        # Proceed with installation using the determined request type
+        return await handle_mcp_response(
+            mcp_request,
+            success_key="mcp_install_success",
+            error_key="mcp_install_error",
+            result=request.server_config,  # Pass original config for success message formatting
+        )
+
+    except HTTPException as http_exc:
+        # Re-raise HTTP exceptions from handle_mcp_response or list request
+        raise http_exc
+    except Exception as e:
+        logger.error(
+            f"Error during MCP install process for '{request.server_config}': {e}"
+        )
+        # Fallback to original behavior if list fails or other errors occur
+        logger.warning("Falling back to direct install request due to previous error.")
+        mcp_request = McpInstallRequest(server_name_or_config=request.server_config)
+        return await handle_mcp_response(
+            mcp_request,
+            success_key="mcp_install_success",
+            error_key="mcp_install_error",
+            result=request.server_config,
+        )
+
+
 @router.post("/api/mcp/add")
-async def add_mcp_server(request: McpAddRequest):
+async def add_marketplace_server(request: MarketplaceAddRequestModel):
     """
-    Adds or updates an MCP server configuration.
-    Accepts command-line style args or a JSON string.
+    Adds a new MCP server configuration to the marketplace file.
     """
-    mcp_request = McpInstallRequest(server_name_or_config=request.server_config)
+    # Convert API model to the internal McpHub model
+    mcp_request = MarketplaceAddRequest(
+        name=request.name,
+        description=request.description,
+        mcp_type=request.mcp_type,
+        command=request.command,
+        args=request.args,
+        env=request.env,
+        url=request.url,
+    )
     return await handle_mcp_response(
         mcp_request,
-        success_key="mcp_install_success",
-        error_key="mcp_install_error",
-        result=request.server_config # Pass original config for success message formatting
+        success_key="marketplace_add_success",
+        error_key="marketplace_add_error",
+        name=request.name,  # Pass name for message formatting
     )
 
+
+@router.post("/api/mcp/update")
+async def update_marketplace_server(request: MarketplaceUpdateRequestModel):
+    """
+    Updates an existing MCP server configuration in the marketplace file.
+    Uses the 'name' field to identify the server to update.
+    """
+    # Convert API model to the internal McpHub model for update
+    # Note: We assume MarketplaceUpdateRequest exists in mcp_server
+    # and handles partial updates based on provided fields.
+    # If a field is None in the request, it might mean "don't update this field"
+    # or "set this field to None/empty", depending on McpHub's implementation.
+    # Here, we pass all fields from the request model.
+    mcp_request = MarketplaceUpdateRequest(
+        name=request.name,  # Identifier
+        description=request.description,
+        mcp_type=request.mcp_type,
+        command=request.command,
+        args=request.args,
+        env=request.env,
+        url=request.url,
+    )
+    return await handle_mcp_response(
+        mcp_request,
+        success_key="marketplace_update_success",  # Define this message key
+        error_key="marketplace_update_error",  # Define this message key
+        name=request.name,  # Pass name for message formatting
+    )
+
+
 @router.post("/api/mcp/remove")
 async def remove_mcp_server(request: McpRemoveRequestModel):
     """Removes an MCP server configuration by name."""
@@ -100,24 +283,36 @@ async def remove_mcp_server(request: McpRemoveRequestModel):
         mcp_request,
         success_key="mcp_remove_success",
         error_key="mcp_remove_error",
-        result=request.server_name # Pass server name for success message formatting
+        result=request.server_name,  # Pass server name for success message formatting
     )
 
+
 @router.get("/api/mcp/list")
 async def list_mcp_servers():
     """Lists all available built-in and external MCP servers."""
     mcp_request = McpListRequest()
     # Specific handling for list as the result is the data itself
     try:
-        response: McpResponse = await async_send_request(mcp_request)
+        response: McpResponse = await send_mcp_request_async(mcp_request)
         if response.error:
             logger.error(f"MCP Error (mcp_list_builtin_error): {response.error}")
-            error_message = get_message_with_format("mcp_list_builtin_error", error=response.error) or response.error
-            raise HTTPException(status_code=400, detail=error_message)
+            error_message = (
+                get_message_with_format("mcp_list_builtin_error", error=response.error)
+                or response.error
+            )
+            # Ensure raw_result is included in the error detail if it's an ErrorResult
+            detail = error_message
+            if isinstance(response.raw_result, ErrorResult):
+                detail = f"{error_message} (Details: {response.raw_result.error})"
+            raise HTTPException(status_code=400, detail=detail)
         else:
-            # Split the result string into a list for better JSON representation
-            server_list = response.result.strip().split('\n') if response.result else []
-            return {"status": "success", "servers": server_list}
+            # Return the raw_result which should be of type ListResult
+            # Ensure the response is structured consistently
+            return {
+                "status": "success",
+                "message": "MCP servers listed successfully.",
+                "raw_result": response.raw_result,
+            }
     except HTTPException as http_exc:
         raise http_exc
     except Exception as e:
@@ -131,58 +326,88 @@ async def list_running_mcp_servers():
     mcp_request = McpListRunningRequest()
     # Specific handling for list_running
     try:
-        response: McpResponse = await async_send_request(mcp_request)
+        response: McpResponse = await send_mcp_request_async(mcp_request)
         if response.error:
             logger.error(f"MCP Error (mcp_list_running_error): {response.error}")
-            error_message = get_message_with_format("mcp_list_running_error", error=response.error) or response.error
-            raise HTTPException(status_code=400, detail=error_message)
+            error_message = (
+                get_message_with_format("mcp_list_running_error", error=response.error)
+                or response.error
+            )
+            # Ensure raw_result is included in the error detail if it's an ErrorResult
+            detail = error_message
+            if isinstance(response.raw_result, ErrorResult):
+                detail = f"{error_message} (Details: {response.raw_result.error})"
+            raise HTTPException(status_code=400, detail=detail)
         else:
-             # Split the result string into a list
-            running_server_list = response.result.strip().split('\n') if response.result else []
-            # Clean up list (remove potential leading hyphens/spaces)
-            cleaned_list = [s.strip().lstrip('-').strip() for s in running_server_list if s.strip()]
-            return {"status": "success", "running_servers": cleaned_list}
+            # Return the raw_result which should be of type ListRunningResult
+            # Ensure the response is structured consistently
+            return {
+                "status": "success",
+                "message": "Running MCP servers listed successfully.",
+                "raw_result": response.raw_result,
+            }
     except HTTPException as http_exc:
         raise http_exc
     except Exception as e:
         logger.error(f"Unexpected error during MCP list_running request: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
+
 @router.post("/api/mcp/refresh")
 async def refresh_mcp_connections(request: McpRefreshRequestModel):
     """Refreshes connections to MCP servers (all or a specific one)."""
     mcp_request = McpRefreshRequest(name=request.server_name)
     return await handle_mcp_response(
-        mcp_request,
-        success_key="mcp_refresh_success",
-        error_key="mcp_refresh_error"
+        mcp_request, success_key="mcp_refresh_success", error_key="mcp_refresh_error"
     )
 
+
 @router.get("/api/mcp/info")
-async def get_mcp_server_info(model: Optional[str] = None, product_mode: Optional[str] = None):
+async def get_mcp_server_info(
+    model: Optional[str] = None, product_mode: Optional[str] = "lite"
+):
     """Gets detailed information about connected MCP servers."""
     # TODO: Determine how to get model/product_mode - from app state, global config, or request?
     # Using optional query params for now.
     mcp_request = McpServerInfoRequest(model=model, product_mode=product_mode)
     # Specific handling for info
     try:
-        response: McpResponse = await async_send_request(mcp_request)
+        response: McpResponse = await send_mcp_request_async(mcp_request)
         if response.error:
             logger.error(f"MCP Error (mcp_server_info_error): {response.error}")
-            error_message = get_message_with_format("mcp_server_info_error", error=response.error) or response.error
-            raise HTTPException(status_code=400, detail=error_message)
+            error_message = (
+                get_message_with_format("mcp_server_info_error", error=response.error)
+                or response.error
+            )
+            # Ensure raw_result is included in the error detail if it's an ErrorResult
+            detail = error_message
+            if isinstance(response.raw_result, ErrorResult):
+                detail = f"{error_message} (Details: {response.raw_result.error})"
+            raise HTTPException(status_code=400, detail=detail)
         else:
-            # The result is likely a markdown string or complex structure. Return as is.
-            return {"status": "success", "info": response.result}
+            # Return the raw_result. It might be a string or a specific Pydantic model later.
+            # For now, we assume it's included in McpResponse.raw_result
+            # Ensure the response is structured consistently
+            # The success message might vary or be generic
+            success_message = (
+                get_message_with_format("mcp_server_info_success")
+                or "Server info retrieved successfully."
+            )
+            return {
+                "status": "success",
+                "message": success_message,
+                "raw_result": response.raw_result,
+            }
     except HTTPException as http_exc:
         raise http_exc
     except Exception as e:
         logger.error(f"Unexpected error during MCP info request: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
+
 # Potentially add endpoints for direct tool calls or resource access if needed in the future
 # @router.post("/api/mcp/call_tool")
 # async def call_mcp_tool(...): ...
 
 # @router.get("/api/mcp/read_resource")
-# async def read_mcp_resource(...): ...
+# async def read_mcp_resource(...): ...

auto_coder_web/version.py

@@ -1 +1 @@
-__version__ = "0.1.60"
+__version__ = "0.1.62"