Merge branch 'AstrBotDevs:master' into fix/openai-max-retries

Author: SweetenedSuzuka

astrbot/core/config/astrbot_config.py

@@ -98,14 +98,6 @@ def __init__(
         ):
             self._reset_generated_dashboard_password(conf)
             has_new = True
-        elif (
-            "dashboard" in conf
-            and isinstance(conf["dashboard"], dict)
-            and stored_dashboard_password_change_required
-            and conf["dashboard"].get("pbkdf2_password")
-        ):
-            self._reset_generated_dashboard_password(conf)
-            has_new = True
         self.update(conf)
         if has_new:
             self.save_config()

astrbot/core/config/default.py

@@ -2170,6 +2170,13 @@
                                 "type": "int",
                                 "default": 8192,
                             },
+                            "reasoning_effort": {
+                                "name": "Reasoning Effort",
+                                "description": "推理强度",
+                                "hint": "控制推理模型的推理强度，支持的值取决于具体模型。",
+                                "type": "string",
+                                "default": "high",
+                            },
                         },
                     },
                     "provider": {

astrbot/core/platform/sources/misskey/misskey_event.py

@@ -13,7 +13,7 @@
     extract_user_id_from_session_id,
     is_valid_room_session_id,
     is_valid_user_session_id,
-    resolve_visibility_from_raw_message,
+    resolve_message_visibility,
     serialize_message_chain,
 )
 
@@ -108,7 +108,7 @@ async def send(self, message: MessageChain) -> None:
                     room_id = extract_room_id_from_session_id(self.session_id)
                     await self.client.send_room_message(room_id, content)
                 elif original_message_id and hasattr(self.client, "create_note"):
-                    visibility, visible_user_ids = resolve_visibility_from_raw_message(
+                    visibility, visible_user_ids = resolve_message_visibility(
                         raw_message,
                     )
                     await self.client.create_note(

astrbot/dashboard/services/config_service.py

@@ -1358,6 +1358,20 @@ def __init__(self, core_lifecycle: AstrBotCoreLifecycle) -> None:
         self.config = core_lifecycle.astrbot_config
         self.provider_manager = core_lifecycle.provider_manager
 
+    @staticmethod
+    def _strip_legacy_reasoning_metadata(provider: dict) -> dict:
+        """Remove reasoning metadata accidentally stored as provider configuration.
+
+        Args:
+            provider: Provider configuration to sanitize in place.
+
+        Returns:
+            The sanitized provider configuration.
+        """
+        if provider.get("provider_source_id"):
+            provider.pop("reasoning", None)
+        return provider
+
     def get_provider_schema(self) -> dict:
         provider_metadata = ConfigMetadataI18n.convert_to_i18n_keys(
             {
@@ -1382,6 +1396,7 @@ def get_provider_schema(self) -> dict:
 
         model_metadata = {}
         for provider in providers:
+            self._strip_legacy_reasoning_metadata(provider)
             model_id = provider.get("model")
             if isinstance(model_id, str) and model_id in LLM_METADATAS:
                 model_metadata[model_id] = LLM_METADATAS[model_id]
@@ -1659,6 +1674,7 @@ def list_providers(
                 )
             else:
                 provider_response = copy.deepcopy(provider)
+            self._strip_legacy_reasoning_metadata(provider_response)
             model_id = provider_response.get("model")
             if isinstance(model_id, str) and model_id in LLM_METADATAS:
                 model_metadata[model_id] = LLM_METADATAS[model_id]
@@ -1694,6 +1710,7 @@ def get_provider(self, provider_id: str, *, merged: bool = False) -> dict:
         if provider is None:
             raise ValueError(f"Provider {provider_id} not found")
         provider_response = copy.deepcopy(provider)
+        self._strip_legacy_reasoning_metadata(provider_response)
         from astrbot.core.utils.llm_metadata import LLM_METADATAS
 
         model_id = provider_response.get("model")
@@ -1706,11 +1723,14 @@ async def create_provider(self, config: dict, source_id: str | None = None) -> N
         config = copy.deepcopy(config)
         if source_id:
             config["provider_source_id"] = source_id
+        self._strip_legacy_reasoning_metadata(config)
         await self.provider_manager.create_provider(config)
 
     async def update_provider(self, provider_id: str, config: dict) -> None:
+        config = copy.deepcopy(config)
         if not config.get("id"):
             config["id"] = provider_id
+        self._strip_legacy_reasoning_metadata(config)
         await self.provider_manager.update_provider(provider_id, config)
 
     async def set_provider_enabled(self, provider_id: str, enabled: bool) -> None:

astrbot/dashboard/services/knowledge_base_service.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import shutil
 import traceback
 import uuid
 from pathlib import Path
@@ -11,7 +12,7 @@
 from astrbot.core import logger
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
 from astrbot.core.provider.provider import EmbeddingProvider, RerankProvider
-from astrbot.core.utils.astrbot_path import get_astrbot_temp_path
+from astrbot.core.utils.astrbot_path import get_astrbot_system_tmp_path
 from astrbot.dashboard.schemas import KnowledgeBaseRequest
 from astrbot.dashboard.utils import generate_tsne_visualization
 
@@ -116,17 +117,45 @@ def format_failed_doc_error(file_name: str, error: Exception) -> str:
             return message
         return f"{file_name}: {message}"
 
+    @staticmethod
+    def _cleanup_staging_dir(staging_dir: Path) -> None:
+        """Remove a knowledge base upload staging directory.
+
+        Args:
+            staging_dir: Task-specific system temporary directory to remove.
+        """
+        try:
+            shutil.rmtree(staging_dir)
+        except FileNotFoundError:
+            pass
+        except OSError as exc:
+            logger.warning(f"Failed to clean upload staging directory: {exc}")
+
     async def background_upload_task(
         self,
         task_id: str,
         kb_helper,
         files_to_upload: list[dict[str, Any]],
+        staging_dir: Path,
         chunk_size: int,
         chunk_overlap: int,
         batch_size: int,
         tasks_limit: int,
         max_retries: int,
     ) -> None:
+        """Process staged knowledge base files one at a time.
+
+        Args:
+            task_id: Identifier used to report upload progress and results.
+            kb_helper: Knowledge base helper that parses and stores documents.
+            files_to_upload: Metadata and temporary paths for staged files.
+            staging_dir: Task-specific system temporary directory.
+            chunk_size: Maximum size of each generated document chunk.
+            chunk_overlap: Number of overlapping characters between chunks.
+            batch_size: Number of chunks sent in each embedding batch.
+            tasks_limit: Maximum number of concurrent embedding tasks.
+            max_retries: Maximum retries for embedding operations.
+        """
         try:
             self.init_task(task_id, status="processing")
             self.upload_progress[task_id] = {
@@ -142,7 +171,11 @@ async def background_upload_task(
             failed_docs = []
 
             for file_idx, file_info in enumerate(files_to_upload):
+                file_content = None
                 try:
+                    temp_file_path = Path(file_info["temp_file_path"])
+                    async with aiofiles.open(temp_file_path, "rb") as file_obj:
+                        file_content = await file_obj.read()
                     self.update_progress(
                         task_id,
                         status="processing",
@@ -157,7 +190,7 @@ async def background_upload_task(
                     )
                     doc = await kb_helper.upload_document(
                         file_name=file_info["file_name"],
-                        file_content=file_info["file_content"],
+                        file_content=file_content,
                         file_type=file_info["file_type"],
                         chunk_size=chunk_size,
                         chunk_overlap=chunk_overlap,
@@ -177,6 +210,10 @@ async def background_upload_task(
                             ),
                         },
                     )
+                finally:
+                    # Release the current file before reading the next one.
+                    file_content = None
+                    Path(file_info["temp_file_path"]).unlink(missing_ok=True)
 
             self.set_task_result(
                 task_id,
@@ -194,6 +231,8 @@ async def background_upload_task(
             logger.error(f"后台上传任务 {task_id} 失败: {exc}")
             logger.error(traceback.format_exc())
             self.set_task_result(task_id, "failed", error=str(exc))
+        finally:
+            self._cleanup_staging_dir(staging_dir)
 
     async def background_import_task(
         self,
@@ -520,52 +559,62 @@ async def upload_document(
                 file_list.extend(files.getlist(key))
         if not file_list:
             raise KnowledgeBaseServiceError("缺少文件")
-        if len(file_list) > 10:
-            raise KnowledgeBaseServiceError("最多只能上传10个文件")
 
+        task_id = str(uuid.uuid4())
+        system_temp_root = Path(get_astrbot_system_tmp_path())
+        system_temp_root.mkdir(mode=0o700, parents=True, exist_ok=True)
+        staging_dir = system_temp_root / f"kb_upload_{task_id}"
+        staging_dir.mkdir(mode=0o700)
         files_to_upload = []
-        for file in file_list:
-            file_name = Path(str(file.filename or "document").replace("\\", "/")).name
-            if file_name in {"", ".", ".."}:
-                file_name = "document"
-            temp_file_path = (
-                Path(get_astrbot_temp_path()) / f"kb_upload_{uuid.uuid4()}_{file_name}"
-            )
-            await file.save(temp_file_path)
-            try:
-                async with aiofiles.open(temp_file_path, "rb") as file_obj:
-                    file_content = await file_obj.read()
+        try:
+            for file in file_list:
+                file_name = Path(
+                    str(file.filename or "document").replace("\\", "/")
+                ).name
+                if file_name in {"", ".", ".."}:
+                    file_name = "document"
+                temp_file_path = staging_dir / f"{uuid.uuid4()}_{file_name}"
                 file_type = (
                     file_name.rsplit(".", 1)[-1].lower() if "." in file_name else ""
                 )
                 files_to_upload.append(
                     {
                         "file_name": file_name,
-                        "file_content": file_content,
+                        "temp_file_path": temp_file_path,
                         "file_type": file_type,
                     },
                 )
-            finally:
-                temp_file_path.unlink(missing_ok=True)
+                await file.save(temp_file_path)
+        except Exception:
+            self._cleanup_staging_dir(staging_dir)
+            raise
 
-        kb_helper = await self.get_kb_manager().get_kb(kb_id)
-        if not kb_helper:
-            raise KnowledgeBaseServiceError("知识库不存在")
+        try:
+            kb_helper = await self.get_kb_manager().get_kb(kb_id)
+            if not kb_helper:
+                raise KnowledgeBaseServiceError("知识库不存在")
+        except Exception:
+            self._cleanup_staging_dir(staging_dir)
+            raise
 
-        task_id = str(uuid.uuid4())
-        self.init_task(task_id, status="pending")
-        asyncio.create_task(
-            self.background_upload_task(
-                task_id=task_id,
-                kb_helper=kb_helper,
-                files_to_upload=files_to_upload,
-                chunk_size=chunk_size,
-                chunk_overlap=chunk_overlap,
-                batch_size=batch_size,
-                tasks_limit=tasks_limit,
-                max_retries=max_retries,
-            ),
-        )
+        try:
+            self.init_task(task_id, status="pending")
+            asyncio.create_task(
+                self.background_upload_task(
+                    task_id=task_id,
+                    kb_helper=kb_helper,
+                    files_to_upload=files_to_upload,
+                    staging_dir=staging_dir,
+                    chunk_size=chunk_size,
+                    chunk_overlap=chunk_overlap,
+                    batch_size=batch_size,
+                    tasks_limit=tasks_limit,
+                    max_retries=max_retries,
+                ),
+            )
+        except Exception:
+            self._cleanup_staging_dir(staging_dir)
+            raise
         return {
             "task_id": task_id,
             "file_count": len(files_to_upload),

dashboard/src/components/provider/ProviderModelsPanel.vue

@@ -378,7 +378,7 @@ const capabilityBadges = (entry) => {
       key: 'reasoning',
       icon: 'mdi-brain',
       supported: props.supportsReasoning(metadata),
-      enabled: !isConfigured || Boolean(provider?.reasoning),
+      enabled: props.supportsReasoning(metadata),
       label: props.tm('models.metadata.reasoning')
     }
   ]