laoxong/AstrBot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(core): supports anthropic-skills-like tool call mode (#4681)

Browse Source 
* feat(core): change llmtool to claude skills like func call

* feat: refactor tool execution logic in ToolLoopAgentRunner for improved clarity and efficiency

* feat(core): 添加工具调用模式配置选项

新增 tool_schema_mode 配置项，支持两种工具调用模式：
- skills_like：先发送工具名称和描述，再查询参数（两阶段）
- full：一次性发送完整工具模式

更新了默认配置、配置元数据定义以及代理子阶段处理逻辑，
添加了完整的工具调用提示语句，并在仪表板中提供了国际化支持。

* feat: 优化工具集获取逻辑，添加轻量和参数工具集返回方法

* refactor(runner): 重构工具模式处理逻辑到ToolLoopAgentRunner

- 将工具集激活逻辑提取到新的_build_active_tool_set方法中
- 实现工具模式配置功能，支持full和light模式的动态切换
- 移除InternalAgentSubStage中的工具模式应用逻辑，统一在runner中处理
- 添加_tool_schema_full_set和_tool_schema_param_set实例变量来管理工具集状态
- 修改工具查询逻辑以使用新的工具集管理方式

* fix: update default tool_schema_mode to 'full' in InternalAgentSubStage

* refactor: rename TOOL_CALL_PROMPT_FULL to TOOL_CALL_PROMPT_SKILLS_LIKE_MODE and update prompt logic

---------

Co-authored-by: Soulter <905617992@qq.com>
This commit is contained in:
vmoranv
2026-01-28 22:49:34 +08:00
committed by GitHub
parent c1b764da04
commit f92f0a3e5d
7 changed files with 207 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files
astrbot/core/agent/runners/tool_loop_agent_runner.py
+91 -1
View File
@@ -1,3 +1,4 @@
import copy
import sys
import time
import traceback
@@ -14,6 +15,7 @@ from mcp.types import (
from astrbot import logger
from astrbot.core.agent.message import TextPart, ThinkPart
from astrbot.core.agent.tool import ToolSet
from astrbot.core.message.components import Json
from astrbot.core.message.message_event_result import (
MessageChain,
@@ -64,6 +66,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
# customize
custom_token_counter: TokenCounter | None = None,
custom_compressor: ContextCompressor | None = None,
tool_schema_mode: str | None = "full",
**kwargs: T.Any,
) -> None:
self.req = request
@@ -99,6 +102,24 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
self.agent_hooks = agent_hooks
self.run_context = run_context
# These two are used for tool schema mode handling
# We now have two modes:
# - "full": use full tool schema for LLM calls, default.
# - "skills_like": use light tool schema for LLM calls, and re-query with param-only schema when needed.
# Light tool schema does not include tool parameters.
# This can reduce token usage when tools have large descriptions.
# See #4681
self.tool_schema_mode = tool_schema_mode
self._tool_schema_param_set = None
if tool_schema_mode == "skills_like":
tool_set = self.req.func_tool
if not tool_set:
return
light_set = tool_set.get_light_tool_set()
self._tool_schema_param_set = tool_set.get_param_only_tool_set()
# MODIFIE the req.func_tool to use light tool schemas
self.req.func_tool = light_set
messages = []
# append existing messages in the run context
for msg in request.contexts:
@@ -253,6 +274,9 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
# 如果有工具调用，还需处理工具调用
if llm_resp.tools_call_name:
if self.tool_schema_mode == "skills_like":
llm_resp, _ = await self._resolve_tool_exec(llm_resp)
tool_call_result_blocks = []
async for result in self._handle_function_tools(self.req, llm_resp):
if isinstance(result, list):
@@ -269,6 +293,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
type=ar_type,
data=AgentResponseData(chain=result),
)
# 将结果添加到上下文中
parts = []
if llm_resp.reasoning_content or llm_resp.reasoning_signature:
@@ -354,7 +379,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
try:
if not req.func_tool:
return
func_tool = req.func_tool.get_func(func_tool_name)
func_tool = req.func_tool.get_tool(func_tool_name)
logger.info(f"使用工具：{func_tool_name}，参数：{func_tool_args}")
if not func_tool:
@@ -537,6 +562,71 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
if tool_call_result_blocks:
yield tool_call_result_blocks
def _build_tool_requery_context(
self, tool_names: list[str]
) -> list[dict[str, T.Any]]:
"""Build contexts for re-querying LLM with param-only tool schemas."""
contexts: list[dict[str, T.Any]] = []
for msg in self.run_context.messages:
if hasattr(msg, "model_dump"):
contexts.append(msg.model_dump()) # type: ignore[call-arg]
elif isinstance(msg, dict):
contexts.append(copy.deepcopy(msg))
instruction = (
"You have decided to call tool(s): "
+ ", ".join(tool_names)
+ ". Now call the tool(s) with required arguments using the tool schema, "
"and follow the existing tool-use rules."
)
if contexts and contexts[0].get("role") == "system":
content = contexts[0].get("content") or ""
contexts[0]["content"] = f"{content}\n{instruction}"
else:
contexts.insert(0, {"role": "system", "content": instruction})
return contexts
def _build_tool_subset(self, tool_set: ToolSet, tool_names: list[str]) -> ToolSet:
"""Build a subset of tools from the given tool set based on tool names."""
subset = ToolSet()
for name in tool_names:
tool = tool_set.get_tool(name)
if tool:
subset.add_tool(tool)
return subset
async def _resolve_tool_exec(
self,
llm_resp: LLMResponse,
) -> tuple[LLMResponse, ToolSet | None]:
"""Used in 'skills_like' tool schema mode to re-query LLM with param-only tool schemas."""
tool_names = llm_resp.tools_call_name
if not tool_names:
return llm_resp, self.req.func_tool
full_tool_set = self.req.func_tool
if not isinstance(full_tool_set, ToolSet):
return llm_resp, self.req.func_tool
subset = self._build_tool_subset(full_tool_set, tool_names)
if not subset.tools:
return llm_resp, full_tool_set
if isinstance(self._tool_schema_param_set, ToolSet):
param_subset = self._build_tool_subset(
self._tool_schema_param_set, tool_names
)
if param_subset.tools and tool_names:
contexts = self._build_tool_requery_context(tool_names)
requery_resp = await self.provider.text_chat(
contexts=contexts,
func_tool=param_subset,
model=self.req.model,
session_id=self.req.session_id,
)
if requery_resp:
llm_resp = requery_resp
return llm_resp, subset
def done(self) -> bool:
"""检查 Agent 是否已完成工作"""
return self._state in (AgentState.DONE, AgentState.ERROR)
astrbot/core/agent/tool.py
+56 -20
View File
@@ -1,3 +1,4 @@
import copy
from collections.abc import AsyncGenerator, Awaitable, Callable
from typing import Any, Generic
@@ -102,6 +103,47 @@ class ToolSet:
return tool
return None
def get_light_tool_set(self) -> "ToolSet":
"""Return a light tool set with only name/description."""
light_tools = []
for tool in self.tools:
if hasattr(tool, "active") and not tool.active:
continue
light_params = {
"type": "object",
"properties": {},
}
light_tools.append(
FunctionTool(
name=tool.name,
parameters=light_params,
description=tool.description,
handler=None,
)
)
return ToolSet(light_tools)
def get_param_only_tool_set(self) -> "ToolSet":
"""Return a tool set with name/parameters only (no description)."""
param_tools = []
for tool in self.tools:
if hasattr(tool, "active") and not tool.active:
continue
params = (
copy.deepcopy(tool.parameters)
if tool.parameters
else {"type": "object", "properties": {}}
)
param_tools.append(
FunctionTool(
name=tool.name,
parameters=params,
description="",
handler=None,
)
)
return ToolSet(param_tools)
@deprecated(reason="Use add_tool() instead", version="4.0.0")
def add_func(
self,
@@ -147,18 +189,15 @@ class ToolSet:
"""Convert tools to OpenAI API function calling schema format."""
result = []
for tool in self.tools:
func_def = {
"type": "function",
"function": {
"name": tool.name,
"description": tool.description,
},
}
func_def = {"type": "function", "function": {"name": tool.name}}
if tool.description:
func_def["function"]["description"] = tool.description
if (
tool.parameters and tool.parameters.get("properties")
) or not omit_empty_parameter_field:
func_def["function"]["parameters"] = tool.parameters
if tool.parameters is not None:
if (
tool.parameters and tool.parameters.get("properties")
) or not omit_empty_parameter_field:
func_def["function"]["parameters"] = tool.parameters
result.append(func_def)
return result
@@ -171,11 +210,9 @@ class ToolSet:
if tool.parameters:
input_schema["properties"] = tool.parameters.get("properties", {})
input_schema["required"] = tool.parameters.get("required", [])
tool_def = {
"name": tool.name,
"description": tool.description,
"input_schema": input_schema,
}
tool_def = {"name": tool.name, "input_schema": input_schema}
if tool.description:
tool_def["description"] = tool.description
result.append(tool_def)
return result
@@ -245,10 +282,9 @@ class ToolSet:
tools = []
for tool in self.tools:
d: dict[str, Any] = {
"name": tool.name,
"description": tool.description,
}
d: dict[str, Any] = {"name": tool.name}
if tool.description:
d["description"] = tool.description
if tool.parameters:
d["parameters"] = convert_schema(tool.parameters)
tools.append(d)
astrbot/core/config/default.py
+14
View File
@@ -106,6 +106,7 @@ DEFAULT_CONFIG = {
"reachability_check": False,
"max_agent_step": 30,
"tool_call_timeout": 60,
"tool_schema_mode": "full",
"llm_safety_mode": True,
"safety_mode_strategy": "system_prompt", # TODO: llm judge
"file_extract": {
@@ -2183,6 +2184,9 @@ CONFIG_METADATA_2 = {
"tool_call_timeout": {
"type": "int",
},
"tool_schema_mode": {
"type": "string",
},
"file_extract": {
"type": "object",
"items": {
@@ -2812,6 +2816,16 @@ CONFIG_METADATA_3 = {
"provider_settings.agent_runner_type": "local",
},
},
"provider_settings.tool_schema_mode": {
"description": "工具调用模式",
"type": "string",
"options": ["skills_like", "full"],
"labels": ["Skills-like（两阶段）", "Full（完整参数）"],
"hint": "skills-like 先下发工具名称与描述，再下发参数；full 一次性下发完整参数。",
"condition": {
"provider_settings.agent_runner_type": "local",
},
},
"provider_settings.wake_prefix": {
"description": "LLM 聊天额外唤醒前缀 ",
"type": "string",
astrbot/core/pipeline/process_stage/method/agent_sub_stages/internal.py
+15 -1
View File
@@ -46,6 +46,7 @@ from ...utils import (
PYTHON_TOOL,
SANDBOX_MODE_PROMPT,
TOOL_CALL_PROMPT,
TOOL_CALL_PROMPT_SKILLS_LIKE_MODE,
decoded_blocked,
retrieve_knowledge_base,
)
@@ -62,6 +63,13 @@ class InternalAgentSubStage(Stage):
]
self.max_step: int = settings.get("max_agent_step", 30)
self.tool_call_timeout: int = settings.get("tool_call_timeout", 60)
self.tool_schema_mode: str = settings.get("tool_schema_mode", "full")
if self.tool_schema_mode not in ("skills_like", "full"):
logger.warning(
"Unsupported tool_schema_mode: %s, fallback to skills_like",
self.tool_schema_mode,
)
self.tool_schema_mode = "full"
if isinstance(self.max_step, bool): # workaround: #2622
self.max_step = 30
self.show_tool_use: bool = settings.get("show_tool_use_status", True)
@@ -672,7 +680,12 @@ class InternalAgentSubStage(Stage):
# 注入基本 prompt
if req.func_tool and req.func_tool.tools:
req.system_prompt += f"\n{TOOL_CALL_PROMPT}\n"
tool_prompt = (
TOOL_CALL_PROMPT
if self.tool_schema_mode == "full"
else TOOL_CALL_PROMPT_SKILLS_LIKE_MODE
)
req.system_prompt += f"\n{tool_prompt}\n"
action_type = event.get_extra("action_type")
if action_type == "live":
@@ -693,6 +706,7 @@ class InternalAgentSubStage(Stage):
llm_compress_provider=self._get_compress_provider(),
truncate_turns=self.dequeue_context_length,
enforce_max_turns=self.max_context_length,
tool_schema_mode=self.tool_schema_mode,
)
# 检测 Live Mode
astrbot/core/pipeline/process_stage/utils.py
+15 -3
View File
@@ -40,11 +40,23 @@ SANDBOX_MODE_PROMPT = (
TOOL_CALL_PROMPT = (
"You MUST NOT return an empty response, especially after invoking a tool."
"Before calling any tool, provide a brief explanatory message to the user stating the purpose of the tool call."
"After the tool call is completed, you must briefly summarize the results returned by the tool for the user."
"Keep the role-play and style consistent throughout the conversation."
" Before calling any tool, provide a brief explanatory message to the user stating the purpose of the tool call."
" Use the provided tool schema to format arguments and do not guess parameters that are not defined."
" After the tool call is completed, you must briefly summarize the results returned by the tool for the user."
" Keep the role-play and style consistent throughout the conversation."
)
TOOL_CALL_PROMPT_SKILLS_LIKE_MODE = (
"You MUST NOT return an empty response, especially after invoking a tool."
" Before calling any tool, provide a brief explanatory message to the user stating the purpose of the tool call."
" Tool schemas are provided in two stages: first only name and description; "
"if you decide to use a tool, the full parameter schema will be provided in "
"a follow-up step. Do not guess arguments before you see the schema."
" After the tool call is completed, you must briefly summarize the results returned by the tool for the user."
" Keep the role-play and style consistent throughout the conversation."
)
CHATUI_SPECIAL_DEFAULT_PERSONA_PROMPT = (
"You are a calm, patient friend with a systems-oriented way of thinking.\n"
"When someone expresses strong emotional needs, you begin by offering a concise, grounding response "
dashboard/src/i18n/locales/en-US/features/config-metadata.json
+8
View File
@@ -247,6 +247,14 @@
"tool_call_timeout": {
"description": "Tool Call Timeout (seconds)"
},
"tool_schema_mode": {
"description": "Tool Schema Mode",
"hint": "Skills-like sends name/description first and re-queries for parameters; Full sends the complete schema in one step.",
"labels": [
"Skills-like (two-stage)",
"Full schema"
]
},
"streaming_response": {
"description": "Streaming Output"
},
dashboard/src/i18n/locales/zh-CN/features/config-metadata.json
+8
View File
@@ -244,6 +244,14 @@
"tool_call_timeout": {
"description": "工具调用超时时间(秒)"
},
"tool_schema_mode": {
"description": "工具调用模式",
"hint": "skills-like 先下发工具名称与描述，再下发参数；full 一次性下发完整参数。",
"labels": [
"Skills-like（两阶段）",
"Full（完整参数）"
]
},
"streaming_response": {
"description": "流式输出"
},