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

No annotations are present, so the description carries the full burden of behavioral disclosure. 'Assert' implies a check and potential failure, but the description does not state whether it throws, returns a result, waits, or has side effects. An agent cannot predict the tool's runtime behavior from this text.

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 a single short phrase, which is under-specification rather than conciseness. It provides no structural information, front-loading, or elaboration that would help an agent decide or invoke the tool, and it barely surpasses restating the tool name.

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?

Given the complexity of the target parameter (with ref vs path locators, multiple selector kinds, and max depth of 16), the description is critically incomplete. It omits behavior, return semantics, and any advisory on constructing valid locators, so an agent lacks essential information for reliable invocation despite the output schema being present.

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 phrase 'element attribute value' loosely maps to the three parameters (target, attributeKey, attributeValue), but adds no detail about locator formats, value matching rules, or relationships. With schema description coverage at only 67%, the description should compensate for the gaps but does not, leaving the agent reliant solely on 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 ('断言'/assert) and resource ('元素属性值'/element attribute value), which clearly separates it from sibling tools like assert_text and assert_state. However, it is extremely terse and does not elaborate on the semantics beyond a direct restatement of the tool's name, so it only partially earns 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?

There is no guidance about when to use this tool versus alternatives, nor any exclusions or context. The description gives no hint about the intended scenario (e.g., in a test flow versus runtime validation) or how it differs from assert_text or get_value.

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 check, but it does not disclose whether the tool returns a boolean, throws on failure, retries, waits, or what happens on mismatch. This is a significant gap for an assertion 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 description is a single compact sentence with no redundant content. It is appropriately short, though the phrase '各种状态' is vague and slightly under-informative.

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?

The tool has a complex nested target schema and no annotations, yet the description only says 'assert various states of the element.' It does not enumerate the states, mention the locator mechanics, or clarify assertion behavior. This is incomplete for an agent to call the tool correctly.

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 80%, and the schema already explains target, checked, enabled, focused, and visible. The description adds no extra parameter meaning, but at high schema coverage 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 clear verb ('断言' / assert) and resource ('元素' / element), and the scope is '各种状态' (various states). This distinguishes it from assertion siblings focused on attributes or text, though it does not explicitly name them or enumerate the states.

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 guidance on when to use this tool versus alternatives like assert_attribute or assert_text. No exclusions, prerequisites, or sibling comparisons are given; the agent must infer usage entirely from the tool name and 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 of behavioral disclosure. It only states that text content is asserted, but does not explain what happens on mismatch, whether the assertion waits for a condition, whether it throws, or whether it supports the different matching semantics visible 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 description is extremely short, which is concise, but it is under-specified rather than efficiently informative. It does not earn its place because it adds almost no information beyond the tool name, lacking the specifics that would justify its existence.

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?

This is a complex tool with a rich target schema and three distinct text-matching modes, yet the description provides none of that context. With no annotations and no behavioral guidance, an agent cannot fully understand how to construct a correct call from the description alone.

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 high (75%) and the parameters text, textMatches, textContains, and target all have meaningful descriptions. The tool description itself adds no parameter-level meaning, but the baseline of 3 is appropriate since the schema already documents the parameter semantics adequately.

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 '断言元素文本内容' ('assert element text content') is essentially a direct restatement of the tool name assert_text, adding only the word 'element'. It does not differentiate the tool from siblings like assert_attribute or assert_state, and it does not mention the important matching modes (exact, regex, contains) that the schema exposes.

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 mention of prerequisites, and no exclusions. The description simply states the action without any context that would help an agent select it over assert_attribute, assert_state, or wait_for.

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 disclosure burden. It only says 'click', without stating whether the action waits for navigation, scrolls elements into view, fails on missing targets, or has any side effects. For a tool that can trigger page changes, 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 a single, terse Chinese sentence with no extraneous words. It front-loads the action and object. However, the brevity borders on under-specification, but for pure conciseness it earns a high score.

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?

Given the tool's moderate complexity (nested target schema, multiple target kinds, double-click flag) and no annotations, this description is not complete enough. It does not explain the different target kinds (ref vs. locator path), when dblClick should be used, or what the output schema contains. The presence of an output schema reduces some burden, but the behavioral and usage gaps remain substantial.

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 description adds no meaning beyond the schema. It merely references 'target' while the schema already documents the target structure (ref, path, element selectors) and dblClick. With schema description coverage at 50%, the description should compensate for undocumented parameters, but it does not explain how to choose between ref and path or how dblClick alters behavior.

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 '点击指定 target 的页面元素' clearly states the action (click) and the resource (page element of the specified target). It distinguishes itself from siblings like input_text, navigate_to, and evaluate_script, which have different actions. However, it does not mention the double-click capability or any scope detail (e.g., current page), though the schema provides these.

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 mention of prerequisites, when clicking is appropriate (e.g., after a page snapshot), or when to prefer other tools like set_form_control or evaluate_script. The description leaves all usage decisions to the agent's inference.

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 does disclose the significant project-side effect of launching before connecting, but it omits what happens on failure, whether the connection is persistent, how healthCheck behaves, or whether reconnect is expected to follow. This is a meaningful gap for a connection 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 description is short with no filler and front-loads the core purpose. However, it is a single terse sentence for a tool with a four-variant target union and two optional behavior-controlling parameters, so brevity comes at the cost of under-specification.

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 connection tool with no annotations, no schema descriptions, and four target kinds, the description is incomplete. It does not cover how to invoke the non-project variants, what timeoutMs and healthCheck do, or how this connects to the broader lifecycle managed by sibling tools.

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 0%, and the description only hints at the project target variant with 'project 固定按 launch → connect 尝试'. It does not explain the target union (project, wsEndpoint, browserUrl, discover), timeoutMs, or healthCheck, so the schema remains the only source and it has no descriptions.

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 clearly states the action and resource: connecting to an explicit WeChat Developer Tools target, with a specific behavioral note that project targets follow a launch-then-connect flow. It is reasonably distinct from siblings like reconnect_devtools, though it does not explicitly name or contrast 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?

The description gives no explicit guidance on when to use this tool versus reconnect_devtools, disconnect_devtools, or get_connection_status. The phrase 'explicit target' implies a scope, but there are no exclusions, prerequisites, or alternative-tool routing.

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 of behavioral disclosure. It mentions the disconnect and context cleanup but does not disclose side effects, idempotency, reversibility, or whether an active connection is required. This is insufficient for a state-changing tool with zero annotation support.

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 a single, front-loaded sentence with no repetition or filler. Every word contributes to stating the tool's purpose, making it appropriately 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?

The tool is simple (no parameters, output schema present), so the description's core statement of disconnecting and cleaning up context is mostly sufficient. However, it lacks context about preconditions (e.g., must be connected) and possible error behavior, leaving some ambiguity for an agent deciding when to call it correctly.

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 has zero parameters, so the baseline score is 4. There is nothing for the description to add about parameter semantics; the schema already confirms an empty parameter set.

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 is a specific verb+resource+effect: it disconnects from WeChat Developer Tools and cleans up context state. It clearly distinguishes itself from sibling tools like connect_devtools and reconnect_devtools by naming the exact action and resource.

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 only states what the tool does; it gives no guidance on when to use it versus alternatives. It does not mention prerequisites, typical scenarios, or exclusions such as 'use reconnect_devtools to restore'. No explicit when/when-not guidance 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?

With no annotations, the description carries the full burden of behavioral disclosure. It discloses the execution context, supported globals, and the JSON-serializable return requirement, which are useful. However, it does not mention potential side effects of arbitrary code execution (e.g., modifying storage or app state), error handling, or timeout behavior, which are significant for a code execution 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 description is concise and front-loaded: the first sentence states the action and result, the second lists accessible globals, and the third sets the return type. Every sentence adds value and there is no redundancy or filler.

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?

The tool is moderately complex (arbitrary code execution) but the schema descriptions are rich (100% coverage) and an output schema exists, so the description need not explain return structure. The description covers the essential execution context, supported globals, and serialization requirement. It falls short only in not addressing side-effect risk and use-case guidance, but overall it is sufficiently complete 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 input schema already provides detailed explanations for both 'args' and 'function', including examples and constraints. The tool description adds context about the AppService environment and return constraint but does not add per-parameter semantics beyond what the schema provides, so the baseline score 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 clearly states a specific verb ('执行' / execute) and resource ('小程序 AppService 上下文' / mini-program AppService context), and explains it returns results. This distinguishes it from sibling tools like click, get_value, and navigate_to which handle UI or state, not arbitrary code execution.

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 implies usage for executing JavaScript logic in the mini-program environment and lists accessible globals, but it does not explicitly state when to use this tool versus alternatives or provide exclusions. There is no reference to sibling tools or conditions that would route an agent to this tool over others.

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 adds useful behavioral detail: lookup is scoped to Page root and returns an opaque ref rather than a value. It does not cover no-match behavior, multi-match indexing, or side effects, but for a read-only find operation this is a moderate 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?

One sentence, front-loaded with scope, then locator kinds, then return type; every phrase carries meaning. No redundancy or filler.

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?

The tool has a single, richly described locator parameter and an output schema, so the description only needs to convey purpose, scope, and return nature, which it does. Minor omissions—alternative guidance and edge-case behavior—do not block 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 coverage for the locator parameter is 0%, and the description compensates by enumerating the five accepted kinds (selector, id, testId, dataId, text). It does not mention variant-specific fields like index, exact, or tagName, though those are described in the input schema, so the addition is partial.

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?

Description names a specific verb ('查找'), object ('元素'), scopes it to 'Page 根作用域', lists five locator strategies, and states the result is an 'opaque ref'. This makes it distinguishable from value-returning siblings like get_value or get_page_snapshot.

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 clearly bounds usage to the Page root scope and enumerates the supported locator kinds, so an agent can infer when it applies. It does not explicitly name alternatives or exclusion conditions, but the scope and opaque-ref return type provide enough context to choose it over value-returning tools.

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 of behavioral disclosure. The verb '获取' implies a read operation, which suggests non-mutating behavior, but the description does not explicitly state that it is read-only or disclose whether the refreshHealth option causes side effects such as network calls or state changes.

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 a single concise sentence that front-loads the core purpose. Every element earns its place, and there is no redundant or filler 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?

The tool is simple, has an output schema, and the parameter is schema-documented, so the description need not explain return values or parameter syntax. However, it lacks any usage context, such as when to check connection status or how this relates to connection lifecycle siblings, leaving selection somewhat under-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%, so the single optional parameter refreshHealth is fully documented in the schema. The tool description adds no additional parameter-level meaning, but the baseline of 3 applies because the schema already explains the parameter's purpose.

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 clearly states a specific verb ('获取' / get) and the resource: connection, tool profile, and listener lifecycle status. This distinguishes it from sibling getters like get_current_page and get_value, which target different resources.

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 guidance on when to use this tool versus alternatives such as connect_devtools, disconnect_devtools, or reconnect_devtools. There is no mention of conditions, prerequisites, or exclusions, leaving the agent to infer appropriate use solely from 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses a meaningful side effect ('设置为活动页面') beyond what the name alone conveys. It does not explain what 'active page' means or what information is returned, but the output schema is available to cover return values.

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 concise Chinese sentence that front-loads the main action and then adds the side effect. Every word earns its place, with no redundancy or filler.

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?

Given zero parameters and the presence of an output schema, the description covers the core behavior and side effect adequately. The main missing detail is the semantics of 'active page' and how this relates to sibling page/snapshot tools, but that is a minor gap for this simple 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?

The input schema has zero parameters and schema description coverage is effectively 100%, so there is nothing for the description to add. The baseline of 4 applies because there are no parameter semantics to clarify.

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 ('当前页面信息'), and adds a distinct behavior ('设置为活动页面') that helps differentiate it from siblings like get_page_snapshot. It is clear about what the tool does, though it does not explicitly distinguish itself from related tools.

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 described behavior: call this when you want current page information and to mark it as active. However, it gives no explicit when-to-use guidance, exclusions, or alternatives, so an agent must infer the appropriate 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 behavioral disclosure burden. It adds useful context about default budget values (4/64/1000) and the non-mutating 'get' nature, but it does not mention possible side effects, error behavior, or what happens when root is omitted.

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 a single sentence with no filler, and it front-loads the default budget. It is concise, though the compactness leaves some important context unstated.

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?

Given the complex nested root schema and six optional parameters, the description is too brief to be complete. It omits guidance on when to use the path-based root, what the budget limits mean behaviorally, and how the snapshot relates to other debugging tools. The output schema covers return shape, but invocation context is incomplete.

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 only 33%, so the description must compensate. It does mention Page vs custom component and the default budget, which helps with root and budget, but it does not clarify format, filePath, includePosition, or includeAttributes semantics.

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 uses a specific verb and resource: it retrieves the V2 scopes/edges scope graph for a Page or custom component. It is clear about what the tool produces, though it does not explain the 'scopes/edges' jargon or distinguish itself from siblings like find_elements.

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 guidance on when to use this tool versus alternatives such as find_elements or get_current_page. The description implies it is for scope-graph inspection, but does not state conditions, exclusions, or preferred use cases.

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 only restates the generic read operation and does not mention whether the tool waits for the element, how it handles no-match or multiple-match cases, or that it is read-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?

The description is a single sentence with no wasted words and the core operation is front-loaded. It is concise to the point of under-specification, but it does not suffer from verbosity or structural disorganization.

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?

The target parameter is quite complex, offering ref and path locator modes with nested selector types, and there are no annotations to cover safety or behavioral context. Since an output schema exists, return-value details are not required, but the description still fails to provide guidance on choosing target modes or anticipating behavior in edge cases.

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 description adds almost no parameter meaning beyond what the schema already provides; the 'value or text' behavior is already explained in the attribute parameter description ('不指定则获取value或text'). With schema coverage at 50%, the description should help disambiguate the two target modes (ref vs path), but it does not.

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 Chinese description '获取元素的值或文本内容' clearly states a specific operation (get) on a specific resource (an element's value or text). It is distinct enough from mutation tools like click and input_text, though it does not explicitly contrast with sibling read/assert tools such as assert_text or assert_attribute.

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 guidance on when to use get_value versus assert_text, assert_attribute, find_elements, or get_page_snapshot. An agent must infer the use case from the tool name and schema rather than from explicit usage direction.

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 present, so the description carries the full burden of behavioral disclosure. It does not state whether the tool simulates user typing, replaces the existing value, triggers events, or how it interacts with focus/visibility—only that text is entered. Critical behavior around the 'mode' parameter is also not revealed in prose.

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 one short, front-loaded sentence with no wasted words, which is structurally clean. However, it is so minimal that it borders on under-specification rather than effective conciseness, so it earns only a mid score.

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?

This is a complex tool with a rich target locator schema, three parameters, no annotations, and no parameter descriptions. A single clause describing the tool's purpose is completely inadequate for an agent to invoke it correctly across the possible target kinds and 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 0%, and the description provides no parameter-level meaning. It does not explain what 'target' accepts, what mode 'replace/append/clear' means, or how 'text' is applied. The schema alone cannot carry this burden, and the description adds almost no semantic 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 action ('input text') and target resource ('input/textarea elements'), so an agent can tell this is a text-entry tool. It does not explicitly differentiate it from sibling tools like set_form_control, but the core purpose is clear.

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 such as set_form_control or click. No prerequisites, exclusions, or selection criteria are provided, leaving the agent to guess based on the 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?

There are no annotations, so the description carries the full burden. It discloses one key behavioral constraint: the current automator version only supports delta=1. However, it does not mention side effects on the page, error behavior when no previous page exists, or interaction with timeout/waitForLoad parameters.

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 a single concise sentence with a parenthetical caveat. Every word contributes information, and the key constraint is front-loaded.

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?

The tool is simple, the schema is comprehensive, and an output schema exists, so the description need not explain return values. Still, the lack of any usage or behavior context beyond the delta limitation leaves some gaps, such as what happens when there is no history to navigate back to.

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 adds minimal extra meaning beyond the schema—it restates the delta restriction, which the schema already encodes as const:1, but does not clarify timeout or waitForLoad semantics beyond their existing descriptions.

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: 返回上一页 (go back to the previous page). This clearly conveys the core function and is easily distinguished from navigation siblings like navigate_to or switch_tab, 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?

No explicit guidance is given about when to use this tool versus alternatives. The only contextual hint is the limitation note about delta=1, which does not clarify selection criteria relative to navigate_to or switch_tab.

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 present, so the description carries the full burden of behavioral disclosure. It only restates the navigation action and does not mention side effects such as replacing the current page, redirect-closing behavior, load-waiting semantics, 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?

The description is one short, front-loaded sentence with no filler. It is concise, though it is minimal enough that behavioral and usage context is left to other dimensions.

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?

The schema covers all five parameters and an output schema exists, so the return contract does not need explaining. Still, the description gives no usage context or behavioral nuance, leaving the agent to infer alternatives and side effects; this is adequate but not 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 parameters are already documented with types, defaults, and meanings. The description's 'specified page' only loosely maps to the url parameter and adds no value 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?

Description states a concrete action ('navigate/jump') and a resource ('specified page'), so an agent can tell this is a page-navigation tool. It does not explicitly distinguish itself from sibling navigate_back, 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?

No guidance is given about when to choose navigate_to over navigate_back, switch_tab, or other navigation-related siblings. There are no conditions, exclusions, or alternative tool mentions; the agent must infer usage from the 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?

With no annotations, the description carries the behavioral burden and does disclose the stateful reuse/replacement behavior. However, it omits important consequences such as the effect on an existing connection, what happens if no previous successful request exists, and the behavior of timeoutMs/healthCheck.

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 sentence efficiently packs two usage branches with no filler, and the default no-argument behavior is front-loaded. Every word contributes meaning.

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?

The tool has a complex discriminated-union target plus timeoutMs and healthCheck, yet the description covers only the target/no-target distinction. It omits target kind semantics, parameter behavior, failure conditions, and any guidance about the output, leaving the schema to do nearly all of the explanatory work.

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 0%, so the description must compensate, but it only mentions target as a trigger for a new request. It does not explain timeoutMs, healthCheck, or the four target variants (project, wsEndpoint, browserUrl, discover) that the schema defines.

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, non-tautological behavior: with no parameters it reuses the last successful request, and with target it replaces it with a new request. However, it never explicitly names the DevTools reconnection outcome, and it does not differentiate this tool from connect_devtools or disconnect_devtools.

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 provides clear branch conditions for when to omit parameters versus when to pass target. But it does not advise when to choose reconnect_devtools over the sibling connection tools, and it gives no exclusion cases.

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 mentions restarting and navigating but does not disclose side effects such as loss of current state, whether the restart closes all existing pages, or any prerequisites like an active devtools connection. This is minimal beyond the literal action and leaves critical behaviors 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 description is a single concise sentence with no filler. It front-loads the primary action ('restart the mini program') and the secondary action ('navigate to the specified page') efficiently. Every word contributes to the meaning.

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?

Given an output schema exists and all parameters are described, the core functionality is covered. However, for a side-effectful operation like relaunch, the description lacks usage context and behavioral side-effect disclosure. An agent can call it correctly based on the schema, but may not anticipate consequences (e.g., reset state, timeout behavior) without additional info.

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 adds no parameter-specific meaning beyond the schema, but the schema itself already documents all four parameters (url, params, timeout, waitForLoad) adequately. Therefore, no extra credit or penalty is warranted.

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 clearly states the action: restart the mini program and navigate to a specified page. This uses a specific verb and resource, and it distinguishes itself from sibling tools like navigate_to (which likely only navigates) and switch_tab by adding the restart behavior. It is not a tautology.

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 guidance on when to use this tool versus alternatives. It only states what the tool does, without indicating scenarios (e.g., 'use when you need a clean session') or excluding cases (e.g., 'use navigate_to if you don't need to restart'). No when-not conditions or alternative references are present.

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 must carry behavioral disclosure, but it only states that a value is set. It does not mention event triggering, side effects, supported control types beyond examples, or error behavior, leaving the mutation's behavior opaque.

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 a single front-loaded sentence with no filler and clear examples. It is appropriately concise, though it could use more structure to compensate for its brevity.

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?

Given the rich input schema and presence of an output schema, the description doesn't need to repeat parameter details. However, with no annotations and minimal description, it leaves behavioral and usage context under-specified, so it is minimally viable 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?

The schema already documents target, value, and trigger with descriptions, so the baseline is 3. The description adds only the form-control framing and examples, not parameter-level 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 names a specific operation ('设置...的值') and a concrete resource class ('表单控件') with examples (picker, switch, slider), which distinguishes it from siblings like click or navigate_to. It is not a tautology and makes the tool's core function immediately understandable.

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 prefer this tool over siblings such as input_text or get_value. The examples imply form controls, but there is no explicit context, exclusions, or alternative routing, so the agent must infer 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only restates the action and does not mention side effects, waitForLoad/timeout behavior, or failure 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 a single concise sentence with no filler, and the core action is front-loaded. However, it is somewhat under-specified rather than genuinely informative.

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 a sibling list containing navigation tools, the description lacks context about tab semantics, when switching is appropriate, and what waiting for load entails. The output schema may cover return values, but usage and behavior context are incomplete.

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 adds no parameter detail beyond what the schema already provides for url, timeout, and waitForLoad. It neither compensates for gaps nor adds format/example guidance.

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 clear verb-resource pair: 'switch' to 'specified Tab page'. It is self-explanatory but does not explicitly differentiate it from sibling navigation tools like navigate_to or get_current_page.

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 provided on when to use switch_tab versus alternatives such as navigate_to, navigate_back, or get_current_page. Prerequisites, context, and exclusions are all left to inference.

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 present, so the description carries the full burden of behavioral disclosure. It mentions wait modes but does not disclose how polling works, behavior on timeout, whether a timeout throws or returns normally, or whether waiting has side effects. The description largely restates schema properties rather than adding operational 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 description is a single concise sentence with the main purpose front-loaded and supported modes listed compactly. The trailing '等' adds mild vagueness, but the description wastes no words and is easy to scan.

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?

The tool has a complex schema with six optional parameters, a polymorphic target, multiple matching modes, and timeout semantics, yet no annotations and no behavioral guidance in the description. It does not explain how delay relates to the wait-target modes, what happens at timeout, or whether visible and disappear are mutually exclusive. For this complexity, the description is too sparse.

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 six parameters and their modes. The description adds little beyond the schema, merely grouping visible, disappear, and text concepts without explaining combinations, precedence, or which params are mutually exclusive. 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 the tool waits for a condition, and explicitly enumerates supported condition kinds: element appearance, disappearance, and text matching. This clearly identifies the operation and resource. It does not explicitly contrast with sibling assertion/query tools, 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?

The description gives no guidance on when to use wait_for instead of related tools such as assert_state, assert_text, find_elements, or get_page_snapshot. It implies a synchronization role but provides no exclusions, prerequisites, or alternative routing.

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