Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It conveys that this is a raw escape hatch bypassing the safe named wrappers and documents the timeout default, but it never warns that the same call can trigger destructive actions (kick, ban, send), nor describes error behavior or how failures surface for unknown actions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the purpose in the first sentence, then the routing rule, then parameter notes. Every sentence earns its place and the ordering matches how an agent reads a definition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a generic passthrough with no output schema and no annotations, the definition covers purpose, when-to-use, and parameters well. The one gap is that it does not note that return shapes vary by action, which an agent would need to know when composing follow-up calls.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents action, params, and timeout. The description's parameter notes largely restate the schema fields, adding example action names but no new semantics about the params dictionary's per-action shape. Baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: a universal low-level passthrough that directly calls any OneBot 11 standard or extended Action supported by NapCatQQ, covering 144+ functions. It explicitly carves out its niche relative to the named siblings, so an agent can tell it apart without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly names the condition that selects this tool — when high-level named tools do not cover a specific rare interface — and gives concrete examples (group album, group sign-in, fetch_ptt_text, send_group_ai_record, clean_cache). This implies the inverse rule (prefer named tools otherwise), which is strong routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It discloses the inspection scope (environment, ports, accounts, version diff), which implies a read-only diagnostic, but never states whether it requires permissions, how long it takes, or what it returns. Adequate but with clear gaps for an annotation-free tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the concrete checks and followed by the selection condition. No filler; every clause earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter diagnostic with no output schema, the description enumerates what is inspected (environment, ports, accounts, version comparison), which is enough for an agent to know what the call covers. It does not describe the shape of the result, a minor gap given there is no output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so per the rubric the baseline is 4. There is no parameter syntax to clarify, and the description correctly implies a no-argument invocation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (检查/check) plus concrete resources: local NapCatQQ runtime environment, service port status, saved account list, and comparison against the latest GitHub Release. This is a clear, non-tautological purpose. It does not explicitly name the sibling tools it differs from (e.g., get_napcat_status), so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear when-to-use guidance: call it when uncertain whether NapCat is deployed, running, or has an update available. This gives real context for selection. It stops short of naming alternatives or when-not-to-use conditions, so it is not a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It usefully scopes the effect to '本地内存' (local memory) and identifies the target as a cache pool, which tells the agent that persistent message history is likely unaffected. However, it omits whether the action is reversible, whether in-flight/queued messages are lost, and whether confirmation or elevated permissions are required.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded clause with no filler or redundancy. It is tight, though for an operation that discards data it may be terse to the point of under-informing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No annotations, no output schema, and no statement of when the tool is appropriate or what the caller observes afterward. For a state-clearing operation, an agent needs at least a hint about timing/appropriateness, and nothing here supplies it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to disambiguate. The baseline for a parameterless tool applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (清空/clear) and a specific resource (近期实时消息缓存池 – the recent realtime message buffer). An agent can distinguish it from the read-oriented sibling get_recent_messages, but the description never names or contrasts with any sibling explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to invoke this tool versus alternatives such as get_recent_messages or get_recent_notices_and_requests, nor any stated preconditions or consequences. The agent must infer the use case entirely from the verb.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose permission requirements, whether the removal is reversible, or any error conditions, despite being a mutation of group state.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core sentence is front-loaded and concise, but the appended ':param message_id: 要移出精华的消息 ID' is a docstring artifact that repeats the schema and adds no value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter tool with no output schema, the purpose is conveyed adequately. However, with no annotations and a mutating action, missing permission and reversibility details leave it only minimally complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the single parameter is fully described in the schema. The description's ':param message_id' line merely duplicates the schema text verbatim, adding no new meaning, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: 移出 (remove) the specified 群精华消息 (group essence message). It is clear what the tool does, but it never names its natural counterpart set_essence_msg, so sibling differentiation is left to the agent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this versus alternatives. It does not mention set_essence_msg (the opposite operation) or get_essence_msg_list, nor any prerequisite such as needing the message to already be an essence message.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose that deletion is irreversible, whether the friend is notified, what permissions are required, or what happens to message history — significant omissions for a destructive mutation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The definition is short and front-loads the action, which is appropriate. The trailing ':param' docstring line is redundant with the schema but does not bloat the description significantly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive one-parameter mutation with no annotations and no output schema, the description is too thin: it omits irreversibility, side effects on history/notifications, and any failure modes. The schema alone cannot carry that behavioral context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents user_id fully. The description's ':param user_id' line is a verbatim duplicate of the schema property description and adds no syntax, format, or constraint information beyond it, so baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (删除/delete a QQ friend) and even cites the underlying OneBot 11 action, so the operation is unambiguous. No sibling tool performs friend deletion, so it is implicitly distinguished from the sibling list, though the description does not explicitly contrast with any of them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g. confirming the friend relationship exists), and no warning about the destructive nature of the operation. The single sentence only restates the purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It states the tool deletes a file but does not disclose irreversibility, required permissions, or any side effects. For a destructive operation, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short and front-loads the purpose sentence. The parameter list duplicates schema content but does not pad the description with extraneous prose. Minor formatting oddity with the ':param' style, but overall efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive deletion tool with zero annotations and no output schema, the description should at least mention irreversibility, permissions, or what happens on success/failure. It provides only purpose and parameter names already covered by the schema, leaving key behavioral context missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters. The description duplicates those same descriptions ('群号', '群文件 ID', '文件类型 busid，默认 102') without adding any new meaning or format details. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource in Chinese: '删除指定的 QQ 群文件' (delete the specified QQ group file). This clearly distinguishes it from sibling tools like delete_group_folder (folders) and delete_msg (messages). However, it does not explicitly name an alternative or clarify the boundary with delete_group_folder beyond the inherent noun difference.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It only lists parameter descriptions, leaving the agent to infer usage context entirely from the tool name and schema.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. 'Delete' implies a destructive mutation, but nothing states what gets destroyed (the folder's contents/files?), whether the operation is irreversible, what permissions are required, or what happens on a nonexistent folder. The only extra signal is the NapCat OneBot 11 API reference, which is metadata rather than behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in a single clean sentence, but the trailing Sphinx-style ':param' lines duplicate what the input schema already provides and add noise without value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive delete operation with no annotations and no output schema, the description should carry the safety and consequence burden. It fails to say what is removed, whether it is recoverable, or any error conditions, leaving the agent under-informed before an irreversible action.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters. The description merely repeats the same text ('群号', '群文件夹 ID') with no added format, range, or sourcing detail, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('删除指定的 QQ 群文件夹' = delete the specified QQ group folder), which clearly distinguishes it from the sibling delete_group_file (a file vs a folder). However it does not name any sibling explicitly or explain the folder/file distinction, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as delete_group_file or the folder-listing tools. The agent gets the action but nothing about the conditions that should select this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries behavioral burden. It discloses the permission constraint (own message vs admin privilege), which is valuable context. However, it doesn't state what happens on failure (e.g., timeout, already retracted), whether retraction is reversible, or rate limits. For a mutation tool with no annotations, this is adequate but incomplete.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the action and its OneBot equivalent, then permission rules, then param. No wasted sentences. The ':param' line is redundant with the schema but harmless.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-param mutation tool with no annotations and no output schema, the description covers the core action and permission model but omits error behavior, rate limits, and confirmation of deletion. It is minimally sufficient but leaves gaps an agent might need.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the parameter is fully documented in the schema. The description repeats ':param message_id: 目标消息 ID', adding no new information beyond the schema. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('撤回指定消息' / retract a specified message) and maps it to the OneBot 11 action delete_msg. Clear and distinct from siblings like get_msg or send_msg.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states usage context: can retract one's own messages, or as a group admin, retract group members' messages. This clarifies the permission model. Doesn't name alternatives (e.g., no comparison to other message tools) but none are needed given the unique purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the behavioral burden and does well: it discloses the confirmation workflow, that confirmed=False returns only a preview while True performs real download/extraction, and that local offline packages are preferred when available. It does not cover rollback behavior or exactly how an update mutates an existing installation, so it is not fully exhaustive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with purpose, followed by a safety warning and parameter notes. It is efficient but the trailing :param list duplicates the input schema nearly verbatim, which slightly reduces conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a deployment/update tool with no annotations and no output schema, the description supplies the essential behavioral context: the preview/execute confirmation flow, local zip priority, and target_uin purpose. It is largely complete, though it could say more about what happens to an existing NapCat installation during an update.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all four parameters in detail. The description repeats the same parameter meanings without adding format, constraints, or examples beyond the schema, which is the baseline 3 case when structured fields do the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: '一键自动部署或更新 NapCat 运行时环境', with explicit modes (deploy/update), download vs local zip, and OneBot port configuration. This clearly distinguishes it from sibling service-control tools like start/stop/restart_napcat_service and check_napcat_environment.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives a strong usage protocol: first call must use confirmed=False to get a preview, then after explicit user authorization call with confirmed=True. It does not name alternative sibling tools or state when deployment should be preferred over, for example, checking the environment first, so it stops short of explicit alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It usefully discloses the side effect (writes the file to the local cache directory) and the return value (local absolute path), but omits permission/auth requirements, rate limits, or failure behavior for a network operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose sentence is front-loaded and clear, but the following :param lines duplicate the schema verbatim, adding bulk without new information. Reasonably sized but not maximally efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description does partially compensate by naming the return value (local absolute path). However, for a network I/O tool with side effects, it lacks context on permissions, error cases, and cache location details, leaving notable gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all three parameters are already documented in the input schema. The description's :param lines restate the same information (URL, thread count default 3, headers format) without adding meaning beyond the schema, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (download) and resource (network file to local cache directory via NapCat), and clarifies it returns the local absolute path. An agent can distinguish this from upload/delete file siblings, though the description does not explicitly name any alternative.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains what the tool does but offers no guidance on when to use it versus alternatives like get_group_file_url or get_private_file_url, nor any prerequisites or exclusions. Usage must be inferred entirely by the agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It implies a read operation via 获取, but says nothing about return shape, whether the list is paginated or capped, ordering, or required permissions for the group.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Short and front-loaded, with the core purpose stated first. The trailing ':param group_id:' docstring artifact is slightly redundant clutter but the whole entry stays compact.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a one-parameter read getter with no output schema, the description is minimally adequate. It does not describe what the returned list contains or how large it may be, which is the main remaining gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with a single required group_id already documented as 目标群号 in the schema. The description merely repeats that same meaning, adding no format or constraint detail beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource: 获取 (get) the 精华消息列表 (essence/pinned message list) for a specified QQ group. This clearly separates it from the write-side siblings set_essence_msg and delete_essence_msg, though it never explicitly names them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied by the tool name and read semantics; the description gives no when-to-use, no prerequisites, and no mention of the sibling mutation tools. An agent can infer it is the read counterpart, but nothing is stated explicitly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that it retrieves a node list, but says nothing about read-only safety, permissions, response format beyond 'node list', or error behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short and front-loads the purpose before the parameter line. The separate ':param' line duplicates the schema, but the overall structure remains efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter getter with no output schema and no annotations, the description gives minimal but adequate purpose and parameter info. It does not describe the returned node structure or any failure conditions, so it is only minimally complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single parameter, and the description simply repeats the schema's wording for message_id. Baseline 3 is appropriate when the schema already documents the parameter fully.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: it retrieves the content node list of a merged forward message, and it names the OneBot 11 action name. It does not differentiate itself from siblings like get_msg or send_private_forward_msg, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given about when to use this tool versus alternatives such as get_msg or the send_*_forward_msg tools. The usage is only implied by the purpose statement.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses returned fields and the cache-refresh option, and '获取' implies read-only, but it does not state authentication prerequisites, rate limits, or detailed cache semantics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short and front-loads the purpose, which is good. However, it includes the OneBot 11 API name and a ':param no_cache' line that duplicates the schema, adding minor unnecessary text.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-optional-parameter read tool with no output schema, the description gives purpose, key fields, and the cache option. It still lacks sibling differentiation and any detail on return shape, pagination, or size handling.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the single no_cache parameter is already documented in the schema. The description repeats the same explanation without adding syntax, constraints, or behavioral meaning beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (获取) and resource (好友列表), scoped to the currently logged-in QQ, and lists example returned fields. However, it does not distinguish this from sibling get_friends_with_category, which also returns friends.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance or mention of alternatives. The phrase '全部好友列表' implies all friends, but an agent gets no explicit instruction on choosing this over get_friends_with_category or get_stranger_info.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It does disclose the data source (NapCat) and the paging direction when message_seq is omitted, which is genuinely useful behavior, but it says nothing about result ordering guarantees, how count interacts with message_seq, permissions, or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The text is short and front-loaded with the core action, followed by parameter notes. It is efficient, though the param lines are pure duplication of the schema and thus slightly wasted space.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description should ideally describe the returned message structure or pagination contract. It covers inputs adequately but leaves the return shape and pagination semantics unstated, which is a real gap for a history-fetch tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the description simply restates the same three parameter descriptions verbatim (user_id, count default 20, message_seq optional). It adds no syntax, format, or constraint detail beyond the schema, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb+resource: retrieve historical private chat messages with a specified friend, and names the upstream API (NapCat OneBot 11 get_friend_msg_history). It is clearly distinct from sibling tools by resource type (friend vs group), though it never explicitly contrasts with get_group_msg_history or get_recent_messages.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use / when-not-to-use guidance and no mention of alternatives such as get_group_msg_history or get_recent_messages. Usage is only implied by the tool name and the note that omitting message_seq pulls from the newest message backward.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the name. It does not indicate pagination, rate limits, ordering, or what happens when the endpoint is unavailable; the only added signal is that this is a NapCat extension rather than standard OneBot. For a zero-param read this is low risk, but the disclosure is still minimal.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One short sentence that front-loads the function and tucks the endpoint identity into a parenthetical. The parenthetical partially restates the tool name already visible to the agent, but it also contributes the 'NapCat extension' tag, so waste is minor.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-param read with no output schema, the description is adequate but does not explain the shape of the returned grouping (how categories and their members are represented), which the absent output schema leaves entirely open. It does correctly imply the result is categorized rather than flat.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is no parameter semantics for the description to supply; the baseline of 4 applies. Nothing is misleading or inconsistent with the empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('获取好友列表') plus a scope qualifier ('按好友分组归类'), which implicitly separates it from the flat sibling get_friend_list. The parenthetical identifies it as a NapCat extension endpoint, reinforcing what it is. It never names get_friend_list explicitly, so the differentiation is left to inference.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no when-to-use guidance: it does not say to prefer this over get_friend_list when category/group data is needed, nor when it is unnecessary. No prerequisites, no alternatives, no exclusions are offered.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. '查询' implies a read-only operation and '今日剩余' hints at a daily-reset quota, but the description never explicitly confirms it is side-effect-free nor describes the return format. For a simple read this is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core sentence is front-loaded and clear, but the trailing ':param group_id: 群号' docstring fragment is redundant with the schema and adds no value, making the structure slightly wasteful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-parameter read tool with no output schema, the description covers the basic purpose but does not explain the shape of the return value (e.g., count fields or reset behavior), leaving a modest gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, with group_id fully documented as 群号. The description's ':param group_id: 群号' merely repeats the schema without adding format, range, or example detail, so baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb (查询/query) and a precise resource: the remaining @全体成员 count for a given group today. This is clearly distinguishable from other read tools like get_group_shut_list or get_group_info. However, it offers no explicit differentiation from siblings, so a 4 is appropriate.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description says what the tool returns but gives no when-to-use guidance, no prerequisites, and no alternatives. An agent is left to infer that this is a diagnostic/read call with no explicit routing context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full disclosure burden, and it discloses almost nothing behavioral. It implies a read-only listing operation but never states that it is non-mutating, whether it requires bot/group permissions, how results are paginated, or what happens for an invalid folder_id.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The definition is a single front-loaded sentence plus two terse param notes, with no wasted prose. It is efficient, though the param lines simply duplicate the schema.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a two-parameter read-only listing tool with full schema coverage and no output schema, the essentials are covered. However, it omits how folder_id is obtained and gives no hint of the returned list structure, which a description could reasonably supply in the absence of an output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%; both group_id and folder_id are documented in the schema, and the description merely repeats '群号' and '文件夹 ID'. Baseline 3 applies since the schema does the heavy lifting and the description adds no format or sourcing detail.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: retrieve the list of files and subfolders inside a specified folder of a QQ group. The '指定文件夹' scoping implicitly distinguishes it from the sibling get_group_root_files, which handles root-level listing. It is clear but never explicitly names the sibling it differs from.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no statement of when to use this tool versus alternatives such as get_group_root_files or get_group_file_url. An agent must infer from the name alone that a folder_id from a parent listing call is required first. No prerequisites or exclusions are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It does disclose what data is returned (total space, used space, file-count limit), which is useful since there is no output schema, but it says nothing about permissions, failure modes, or rate limits. For a simple read-only getter this is acceptable but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core purpose sentence is short and front-loaded, which is good. However, the appended docstring fragment ':param group_id: 群号' is redundant noise that duplicates the schema and slightly muddies an otherwise clean one-liner.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-parameter, read-only getter with no output schema or annotations, the description is adequate: it names the resource and lists the kinds of values returned, partially compensating for the missing output schema. Missing guidance on prerequisites and sibling alternatives keeps it from a 5.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single group_id parameter, so the schema already documents it fully. The trailing ':param group_id: 群号' merely restates the schema text and adds no syntax, format, or constraint detail. Baseline 3 applies when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource: retrieving QQ group file-system space usage (total space, used space, file-count limit). This is clearly distinct from sibling file tools like get_group_root_files or get_group_files_by_folder, which enumerate files rather than report quota. It lacks an explicit contrast to those siblings, so it falls just short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to call this versus the many sibling file/quota tools, nor any prerequisite or context such as needing the bot to be in the group. Usage is only implied by the name and resource. No when/when-not conditions are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation and that the result is a direct HTTP link, but says nothing about auth/permission requirements, link expiry, or failure modes when a file is unavailable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in one clear sentence, but the three ':param' lines duplicate schema content that is already fully documented, so a portion of the text does not earn its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 3-param URL-retrieval tool with full schema coverage but no annotations and no output schema, the description is minimally adequate. It omits what the returned link looks like and when the call fails, which an agent would benefit from knowing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The ':param' lines merely restate the schema descriptions verbatim (群号, 群文件 ID, busid optional default 102), adding no syntax or format detail beyond the structured fields.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (获取/get) and resource (群文件的直接 HTTP 下载链接/direct HTTP download link of a group file), which is unambiguous. It does not explicitly differentiate from the sibling get_private_file_url, but the 'group' scope is clear from the name and text.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this versus get_private_file_url or get_group_root_files, nor any prerequisite (e.g. that a file_id must first be obtained from a listing call). Only the purpose is given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. The 'get_' prefix implies a read-only operation, but there is no disclosure of permission requirements, rate limits, whether an empty result is possible, or what the response contains — significant gaps for an unannotated tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded and the entry is short, but the :param lines duplicate the schema descriptions word-for-word, which is wasted text given full schema coverage. Structure is fine, content is partly redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a two-parameter read tool with no output schema, the description covers the operation and parameters adequately, but it omits any description of return values or result shape and offers no behavioral context. It is the minimum viable without being rich.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description restates the group_id and honor_type documentation verbatim from the schema rather than adding format, constraints, or behavior detail, so it adds no meaning beyond the structured fields.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource (获取指定 QQ 群的群荣誉信息) and enumerates the honor categories it can return, so an agent knows exactly what this tool does. It doesn't need to distinguish from siblings since no other tool retrieves group honors, but it offers no explicit contrast either, keeping it just short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance and no named alternatives. The only implicit signal is the honor_type default of 'all', which hints at a query use case but is not stated as guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It usefully discloses the shape of the returned data (name, member count, owner, remark) and cites the underlying OneBot 11 action, but says nothing about permissions, error behavior, or the practical effect of no_cache beyond its literal meaning.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core purpose is front-loaded in the first sentence and the whole thing is short. The trailing ':param' block duplicates the schema, which is mild redundancy rather than bloat.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the field enumeration is a valuable substitute for documenting the return value. However, the description omits error cases and any auth or rate-limit context, leaving it only minimally complete for a no-annotation, no-output-schema tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so both parameters are already documented. The ':param' lines merely restate the schema descriptions verbatim (目标群号, 是否不使用缓存) without adding format, range, or behavioral detail, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource ('获取指定 QQ 群的详细信息') and enumerates the returned fields (群名称、人数、群主、群备注), which clearly distinguishes it from the list-style siblings like get_group_list. It lacks explicit sibling differentiation by name, but the scope is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance and no mention of alternatives (e.g. get_group_list for enumerating groups). The agent must infer usage context entirely on its own.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It does disclose a real behavioral trait: results come from cache unless no_cache is set (default True), which is useful. However, it never states that this is a read-only operation or whether any auth/session prerequisites apply.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the core purpose, then return fields, then the OneBot 11 API mapping. Only the parameter note is redundant with the schema, so it is close to fully efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, listing the returned fields compensates well, and the single parameter is covered. Missing only usage context and read-only/permission framing, which are minor for a simple read tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the description merely repeats the no_cache parameter text verbatim from the schema. Baseline 3 applies since the schema already does the documentation work and the description adds no syntax or edge-case detail.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: retrieves all QQ groups the current account has joined, and even enumerates the returned fields (group_id, group_name, member_count, max_member_count). An agent can distinguish it from get_group_info or get_group_member_list by scope, though no sibling is named explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this versus alternatives such as get_group_info, nor any stated preconditions (e.g., requiring a logged-in account). Usage is only implied by the tool name and 'current account' phrasing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. '获取' implies a read-only lookup and the enumerated return fields are useful output context (especially with no output schema), but the description never explicitly states the operation is side-effect-free, nor how the no_cache refresh behaves.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose sentence is front-loaded and information-dense, but the three ':param' lines duplicate the schema verbatim and earn no place given 100% schema coverage, adding pure redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the enumeration of returned fields (card, nickname, role, join time, last speak time, title) usefully compensates by telling the agent what comes back. Only the read-only/caching semantics remain unstated for a definition with no annotations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all three parameters are already documented in the schema. The ':param' lines in the description simply restate 群号, 群成员 QQ 号, and 是否强制刷新缓存, adding no meaning beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('获取指定群成员的详细资料') and enumerates exactly what is returned (群名片 card, 昵称 nickname, 群角色 role[owner/admin/member], 入群时间, 最后发言时间, 头衔). This clearly separates it from list-oriented siblings like get_group_member_list and get_stranger_info, though it never names an alternative explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied by the purpose: fetch details for one specific member identified by group_id + user_id. There is no statement of when to prefer this over get_group_member_list, nor any prerequisites or when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden, yet it only restates the schema's no_cache field. It says nothing about permissions/auth, response size for large groups, whether the result is paginated, or rate limiting — significant gaps for a tool that can return an entire group's roster.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The first sentence is front-loaded and efficient, but the two ':param' lines merely re-repeat the schema descriptions, adding length without value. Trimming them would lose nothing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read tool with no output schema and fully covered parameters, the definition is adequate but thin: it does not hint at the shape of the returned member list, handling of large groups, or cache-vs-fresh semantics beyond the flag name.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with both group_id and no_cache already documented in the schema. The description's ':param' lines duplicate that text verbatim and add no syntax, format, or edge-case meaning, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource in Chinese — fetch the full member list of a specified QQ group — and cites the underlying OneBot 11 action. It implicitly distinguishes itself from get_group_member_info (single member) via '全部成员', though it never names that sibling explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance, no exclusions, and no mention of the nearest alternatives (get_group_member_info, get_group_list). The agent must infer that this is the bulk-membership read rather than the single-member read from the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It does disclose one useful behavior — message_seq omitted means pulling backwards from the newest message — but says nothing about result ordering, pagination limits, authentication requirements, or error conditions for an invalid/ungrouped group_id.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in the first sentence and the parameter notes are terse. The param lines are largely redundant with the schema, which slightly dilutes efficiency, but there is no filler prose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a query tool with no output schema and no annotations, the description covers the inputs but omits the return shape (what a message record looks like) and any behavioral caveats. It is minimally sufficient but leaves the agent guessing about response structure and failure modes.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters, and the description repeats them nearly verbatim (群号, 获取的消息条数，默认 20, 起始消息序号). It adds no format, range, or semantics beyond what the schema provides, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: fetch historical chat records for a specified group chat via NapCat's OneBot 11 get_group_msg_history action. An agent immediately knows what the tool returns. It does not, however, explicitly distinguish itself from the sibling get_friend_msg_history or get_recent_messages, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no statement of when to use this tool versus alternatives such as get_recent_messages, get_msg, or get_friend_msg_history, and no prerequisites (e.g. the QQ account must be logged in). Usage is only implied by the tool name and the group_id parameter.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. The verb '获取' implies a read-only operation, but there is no statement of permissions/auth requirements, pagination or result-size behavior, or how the root listing differs from the folder-scoped variant — significant gaps for a tool with zero annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded one-line statement of purpose, with the NapCat/OneBot provenance in parentheses. The trailing ':param group_id: 群号' duplicates the schema and is mildly wasteful, but the description stays short overall.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

A simple single-parameter read tool with no output schema; the description conveys what is returned at a high level ('所有文件与文件夹列表'), which is adequate. It omits any detail on result shape (file metadata fields), size limits, or error cases, so it is minimally sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the single parameter is already documented as '群号' in the schema; the description merely repeats it via the ':param group_id: 群号' line. Baseline 3 applies when the schema does all the work.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (获取/list) and resource (QQ 群文件根目录下的文件与文件夹), and the '根目录' (root directory) scope implicitly distinguishes it from the sibling get_group_files_by_folder. Clear, though it does not name the alternative explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied by the resource name — listing group root files. There is no explicit when-to-use, when-not-to-use, or pointer to get_group_files_by_folder for subfolder navigation, leaving the agent to infer the boundary.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that this is a read-only operation, what permissions or group context are required, whether pagination applies, or any rate-limit/auth behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The main sentence is front-loaded and names the resource and filter efficiently. The trailing ':param group_id: 群号' is redundant with the schema, which is a minor structural waste but not harmful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-list tool with one fully documented parameter, the description says what is returned (被禁言状态的成员列表). However, with no annotations or output schema, it omits read-only safety context and any response-shape or pagination detail, leaving moderate gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and the input schema already describes group_id as 群号. The description repeats ':param group_id: 群号' without adding syntax, constraints, or context, so it meets the baseline for a fully documented schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific action (获取) and resource (指定群聊当前处于被禁言状态的成员列表), including the muted-members filter that separates it from get_group_member_list. The NapCat extension note adds provenance, and an agent can identify the tool's purpose without ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit when-to-use, prerequisites, or alternatives are provided. The agent must infer that this tool is for inspecting muted members and is not told when to prefer it over get_group_member_list or other group-management siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full behavioral burden. It usefully describes what the list contains, but says nothing about pagination, read-state side effects, permissions, or ordering for what is presumably a read operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with the OneBot API mapping appended. No wasted text, and the purpose is stated immediately.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-param listing tool with no output schema, the description partially fills the gap by naming the returned content types, which helps. However, it omits pagination or scope details that would make it fully self-contained.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to compensate for. Baseline 4 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (获取) and resource (群系统消息列表), and clarifies what it contains (pending join requests, invitation notifications). This is clear, though it doesn't explicitly distinguish itself from the similarly named sibling get_recent_notices_and_requests.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance and no mention of alternatives. The sibling get_recent_notices_and_requests appears related, but the description gives no signal about when to prefer one over the other.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, but for a zero-parameter read-only lookup the burden is light. It usefully discloses the return fields (user_id, nickname) and the underlying OneBot 11 action, yet says nothing about auth prerequisites, rate limits, or failure behavior when no account is logged in.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence that leads with the action and resource. The two trailing parentheses (return fields, OneBot action name) add some value but are slightly redundant padding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema exists, so the description must carry return-value information, and it does so by naming user_id and nickname. For a trivial no-argument read, nothing critical is missing, though error/empty-state behavior is unaddressed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so the baseline is 4. The parenthetical return-field note describes output rather than input and does not mislead about parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: retrieve the currently logged-in QQ account info, and even names the returned fields (user_id, nickname). It is unambiguous in isolation, but does not differentiate from the sibling list_qq_accounts, which could also surface account data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use, when-not-to-use, or alternative guidance. The sibling set contains list_qq_accounts, switch_qq_account, and login_new_qq_by_qrcode, so an agent gets no help deciding when this single-account lookup is the right call versus those.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden and does disclose a meaningful side effect: opening an on-screen image viewer, gated on the file existing. However it omits what happens if the file is missing, error behavior, and the fact that the returned value is a file path.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose sentence is front-loaded and compact, but the trailing `:param` line is pure duplication of the schema and does not earn its place in the description.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-parameter tool with no output schema, the description adequately conveys purpose and the display side effect. It stops short of stating the return format (a path) or failure behavior, which matters since no output schema exists to fill that gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the only parameter is fully documented in the schema. The description's `:param open_image` line simply duplicates that schema text verbatim, adding no new meaning. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource: it retrieves the path to the local NapCat login QR code image (`qrcode.png`) and optionally displays it. This is distinct from the login flow sibling, though it never explicitly differentiates itself from `login_new_qq_by_qrcode`.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus the closely related `login_new_qq_by_qrcode` sibling, nor any stated preconditions (e.g. that the QR code only exists during a pending login). The reader must infer the usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It conveys that this is a read but says nothing about permissions, whether the message may have been deleted/expired, rate limits, or error behavior such as an invalid message_id. For a lone-parameter lookup with no annotation coverage this is thin.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The first sentence front-loads the tool's purpose and returned fields, and the trailing param line is a minor redundancy. It is compact and largely earns its place, though the param restatement is wasted text.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With one required parameter, no annotations, and no output schema, the description minimally tells an agent what it gets back (sender, time, raw segments). However, it omits how message_id is obtained (the get_*_history tools) and what happens on a missing/stale ID, leaving real gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents message_id as '目标消息 ID'. The description's ':param message_id' line only restates the target message ID and adds no format, scope, or sourcing detail beyond the schema, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: retrieve detailed info for a single message by message_id, and enumerates the returned fields (sender, time, raw message segments). This clearly distinguishes it from the history-listing siblings like get_group_msg_history and get_recent_messages, though it does not explicitly name them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the single-message scope and the required message_id, but the description never states when to prefer this over get_group_msg_history, get_friend_msg_history, or get_forward_msg. No explicit alternatives or exclusions are offered.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It does add real value by revealing that this is an aggregate of get_status and get_version_info, implying a read-only, side-effect-free call, but it says nothing about permissions, latency, failure modes when NapCat is down, or return shape.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence that names the resource and then parenthetically explains the mechanism. Every clause earns its place; nothing is padded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a no-argument, no-annotation, no-output-schema read tool, the description conveys the essential outcome (status + version). It is nearly complete, though an agent gets no hint of what fields come back or how the composite behaves if one underlying call fails.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there are no parameter semantics to explain; the baseline for a 0-param tool applies. Nothing in the description misleads about inputs.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: retrieving NapCat OneBot 11 runtime status and version info. It also discloses the underlying composition (get_status + get_version_info), which is unusually informative. It stops short of 5 because it never distinguishes itself from the sibling check_napcat_environment, which an agent could plausibly confuse with this tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives. The closest sibling, check_napcat_environment, is left unaddressed even though it sounds like a competing way to inspect NapCat health, leaving the agent to infer the boundary.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations present, the description carries the full burden, and it does disclose the meaningful behavior that the result is either a direct download URL or a local cache path. However, it omits whether the call requires the file to still exist, permission/auth requirements, or expiry/rate-limit behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in a single clear clause and the size is appropriate. The embedded Sphinx-style ':param' docstring is redundant with the schema and slightly clutters the sentence, but it is not a structural problem.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter getter with no output schema, the description is nearly complete: it names what is returned. It still lacks the origin of file_id and the private-vs-group distinction, and with no annotations those gaps are not covered elsewhere.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the single file_id parameter is already documented in the schema, and the description merely repeats ':param file_id: 私聊文件 file_id'. It adds no format, source, or validation detail beyond the schema, which is the expected baseline when the schema does the work.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (获取) and resource (私聊文件的直接下载链接或本地缓存路径), so an agent knows it retrieves a download link or cache path for a private-chat file. The 'private' scope implicitly distinguishes it from the sibling get_group_file_url, though that alternative is never named.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance, no prerequisites (e.g. that file_id comes from a received message), and no reference to the group-file sibling. The agent must infer context entirely.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It usefully scopes the return (recent friends, groups, latest message summaries) and flags it as a NapCat extension interface, but says nothing about auth/login requirements, ordering, or pagination behavior for a read endpoint.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the purpose, which is good, but the ':param count' line duplicates the schema verbatim and '最近联系列表 / 最近会话列表' is a near-synonym pair, so there is mild redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-required, one-parameter read tool this is adequate, but with no output schema the description should more concretely describe the shape of returned entries (fields per contact/conversation) rather than only naming the categories.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the sole parameter (count, default 20) is fully documented in the schema. The description merely restates the same :param line, adding no semantics beyond what structured data already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('获取...最近联系列表/最近会话列表') and clarifies the payload covers both friends and group chats with latest message summaries. It is distinguishable from sibling get_recent_messages, but the description never explicitly contrasts itself with it or with get_friend_msg_history/get_group_msg_history.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance and no alternatives named. An agent cannot tell from the text whether get_recent_contact should be preferred over get_recent_messages or get_friend_list for the same conversational intent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, and it does disclose meaningful behavior: messages are captured live over WebSocket and served from a backend cache, implying freshness limits and possible buffer bounds. However, it never states how far back the cache reaches, whether the buffer is cleared (a sibling clear_recent_messages_buffer exists), or the ordering of results — gaps that matter for a read tool with zero annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The opening sentence is well front-loaded and informative, but the five :param: lines duplicate the input schema verbatim, adding bulk without value. Roughly half the description is redundant repetition of structured fields.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 5-parameter, no-output-schema, no-annotation tool, the description covers purpose, data source, and filtering but omits return shape, result ordering, and the cache's time/size bounds. Adequate to call the tool, but not enough to predict what comes back.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the description's parameter block simply restates the same text (count, chat_type, target_id, keyword, include_self_sent). It adds no new syntax, format, or interaction detail beyond what the schema already documents, so baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb+resource (获取近期 QQ 消息列表) and adds an important qualifier: the data comes from a WebSocket real-time listener cache in the MCP backend, which distinguishes it from server-side history APIs. It stops short of naming the sibling it competes with (get_friend_msg_history / get_group_msg_history), so differentiation is implied rather than explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It lists supported filters but never says when to use this tool versus get_friend_msg_history, get_group_msg_history, or get_recent_contact. No prerequisites, exclusions, or alternative-selection criteria are given, leaving the agent to infer that 'recent cached' is the distinguishing condition.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that events are captured in real time and held as a recent buffer, and that returned items carry a flag field, but it says nothing about buffer lifetime, whether reading consumes/clears events, ordering, or the fact that a sibling (clear_recent_messages_buffer) exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core purpose is front-loaded in the first sentence and the flag-to-approval linkage follows logically, with no filler. The only flaw is the leftover ':param count:' docstring marker embedded in prose, which is a minor formatting artifact rather than wasted content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations and no output schema, the description must explain both behavior and returns. It does describe the kinds of events and the flag field, but leaves out buffer scope, whether results are paginated or capped by the count parameter (beyond restating the default), and whether events persist across calls.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the single count parameter is already fully documented. The description's trailing ':param count: 最大返回条数，默认 20' merely repeats the schema text verbatim and adds no new semantics; baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: retrieving recent group notification events (file upload, recall, mute, member changes) plus friend/group add-verification requests. It is concrete about the payload categories, but it does not distinguish itself from siblings like get_group_system_msg, get_recent_messages, or get_recent_contact, which an agent could plausibly confuse it with.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It establishes a useful downstream workflow by naming set_friend_add_request and set_group_add_request as consumers of the returned flag field, which is real routing value. However, it never states when this tool is the right source versus get_group_system_msg or get_recent_contact, and there are no exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It implies read-only retrieval and mentions a no_cache option, but it does not disclose permissions, rate limits, error behavior, or what happens when no_cache is used beyond restating the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the tool's purpose and then lists returned fields and parameters. It is reasonably concise, though the parameter notes duplicate the schema and add little new information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only profile lookup with no output schema, the description helpfully lists the returned fields and covers both parameters. It is largely complete for calling the tool, though it lacks explicit output shape and behavioral caveats.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so both parameters are already documented in the input schema. The description restates 'user_id' and 'no_cache' without adding format, constraints, or behavior beyond what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource: fetching the public profile of a specified QQ user (friend or stranger), with example fields like nickname, gender, age, level, and signature. It is distinct from most siblings, but it does not explicitly differentiate itself from related tools such as get_group_member_info or get_friend_list.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no when-to-use guidance, no prerequisites, and no alternatives to consider. It says what the tool does but not when an agent should choose it over sibling tools like get_group_member_info or get_friend_list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, and it does disclose the return content categories, which is valuable given there is no output schema. It also surfaces the behavioral trait that listed accounts support QR-free switching. It omits any explicit read-only/safety statement or freshness caveats, but the 'view/list' framing makes the read nature unambiguous.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with what the tool returns and followed by the actionable next step. No filler or repetition; every clause carries a distinct fact (accounts, default account, online account, switch linkage).

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter read tool with no annotations and no output schema, the description fully covers what an agent must know: the absence of inputs is moot, and the missing output schema is compensated by an explicit enumeration of the returned account categories plus the switch workflow.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing to disambiguate and the baseline is 4. No parameter description is needed or expected here.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('view' a list of QQ accounts) and enumerates the three distinct data categories returned: saved-credential accounts, the default active account, and the currently online account. An agent can understand the scope without opening any schema, and switch_qq_account is named for differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The second sentence gives a clear downstream workflow: accounts in this list can be brought online via switch_qq_account without a QR scan, which tells the agent when this tool is the right entry point. It stops short of explicit when-not-use conditions or prerequisites, so it is clear context rather than full routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the behavioral burden. It discloses the catalog nature and its scale (140+), implying a read-only lookup, but never states that it is side-effect free, nor how results are grouped/returned. Adequate but leaves the safety profile to inference.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The first sentence is well front-loaded, but a raw Sphinx-style ':param category:' directive has leaked into the description text, which is a structural artifact rather than clean prose. Still short and readable overall.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a one-optional-param catalog tool with no output schema, the description tells the agent what is returned (action name directory) and its size. Minor gaps remain (whether results are grouped by category, whether descriptions accompany names) but nothing critical for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the description's category text is an exact duplicate of the schema enum, adding no format, default, or behavioral detail beyond it. Baseline 3 applies when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (列出/list) and resource (NapCatQQ 官方引擎支持的全部 140+ 个底层 Action 名称目录), and quantifies the scope. It explicitly positions itself relative to the sibling call_napcat_api, so an agent can distinguish it without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The clause '方便在使用 call_napcat_api 前查阅精确的接口名' clearly names the alternative tool and the condition that selects this one. It gives positive routing context but no explicit exclusions or negative guidance, so it falls short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so well: it discloses that the flow stops the running NapCat process, wipes auto-login config, generates qrcode.png, pops up the image, waits for a scan, then writes OneBot 11 port config and switches to a background daemon. These are exactly the destructive and side-effecting traits an agent must know before invoking.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the purpose, then uses a numbered execution flow that is easy to scan. The trailing :param lines duplicate the schema rather than adding value, which is the only real waste in an otherwise well-structured description.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex multi-step, side-effecting login operation with no output schema, the description covers prerequisites, side effects, timing, and the resulting port configuration. It does not say what the tool returns on success/failure, which is a minor remaining gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the two params (open_image default true, wait_scan_seconds default 45) are already fully documented in the schema; the description repeats them nearly verbatim. No additional syntax or behavioral meaning is added, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: starting a new QQ account QR-code login flow. The parenthetical narrows the scenario (binding a new QQ or re-scanning when old credentials expire), which separates it from siblings like switch_qq_account and get_login_qrcode_image without needing to open any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when to use it: binding a new QQ account or re-authenticating when existing credentials have expired. It gives clear triggering conditions but does not name alternative tools (e.g., switch_qq_account) that an agent might otherwise consider, so this lands just under the top band.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations at all, the description carries the full behavioral burden, yet it only states the mutation and the wrapped interface names. It does not disclose side effects (e.g., whether clearing one message also clears the session's unread badge), permission requirements, idempotency, or failure behavior for an all-optional-parameter mutation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core action is front-loaded in a single clear sentence, and the trailing :param lines are compact. They are, however, pure duplication of the schema descriptions, which slightly dilutes the value of the text.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a three-parameter mutation with no annotations and no output schema, the definition covers the action and targeting options but omits what the tool actually does when multiple or zero of the optional parameters are provided, and what effect/return the caller should expect.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters, and the description's parameter lines are verbatim duplicates of those descriptions. Baseline 3 is appropriate since no additional semantics (mutual exclusivity, precedence, defaults) are added.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: mark a message, private chat, or group chat as read, and names the three underlying NapCat interfaces it wraps. No sibling in the list performs a read-state mutation, so the agent can place it easily, though it does not explicitly say how it differs from read-only siblings like get_msg.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied through the parameter descriptions (message_id for a single message, user_id for a private chat, group_id for a group chat). There is no explicit statement of when to prefer one targeting mode, what happens if multiple or no parameters are supplied, or any prerequisite context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It discloses the engine (QQ 内置 OCR) but says nothing about return format, accuracy, size limits, failure behavior, or whether the operation is read-only. For a tool with zero structured hints, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The first sentence is tight and front-loaded, but the second sentence is a verbatim repeat of the schema's parameter description, complete with Sphinx-style ':param' markup that leaks authoring artifacts into agent-facing text. Partly efficient, partly redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema and no annotations, so the description should ideally cover the return shape and constraints. It establishes the what and the input format adequately for a one-parameter tool, but omits any notion of what the OCR call returns, leaving it only minimally complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the single parameter is already fully documented by the schema. The description merely restates the identical text (file ID, local absolute path, or HTTP URL), adding no syntax or format nuance beyond the schema. Baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource in Chinese — calling QQ's built-in OCR engine to recognize text in images — and identifies the underlying NapCat OneBot 11 action. No sibling performs OCR, so the purpose is unambiguous even without an explicit contrast sentence.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g. whether the image must be accessible to the NapCat host), and no exclusions. The agent is left to infer everything about invocation context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations present, the description carries the full behavioral burden. It does disclose one useful trait beyond the schema: it blocks/wait until the port is listening ready, via wait_seconds, implying the restart is not instantaneous. However it omits what happens to in-flight connections, existing sessions, or the failure mode if the process does not come back up.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in a single clear sentence, which is good. But the trailing ':param ...' lines duplicate the input schema word-for-word, adding length without adding information, so structure is only adequate.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a disruptive restart tool with no annotations and no output schema, the description covers the action and its blocking wait but omits permissions/auth requirements, failure behavior, and the effect on active sessions or logins. It is minimally sufficient to call but not complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters, and the description only restates them verbatim (':param uin:' / ':param wait_seconds:') with no added format, constraint, or fallback semantics. Baseline 3 applies when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource: '强制重启本地 NapCat 后台服务进程' (force-restart the local NapCat backend service process). It clearly reads as a restart action, which an agent can distinguish from start/stop siblings by the verb. It stops short of explicitly contrasting itself with start_napcat_service/stop_napcat_service, so it is not a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use or when-not-to-use guidance is given. It never says when a restart is preferable to stop+start, or what state triggers a restart, and no prerequisite conditions are mentioned. The only conditional content is the optional uin parameter, which is usage of a parameter, not guidance on tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden but only implies a write/mutation via '发送'. It discloses nothing about permissions, rate limits, failure behavior, or whether the forward is persisted, leaving the safety and side-effect profile unspecified.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded, followed by the node format example, then param docs. The param lines largely restate the schema, but the format example earns its place and the whole entry is compact.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a send tool with no output schema and no annotations, the key complexity—the node array format—is covered, along with the target group. Missing details about the return value and error handling are minor given the format example is the main callability hurdle.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and both params are documented, but the schema's messages.items is an empty type {}, so the description's concrete node example ({type, data:{name, uin, content}}) supplies the array element structure the schema omits. That is genuine added value beyond the baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: sending a merged/combined forward message to a specified group chat, tied to the NapCat OneBot 11 action. '群聊' and '合并转发' implicitly separate it from send_group_msg and send_private_forward_msg, though no sibling is named explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance is given, and no alternatives are mentioned. An agent must infer that this differs from send_group_msg or send_private_forward_msg purely from the tool name, with no exclusions or prerequisites stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It usefully discloses CQ-code support and the auto_escape plain-text mode, but says nothing about permissions, rate limits, what happens on failure, or the return value (e.g., message_id) of a send operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in the first sentence, followed by the supported message formats. The trailing :param block largely duplicates the schema, which is mild redundancy, but overall the text is efficient and well-ordered.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 3-parameter mutation tool with no annotations and no output schema, the description covers message formatting well but omits the return contract (message identifier) and error/edge behavior. Adequate but with clear gaps for correct invocation handling.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters. The description's :param lines simply restate the schema descriptions verbatim, adding no syntax or format detail beyond it — baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('向指定 QQ 群发送群聊消息') with the underlying OneBot 11 action named, so an agent immediately knows what it does. It does not explicitly distinguish itself from close siblings like send_msg or send_group_forward_msg, so it stops short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the name and description (send a message to a group), but there is no explicit when-to-use guidance and no routing to alternatives such as send_msg (unified) or send_group_forward_msg (forwarded content). An agent must infer the choice from sibling names alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It mentions the action and the times range/default, but does not disclose side effects, permission requirements, rate limits, or what happens on repeated calls. This is minimal for a side-effecting action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short and front-loads the purpose, followed by parameter notes. The parameter lines largely repeat the input schema, which slightly reduces efficiency, but the overall text is concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple two-parameter action with full schema coverage and no output schema, the description covers the basic call requirements. However, it leaves behavioral context and usage routing to the agent, so it is adequate but not complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description duplicates the schema parameter descriptions exactly and adds no extra meaning or format details beyond what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: liking a specified friend's profile card, and identifies the underlying OneBot 11 action 'send_like'. It does not explicitly distinguish this tool from similar siblings such as set_msg_emoji_like or send_poke, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. The implied usage is simply that it likes a friend's profile card, but no routing information is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It states the operation is a message send but discloses nothing about rate limits, permissions, return values, or side effects for a mutation tool. The only behavioral hint (message_type drives routing) is already implied by the parameter set.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose sentence is reasonably front-loaded, but the four :param lines duplicate the input schema one-for-one and inflate the definition without adding information. This redundancy costs structure quality.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

A mutation tool with no annotations and no output schema should describe behavioral traits (permissions, return shape, failure modes) in the description. It instead only restates parameters, leaving the behavioral burden unmet for an agent deciding how to call it safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all four parameters. The description's :param blocks merely repeat the schema text verbatim, adding no syntax, format, or edge-case detail beyond it. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a verb and resource ('通用消息发送接口' / send_msg) and explains it sends private or group messages based on message_type. However, it is a generic framing that fails to differentiate from siblings send_private_msg and send_group_msg, which do the same thing with a fixed type.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance and no mention of the specialized siblings (send_private_msg, send_group_msg). The agent must infer when the general send_msg is preferable to the dedicated tools, which is exactly the ambiguity this field should resolve.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It discloses the two delivery modes and that this is a NapCat extension interface, but says nothing about rate limits, permission requirements, failure modes (e.g., non-friend target), or whether the recipient is notified.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core purpose and the mode-selection rule are front-loaded in the first two clauses, which is efficient. The trailing ':param' lines duplicate the schema descriptions and add some redundancy, but overall it is short and readable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple two-parameter interaction tool with no output schema and no annotations, the description covers the essential calling logic (mode selection). Return values need not be explained without an output schema, but failure conditions and prerequisites remain unaddressed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and both parameters are already fully documented in the schema. The description merely restates the same parameter text ('要戳的目标 QQ 号', '所在群号 (可选，不填则为私聊戳一戳)') without adding syntax, constraints, or format details beyond it, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb and resource ('发送戳一戳互动提醒') and immediately clarifies the two operating modes (group vs. private) based on group_id. It is unambiguous against most siblings, though it never explicitly contrasts itself with related interaction tools like send_like or send_group_msg.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It states the conditional that selects group vs. private behavior ('若提供 group_id 则在群内戳指定成员；若不提供则发送私聊戳一戳'), which is genuine usage guidance. However, there is no guidance on when to prefer this over alternatives (send_like, send_msg) or any prerequisites such as needing an existing friend/group relationship.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It is a mutation tool, yet nothing is said about permissions, rate limits, whether the message is reversible, or what the return value looks like. The node format example is useful but is structural, not behavioral.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded and the example is valuable, but the trailing ':param' lines merely restate the schema descriptions verbatim, adding length without new meaning. The OneBot 11 action-name reference is only marginally useful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool whose only real complexity is building the nested node array, the inline example makes it callable. However, with no annotations and no output schema, the description should at least hint at success/failure behavior or the result shape, and it does not.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline would be 3. However, the description goes beyond the schema by supplying a concrete node format example ('[{type: node, data: {name, uin, content}}]'), which is genuinely needed to construct the 'messages' array that the schema leaves as an untyped items:{} list. This adds real construction value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource ('向指定好友发送合并转发消息' – send a merged forward message to a specified friend), which inherently distinguishes it from send_group_forward_msg (group) and send_private_msg (single message). It does not explicitly name those siblings, but the scope is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance, and no alternatives are named. An agent must infer that this is the tool for multi-node merged forwards to friends versus send_private_msg for single messages, but the description never states that.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries the burden. It usefully discloses that the message body supports text and CQ codes and what auto_escape does, but it says nothing about failure modes (e.g. non-friend targets), rate limits, or what is returned. Partial behavioral coverage only.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose and the upstream action name are front-loaded in the first sentence, and the CQ-code support is called out early. The subsequent ':param' lines largely duplicate the schema descriptions, which is mild redundancy but not verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations and no output schema, the description should say more: it never explains that a successful call returns a message_id, nor any error/permission behavior for a mutation-style tool. Core calling information is present, but important operational context is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents user_id, message and auto_escape; the docstring lines restate them nearly verbatim. The only added value is the concrete CQ-code example format, which is minor. Baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('向指定好友或用户发送私聊消息') and names the upstream OneBot 11 action, so the agent can tell it apart from send_group_msg by the '私聊' scope. It does not explicitly name the sibling to prefer/reject, so it falls just short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by '私聊' (private vs group) and by the required user_id, but there is no explicit when-to-use/when-not guidance and no mention of prerequisites such as being friends with the target. Adequate but leaves the agent to infer routing between this and send_group_msg/send_msg.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It notes the tool is a NapCat extension interface but does not disclose permission requirements, idempotency, error behavior, or reversibility for this mutation. That is a significant gap for a write operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core purpose sentence is front-loaded and efficient, but the trailing ':param message_id' line duplicates the schema description verbatim and earns no place. Slightly redundant rather than maximally tight.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations and no output schema, the description is too thin. It omits permission requirements, side effects, and failure modes, leaving the agent without enough to invoke it confidently.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already fully documents the single parameter. The description merely repeats the same text ('要设为精华的消息 ID') and adds no new syntax, format, or constraint details. Baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: setting a specified group message as an essence message, with the NapCat extension API name. It is clearly distinguishable from siblings like delete_essence_msg and get_essence_msg_list, though it does not explicitly name those siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this versus alternatives such as delete_essence_msg or get_essence_msg_list, and no stated prerequisites (e.g., admin/owner permission required to set an essence message). Usage must be inferred entirely.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It conveys that approve=false rejects and that remark is applied after approval, but says nothing about permissions, whether a rejection is final/irreversible, or what happens to the pending request state.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in a single clear sentence, and the docstring-style parameter lines are compact. The :param lines duplicate the schema descriptions, which is mild redundancy rather than bloat.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations and no output schema, the description should disclose the mutation's safety profile and expected result, and it only partially does so. It is adequate for a simple 3-parameter approval action but leaves the agent guessing about reversibility and the return value.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the description merely restates the same per-parameter text verbatim (flag, approve, remark). It adds no format, source, or constraint detail beyond the schema, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource: approving/handling incoming friend-add requests, with the OneBot 11 action name given for traceability. It is clearly distinguishable from the sibling set_group_add_request by resource (friend vs group), though it does not explicitly name that sibling.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied: you call this when you have a pending friend request and want to accept or reject it, and the 'flag' note hints it comes from an event report. However, it never names where to obtain the flag (e.g. get_recent_notices_and_requests) or states any when-not conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It states a mutation ('设置或修改') but doesn't disclose permissions required, reversibility, rate limits, or whether the remark can be cleared.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core sentence is efficient and front-loaded, but the inclusion of ':param' lines duplicates schema content and the '(NapCat 扩展接口)' parenthetical adds little for an agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with zero annotations and no output schema, the description omits prerequisites, permission needs, and error behavior. It is not complete enough for reliable invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the description repeats the same param docs ('好友 QQ 号', '新备注名称') without adding format, constraints, or edge cases. Baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: '设置或修改指定好友的备注名' (set or modify a friend's remark name), which is unambiguous and distinguishable from siblings like set_group_card or set_qq_profile.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this versus alternatives such as set_group_card or set_self_longnick. It implicitly handles friend remarks only, but exclusions and context are absent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It is a mutating, effectively irreversible approval action, yet it says nothing about required permissions (admin/owner), what happens on approval, or error behavior. It only clarifies the approve/reason interaction, which is already in the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The opening sentence is appropriately front-loaded, but the following four lines duplicate the schema's parameter descriptions word-for-word, which is wasted space given 100% schema coverage.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutating tool with no annotations and no output schema, the description leaves out the key operational context: where the flag comes from and what permissions are needed. It is not complete enough for an agent to invoke it correctly in a real flow.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all four parameters. The description merely restates the same parameter text verbatim, adding no new syntax, format, or sourcing information for 'flag'.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: approving/handling group join requests or group invite requests, and names the OneBot 11 action. It is clearly distinguishable from the sibling set_friend_add_request by the 'group' resource, though it never explicitly calls out that distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives, nor on the prerequisite that a 'flag' must first be obtained from an event report (e.g. get_group_system_msg / get_recent_notices_and_requests). The agent is told what the params are but not the workflow context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It usefully discloses the group-owner authorization requirement, but for a mutating tool it says nothing about reversibility, effect on the target member, failure modes, or whether the target must already be in the group.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose and permission requirement are front-loaded in the first two sentences, and the whole definition is short. The trailing ':param' lines duplicate the schema, which is mild waste, but nothing is padded or meandering.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema and no annotations, so the description must carry the behavioral load. It covers identity, permission, and the enable flag, but omits return/failure behavior and edge cases for a mutation tool — adequate but with clear gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the description's param lines ('群号', '目标成员 QQ 号', 'True 设为管理员，False 取消管理员') merely restate what the schema already documents verbatim. With the schema doing the heavy lifting, the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb pair and resource — set or revoke group administrator — plus the OneBot 11 action name, so the agent knows exactly what it does. It does not explicitly contrast itself with nearby siblings such as set_group_special_title or set_group_ban, but the overlap risk is low, so 4 rather than 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

'需群主权限' gives a real precondition (group-owner permission) that helps the agent decide whether the call can succeed. However, there is no explicit when-to-use vs alternatives guidance or exclusion conditions, so this lands at implied rather than stated usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It does disclose the key behavioral fact that duration=0 lifts the ban and the default is 1800 seconds, which is genuinely useful. However, it omits permission requirements (admin/bot rights), what happens if the target is invalid or already banned, and rate-limit behavior for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The opening sentence is tight and front-loaded, but the trailing :param lines duplicate the input schema exactly, adding length without new information. Front-loading is good; the redundant parameter restatement costs it a point.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 3-parameter mutation tool with no annotations and no output schema, the description covers the core semantics (including the duration=0 unmute sentinel) but says nothing about permissions, error conditions, or response. Adequate but with clear gaps an agent would want filled.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters, and the description's :param block repeats them verbatim with no added syntax or format detail. Baseline 3 applies when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: single-member mute/unmute in a group chat, and references the OneBot 11 action name. The word '单人' (single person) implicitly distinguishes it from the whole-group ban sibling set_group_whole_ban, so an agent can route correctly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the description ('mute or unmute a member'), but no explicit when-to-use guidance, no prerequisites, and no named alternatives are given. The contrast with set_group_whole_ban must be inferred from the word '单人'.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden for a mutation tool. It discloses one useful behavioral trait — an empty string clears the card — but that same note is already in the schema, and it says nothing about required permissions, whether the bot can rename itself or only others, or failure behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose is front-loaded in the first line, which is good, but the three ':param' lines duplicate the schema descriptions verbatim and consume most of the length without adding information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a three-parameter mutation tool with no annotations and no output schema, the description covers the action and its parameters but omits permission requirements and result semantics, leaving meaningful gaps for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so group_id, user_id, and card are all already documented in the schema. The description merely restates those same descriptions, adding no format, range, or edge-case detail beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: modifying a group member's card/nickname, and cites the underlying OneBot 11 action name. An agent can distinguish it from neighbours like set_group_name or set_qq_profile, though it doesn't explicitly contrast with set_group_special_title or set_friend_remark.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No statement of when to use this versus alternatives, no prerequisites (e.g. admin/owner rights needed to change another member's card), and no exclusions. Usage is only implied by the tool name and the param list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It usefully discloses the required authorization level and the side effect that reject_add_request can block future join requests, but says nothing about reversibility, failure behavior, or return format. Partial but meaningful disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Compact and front-loaded: the primary action and permission requirement come first, followed by parameter notes. The param lines duplicate the schema, which is slightly redundant but not wasteful enough to hurt much.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutating, no-annotation, no-output-schema tool, the description covers the action, the permission requirement, and one side effect. It is adequate but leaves gaps around failure modes and any output/confirmation, so it is complete only at a minimum-viable level.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description merely restates group_id, user_id, and reject_add_request, adding no syntax, constraints, or format detail beyond the structured fields. Baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: remove a designated member from a group chat (kick). The action is unambiguous and distinguishable from set_group_leave (self-leave) by its member-targeting semantics. However, it does not explicitly name or contrast a sibling tool, so it stops short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It states a prerequisite (requires admin or group-owner permissions), which implies when the call is valid, but gives no explicit when-to-use vs when-to-avoid guidance and names no alternative (e.g., set_group_ban for temporary removal). Usage context is implied rather than spelled out.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the owner-only precondition for is_dismiss, but omits that this is an irreversible self-removal/mutation, whether the bot loses access to the group afterward, or any permission/error behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the action and the API reference, then the params. It is short and readable, though the :param block is pure duplication of the schema and earns no extra value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a two-parameter destructive tool with no annotations and no output schema, the description covers purpose, params, and one precondition. It still leaves the agent guessing about reversibility, side effects on group membership, and failure modes.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the two :param lines simply restate the schema descriptions verbatim, adding no new syntax, ranges, or edge cases. Baseline 3 applies when the schema already does the documenting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource pair with two clear modes: leaving a group or dismissing it, and names the underlying OneBot action. It is distinguishable from write-oriented siblings like set_group_kick, but it does not explicitly contrast itself with any of them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the two named modes (leave vs. dismiss), and it adds one real precondition — dismissal only works when the caller is the group owner. It does not say when to prefer this over related tools such as set_group_kick or set_group_ban.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It says nothing about required privileges, whether the change is reversible, what happens on failure (e.g. insufficient permission or invalid name), or rate limits — significant gaps for a group-mutating action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose is front-loaded in one short line, which is good, but the trailing ':param' lines simply duplicate the schema descriptions and consume space without adding information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a write operation with no annotations and no output schema, the description omits everything behavioral: permission requirements, failure modes, and side effects on group members. The schema covers the inputs, but the description leaves the operation opaque.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and both params carry identical text ('群号', '新群名称') in the description, so the description adds no meaning beyond what the schema already provides. Baseline 3 applies when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: '修改 QQ 群名称' (modify QQ group name), plus the underlying OneBot 11 action name for reference. It is distinct from nearby siblings like set_group_card, set_group_admin, or set_group_portrait, though it never explicitly says so.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool, what preconditions apply (bot must be owner/admin), or what alternative exists for renaming other entities. The agent gets no context beyond the bare action.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It reveals nothing about required permissions, whether the change overwrites an existing portrait, rate limits, or the response on success/failure for what is clearly a mutation operation — a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in one clear line, but the two ':param' lines duplicate the schema descriptions verbatim, adding length without information. It is compact but partly redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations and no output schema, the description is too thin: it omits permission requirements, overwrite behavior, and expected outcomes. The parameter details it does include only repeat the schema, leaving real behavioral questions unanswered.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the description merely restates the same parameter text already present in the schema for both group_id and file. It adds no meaning beyond what the structured schema documents, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource ('修改 QQ 群头像') and cites the exact OneBot 11 action name, so an agent knows this sets a group's avatar. It doesn't explicitly distinguish itself from the sibling set_qq_avatar (personal avatar), leaving that inference to the agent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives, nor any prerequisites (e.g., admin/bot permission needed to change a group avatar). Usage is entirely implied by the name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does disclose the group-owner permission requirement plus the empty-string-cancels semantics and the -1=permanent default. It omits failure behavior, whether existing titles are overwritten, and any rate limits, so the disclosure is partial.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose line is front-loaded and efficient, but the four :param lines duplicate schema text word-for-word, which is pure redundancy rather than conciseness. The useful permission and cancel-semantics notes are buried in the schema echo rather than stated up front.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 4-parameter mutation with no annotations and no output schema, the description covers the essentials: permission requirement, required vs optional params, and the meaning of cancel/permanent values. Return values are not described but the tool's contract is otherwise adequately specified.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the description's :param lines are verbatim repetitions of the schema descriptions, adding no syntax, format, or edge-case meaning beyond them. Baseline 3 applies when the schema already does the work.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('设置群成员专属头衔') and cites the OneBot 11 action name, so the agent knows it targets a group member's honorific rather than a card, admin flag, or group name. The unique resource makes it distinguishable from siblings, though it never names a sibling explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

States a prerequisite ('需群主权限'), which implies who may call it and under what condition. It does not, however, tell the agent when to prefer this over adjacent tools like set_group_admin or set_group_card, or what to do if permission is lacking.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.