Release/v1.8.0.1

backend/agents/create_agent_info.py

@@ -19,6 +19,7 @@
 from services.memory_config_service import build_memory_context
 from services.image_service import get_vlm_model
 from database.agent_db import search_agent_info_by_agent_id, query_sub_agents_id_list
+from database.agent_version_db import query_current_version_no
 from database.tool_db import search_tools_for_sub_agent
 from database.model_management_db import get_model_records, get_model_by_model_id
 from database.client import minio_client
@@ -75,26 +76,31 @@ async def create_agent_config(
     language: str = LANGUAGE["ZH"],
     last_user_query: str = None,
     allow_memory_search: bool = True,
+    version_no: int = 0,
 ):
     agent_info = search_agent_info_by_agent_id(
-        agent_id=agent_id, tenant_id=tenant_id)
+        agent_id=agent_id, tenant_id=tenant_id, version_no=version_no)
 
     # create sub agent
     sub_agent_id_list = query_sub_agents_id_list(
-        main_agent_id=agent_id, tenant_id=tenant_id)
+        main_agent_id=agent_id, tenant_id=tenant_id, version_no=version_no)
     managed_agents = []
     for sub_agent_id in sub_agent_id_list:
+        # Get the current published version for this sub-agent (from draft version 0)
+        sub_agent_version_no = query_current_version_no(
+            agent_id=sub_agent_id, tenant_id=tenant_id) or 0
         sub_agent_config = await create_agent_config(
             agent_id=sub_agent_id,
             tenant_id=tenant_id,
             user_id=user_id,
             language=language,
             last_user_query=last_user_query,
             allow_memory_search=allow_memory_search,
+            version_no=sub_agent_version_no,
         )
         managed_agents.append(sub_agent_config)
 
-    tool_list = await create_tool_config_list(agent_id, tenant_id, user_id)
+    tool_list = await create_tool_config_list(agent_id, tenant_id, user_id, version_no=version_no)
 
     # Build system prompt: prioritize segmented fields, fallback to original prompt field if not available
     duty_prompt = agent_info.get("duty_prompt", "")
@@ -202,13 +208,13 @@ async def create_agent_config(
     return agent_config
 
 
-async def create_tool_config_list(agent_id, tenant_id, user_id):
+async def create_tool_config_list(agent_id, tenant_id, user_id, version_no: int = 0):
     # create tool
     tool_config_list = []
     langchain_tools = await discover_langchain_tools()
 
     # now only admin can modify the agent, user_id is not used
-    tools_list = search_tools_for_sub_agent(agent_id, tenant_id)
+    tools_list = search_tools_for_sub_agent(agent_id, tenant_id, version_no=version_no)
     for tool in tools_list:
         param_dict = {}
         for param in tool.get("params", []):
@@ -355,7 +361,21 @@ async def create_agent_run_info(
     user_id: str,
     language: str = "zh",
     allow_memory_search: bool = True,
+    is_debug: bool = False,
 ):
+    # Determine which version_no to use based on is_debug flag
+    # If is_debug=false, use the current published version (current_version_no)
+    # If is_debug=true, use version 0 (draft/editing state)
+    if is_debug:
+        version_no = 0
+    else:
+        # Get current published version number
+        version_no = query_current_version_no(agent_id=agent_id, tenant_id=tenant_id)
+        # Fallback to 0 if no published version exists
+        if version_no is None:
+            version_no = 0
+            logger.info(f"Agent {agent_id} has no published version, using draft version 0")
+
     final_query = await join_minio_file_description_to_query(minio_files=minio_files, query=query)
     model_list = await create_model_config_list(tenant_id)
     agent_config = await create_agent_config(
@@ -365,19 +385,45 @@ async def create_agent_run_info(
         language=language,
         last_user_query=final_query,
         allow_memory_search=allow_memory_search,
+        version_no=version_no,
     )
 
-    remote_mcp_list = await get_remote_mcp_server_list(tenant_id=tenant_id)
+    remote_mcp_list = await get_remote_mcp_server_list(tenant_id=tenant_id, is_need_auth=True)
     default_mcp_url = urljoin(LOCAL_MCP_SERVER, "sse")
     remote_mcp_list.append({
         "remote_mcp_server_name": "nexent",
         "remote_mcp_server": default_mcp_url,
-        "status": True
+        "status": True,
+        "authorization_token": None
     })
     remote_mcp_dict = {record["remote_mcp_server_name"]: record for record in remote_mcp_list if record["status"]}
 
-    # Filter MCP servers and tools
-    mcp_host = filter_mcp_servers_and_tools(agent_config, remote_mcp_dict)
+    # Filter MCP servers and tools, and build mcp_host with authorization
+    used_mcp_urls = filter_mcp_servers_and_tools(agent_config, remote_mcp_dict)
+
+    # Build mcp_host list with authorization tokens
+    mcp_host = []
+    for url in used_mcp_urls:
+        # Find the MCP record for this URL
+        mcp_record = None
+        for record in remote_mcp_list:
+            if record.get("remote_mcp_server") == url and record.get("status"):
+                mcp_record = record
+                break
+
+        if mcp_record:
+            mcp_config = {
+                "url": url,
+                "transport": "sse" if url.endswith("/sse") else "streamable-http"
+            }
+            # Add authorization if present
+            auth_token = mcp_record.get("authorization_token")
+            if auth_token:
+                mcp_config["authorization"] = auth_token
+            mcp_host.append(mcp_config)
+        else:
+            # Fallback to string format if record not found
+            mcp_host.append(url)
 
     agent_run_info = AgentRunInfo(
         query=final_query,

backend/apps/agent_app.py

@@ -6,7 +6,7 @@
 from fastapi.encoders import jsonable_encoder
 from starlette.responses import JSONResponse
 
-from consts.model import AgentRequest, AgentInfoRequest, AgentIDRequest, ConversationResponse, AgentImportRequest, AgentNameBatchCheckRequest, AgentNameBatchRegenerateRequest, VersionPublishRequest, VersionListResponse, VersionDetailResponse, VersionRollbackRequest, VersionStatusRequest, CurrentVersionResponse, VersionCompareRequest
+from consts.model import AgentRequest, AgentInfoRequest, AgentIDRequest, ConversationResponse, AgentImportRequest, AgentNameBatchCheckRequest, AgentNameBatchRegenerateRequest, VersionPublishRequest, VersionListResponse, VersionDetailResponse, VersionRollbackRequest, VersionStatusRequest, CurrentVersionResponse, VersionCompareRequest, VersionUpdateRequest
 from services.agent_service import (
     get_agent_info_impl,
     get_creating_sub_agent_info_impl,
@@ -29,6 +29,7 @@
     get_version_detail_impl,
     rollback_version_impl,
     update_version_status_impl,
+    update_version_impl,
     delete_version_impl,
     get_current_version_impl,
     compare_versions_impl,
@@ -443,6 +444,34 @@ async def update_version_status_api(
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Update version status error.")
 
 
+@agent_config_router.put("/{agent_id}/versions/{version_no}")
+async def update_version_api(
+    agent_id: int,
+    version_no: int,
+    request: VersionUpdateRequest,
+    authorization: str = Header(None),
+):
+    """
+    Update version metadata (version_name and release_note)
+    """
+    try:
+        user_id, tenant_id = get_current_user_id(authorization)
+        result = update_version_impl(
+            agent_id=agent_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            version_no=version_no,
+            version_name=request.version_name,
+            release_note=request.release_note,
+        )
+        return JSONResponse(status_code=HTTPStatus.OK, content=result)
+    except ValueError as e:
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail=str(e))
+    except Exception as e:
+        logger.error(f"Update version error: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Update version error.")
+
+
 @agent_config_router.delete("/{agent_id}/versions/{version_no}")
 async def delete_version_api(
     agent_id: int,

backend/apps/conversation_management_app.py

@@ -175,12 +175,15 @@ async def generate_conversation_title_endpoint(
         authorization: Optional[str] = Header(None)
 ):
     """
-    Generate conversation title
+    Generate conversation title from user question
+
+    This endpoint generates title immediately after user sends a message,
+    using only the question content instead of waiting for full conversation.
 
     Args:
         request: GenerateTitleRequest object containing:
             - conversation_id: Conversation ID
-            - history: Conversation history list
+            - question: User's question content
         http_request: http request containing language info
         authorization: Authorization header
 
@@ -190,7 +193,8 @@ async def generate_conversation_title_endpoint(
     try:
         user_id, tenant_id, language = get_current_user_info(
             authorization=authorization, request=http_request)
-        title = await generate_conversation_title_service(request.conversation_id, request.history, user_id, tenant_id=tenant_id, language=language)
+        title = await generate_conversation_title_service(
+            request.conversation_id, request.question, user_id, tenant_id=tenant_id, language=language)
         return ConversationResponse(code=0, message="success", data=title)
     except Exception as e:
         logging.error(f"Failed to generate conversation title: {str(e)}")

backend/apps/mock_user_management_app.py

@@ -33,28 +33,24 @@ async def signup(request: UserSignUpRequest):
     Mock user registration endpoint
     """
     try:
-        logger.info(
-            f"Mock signup request: email={request.email}, is_admin={request.is_admin}")
+        logger.info(f"Mock signup request: email={request.email}")
 
         # Mock success response matching user_management_app.py format
-        if request.is_admin:
-            success_message = "🎉 Admin account registered successfully! You now have system management permissions."
-        else:
-            success_message = "🎉 User account registered successfully! Please start experiencing the AI assistant service."
+        success_message = "🎉 User account registered successfully! Please start experiencing the AI assistant service."
 
         user_data = {
             "user": {
                 "id": MOCK_USER["id"],
                 "email": request.email,
-                "role": "admin" if request.is_admin else "user"
+                "role": "user"
             },
             "session": {
                 "access_token": MOCK_SESSION["access_token"],
                 "refresh_token": MOCK_SESSION["refresh_token"],
                 "expires_at": int((datetime.now() + timedelta(days=3650)).timestamp()),
                 "expires_in_seconds": MOCK_SESSION["expires_in_seconds"]
             },
-            "registration_type": "admin" if request.is_admin else "user"
+            "registration_type": "user"
         }
 
         return JSONResponse(status_code=HTTPStatus.OK,

backend/apps/remote_mcp_app.py

@@ -17,6 +17,7 @@
     upload_and_start_mcp_image,
     update_remote_mcp_server_list,
     attach_mcp_container_permissions,
+    get_mcp_record_by_id,
 )
 from database.remote_mcp_db import check_mcp_name_exists
 from services.tool_configuration_service import get_tool_from_remote_mcp_server
@@ -30,11 +31,18 @@
 @router.post("/tools")
 async def get_tools_from_remote_mcp(
     service_name: str,
-    mcp_url: str
+    mcp_url: str,
+    authorization: Optional[str] = Header(None),
+    http_request: Request = None
 ):
     """ Used to list tool information from the remote MCP server """
     try:
-        tools_info = await get_tool_from_remote_mcp_server(mcp_server_name=service_name, remote_mcp_server=mcp_url)
+        user_id, tenant_id, _ = get_current_user_info(authorization, http_request)
+        tools_info = await get_tool_from_remote_mcp_server(
+            mcp_server_name=service_name,
+            remote_mcp_server=mcp_url,
+            tenant_id=tenant_id
+        )
         return JSONResponse(
             status_code=HTTPStatus.OK,
             content={
@@ -54,6 +62,8 @@ async def get_tools_from_remote_mcp(
 async def add_remote_proxies(
     mcp_url: str,
     service_name: str,
+    authorization_token: Optional[str] = Query(
+        None, description="Authorization token for MCP server authentication (e.g., Bearer token)"),
     tenant_id: Optional[str] = Query(
         None, description="Tenant ID for filtering (uses auth if not provided)"),
     authorization: Optional[str] = Header(None),
@@ -68,7 +78,8 @@ async def add_remote_proxies(
                                          user_id=user_id,
                                          remote_mcp_server=mcp_url,
                                          remote_mcp_server_name=service_name,
-                                         container_id=None)
+                                         container_id=None,
+                                         authorization_token=authorization_token)
         return JSONResponse(
             status_code=HTTPStatus.OK,
             content={"message": "Successfully added remote MCP proxy",
@@ -170,6 +181,7 @@ async def get_remote_proxies(
         remote_mcp_server_list = await get_remote_mcp_server_list(
             tenant_id=effective_tenant_id,
             user_id=user_id,
+            is_need_auth=False
         )
         return JSONResponse(
             status_code=HTTPStatus.OK,
@@ -183,6 +195,50 @@ async def get_remote_proxies(
                             detail="Failed to get remote MCP proxy")
 
 
+@router.get("/record/{mcp_id}")
+async def get_mcp_record(
+    mcp_id: int,
+    tenant_id: Optional[str] = Query(
+        None, description="Tenant ID for filtering (uses auth if not provided)"),
+    authorization: Optional[str] = Header(None),
+    http_request: Request = None
+):
+    """ Get single MCP record by ID """
+    try:
+        user_id, auth_tenant_id, _ = get_current_user_info(authorization, http_request)
+        # Use explicit tenant_id if provided, otherwise fall back to auth tenant_id
+        effective_tenant_id = tenant_id or auth_tenant_id
+
+        mcp_record = await get_mcp_record_by_id(
+            mcp_id=mcp_id,
+            tenant_id=effective_tenant_id
+        )
+
+        if not mcp_record:
+            raise HTTPException(
+                status_code=HTTPStatus.NOT_FOUND,
+                detail="MCP record not found"
+            )
+
+        return JSONResponse(
+            status_code=HTTPStatus.OK,
+            content={
+                "mcp_name": mcp_record.get("mcp_name"),
+                "mcp_server": mcp_record.get("mcp_server"),
+                "authorization_token": mcp_record.get("authorization_token"),
+                "status": "success"
+            }
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get MCP record: {e}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail="Failed to get MCP record"
+        )
+
+
 @router.get("/healthcheck")
 async def check_mcp_health(
     mcp_url: str,