♻️ Add Unitest and fix node.js server env read

Author: Phinease

backend/services/conversation_management_service.py

@@ -263,8 +263,13 @@ def call_llm_for_title(content: str, tenant_id: str, language: str = LANGUAGE["Z
         key=MODEL_CONFIG_MAPPING["llm"], tenant_id=tenant_id)
 
     # Create OpenAIServerModel instance
-    llm = OpenAIServerModel(model_id=get_model_name_from_config(model_config) if model_config.get("model_name") else "", api_base=model_config.get("base_url", ""),
-                            api_key=model_config.get("api_key", ""), temperature=0.7, top_p=0.95)
+    llm = OpenAIServerModel(
+        model_id=get_model_name_from_config(model_config) if model_config.get("model_name") else "",
+        api_base=model_config.get("base_url", ""),
+        api_key=model_config.get("api_key", ""),
+        temperature=0.7,
+        top_p=0.95
+    )
 
     # Build messages
     user_prompt = Template(prompt_template["USER_PROMPT"], undefined=StrictUndefined).render({

backend/services/vectordatabase_service.py

@@ -15,12 +15,11 @@
 import time
 import uuid
 from datetime import datetime, timezone
-from typing import Any, Dict, Generator, List, Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import Body, Depends, Path, Query
 from fastapi.responses import StreamingResponse
 from nexent.core.models.embedding_model import OpenAICompatibleEmbedding, JinaEmbedding, BaseEmbedding
-from nexent.core.nlp.tokenizer import calculate_term_weights
 from nexent.vector_database.base import VectorDatabaseCore
 from nexent.vector_database.elasticsearch_core import ElasticSearchCore
 

backend/services/voice_service.py

@@ -1,6 +1,6 @@
 import asyncio
 import logging
-from typing import Dict, Any, Optional
+from typing import Any, Optional
 
 from nexent.core.models.stt_model import STTConfig, STTModel
 from nexent.core.models.tts_model import TTSConfig, TTSModel

frontend/server.js

@@ -2,6 +2,15 @@ const { createServer } = require('http');
 const { parse } = require('url');
 const next = require('next');
 const { createProxyServer } = require('http-proxy');
+const path = require('path');
+
+// Load environment variables from .env file in parent directory (project root)
+// In container environments, env vars are injected directly by Docker, so .env file may not exist
+// Using optional: true to avoid errors if .env file is not found
+require('dotenv').config({ 
+  path: path.resolve(__dirname, '../.env'),
+  override: false // Don't override existing environment variables (important for Docker)
+});
 
 const dev = process.env.NODE_ENV !== 'production';
 const app = next({ 

sdk/nexent/core/agents/core_agent.py

@@ -129,7 +129,7 @@ def _step_stream(self, memory_step: ActionStep) -> Generator[Any]:
             additional_args = {
                 "grammar": self.grammar} if self.grammar is not None else {}
             chat_message: ChatMessage = self.model(input_messages,
-                                                   stop_sequences=["<END_CODE>", "Observation:", "Calling tools:", "<END_CODE"], **additional_args, )
+                                                   stop_sequences=["<END_CODE>", "Observation:", "Calling tools:", "<END_CODE"], **additional_args)
             memory_step.model_output_message = chat_message
             model_output = chat_message.content
             memory_step.model_output = model_output

test/backend/database/test_model_managment_db.py

@@ -150,3 +150,247 @@ def test_get_model_by_model_id_fills_default_chunk_sizes(monkeypatch):
     assert out is not None
     assert out["expected_chunk_size"] == 1024
     assert out["maximum_chunk_size"] == 1536
+
+
+def test_create_model_record(monkeypatch):
+    """Test create_model_record function (covers lines 23-42)"""
+    mock_result = MagicMock()
+    mock_result.rowcount = 1
+    
+    mock_stmt = MagicMock()
+    mock_stmt.values.return_value = mock_stmt
+    
+    mock_insert = MagicMock(return_value=mock_stmt)
+    monkeypatch.setattr("backend.database.model_management_db.insert", mock_insert)
+    
+    session = MagicMock()
+    session.execute.return_value = mock_result
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    
+    # Mock clean_string_values and add_creation_tracking
+    monkeypatch.setattr("backend.database.model_management_db.db_client.clean_string_values", lambda x: x)
+    monkeypatch.setattr("backend.database.model_management_db.add_creation_tracking", lambda x, uid: x)
+    monkeypatch.setattr("backend.database.model_management_db.func.current_timestamp", MagicMock())
+    
+    model_data = {"model_name": "test", "model_type": "llm"}
+    result = model_mgmt_db.create_model_record(model_data, user_id="u1", tenant_id="t1")
+    
+    assert result is True
+    session.execute.assert_called_once()
+
+
+def test_update_model_record(monkeypatch):
+    """Test update_model_record function (covers lines 63-84)"""
+    mock_result = MagicMock()
+    mock_result.rowcount = 1
+    
+    mock_stmt = MagicMock()
+    mock_stmt.where.return_value = mock_stmt
+    mock_stmt.values.return_value = mock_stmt
+    
+    mock_update = MagicMock(return_value=mock_stmt)
+    monkeypatch.setattr("backend.database.model_management_db.update", mock_update)
+    
+    session = MagicMock()
+    session.execute.return_value = mock_result
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    
+    # Mock clean_string_values and add_update_tracking
+    monkeypatch.setattr("backend.database.model_management_db.db_client.clean_string_values", lambda x: x)
+    monkeypatch.setattr("backend.database.model_management_db.add_update_tracking", lambda x, uid: x)
+    monkeypatch.setattr("backend.database.model_management_db.func.current_timestamp", MagicMock())
+    
+    update_data = {"model_name": "updated"}
+    result = model_mgmt_db.update_model_record(1, update_data, user_id="u1", tenant_id="t1")
+    
+    assert result is True
+    session.execute.assert_called_once()
+
+
+def test_delete_model_record(monkeypatch):
+    """Test delete_model_record function (covers lines 99-119)"""
+    mock_result = MagicMock()
+    mock_result.rowcount = 1
+    
+    mock_stmt = MagicMock()
+    mock_stmt.where.return_value = mock_stmt
+    mock_stmt.values.return_value = mock_stmt
+    
+    mock_update = MagicMock(return_value=mock_stmt)
+    monkeypatch.setattr("backend.database.model_management_db.update", mock_update)
+    
+    session = MagicMock()
+    session.execute.return_value = mock_result
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    
+    # Mock add_update_tracking
+    monkeypatch.setattr("backend.database.model_management_db.add_update_tracking", lambda x, uid: x)
+    monkeypatch.setattr("backend.database.model_management_db.func.current_timestamp", MagicMock())
+    
+    result = model_mgmt_db.delete_model_record(1, user_id="u1", tenant_id="t1")
+    
+    assert result is True
+    session.execute.assert_called_once()
+
+
+def test_get_model_records_with_tenant_id(monkeypatch):
+    """Test get_model_records with tenant_id filter (covers lines 137->141)"""
+    mock_model = SimpleNamespace(
+        model_id=4,
+        model_factory="openai",
+        model_type="llm",
+        tenant_id="tenant4",
+        delete_flag="N",
+    )
+    mock_scalars = MagicMock()
+    mock_scalars.all.return_value = [mock_model]
+    session = MagicMock()
+    session.scalars.return_value = mock_scalars
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.model_management_db.as_dict", lambda obj: obj.__dict__)
+    
+    records = model_mgmt_db.get_model_records({"model_type": "llm"}, tenant_id="tenant4")
+    assert len(records) == 1
+    assert records[0]["tenant_id"] == "tenant4"
+
+
+def test_get_model_records_with_none_filter(monkeypatch):
+    """Test get_model_records with None value in filter (covers line 145)"""
+    mock_model = SimpleNamespace(
+        model_id=5,
+        model_factory="openai",
+        model_type="llm",
+        tenant_id="tenant5",
+        delete_flag="N",
+        display_name=None,
+    )
+    mock_scalars = MagicMock()
+    mock_scalars.all.return_value = [mock_model]
+    session = MagicMock()
+    session.scalars.return_value = mock_scalars
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.model_management_db.as_dict", lambda obj: obj.__dict__)
+    
+    records = model_mgmt_db.get_model_records({"display_name": None}, tenant_id="tenant5")
+    assert len(records) == 1
+
+
+def test_get_model_by_display_name(monkeypatch):
+    """Test get_model_by_display_name function (covers lines 178-185)"""
+    mock_model = SimpleNamespace(
+        model_id=6,
+        model_factory="openai",
+        model_name="gpt-4",
+        display_name="GPT-4",
+        tenant_id="tenant6",
+        delete_flag="N",
+    )
+    mock_scalars = MagicMock()
+    mock_scalars.all.return_value = [mock_model]
+    session = MagicMock()
+    session.scalars.return_value = mock_scalars
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.model_management_db.as_dict", lambda obj: obj.__dict__)
+    
+    result = model_mgmt_db.get_model_by_display_name("GPT-4", "tenant6")
+    assert result is not None
+    assert result["display_name"] == "GPT-4"
+
+
+def test_get_model_id_by_display_name(monkeypatch):
+    """Test get_model_id_by_display_name function (covers lines 199-200)"""
+    mock_model = SimpleNamespace(
+        model_id=7,
+        model_factory="openai",
+        model_name="gpt-4",
+        display_name="GPT-4",
+        tenant_id="tenant7",
+        delete_flag="N",
+    )
+    mock_scalars = MagicMock()
+    mock_scalars.all.return_value = [mock_model]
+    session = MagicMock()
+    session.scalars.return_value = mock_scalars
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.model_management_db.as_dict", lambda obj: obj.__dict__)
+    
+    result = model_mgmt_db.get_model_id_by_display_name("GPT-4", "tenant7")
+    assert result == 7
+
+
+def test_get_model_by_model_id_with_tenant_id(monkeypatch):
+    """Test get_model_by_model_id with tenant_id filter (covers lines 222->226)"""
+    mock_model = SimpleNamespace(
+        model_id=8,
+        model_factory="openai",
+        model_type="llm",
+        tenant_id="tenant8",
+        delete_flag="N",
+    )
+    mock_scalars = MagicMock()
+    mock_scalars.first.return_value = mock_model
+    session = MagicMock()
+    session.scalars.return_value = mock_scalars
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    
+    result = model_mgmt_db.get_model_by_model_id(8, tenant_id="tenant8")
+    assert result is not None
+    assert result["model_id"] == 8
+
+
+def test_get_model_by_name_factory(monkeypatch):
+    """Test get_model_by_name_factory function (covers lines 269-274)"""
+    mock_model = SimpleNamespace(
+        model_id=9,
+        model_factory="openai",
+        model_name="gpt-4",
+        tenant_id="tenant9",
+        delete_flag="N",
+    )
+    mock_scalars = MagicMock()
+    mock_scalars.all.return_value = [mock_model]
+    session = MagicMock()
+    session.scalars.return_value = mock_scalars
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.model_management_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.model_management_db.as_dict", lambda obj: obj.__dict__)
+    
+    result = model_mgmt_db.get_model_by_name_factory("gpt-4", "openai", "tenant9")
+    assert result is not None
+    assert result["model_name"] == "gpt-4"
+    assert result["model_factory"] == "openai"

test/backend/services/test_me_model_management_service.py

@@ -130,3 +130,30 @@ async def test_check_me_connectivity_variables_not_set():
 
         # Assert
         assert result is False
+
+
+@pytest.mark.asyncio
+async def test_check_me_connectivity_general_exception():
+    """Test ME connectivity check with general exception (covers lines 54-55)"""
+    with patch.object(svc, 'MODEL_ENGINE_APIKEY', 'mock-api-key'), \
+            patch.object(svc, 'MODEL_ENGINE_HOST', 'https://me-host.com'), \
+            patch('backend.services.me_model_management_service.aiohttp.ClientSession') as mock_session_class:
+
+        # Create mock session that raises a general exception
+        mock_session = AsyncMock()
+        mock_get = AsyncMock()
+        mock_get.__aenter__.side_effect = ValueError("Unexpected error")
+        mock_session.get = MagicMock(return_value=mock_get)
+
+        # Create mock session factory
+        mock_client_session = AsyncMock()
+        mock_client_session.__aenter__.return_value = mock_session
+        mock_session_class.return_value = mock_client_session
+
+        # Execute and expect a generic Exception
+        with pytest.raises(Exception) as exc_info:
+            await svc.check_me_connectivity(timeout=30)
+
+        # Assert the exception message contains "Unknown error occurred"
+        assert "Unknown error occurred" in str(exc_info.value)
+        assert "Unexpected error" in str(exc_info.value)