jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_rag/cli.py

@@ -1,10 +1,10 @@
 import os
 import sys
 from pathlib import Path
-from typing import Optional, List, Literal, cast
+from typing import Optional, List, Tuple
 import mimetypes
 
-import pathspec
+import pathspec  # type: ignore
 import typer
 from langchain.docstore.document import Document
 from langchain_community.document_loaders import (
@@ -14,7 +14,13 @@ from langchain_community.document_loaders import (
 from langchain_core.document_loaders.base import BaseLoader
 from rich.markdown import Markdown
 
-from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.utils import init_env, is_rag_installed, get_missing_rag_modules
+from jarvis.jarvis_utils.config import (
+    get_rag_embedding_model,
+    get_rag_use_bm25,
+    get_rag_use_rerank,
+)
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 def is_likely_text_file(file_path: Path) -> bool:
@@ -48,10 +54,10 @@ _project_root = os.path.abspath(
 if _project_root not in sys.path:
     sys.path.insert(0, _project_root)
 
-from jarvis.jarvis_platform.base import BasePlatform
-from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_rag.llm_interface import LLMInterface
-from jarvis.jarvis_rag.rag_pipeline import JarvisRAGPipeline
+from jarvis.jarvis_platform.base import BasePlatform  # noqa: E402
+from jarvis.jarvis_platform.registry import PlatformRegistry  # noqa: E402
+from jarvis.jarvis_rag.llm_interface import LLMInterface  # noqa: E402
+from jarvis.jarvis_rag.rag_pipeline import JarvisRAGPipeline  # noqa: E402
 
 app = typer.Typer(
     name="jarvis-rag",
@@ -65,8 +71,9 @@ class _CustomPlatformLLM(LLMInterface):
 
     def __init__(self, platform: BasePlatform):
         self.platform = platform
-        print(
-            f"✅ 使用自定义LLM: 平台='{platform.platform_name()}', 模型='{platform.name()}'"
+        PrettyOutput.print(
+            f"使用自定义LLM: 平台='{platform.platform_name()}', 模型='{platform.name()}'",
+            OutputType.INFO,
         )
 
     def generate(self, prompt: str, **kwargs) -> str:
@@ -81,17 +88,19 @@ def _create_custom_llm(platform_name: str, model_name: str) -> Optional[LLMInter
         registry = PlatformRegistry.get_global_platform_registry()
         platform_instance = registry.create_platform(platform_name)
         if not platform_instance:
-            print(f"❌ 错误: 平台 '{platform_name}' 未找到。")
+            PrettyOutput.print(
+                f"错误: 平台 '{platform_name}' 未找到。", OutputType.ERROR
+            )
             return None
         platform_instance.set_model_name(model_name)
         platform_instance.set_suppress_output(True)
         return _CustomPlatformLLM(platform_instance)
     except Exception as e:
-        print(f"❌ 创建自定义LLM时出错: {e}")
+        PrettyOutput.print(f"创建自定义LLM时出错: {e}", OutputType.ERROR)
         return None
 
 
-def _load_ragignore_spec() -> tuple[Optional[pathspec.PathSpec], Optional[Path]]:
+def _load_ragignore_spec() -> Tuple[Optional[pathspec.PathSpec], Optional[Path]]:
     """
     从项目根目录加载忽略模式。
     首先查找 `.jarvis/rag/.ragignore`，如果未找到，则回退到 `.gitignore`。
@@ -111,10 +120,14 @@ def _load_ragignore_spec() -> tuple[Optional[pathspec.PathSpec], Optional[Path]]
             with open(ignore_file_to_use, "r", encoding="utf-8") as f:
                 patterns = f.read().splitlines()
             spec = pathspec.PathSpec.from_lines("gitwildmatch", patterns)
-            print(f"✅ 加载忽略规则: {ignore_file_to_use}")
+            PrettyOutput.print(
+                f"加载忽略规则: {ignore_file_to_use}", OutputType.SUCCESS
+            )
             return spec, project_root_path
         except Exception as e:
-            print(f"⚠️ 加载 {ignore_file_to_use.name} 文件失败: {e}")
+            PrettyOutput.print(
+                f"加载 {ignore_file_to_use.name} 文件失败: {e}", OutputType.WARNING
+            )
 
     return None, None
 
@@ -165,7 +178,7 @@ def add_documents(
                 continue
 
             if path.is_dir():
-                print(f"🔍 正在扫描目录: {path}")
+                PrettyOutput.print(f"正在扫描目录: {path}", OutputType.INFO)
                 for item in path.rglob("*"):
                     if item.is_file() and is_likely_text_file(item):
                         files_to_process.add(item)
@@ -173,10 +186,12 @@ def add_documents(
                 if is_likely_text_file(path):
                     files_to_process.add(path)
                 else:
-                    print(f"⚠️ 跳过可能的二进制文件: {path}")
+                    PrettyOutput.print(
+                        f"跳过可能的二进制文件: {path}", OutputType.WARNING
+                    )
 
     if not files_to_process:
-        print("⚠️ 在指定路径中未找到任何文本文件。")
+        PrettyOutput.print("在指定路径中未找到任何文本文件。", OutputType.WARNING)
         return
 
     # 使用 .ragignore 过滤文件
@@ -197,14 +212,20 @@ def add_documents(
 
         ignored_count = initial_count - len(retained_files)
         if ignored_count > 0:
-            print(f"ℹ️ 根据 .ragignore 规则过滤掉 {ignored_count} 个文件。")
+            PrettyOutput.print(
+                f"根据 .ragignore 规则过滤掉 {ignored_count} 个文件。", OutputType.INFO
+            )
         files_to_process = retained_files
 
     if not files_to_process:
-        print("⚠️ 所有找到的文本文件都被忽略规则过滤掉了。")
+        PrettyOutput.print(
+            "所有找到的文本文件都被忽略规则过滤掉了。", OutputType.WARNING
+        )
         return
 
-    print(f"✅ 发现 {len(files_to_process)} 个独立文件待处理。")
+    PrettyOutput.print(
+        f"发现 {len(files_to_process)} 个独立文件待处理。", OutputType.INFO
+    )
 
     try:
         pipeline = JarvisRAGPipeline(
@@ -219,6 +240,7 @@ def add_documents(
 
         sorted_files = sorted(list(files_to_process))
         total_files = len(sorted_files)
+        loaded_msgs: List[str] = []
 
         for i, file_path in enumerate(sorted_files):
             try:
@@ -228,28 +250,40 @@ def add_documents(
                     loader = TextLoader(str(file_path), encoding="utf-8")
 
                 docs_batch.extend(loader.load())
-                print(f"✅ 已加载: {file_path} (文件 {i + 1}/{total_files})")
+                loaded_msgs.append(f"已加载: {file_path} (文件 {i + 1}/{total_files})")
             except Exception as e:
-                print(f"⚠️ 加载失败 {file_path}: {e}")
+                PrettyOutput.print(f"加载失败 {file_path}: {e}", OutputType.WARNING)
 
             # 当批处理已满或是最后一个文件时处理批处理
             if docs_batch and (len(docs_batch) >= batch_size or (i + 1) == total_files):
-                print(f"⚙️ 正在处理批次，包含 {len(docs_batch)} 个文档...")
+                if loaded_msgs:
+                    PrettyOutput.print("\n".join(loaded_msgs), OutputType.INFO)
+                    loaded_msgs = []
+                PrettyOutput.print(
+                    f"正在处理批次，包含 {len(docs_batch)} 个文档...", OutputType.INFO
+                )
                 pipeline.add_documents(docs_batch)
                 total_docs_added += len(docs_batch)
-                print(f"✅ 成功添加 {len(docs_batch)} 个文档。")
+                PrettyOutput.print(
+                    f"成功添加 {len(docs_batch)} 个文档。", OutputType.SUCCESS
+                )
                 docs_batch = []  # 清空批处理
 
+        # 最后统一打印可能残留的“已加载”信息
+        if loaded_msgs:
+            PrettyOutput.print("\n".join(loaded_msgs), OutputType.INFO)
+            loaded_msgs = []
         if total_docs_added == 0:
-            print("❌ 未能成功加载任何文档。")
+            PrettyOutput.print("未能成功加载任何文档。", OutputType.ERROR)
             raise typer.Exit(code=1)
 
-        print(
-            f"✅ 成功将 {total_docs_added} 个文档的内容添加至集合 '{collection_name}'。"
+        PrettyOutput.print(
+            f"成功将 {total_docs_added} 个文档的内容添加至集合 '{collection_name}'。",
+            OutputType.SUCCESS,
         )
 
     except Exception as e:
-        print(f"❌ 发生严重错误: {e}")
+        PrettyOutput.print(f"发生严重错误: {e}", OutputType.ERROR)
         raise typer.Exit(code=1)
 
 
@@ -272,11 +306,11 @@ def list_documents(
             collection_name=collection_name,
         )
 
-        collection = pipeline.retriever.collection
+        collection = pipeline._get_collection()
         results = collection.get()  # 获取集合中的所有项目
 
         if not results or not results["metadatas"]:
-            print("ℹ️ 知识库中没有找到任何文档。")
+            PrettyOutput.print("知识库中没有找到任何文档。", OutputType.INFO)
             return
 
         # 从元数据中提取唯一的源文件路径
@@ -288,15 +322,85 @@ def list_documents(
                     sources.add(source)
 
         if not sources:
-            print("ℹ️ 知识库中没有找到任何带有源信息的文档。")
+            PrettyOutput.print(
+                "知识库中没有找到任何带有源信息的文档。", OutputType.INFO
+            )
             return
 
-        print(f"📚 知识库 '{collection_name}' 中共有 {len(sources)} 个独立文档:")
+        # 避免在循环中逐条打印，先拼接后统一打印
+        lines = [f"知识库 '{collection_name}' 中共有 {len(sources)} 个独立文档:"]
         for i, source in enumerate(sorted(list(sources)), 1):
-            print(f"  {i}. {source}")
+            lines.append(f"  {i}. {source}")
+        PrettyOutput.print("\n".join(lines), OutputType.INFO)
+
+    except Exception as e:
+        PrettyOutput.print(f"发生错误: {e}", OutputType.ERROR)
+        raise typer.Exit(code=1)
+
+
+@app.command("retrieve", help="仅从知识库检索相关文档，不生成答案。")
+def retrieve(
+    question: str = typer.Argument(..., help="要提出的问题。"),
+    collection_name: str = typer.Option(
+        "jarvis_rag_collection",
+        "--collection",
+        "-c",
+        help="向量数据库中集合的名称。",
+    ),
+    embedding_model: Optional[str] = typer.Option(
+        None,
+        "--embedding-model",
+        "-e",
+        help="嵌入模型的名称。覆盖全局配置。",
+    ),
+    db_path: Optional[Path] = typer.Option(
+        None, "--db-path", help="向量数据库的路径。覆盖全局配置。"
+    ),
+    n_results: int = typer.Option(5, "--top-n", help="要检索的文档数量。"),
+    rewrite: bool = typer.Option(
+        True,
+        "--rewrite/--no-rewrite",
+        help="是否对查询进行LLM重写以提升召回，默认开启。",
+        show_default=True,
+    ),
+):
+    """仅从RAG知识库检索文档并打印结果。"""
+    try:
+        # 如果未在命令行中指定，则从配置中加载RAG设置
+        final_embedding_model = embedding_model or get_rag_embedding_model()
+        use_bm25 = get_rag_use_bm25()
+        use_rerank = get_rag_use_rerank()
+
+        pipeline = JarvisRAGPipeline(
+            embedding_model=final_embedding_model,
+            db_path=str(db_path) if db_path else None,
+            collection_name=collection_name,
+            use_bm25=use_bm25,
+            use_rerank=use_rerank,
+            use_query_rewrite=rewrite,
+        )
+
+        PrettyOutput.print(f"正在为问题检索文档: '{question}'", OutputType.INFO)
+        retrieved_docs = pipeline.retrieve_only(question, n_results=n_results)
+
+        if not retrieved_docs:
+            PrettyOutput.print("未找到相关文档。", OutputType.INFO)
+            return
+
+        PrettyOutput.print(
+            f"成功检索到 {len(retrieved_docs)} 个文档:", OutputType.SUCCESS
+        )
+        from jarvis.jarvis_utils.globals import console
+
+        for i, doc in enumerate(retrieved_docs, 1):
+            source = doc.metadata.get("source", "未知来源")
+            content = doc.page_content
+            panel_title = f"文档 {i} | 来源: {source}"
+            console.print(f"\n[bold magenta]{panel_title}[/bold magenta]")
+            console.print(Markdown(f"```\n{content}\n```"))
 
     except Exception as e:
-        print(f"❌ 发生错误: {e}")
+        PrettyOutput.print(f"发生错误: {e}", OutputType.ERROR)
         raise typer.Exit(code=1)
 
 
@@ -333,7 +437,7 @@ def query(
 ):
     """查询RAG知识库并打印答案。"""
     if model and not platform:
-        print("❌ 错误: --model 需要指定 --platform。")
+        PrettyOutput.print("错误: --model 需要指定 --platform。", OutputType.ERROR)
         raise typer.Exit(code=1)
 
     try:
@@ -341,41 +445,40 @@ def query(
         if (platform or model) and not custom_llm:
             raise typer.Exit(code=1)
 
+        # 如果未在命令行中指定，则从配置中加载RAG设置
+        final_embedding_model = embedding_model or get_rag_embedding_model()
+        use_bm25 = get_rag_use_bm25()
+        use_rerank = get_rag_use_rerank()
+
         pipeline = JarvisRAGPipeline(
             llm=custom_llm,
-            embedding_model=embedding_model,
+            embedding_model=final_embedding_model,
             db_path=str(db_path) if db_path else None,
             collection_name=collection_name,
+            use_bm25=use_bm25,
+            use_rerank=use_rerank,
         )
 
-        print(f"🤔 正在查询: '{question}'")
+        PrettyOutput.print(f"正在查询: '{question}'", OutputType.INFO)
         answer = pipeline.query(question)
 
-        print("💬 答案:")
-        # 我们仍然可以使用 rich.markdown.Markdown，因为 PrettyOutput 底层使用了 rich
-        from jarvis.jarvis_utils.globals import console
-
-        console.print(Markdown(answer))
+        PrettyOutput.print(answer, OutputType.SUCCESS)
 
     except Exception as e:
-        print(f"❌ 发生错误: {e}")
+        PrettyOutput.print(f"发生错误: {e}", OutputType.ERROR)
         raise typer.Exit(code=1)
 
 
-_RAG_INSTALLED = False
-try:
-    import langchain  # noqa
 
-    _RAG_INSTALLED = True
-except ImportError:
-    pass
 
 
 def _check_rag_dependencies():
-    if not _RAG_INSTALLED:
-        print(
-            "❌ RAG依赖项未安装。"
-            "请运行 'pip install \"jarvis-ai-assistant[rag]\"' 来使用此命令。"
+    if not is_rag_installed():
+        missing = get_missing_rag_modules()
+        missing_str = f"缺少依赖: {', '.join(missing)}。" if missing else ""
+        PrettyOutput.print(
+            f"RAG依赖项未安装或不完整。{missing_str}请运行 'pip install \"jarvis-ai-assistant[rag]\"' 后重试。",
+            OutputType.ERROR,
         )
         raise typer.Exit(code=1)
 

jarvis/jarvis_rag/embedding_manager.py

@@ -1,8 +1,12 @@
 import torch
+import os
 from typing import List, cast
 from langchain_huggingface import HuggingFaceEmbeddings
+from huggingface_hub import snapshot_download
+
 
 from .cache import EmbeddingCache
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class EmbeddingManager:
@@ -23,7 +27,9 @@ class EmbeddingManager:
         """
         self.model_name = model_name
 
-        print(f"🚀 初始化嵌入管理器, 模型: '{self.model_name}'...")
+        PrettyOutput.print(
+            f"初始化嵌入管理器, 模型: '{self.model_name}'...", OutputType.INFO
+        )
 
         # 缓存的salt是模型名称，以防止冲突
         self.cache = EmbeddingCache(cache_dir=cache_dir, salt=self.model_name)
@@ -35,15 +41,148 @@ class EmbeddingManager:
         encode_kwargs = {"normalize_embeddings": True}
 
         try:
-            return HuggingFaceEmbeddings(
-                model_name=self.model_name,
-                model_kwargs=model_kwargs,
-                encode_kwargs=encode_kwargs,
-                show_progress=True,
-            )
+            # First try to load model from local cache without any network access
+            try:
+                local_dir = None
+                # Prefer explicit local dir via env or direct path
+
+                if os.path.isdir(self.model_name):
+                    return HuggingFaceEmbeddings(
+                        model_name=self.model_name,
+                        model_kwargs=model_kwargs,
+                        encode_kwargs=encode_kwargs,
+                        show_progress=False,
+                    )
+
+                # Try common local cache directories for sentence-transformers and HF hub
+                try:
+                    home = os.path.expanduser("~")
+                    st_home = os.path.join(home, ".cache", "sentence_transformers")
+                    torch_st_home = os.path.join(home, ".cache", "torch", "sentence_transformers")
+                    # Build common name variants found in local caches
+                    org, name = (
+                        self.model_name.split("/", 1)
+                        if "/" in self.model_name
+                        else ("", self.model_name)
+                    )
+                    san1 = self.model_name.replace("/", "_")
+                    san2 = self.model_name.replace("/", "__")
+                    san3 = self.model_name.replace("/", "--")
+                    # include plain 'name' for caches that drop org prefix
+                    name_variants = list(dict.fromkeys([self.model_name, san1, san2, san3, name]))
+                    candidates = []
+                    for base in [st_home, torch_st_home]:
+                        for nv in name_variants:
+                            p = os.path.join(base, nv)
+                            if os.path.isdir(p):
+                                candidates.append(p)
+                        # Fuzzy scan cache directory for entries that include variants
+                        try:
+                            for entry in os.listdir(base):
+                                ep = os.path.join(base, entry)
+                                if not os.path.isdir(ep):
+                                    continue
+                                if (
+                                    (org and entry.startswith(f"{org}__") and name in entry)
+                                    or (san1 in entry)
+                                    or (name in entry)
+                                ):
+                                    candidates.append(ep)
+                        except Exception:
+                            pass
+
+                    # Hugging Face Hub cache snapshots
+                    hf_cache = os.path.join(home, ".cache", "huggingface", "hub")
+                    if "/" in self.model_name:
+                        org, name = self.model_name.split("/", 1)
+                        models_dir = os.path.join(hf_cache, f"models--{org}--{name}", "snapshots")
+                        if os.path.isdir(models_dir):
+                            try:
+                                snaps = sorted(
+                                    [os.path.join(models_dir, d) for d in os.listdir(models_dir)],
+                                    key=lambda p: os.path.getmtime(p),
+                                    reverse=True,
+                                )
+                            except Exception:
+                                snaps = [os.path.join(models_dir, d) for d in os.listdir(models_dir)]
+                            for sp in snaps:
+                                if os.path.isdir(sp):
+                                    candidates.append(sp)
+                                    break
+
+                    for cand in candidates:
+                        try:
+                            return HuggingFaceEmbeddings(
+                                model_name=cand,
+                                model_kwargs=model_kwargs,
+                                encode_kwargs=encode_kwargs,
+                                show_progress=False,
+                            )
+                        except Exception:
+                            continue
+                except Exception:
+                    pass
+
+                try:
+                    # Try resolve local cached directory; do not hit network
+                    local_dir = snapshot_download(repo_id=self.model_name, local_files_only=True)
+                except Exception:
+                    local_dir = None
+
+                if local_dir:
+                    return HuggingFaceEmbeddings(
+                        model_name=local_dir,
+                        model_kwargs=model_kwargs,
+                        encode_kwargs=encode_kwargs,
+                        show_progress=False,
+                    )
+
+
+
+                # Fall back to remote download if local cache not found and not offline
+                return HuggingFaceEmbeddings(
+                    model_name=self.model_name,
+                    model_kwargs=model_kwargs,
+                    encode_kwargs=encode_kwargs,
+                    show_progress=True,
+                )
+            except Exception as _e:
+                # 如果已检测到本地候选路径（直接目录 / 本地缓存快照），则视为本地加载失败，
+                # 为避免在用户期望“本地优先不联网”的情况下触发联网，直接抛错并给出修复建议。
+                had_local_candidate = False
+                try:
+                    had_local_candidate = (
+                        os.path.isdir(self.model_name)
+                        # 如果上面 snapshot_download 命中了本地缓存，会将 local_dir 设为非 None
+                        or (locals().get("local_dir") is not None)
+                    )
+                except Exception:
+                    pass
+
+                if had_local_candidate:
+                    PrettyOutput.print(
+                        "检测到本地模型路径但加载失败。为避免触发网络访问，已中止远程回退。\n"
+                        "请确认本地目录包含完整的 Transformers/Tokenizer 文件（如 config.json、model.safetensors、tokenizer.json/merges.txt 等），\n"
+                        "或在配置中将 embedding_model 设置为该本地目录，或将模型放置到默认的 Hugging Face 缓存目录（例如 ~/.cache/huggingface/hub）。",
+                        OutputType.ERROR,
+                    )
+                    raise
+
+                # 未发现任何本地候选，则保持原有行为：回退至远程下载
+                return HuggingFaceEmbeddings(
+                    model_name=self.model_name,
+                    model_kwargs=model_kwargs,
+                    encode_kwargs=encode_kwargs,
+                    show_progress=True,
+                )
         except Exception as e:
-            print(f"❌ 加载嵌入模型 '{self.model_name}' 时出错: {e}")
-            print("请确保您已安装 'sentence_transformers' 和 'torch'。")
+            PrettyOutput.print(
+                f"加载嵌入模型 '{self.model_name}' 时出错: {e}", OutputType.ERROR
+            )
+            PrettyOutput.print(
+                "请确保您已安装 'sentence_transformers' 和 'torch'。",
+                OutputType.WARNING,
+            )
             raise
 
     def embed_documents(self, texts: List[str]) -> List[List[float]]:
@@ -71,8 +210,9 @@ class EmbeddingManager:
 
         # 为不在缓存中的文本计算嵌入
         if texts_to_embed:
-            print(
-                f"🔎 缓存未命中。正在为 {len(texts_to_embed)}/{len(texts)} 个文档计算嵌入。"
+            PrettyOutput.print(
+                f"缓存未命中。正在为 {len(texts_to_embed)}/{len(texts)} 个文档计算嵌入。",
+                OutputType.INFO,
             )
             new_embeddings = self.model.embed_documents(texts_to_embed)
 
@@ -83,7 +223,10 @@ class EmbeddingManager:
             for i, embedding in zip(indices_to_embed, new_embeddings):
                 cached_embeddings[i] = embedding
         else:
-            print(f"✅ 缓存命中。所有 {len(texts)} 个文档的嵌入均从缓存中检索。")
+            PrettyOutput.print(
+                f"缓存命中。所有 {len(texts)} 个文档的嵌入均从缓存中检索。",
+                OutputType.SUCCESS,
+            )
 
         return cast(List[List[float]], cached_embeddings)
 

jarvis/jarvis_rag/llm_interface.py

@@ -1,11 +1,9 @@
 from abc import ABC, abstractmethod
-import os
-import os
-from abc import ABC, abstractmethod
 
 from jarvis.jarvis_agent import Agent as JarvisAgent
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class LLMInterface(ABC):
@@ -41,18 +39,16 @@ class ToolAgent_LLM(LLMInterface):
         """
         初始化工具-代理 LLM 包装器。
         """
-        print("🤖 已初始化工具 Agent 作为最终应答者。")
+        PrettyOutput.print("已初始化工具 Agent 作为最终应答者。", OutputType.INFO)
         self.allowed_tools = ["read_code", "execute_script"]
         # 为代理提供一个通用的系统提示
         self.system_prompt = "You are a helpful assistant. Please answer the user's question based on the provided context. You can use tools to find more information if needed."
         self.summary_prompt = """
-<report>
 请为本次问答任务生成一个总结报告，包含以下内容：
 
 1. **原始问题**: 重述用户最开始提出的问题。
 2. **关键信息来源**: 总结你是基于哪些关键信息或文件得出的结论。
 3. **最终答案**: 给出最终的、精炼的回答。
-</report>
 """
 
     def generate(self, prompt: str, **kwargs) -> str:
@@ -83,7 +79,7 @@ class ToolAgent_LLM(LLMInterface):
             return str(final_answer)
 
         except Exception as e:
-            print(f"❌ Agent 在执行过程中发生错误: {e}")
+            PrettyOutput.print(f"Agent 在执行过程中发生错误: {e}", OutputType.ERROR)
             return "错误: Agent 未能成功生成回答。"
 
 
@@ -101,12 +97,13 @@ class JarvisPlatform_LLM(LLMInterface):
         try:
             self.registry = PlatformRegistry.get_global_platform_registry()
             self.platform: BasePlatform = self.registry.get_normal_platform()
-            self.platform.set_suppress_output(
-                False
-            )  # 确保模型没有控制台输出
-            print(f"🚀 已初始化 Jarvis 平台 LLM，模型: {self.platform.name()}")
+            self.platform.set_suppress_output(False)  # 确保模型没有控制台输出
+            PrettyOutput.print(
+                f"已初始化 Jarvis 平台 LLM，模型: {self.platform.name()}",
+                OutputType.INFO,
+            )
         except Exception as e:
-            print(f"❌ 初始化 Jarvis 平台 LLM 失败: {e}")
+            PrettyOutput.print(f"初始化 Jarvis 平台 LLM 失败: {e}", OutputType.ERROR)
             raise
 
     def generate(self, prompt: str, **kwargs) -> str:
@@ -124,5 +121,5 @@ class JarvisPlatform_LLM(LLMInterface):
             # 使用健壮的chat_until_success方法
             return self.platform.chat_until_success(prompt)
         except Exception as e:
-            print(f"❌ 调用 Jarvis 平台模型时发生错误: {e}")
+            PrettyOutput.print(f"调用 Jarvis 平台模型时发生错误: {e}", OutputType.ERROR)
             return "错误: 无法从本地LLM获取响应。"