jarvis-ai-assistant 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

jarvis/jarvis_utils/config.py

@@ -115,22 +115,26 @@ def get_shell_name() -> str:
     return os.path.basename(shell_path).lower()
 
 
-def _get_resolved_model_config(model_group_override: Optional[str] = None) -> Dict[str, Any]:
+def _get_resolved_model_config(
+    model_group_override: Optional[str] = None,
+) -> Dict[str, Any]:
     """
     解析并合并模型配置，处理模型组。
 
     优先级顺序:
     1. 单独的环境变量 (JARVIS_PLATFORM, JARVIS_MODEL, etc.)
-    2. JARVIS_MODEL_GROUP 中定义的组配置
+    2. JARVIS_LLM_GROUP 中定义的组配置
     3. 代码中的默认值
 
     返回:
         Dict[str, Any]: 解析后的模型配置字典
     """
     group_config = {}
-    model_group_name = model_group_override or GLOBAL_CONFIG_DATA.get("JARVIS_MODEL_GROUP")
+    model_group_name = model_group_override or GLOBAL_CONFIG_DATA.get(
+        "JARVIS_LLM_GROUP"
+    )
     # The format is a list of single-key dicts: [{'group_name': {...}}, ...]
-    model_groups = GLOBAL_CONFIG_DATA.get("JARVIS_MODEL_GROUPS", [])
+    model_groups = GLOBAL_CONFIG_DATA.get("JARVIS_LLM_GROUPS", [])
 
     if model_group_name and isinstance(model_groups, list):
         for group_item in model_groups:
@@ -202,7 +206,9 @@ def get_thinking_model_name(model_group_override: Optional[str] = None) -> str:
     """
     config = _get_resolved_model_config(model_group_override)
     # Fallback to normal model if thinking model is not specified
-    return config.get("JARVIS_THINKING_MODEL", get_normal_model_name(model_group_override))
+    return config.get(
+        "JARVIS_THINKING_MODEL", get_normal_model_name(model_group_override)
+    )
 
 
 def is_execute_tool_confirm() -> bool:
@@ -334,14 +340,65 @@ def get_mcp_config() -> List[Dict[str, Any]]:
 # ==============================================================================
 
 
-def get_rag_config() -> Dict[str, Any]:
+DEFAULT_RAG_GROUPS = [
+    {
+        "text": {
+            "embedding_model": "BAAI/bge-m3",
+            "rerank_model": "BAAI/bge-reranker-v2-m3",
+            "use_bm25": True,
+            "use_rerank": True,
+        }
+    },
+    {
+        "code": {
+            "embedding_model": "Qodo/Qodo-Embed-1-7B",
+            "use_bm25": False,
+            "use_rerank": False,
+        }
+    },
+]
+
+
+def _get_resolved_rag_config(
+    rag_group_override: Optional[str] = None,
+) -> Dict[str, Any]:
     """
-    获取RAG框架的配置。
+    解析并合并RAG配置，处理RAG组。
+
+    优先级顺序:
+    1. JARVIS_RAG 中的顶级设置 (embedding_model, etc.)
+    2. JARVIS_RAG_GROUP 中定义的组配置
+    3. 代码中的默认值
 
     返回:
-        Dict[str, Any]: RAG配置字典
+        Dict[str, Any]: 解析后的RAG配置字典
     """
-    return GLOBAL_CONFIG_DATA.get("JARVIS_RAG", {})
+    group_config = {}
+    rag_group_name = rag_group_override or GLOBAL_CONFIG_DATA.get("JARVIS_RAG_GROUP")
+    rag_groups = GLOBAL_CONFIG_DATA.get("JARVIS_RAG_GROUPS", DEFAULT_RAG_GROUPS)
+
+    if rag_group_name and isinstance(rag_groups, list):
+        for group_item in rag_groups:
+            if isinstance(group_item, dict) and rag_group_name in group_item:
+                group_config = group_item[rag_group_name]
+                break
+
+    # Start with group config
+    resolved_config = group_config.copy()
+
+    # Override with specific settings from the top-level JARVIS_RAG dict
+    top_level_rag_config = GLOBAL_CONFIG_DATA.get("JARVIS_RAG", {})
+    if isinstance(top_level_rag_config, dict):
+        for key in [
+            "embedding_model",
+            "rerank_model",
+            "use_bm25",
+            "use_rerank",
+        ]:
+            if key in top_level_rag_config:
+                resolved_config[key] = top_level_rag_config[key]
+
+    return resolved_config
 
 
 def get_rag_embedding_model() -> str:
@@ -351,7 +408,8 @@ def get_rag_embedding_model() -> str:
     返回:
         str: 嵌入模型的名称
     """
-    return get_rag_config().get("embedding_model", "BAAI/bge-base-zh-v1.5")
+    config = _get_resolved_rag_config()
+    return config.get("embedding_model", "BAAI/bge-m3")
 
 
 def get_rag_rerank_model() -> str:
@@ -361,7 +419,8 @@ def get_rag_rerank_model() -> str:
     返回:
         str: rerank模型的名称
     """
-    return get_rag_config().get("rerank_model", "BAAI/bge-reranker-base")
+    config = _get_resolved_rag_config()
+    return config.get("rerank_model", "BAAI/bge-reranker-v2-m3")
 
 
 def get_rag_embedding_cache_path() -> str:
@@ -382,3 +441,25 @@ def get_rag_vector_db_path() -> str:
         str: 数据库路径
     """
     return ".jarvis/rag/vectordb"
+
+
+def get_rag_use_bm25() -> bool:
+    """
+    获取RAG是否使用BM25。
+
+    返回:
+        bool: 如果使用BM25则返回True，默认为True
+    """
+    config = _get_resolved_rag_config()
+    return config.get("use_bm25", True) is True
+
+
+def get_rag_use_rerank() -> bool:
+    """
+    获取RAG是否使用rerank。
+
+    返回:
+        bool: 如果使用rerank则返回True，默认为True
+    """
+    config = _get_resolved_rag_config()
+    return config.get("use_rerank", True) is True

jarvis/jarvis_utils/globals.py

@@ -9,9 +9,11 @@
 """
 import os
 
-# 全局变量：保存最后一条消息
-last_message: str = ""
-from typing import Any, Dict, Set
+# 全局变量：保存消息历史
+from typing import Any, Dict, Set, List
+
+message_history: List[str] = []
+MAX_HISTORY_SIZE = 50
 
 import colorama
 from rich.console import Console
@@ -169,13 +171,18 @@ def get_interrupt() -> int:
 
 def set_last_message(message: str) -> None:
     """
-    设置最后一条消息。
+    将消息添加到历史记录中。
 
     参数:
         message: 要保存的消息
     """
-    global last_message
-    last_message = message
+    global message_history
+    if message:
+        # 避免重复添加
+        if not message_history or message_history[-1] != message:
+            message_history.append(message)
+            if len(message_history) > MAX_HISTORY_SIZE:
+                message_history.pop(0)
 
 
 def get_last_message() -> str:
@@ -183,6 +190,20 @@ def get_last_message() -> str:
     获取最后一条消息。
 
     返回:
-        str: 最后一条消息
+        str: 最后一条消息，如果历史记录为空则返回空字符串
+    """
+    global message_history
+    if message_history:
+        return message_history[-1]
+    return ""
+
+
+def get_message_history() -> List[str]:
+    """
+    获取完整的消息历史记录。
+
+    返回:
+        List[str]: 消息历史列表
     """
-    return last_message
+    global message_history
+    return message_history

jarvis/jarvis_utils/http.py

@@ -1,140 +1,120 @@
 # -*- coding: utf-8 -*-
 
-import httpx
-from typing import Any, Dict, Optional, Union, AsyncGenerator, Generator
+import requests
+from typing import Any, Dict, Optional, Generator
 
 
-def get_httpx_client() -> httpx.Client:
+def get_requests_session() -> requests.Session:
     """
-    获取一个配置好的 httpx.Client 对象
+    获取一个配置好的 requests.Session 对象
 
     返回:
-        httpx.Client 对象
+        requests.Session 对象
     """
-    client = httpx.Client(
-        timeout=httpx.Timeout(None),  # 永不超时
-        headers={
+    session = requests.Session()
+    session.headers.update(
+        {
             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
-        },
+        }
     )
-    return client
+    return session
 
 
-def get_async_httpx_client() -> httpx.AsyncClient:
-    """
-    获取一个配置好的 httpx.AsyncClient 对象
-
-    返回:
-        httpx.AsyncClient 对象
-    """
-    client = httpx.AsyncClient(
-        timeout=httpx.Timeout(None),  # 永不超时
-        headers={
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
-        },
-    )
-    return client
-
-
-# 增强版本的 HTTP 请求方法（使用 httpx 实现，带重试机制，解决连接中断问题）
+# 增强版本的 HTTP 请求方法（使用 requests 实现）
 def post(
     url: str,
     data: Optional[Any] = None,
     json: Optional[Dict[str, Any]] = None,
     **kwargs,
-) -> httpx.Response:
+) -> requests.Response:
     """
-    发送增强版永不超时的 POST 请求，使用 httpx 实现，包含重试机制
+    发送增强版永不超时的 POST 请求，使用 requests 实现
 
     参数:
         url: 请求的 URL
         data: (可选) 请求体数据 (表单数据或原始数据)
         json: (可选) JSON 数据，会自动设置 Content-Type
-        **kwargs: 其他传递给 httpx.post 的参数
+        **kwargs: 其他传递给 requests.post 的参数
 
     返回:
-        httpx.Response 对象
+        requests.Response 对象
 
     注意:
-        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 requests 实现。要实现重试，请考虑使用 Session 和 HTTPAdapter。
+        永不超时通过 timeout=None 设置。
     """
-    client = get_httpx_client()
-    try:
-        response = client.post(url=url, data=data, json=json, **kwargs)
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        response = session.post(url=url, data=data, json=json, **kwargs)
         response.raise_for_status()
         return response
-    finally:
-        client.close()
 
 
-def get(url: str, **kwargs) -> httpx.Response:
+def get(url: str, **kwargs) -> requests.Response:
     """
-    发送增强版永不超时的 GET 请求，使用 httpx 实现，包含重试机制
+    发送增强版永不超时的 GET 请求，使用 requests 实现
 
     参数:
         url: 请求的 URL
-        **kwargs: 其他传递给 httpx.get 的参数
+        **kwargs: 其他传递给 requests.get 的参数
 
     返回:
-        httpx.Response 对象
+        requests.Response 对象
 
     注意:
-        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 requests 实现。
+        永不超时通过 timeout=None 设置。
     """
-    client = get_httpx_client()
-    try:
-        response = client.get(url=url, **kwargs)
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        response = session.get(url=url, **kwargs)
         response.raise_for_status()
         return response
-    finally:
-        client.close()
 
 
-def put(url: str, data: Optional[Any] = None, **kwargs) -> httpx.Response:
+def put(url: str, data: Optional[Any] = None, **kwargs) -> requests.Response:
     """
-    发送增强版永不超时的 PUT 请求，使用 httpx 实现，包含重试机制
+    发送增强版永不超时的 PUT 请求，使用 requests 实现
 
     参数:
         url: 请求的 URL
         data: (可选) 请求体数据 (表单数据或原始数据)
-        **kwargs: 其他传递给 httpx.put 的参数
+        **kwargs: 其他传递给 requests.put 的参数
 
     返回:
-        httpx.Response 对象
+        requests.Response 对象
 
     注意:
-        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 requests 实现。
+        永不超时通过 timeout=None 设置。
     """
-    client = get_httpx_client()
-    try:
-        response = client.put(url=url, data=data, **kwargs)
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        response = session.put(url=url, data=data, **kwargs)
         response.raise_for_status()
         return response
-    finally:
-        client.close()
 
 
-def delete(url: str, **kwargs) -> httpx.Response:
+def delete(url: str, **kwargs) -> requests.Response:
     """
-    发送增强版永不超时的 DELETE 请求，使用 httpx 实现，包含重试机制
+    发送增强版永不超时的 DELETE 请求，使用 requests 实现
 
     参数:
         url: 请求的 URL
-        **kwargs: 其他传递给 httpx.delete 的参数
+        **kwargs: 其他传递给 requests.delete 的参数
 
     返回:
-        httpx.Response 对象
+        requests.Response 对象
 
     注意:
-        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+        此方法使用 requests 实现。
+        永不超时通过 timeout=None 设置。
     """
-    client = get_httpx_client()
-    try:
-        response = client.delete(url=url, **kwargs)
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        response = session.delete(url=url, **kwargs)
         response.raise_for_status()
         return response
-    finally:
-        client.close()
 
 
 # 同步流式POST请求方法
@@ -143,27 +123,26 @@ def stream_post(
     data: Optional[Any] = None,
     json: Optional[Dict[str, Any]] = None,
     **kwargs,
-) -> Generator[bytes, None, None]:
+) -> Generator[str, None, None]:
     """
-    发送流式 POST 请求，使用 httpx 实现，返回标准 Generator
+    发送流式 POST 请求，使用 requests 实现，返回解码后的字符串行生成器
 
     参数:
         url: 请求的 URL
         data: (可选) 请求体数据 (表单数据或原始数据)
         json: (可选) JSON 数据，会自动设置 Content-Type
-        **kwargs: 其他传递给 httpx.post 的参数
+        **kwargs: 其他传递给 requests.post 的参数
 
     返回:
-        Generator[bytes, None, None]: 字节流生成器
+        Generator[str, None, None]: 字符串行生成器
 
     注意:
-        此方法使用 httpx 实现流式请求，适用于处理大文件下载或流式响应
+        此方法使用 requests 实现流式请求，适用于处理大文件下载或流式响应
     """
-    client = get_httpx_client()
-    try:
-        with client.stream("POST", url, data=data, json=json, **kwargs) as response:
+    kwargs.setdefault("timeout", None)
+    with get_requests_session() as session:
+        with session.post(url, data=data, json=json, stream=True, **kwargs) as response:
             response.raise_for_status()
-            for chunk in response.iter_bytes():
-                yield chunk
-    finally:
-        client.close()
+            for line in response.iter_lines(chunk_size=1):
+                if line:
+                    yield line.decode("utf-8", errors="ignore")