AstrBot 4.5.1__py3-none-any.whl → 4.5.2__py3-none-any.whl

astrbot/core/pipeline/process_stage/method/llm_request.py

@@ -1,15 +1,24 @@
-"""
-本地 Agent 模式的 LLM 调用 Stage
-"""
+"""本地 Agent 模式的 LLM 调用 Stage"""
 
 import asyncio
 import copy
 import json
 import traceback
-from datetime import timedelta
 from collections.abc import AsyncGenerator
-from astrbot.core.conversation_mgr import Conversation
+from typing import Any
+
+from mcp.types import CallToolResult
+
 from astrbot.core import logger
+from astrbot.core.agent.handoff import HandoffTool
+from astrbot.core.agent.hooks import BaseAgentRunHooks
+from astrbot.core.agent.mcp_client import MCPTool
+from astrbot.core.agent.run_context import ContextWrapper
+from astrbot.core.agent.runners.tool_loop_agent_runner import ToolLoopAgentRunner
+from astrbot.core.agent.tool import FunctionTool, ToolSet
+from astrbot.core.agent.tool_executor import BaseFunctionToolExecutor
+from astrbot.core.astr_agent_context import AstrAgentContext
+from astrbot.core.conversation_mgr import Conversation
 from astrbot.core.message.components import Image
 from astrbot.core.message.message_event_result import (
     MessageChain,
@@ -22,21 +31,14 @@ from astrbot.core.provider.entities import (
     LLMResponse,
     ProviderRequest,
 )
-from astrbot.core.agent.hooks import BaseAgentRunHooks
-from astrbot.core.agent.runners.tool_loop_agent_runner import ToolLoopAgentRunner
-from astrbot.core.agent.run_context import ContextWrapper
-from astrbot.core.agent.tool import ToolSet, FunctionTool
-from astrbot.core.agent.tool_executor import BaseFunctionToolExecutor
-from astrbot.core.agent.handoff import HandoffTool
+from astrbot.core.provider.register import llm_tools
 from astrbot.core.star.session_llm_manager import SessionServiceManager
-from astrbot.core.star.star_handler import EventType
+from astrbot.core.star.star_handler import EventType, star_map
 from astrbot.core.utils.metrics import Metric
-from ...context import PipelineContext, call_event_hook, call_handler
+
+from ...context import PipelineContext, call_event_hook, call_local_llm_tool
 from ..stage import Stage
 from ..utils import inject_kb_context
-from astrbot.core.provider.register import llm_tools
-from astrbot.core.star.star_handler import star_map
-from astrbot.core.astr_agent_context import AstrAgentContext
 
 try:
     import mcp
@@ -59,24 +61,23 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
 
         Returns:
             AsyncGenerator[None | mcp.types.CallToolResult, None]
+
         """
         if isinstance(tool, HandoffTool):
             async for r in cls._execute_handoff(tool, run_context, **tool_args):
                 yield r
             return
 
-        if tool.origin == "local":
-            async for r in cls._execute_local(tool, run_context, **tool_args):
+        elif isinstance(tool, MCPTool):
+            async for r in cls._execute_mcp(tool, run_context, **tool_args):
                 yield r
             return
 
-        elif tool.origin == "mcp":
-            async for r in cls._execute_mcp(tool, run_context, **tool_args):
+        else:
+            async for r in cls._execute_local(tool, run_context, **tool_args):
                 yield r
             return
 
-        raise Exception(f"Unknown function origin: {tool.origin}")
-
     @classmethod
     async def _execute_handoff(
         cls,
@@ -113,18 +114,22 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
             first_provider_request=run_context.context.first_provider_request,
             curr_provider_request=request,
             streaming=run_context.context.streaming,
+            event=run_context.context.event,
         )
 
+        event = run_context.context.event
+
         logger.debug(f"正在将任务委托给 Agent: {tool.agent.name}, input: {input_}")
-        await run_context.event.send(
-            MessageChain().message("✨ 正在将任务委托给 Agent: " + tool.agent.name)
+        await event.send(
+            MessageChain().message("✨ 正在将任务委托给 Agent: " + tool.agent.name),
         )
 
         await agent_runner.reset(
             provider=run_context.context.provider,
             request=request,
             run_context=AgentContextWrapper(
-                context=astr_agent_ctx, event=run_context.event
+                context=astr_agent_ctx,
+                tool_call_timeout=run_context.tool_call_timeout,
             ),
             tool_executor=FunctionToolExecutor(),
             agent_hooks=tool.agent.run_hooks or BaseAgentRunHooks[AstrAgentContext](),
@@ -146,7 +151,7 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
                 return
 
             logger.debug(
-                f"Agent  {tool.agent.name} 任务完成, response: {llm_response.completion_text}"
+                f"Agent  {tool.agent.name} 任务完成, response: {llm_response.completion_text}",
             )
 
             result = (
@@ -174,25 +179,46 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
         run_context: ContextWrapper[AstrAgentContext],
         **tool_args,
     ):
-        if not run_context.event:
+        event = run_context.context.event
+        if not event:
             raise ValueError("Event must be provided for local function tools.")
 
-        # 检查 tool 下有没有 run 方法
-        if not tool.handler and not hasattr(tool, "run"):
-            raise ValueError("Tool must have a valid handler or 'run' method.")
-        awaitable = tool.handler or getattr(tool, "run")
+        is_override_call = False
+        for ty in type(tool).mro():
+            if "call" in ty.__dict__ and ty.__dict__["call"] is not FunctionTool.call:
+                logger.debug(f"Found call in: {ty}")
+                is_override_call = True
+                break
 
-        wrapper = call_handler(
-            event=run_context.event,
+        # 检查 tool 下有没有 run 方法
+        if not tool.handler and not hasattr(tool, "run") and not is_override_call:
+            raise ValueError("Tool must have a valid handler or override 'run' method.")
+
+        awaitable = None
+        method_name = ""
+        if tool.handler:
+            awaitable = tool.handler
+            method_name = "decorator_handler"
+        elif is_override_call:
+            awaitable = tool.call
+            method_name = "call"
+        elif hasattr(tool, "run"):
+            awaitable = getattr(tool, "run")
+            method_name = "run"
+        if awaitable is None:
+            raise ValueError("Tool must have a valid handler or override 'run' method.")
+
+        wrapper = call_local_llm_tool(
+            context=run_context,
             handler=awaitable,
+            method_name=method_name,
             **tool_args,
         )
-        # async for resp in wrapper:
         while True:
             try:
                 resp = await asyncio.wait_for(
                     anext(wrapper),
-                    timeout=run_context.context.tool_call_timeout,
+                    timeout=run_context.tool_call_timeout,
                 )
                 if resp is not None:
                     if isinstance(resp, mcp.types.CallToolResult):
@@ -207,10 +233,24 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
                     # NOTE: Tool 在这里直接请求发送消息给用户
                     # TODO: 是否需要判断 event.get_result() 是否为空?
                     # 如果为空,则说明没有发送消息给用户,并且返回值为空,将返回一个特殊的 TextContent,其内容如"工具没有返回内容"
+                    if res := run_context.context.event.get_result():
+                        if res.chain:
+                            try:
+                                await event.send(
+                                    MessageChain(
+                                        chain=res.chain,
+                                        type="tool_direct_result",
+                                    )
+                                )
+                            except Exception as e:
+                                logger.error(
+                                    f"Tool 直接发送消息失败: {e}",
+                                    exc_info=True,
+                                )
                     yield None
             except asyncio.TimeoutError:
                 raise Exception(
-                    f"tool {tool.name} execution timeout after {run_context.context.tool_call_timeout} seconds."
+                    f"tool {tool.name} execution timeout after {run_context.tool_call_timeout} seconds.",
                 )
             except StopAsyncIteration:
                 break
@@ -222,19 +262,7 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
         run_context: ContextWrapper[AstrAgentContext],
         **tool_args,
     ):
-        if not tool.mcp_client:
-            raise ValueError("MCP client is not available for MCP function tools.")
-
-        session = tool.mcp_client.session
-        if not session:
-            raise ValueError("MCP session is not available for MCP function tools.")
-        res = await session.call_tool(
-            name=tool.name,
-            arguments=tool_args,
-            read_timeout_seconds=timedelta(
-                seconds=run_context.context.tool_call_timeout
-            ),
-        )
+        res = await tool.call(run_context, **tool_args)
         if not res:
             return
         yield res
@@ -244,18 +272,31 @@ class MainAgentHooks(BaseAgentRunHooks[AstrAgentContext]):
     async def on_agent_done(self, run_context, llm_response):
         # 执行事件钩子
         await call_event_hook(
-            run_context.event, EventType.OnLLMResponseEvent, llm_response
+            run_context.context.event,
+            EventType.OnLLMResponseEvent,
+            llm_response,
         )
 
+    async def on_tool_end(
+        self,
+        run_context: ContextWrapper[AstrAgentContext],
+        tool: FunctionTool[Any],
+        tool_args: dict | None,
+        tool_result: CallToolResult | None,
+    ):
+        run_context.context.event.clear_result()
+
 
 MAIN_AGENT_HOOKS = MainAgentHooks()
 
 
 async def run_agent(
-    agent_runner: AgentRunner, max_step: int = 30, show_tool_use: bool = True
+    agent_runner: AgentRunner,
+    max_step: int = 30,
+    show_tool_use: bool = True,
 ) -> AsyncGenerator[MessageChain, None]:
     step_idx = 0
-    astr_event = agent_runner.run_context.event
+    astr_event = agent_runner.run_context.context.event
     while step_idx < max_step:
         step_idx += 1
         try:
@@ -290,19 +331,18 @@ async def run_agent(
                         MessageEventResult(
                             chain=resp.data["chain"].chain,
                             result_content_type=content_typ,
-                        )
+                        ),
                     )
                     yield
                     astr_event.clear_result()
-                else:
-                    if resp.type == "streaming_delta":
-                        yield resp.data["chain"]  # MessageChain
+                elif resp.type == "streaming_delta":
+                    yield resp.data["chain"]  # MessageChain
             if agent_runner.done():
                 break
 
         except Exception as e:
             logger.error(traceback.format_exc())
-            err_msg = f"\n\nAstrBot 请求失败。\n错误类型: {type(e).__name__}\n错误信息: {str(e)}\n\n请在控制台查看和分享错误详情。\n"
+            err_msg = f"\n\nAstrBot 请求失败。\n错误类型: {type(e).__name__}\n错误信息: {e!s}\n\n请在控制台查看和分享错误详情。\n"
             if agent_runner.streaming:
                 yield MessageChain().message(err_msg)
             else:
@@ -332,7 +372,7 @@ class LLMRequestSubStage(Stage):
         for bwp in self.bot_wake_prefixs:
             if self.provider_wake_prefix.startswith(bwp):
                 logger.info(
-                    f"识别 LLM 聊天额外唤醒前缀 {self.provider_wake_prefix} 以机器人唤醒前缀 {bwp} 开头，已自动去除。"
+                    f"识别 LLM 聊天额外唤醒前缀 {self.provider_wake_prefix} 以机器人唤醒前缀 {bwp} 开头，已自动去除。",
                 )
                 self.provider_wake_prefix = self.provider_wake_prefix[len(bwp) :]
 
@@ -367,7 +407,9 @@ class LLMRequestSubStage(Stage):
         return conversation
 
     async def process(
-        self, event: AstrMessageEvent, _nested: bool = False
+        self,
+        event: AstrMessageEvent,
+        _nested: bool = False,
     ) -> None | AsyncGenerator[None, None]:
         req: ProviderRequest | None = None
 
@@ -423,7 +465,9 @@ class LLMRequestSubStage(Stage):
         # 应用知识库
         try:
             await inject_kb_context(
-                umo=event.unified_msg_origin, p_ctx=self.ctx, req=req
+                umo=event.unified_msg_origin,
+                p_ctx=self.ctx,
+                req=req,
             )
         except Exception as e:
             logger.error(f"调用知识库时遇到问题: {e}")
@@ -475,7 +519,7 @@ class LLMRequestSubStage(Stage):
             # 如果模型不支持工具使用，但请求中包含工具列表，则清空。
             if "tool_use" not in provider_cfg:
                 logger.debug(
-                    f"用户设置提供商 {provider} 不支持工具使用，清空工具列表。"
+                    f"用户设置提供商 {provider} 不支持工具使用，清空工具列表。",
                 )
                 req.func_tool = None
         # 插件可用性设置
@@ -498,19 +542,22 @@ class LLMRequestSubStage(Stage):
         # run agent
         agent_runner = AgentRunner()
         logger.debug(
-            f"handle provider[id: {provider.provider_config['id']}] request: {req}"
+            f"handle provider[id: {provider.provider_config['id']}] request: {req}",
         )
         astr_agent_ctx = AstrAgentContext(
             provider=provider,
             first_provider_request=req,
             curr_provider_request=req,
             streaming=self.streaming_response,
-            tool_call_timeout=self.tool_call_timeout,
+            event=event,
         )
         await agent_runner.reset(
             provider=provider,
             request=req,
-            run_context=AgentContextWrapper(context=astr_agent_ctx, event=event),
+            run_context=AgentContextWrapper(
+                context=astr_agent_ctx,
+                tool_call_timeout=self.tool_call_timeout,
+            ),
             tool_executor=FunctionToolExecutor(),
             agent_hooks=MAIN_AGENT_HOOKS,
             streaming=self.streaming_response,
@@ -522,8 +569,8 @@ class LLMRequestSubStage(Stage):
                 MessageEventResult()
                 .set_result_content_type(ResultContentType.STREAMING_RESULT)
                 .set_async_stream(
-                    run_agent(agent_runner, self.max_step, self.show_tool_use)
-                )
+                    run_agent(agent_runner, self.max_step, self.show_tool_use),
+                ),
             )
             yield
             if agent_runner.done():
@@ -540,7 +587,7 @@ class LLMRequestSubStage(Stage):
                         MessageEventResult(
                             chain=chain,
                             result_content_type=ResultContentType.STREAMING_FINISH,
-                        )
+                        ),
                     )
         else:
             async for _ in run_agent(agent_runner, self.max_step, self.show_tool_use):
@@ -560,17 +607,21 @@ class LLMRequestSubStage(Stage):
                 llm_tick=1,
                 model_name=agent_runner.provider.get_model(),
                 provider_type=agent_runner.provider.meta().type,
-            )
+            ),
         )
 
     async def _handle_webchat(
-        self, event: AstrMessageEvent, req: ProviderRequest, prov: Provider
+        self,
+        event: AstrMessageEvent,
+        req: ProviderRequest,
+        prov: Provider,
     ):
         """处理 WebChat 平台的特殊情况，包括第一次 LLM 对话时总结对话内容生成 title"""
         if not req.conversation:
             return
         conversation = await self.conv_manager.get_conversation(
-            event.unified_msg_origin, req.conversation.cid
+            event.unified_msg_origin,
+            req.conversation.cid,
         )
         if conversation and not req.conversation.title:
             messages = json.loads(conversation.history)
@@ -607,7 +658,7 @@ class LLMRequestSubStage(Stage):
             )
             if llm_resp and llm_resp.completion_text:
                 logger.debug(
-                    f"WebChat 对话标题生成响应: {llm_resp.completion_text.strip()}"
+                    f"WebChat 对话标题生成响应: {llm_resp.completion_text.strip()}",
                 )
                 title = llm_resp.completion_text.strip()
                 if not title or "<None>" in title:
@@ -650,7 +701,9 @@ class LLMRequestSubStage(Stage):
         messages.append({"role": "assistant", "content": llm_response.completion_text})
         messages = list(filter(lambda item: "_no_save" not in item, messages))
         await self.conv_manager.update_conversation(
-            event.unified_msg_origin, req.conversation.cid, history=messages
+            event.unified_msg_origin,
+            req.conversation.cid,
+            history=messages,
         )
 
     def fix_messages(self, messages: list[dict]) -> list[dict]:

astrbot/core/pipeline/process_stage/method/star_request.py

@@ -1,16 +1,17 @@
-"""
-本地 Agent 模式的 AstrBot 插件调用 Stage
-"""
+"""本地 Agent 模式的 AstrBot 插件调用 Stage"""
+
+import traceback
+from collections.abc import AsyncGenerator
+from typing import Any
 
-from ...context import PipelineContext, call_handler
-from ..stage import Stage
-from typing import Dict, Any, List, AsyncGenerator, Union
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.message.message_event_result import MessageEventResult
 from astrbot.core import logger
-from astrbot.core.star.star_handler import StarHandlerMetadata
+from astrbot.core.message.message_event_result import MessageEventResult
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.star.star import star_map
-import traceback
+from astrbot.core.star.star_handler import StarHandlerMetadata
+
+from ...context import PipelineContext, call_handler
+from ..stage import Stage
 
 
 class StarRequestSubStage(Stage):
@@ -21,13 +22,14 @@ class StarRequestSubStage(Stage):
         self.ctx = ctx
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
-        activated_handlers: List[StarHandlerMetadata] = event.get_extra(
-            "activated_handlers"
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
+        activated_handlers: list[StarHandlerMetadata] = event.get_extra(
+            "activated_handlers",
         )
-        handlers_parsed_params: Dict[str, Dict[str, Any]] = event.get_extra(
-            "handlers_parsed_params"
+        handlers_parsed_params: dict[str, dict[str, Any]] = event.get_extra(
+            "handlers_parsed_params",
         )
         if not handlers_parsed_params:
             handlers_parsed_params = {}
@@ -37,7 +39,7 @@ class StarRequestSubStage(Stage):
             md = star_map.get(handler.handler_module_path)
             if not md:
                 logger.warning(
-                    f"Cannot find plugin for given handler module path: {handler.handler_module_path}"
+                    f"Cannot find plugin for given handler module path: {handler.handler_module_path}",
                 )
                 continue
             logger.debug(f"plugin -> {md.name} - {handler.handler_name}")

astrbot/core/pipeline/process_stage/stage.py

@@ -1,12 +1,14 @@
-from typing import List, Union, AsyncGenerator
-from ..stage import Stage, register_stage
+from collections.abc import AsyncGenerator
+
+from astrbot.core import logger
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.provider.entities import ProviderRequest
+from astrbot.core.star.star_handler import StarHandlerMetadata
+
 from ..context import PipelineContext
+from ..stage import Stage, register_stage
 from .method.llm_request import LLMRequestSubStage
 from .method.star_request import StarRequestSubStage
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.star.star_handler import StarHandlerMetadata
-from astrbot.core.provider.entities import ProviderRequest
-from astrbot.core import logger
 
 
 @register_stage
@@ -22,11 +24,12 @@ class ProcessStage(Stage):
         await self.star_request_sub_stage.initialize(ctx)
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         """处理事件"""
-        activated_handlers: List[StarHandlerMetadata] = event.get_extra(
-            "activated_handlers"
+        activated_handlers: list[StarHandlerMetadata] = event.get_extra(
+            "activated_handlers",
         )
         # 有插件 Handler 被激活
         if activated_handlers:

astrbot/core/pipeline/process_stage/utils.py

@@ -1,6 +1,7 @@
-from ..context import PipelineContext
-from astrbot.core.provider.entities import ProviderRequest
 from astrbot.api import logger, sp
+from astrbot.core.provider.entities import ProviderRequest
+
+from ..context import PipelineContext
 
 
 async def inject_kb_context(
@@ -8,14 +9,14 @@ async def inject_kb_context(
     p_ctx: PipelineContext,
     req: ProviderRequest,
 ) -> None:
-    """inject knowledge base context into the provider request
+    """Inject knowledge base context into the provider request
 
     Args:
         umo: Unique message object (session ID)
         p_ctx: Pipeline context
         req: Provider request
-    """
 
+    """
     kb_mgr = p_ctx.plugin_manager.context.kb_manager
 
     # 1. 优先读取会话级配置
@@ -45,7 +46,7 @@ async def inject_kb_context(
 
         if invalid_kb_ids:
             logger.warning(
-                f"[知识库] 会话 {umo} 配置的以下知识库无效: {invalid_kb_ids}"
+                f"[知识库] 会话 {umo} 配置的以下知识库无效: {invalid_kb_ids}",
             )
 
         if not kb_names:

astrbot/core/pipeline/rate_limit_check/stage.py

@@ -1,18 +1,19 @@
 import asyncio
-from datetime import datetime, timedelta
 from collections import defaultdict, deque
-from typing import DefaultDict, Deque, Union, AsyncGenerator
-from ..stage import Stage, register_stage
-from ..context import PipelineContext
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from collections.abc import AsyncGenerator
+from datetime import datetime, timedelta
+
 from astrbot.core import logger
 from astrbot.core.config.astrbot_config import RateLimitStrategy
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
+from ..context import PipelineContext
+from ..stage import Stage, register_stage
 
 
 @register_stage
 class RateLimitStage(Stage):
-    """
-    检查是否需要限制消息发送的限流器。
+    """检查是否需要限制消息发送的限流器。
 
     使用 Fixed Window 算法。
     如果触发限流，将 stall 流水线，直到下一个时间窗口来临时自动唤醒。
@@ -20,32 +21,30 @@ class RateLimitStage(Stage):
 
     def __init__(self):
         # 存储每个会话的请求时间队列
-        self.event_timestamps: DefaultDict[str, Deque[datetime]] = defaultdict(deque)
+        self.event_timestamps: defaultdict[str, deque[datetime]] = defaultdict(deque)
         # 为每个会话设置一个锁，避免并发冲突
-        self.locks: DefaultDict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
+        self.locks: defaultdict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
         # 限流参数
         self.rate_limit_count: int = 0
         self.rate_limit_time: timedelta = timedelta(0)
 
     async def initialize(self, ctx: PipelineContext) -> None:
-        """
-        初始化限流器，根据配置设置限流参数。
-        """
+        """初始化限流器，根据配置设置限流参数。"""
         self.rate_limit_count = ctx.astrbot_config["platform_settings"]["rate_limit"][
             "count"
         ]
         self.rate_limit_time = timedelta(
-            seconds=ctx.astrbot_config["platform_settings"]["rate_limit"]["time"]
+            seconds=ctx.astrbot_config["platform_settings"]["rate_limit"]["time"],
         )
         self.rl_strategy = ctx.astrbot_config["platform_settings"]["rate_limit"][
             "strategy"
         ]  # stall or discard
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
-        """
-        检查并处理限流逻辑。如果触发限流，流水线会 stall 并在窗口期后自动恢复。
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
+        """检查并处理限流逻辑。如果触发限流，流水线会 stall 并在窗口期后自动恢复。
 
         Args:
             event (AstrMessageEvent): 当前消息事件。
@@ -53,6 +52,7 @@ class RateLimitStage(Stage):
 
         Returns:
             MessageEventResult: 继续或停止事件处理的结果。
+
         """
         session_id = event.session_id
         now = datetime.now()
@@ -66,32 +66,33 @@ class RateLimitStage(Stage):
                 if len(timestamps) < self.rate_limit_count:
                     timestamps.append(now)
                     break
-                else:
-                    next_window_time = timestamps[0] + self.rate_limit_time
-                    stall_duration = (next_window_time - now).total_seconds() + 0.3
-
-                    match self.rl_strategy:
-                        case RateLimitStrategy.STALL.value:
-                            logger.info(
-                                f"会话 {session_id} 被限流。根据限流策略，此会话处理将被暂停 {stall_duration:.2f} 秒。"
-                            )
-                            await asyncio.sleep(stall_duration)
-                            now = datetime.now()
-                        case RateLimitStrategy.DISCARD.value:
-                            logger.info(
-                                f"会话 {session_id} 被限流。根据限流策略，此请求已被丢弃，直到限额于 {stall_duration:.2f} 秒后重置。"
-                            )
-                            return event.stop_event()
+                next_window_time = timestamps[0] + self.rate_limit_time
+                stall_duration = (next_window_time - now).total_seconds() + 0.3
+
+                match self.rl_strategy:
+                    case RateLimitStrategy.STALL.value:
+                        logger.info(
+                            f"会话 {session_id} 被限流。根据限流策略，此会话处理将被暂停 {stall_duration:.2f} 秒。",
+                        )
+                        await asyncio.sleep(stall_duration)
+                        now = datetime.now()
+                    case RateLimitStrategy.DISCARD.value:
+                        logger.info(
+                            f"会话 {session_id} 被限流。根据限流策略，此请求已被丢弃，直到限额于 {stall_duration:.2f} 秒后重置。",
+                        )
+                        return event.stop_event()
 
     def _remove_expired_timestamps(
-        self, timestamps: Deque[datetime], now: datetime
+        self,
+        timestamps: deque[datetime],
+        now: datetime,
     ) -> None:
-        """
-        移除时间窗口外的时间戳。
+        """移除时间窗口外的时间戳。
 
         Args:
             timestamps (Deque[datetime]): 当前会话的时间戳队列。
             now (datetime): 当前时间，用于计算过期时间。
+
         """
         expiry_threshold: datetime = now - self.rate_limit_time
         while timestamps and timestamps[0] < expiry_threshold: