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

No annotations are provided, so the description carries full burden. It explains that the method is called via element.callMethod(), returns the serialized result, and fails on non-custom components. This is transparent, though it could mention error handling for missing methods.

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 paragraph but is concise and informative. Every sentence adds value, though a bulleted list would improve readability. No 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?

Given no output schema, the description adequately explains the return value (serialized method result). It also addresses failure conditions and distinguishes from the many sibling tools. Minor omission: no mention of timeout or synchronous nature.

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 low (17%), but the description explains key parameters: method, args, selector, and innerSelector. It clarifies that args are spread in order and that selector supports [index=N]. It does not explain maxBytes or repeat connection's schema description, which is acceptable.

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 tool calls a method on a custom component instance and returns the result, using specific verb '调用' and resource '自定义组件实例的方法'. It distinguishes from sibling tools like page_callMethod and element_getData/element_setData.

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 this tool (custom component instances only, not normal WXML elements) and when to use alternatives (page_callMethod for page-level, element_getData/element_setData for data). Also provides guidance on nested component selection and index syntax.

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 fully discloses behavior: returns null for single missing attribute, errors for all missing, truncates results over maxBytes, and notes that object-type data-* attributes return string '[object Object]' via WXML. This exceeds expectations.

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 fairly concise for the amount of information conveyed, but it is a single block of text without clear separation of concerns. It could benefit from bullet points or structured formatting for easier reading.

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 no output schema, the description explains return values (null for missing, error for all missing, truncation) but does not explicitly state that the result is an object mapping attribute names to values. For a read tool with multiple parameters, it covers most important aspects, but leaves a small 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 low (20%), but the description adds meaning for key parameters: names (list of attribute names), maxBytes (truncation threshold), selector/innerSelector (targeting). However, it does not explicitly describe the return type or the format of the results, leaving some ambiguity.

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 it reads WXML attributes (e.g., class, id, data-index) and distinguishes itself from element_getStyles for CSS styles. The verb '读取' (read) and resource 'WXML 特性值' (WXML attribute values) make the purpose specific.

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 says when to use (read attributes) and when not (CSS styles -> use element_getStyles). Provides guidance on reading custom component inner elements using selector/innerSelector, and warns about object-type data-* attributes, suggesting getBoundingClientRect instead. Also mentions truncation behavior with maxBytes.

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?

没有注解，描述承担全部行为披露责任。完整说明了返回值（rect、dataset、id）、错误行为、跨组件查询机制（内部使用>>>）、选择器限制以及[index=N]的限制。对行为的透明性非常好。

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?

描述为一段长文本，但信息组织有序，先核心功能后细节，每句话都有价值。可以更结构化（如分点），但整体仍算简洁有效。

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?

对于没有输出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覆盖率仅25%（只有connection有描述），描述中对selector和innerSelector的用法提供了额外含义，但未提及maxBytes参数。整体上，描述为selector和innerSelector增加了语义，弥补了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?

明确说明工具功能：获取元素相对视口的边界矩形（left/top/width/height/right/bottom），并强调是CSS transform后的实际渲染尺寸。还提到返回dataset和id，并对比了element_getAttributes，清晰区分了用途。

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?

提供了详尽的使用指导：说明何时使用此工具（读取卡片/组件绑定数据），对比了element_getAttributes的不足；支持跨组件查询的用法（selector和innerSelector）；明确限制（仅支持ID/类选择器，[index=N]不能与innerSelector共用）；以及错误处理（未返回矩形时抛错，无法区分元素不存在与display:none）。

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 discloses that omitting path returns the entire data (potentially large), truncation behavior based on maxBytes, path format constraints, and selector indexing. It does not explicitly state non-destructive nature but implies it. The description adds valuable behavioral context beyond the tool name.

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 dense paragraph that efficiently conveys multiple pieces of information without redundancy. It is front-loaded with the primary purpose. While it could be broken into clearer sentences for readability, it is still concise and to the 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?

Given no output schema and no annotations, the description covers the main aspects: purpose, key parameters, behavioral details (truncation, path constraints). However, it does not describe the return format or error conditions, which could be useful. It is mostly complete for the tool's complexity.

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 only 20%, so the description compensates by explaining path (exact sub-values, format example), maxBytes (default and max, truncation), and the combined use of selector and innerSelector. The connection parameter is described in the schema but not in the tool description; however, the description covers the core parameters 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 clearly states the tool reads rendering data of custom component instances, using the verb '读取' and specifying the resource. It distinguishes itself from the sibling tool page_getData by noting it only works on custom components.

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 explicitly states when to use this tool (for custom components) and when not, directing to page_getData for page data. It also provides usage advice such as preferring path to avoid large data, and explains path format limitations and the use of selector+innerSelector for nested components.

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?

Since no annotations are provided, the description carries the full burden. It discloses that withWxml can return large data, results can be truncated with a wrapper object, and maxBytes can be adjusted. It also mentions selector index support limitations. It does not explicitly state read-only behavior but it is implied.

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 reasonably concise but dense with information. It is well-structured: first states purpose, then usage, then details about withWxml and truncation, then selector limitations. Each sentence adds value, though some redundant phrasing exists.

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 (6 parameters, nested connection object, no output schema), the description explains inputs, behavior, and edge cases (truncation, Wxml size). It mentions return fields (tagName, text, value, size, offset) but does not detail the truncation wrapper structure. It is missing some error handling details but overall 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 only 17% (connection only). The description adds meaning to most parameters: selector (scope element), targetSelector (query within scope), innerSelector (optional scope refinement), withWxml (return full Wxml), maxBytes (truncation threshold). It does not fully describe selector format (e.g., CSS selector), but provides sufficient context.

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 tool's purpose: query a single child element within a scoped element and return a summary (tagName, text, value, size, offset). It distinguishes from page_getElement for root queries and implicitly from element_getInnerElements (plural).

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 explicitly says when to use (inside a container/custom component) and when not (use page_getElement for page root). It mentions alternatives for root queries. However, it does not explicitly contrast with the sibling tool element_getInnerElements.

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 full burden. It discloses the return structure (count, totalCount, limited, elements[]), default/max limit (100), truncation via maxBytes, optional withWxml, and selector index support. It omits stating that the operation is read-only (though implied) and does not mention error conditions, but covers key behavioral traits.

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 paragraph that efficiently packs purpose, return structure, defaults, and constraints. It is front-loaded with the main action. Some structuring (e.g., bullet points for parameters) could improve scanability, but it is not overly verbose and every sentence adds 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?

Given the complexity (7 params, no output schema, no annotations), the description provides substantial information about return structure, limits, and selector behavior. It lacks details on error handling or empty results, but it is sufficient for an agent to select and invoke the tool correctly in most 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?

Schema description coverage is only 14% (connection only), so the description must compensate. It explains the purpose and interplay of selector, targetSelector, innerSelector, limit, maxBytes, and withWxml. It provides defaults and restrictions not in schema. This fully compensates for the low schema coverage.

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 tool retrieves an array of child elements within a positioned element using a selector, returns a structured result with count and summary details. It distinguishes itself from the sibling tool 'element_getInnerElement' (singular) by focusing on multiple elements, and from other element tools by specifying the query mechanism (element.$$).

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 the usage pattern: using selector and optional innerSelector to locate the scope, then targetSelector to query children. It also notes restrictions like [index=N] only for selector. However, it does not explicitly compare to alternatives like page_getElements or state when not to use this tool, but the context is adequate for most scenarios.

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 fully discloses behaviors: reads computed styles, error handling, truncation, and inner element access via selector/innerSelector. It does not explicitly state read-only nature, but overall transparency is strong.

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 very concise, front-loading the main purpose in the first sentence, and every subsequent sentence adds specific, non-redundant information about usage and behavior.

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?

Covers core behavior and edge cases well but lacks description of the return format (e.g., object of style values). Also does not describe the 'connection' parameter. For a tool with 5 parameters and no output schema, slightly more detail would improve completeness.

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?

Description adds significant meaning beyond the schema: explains camelCase format for names, default 50000B for maxBytes, truncation behavior, and selector [index=N] support. Only the 'connection' parameter lacks description, but schema provides its details.

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 it reads computed styles (element.style(name)) using a list of style names. The name 'element_getStyles' and sibling tools like 'element_getAttributes' show it's specifically for styles, distinguishing it from other element access 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?

Provides explicit instructions: use camelCase names array, null for missing individual names, error if all fail, maxBytes truncation, and innerSelector for inner elements. It implies appropriate use cases but does not explicitly exclude alternatives or state when not to use.

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 full burden. It discloses truncation behavior (returns {truncated, bytes, maxBytes, note, data} when exceeding maxBytes), notes that WXML is most likely to exceed, and describes default vs outer behavior. It does not discuss performance or auth, but for a read operation this is sufficient.

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-loads the main purpose. It uses a few sentences to cover key details. While it could be more structured (e.g., bullet points), it is efficient and earns its sentences.

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 parameter complexity (5 params, 1 required, nested object) and no output schema, the description covers the main behavioral aspects: inner vs outer WXML, custom components, and truncation. It does not detail the output format beyond the truncation case, but it provides enough for an agent to select and invoke 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 coverage is only 20% (only connection object has a description). The description adds significant meaning: explains outer parameter effect, maxBytes default and truncation handling, selector usage with [index=N] syntax, and innerSelector for custom components. This compensates well for the low schema coverage.

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 '获取元素 WXML' (get element WXML), specifying the verb and resource. It distinguishes between internal WXML (default) and outer WXML (with outer=true), and addresses custom component WXML via innerSelector, differentiating it from sibling tools that handle other element properties.

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 explicit guidance on when to use outer=true vs default, when to use innerSelector for custom components, and how to handle truncation (use more specific selector or increase maxBytes). It does not explicitly state when not to use this tool, but the scenarios are well-covered.

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 reveals that value accepts string or number, selector supports indexing, and failure occurs on non-input elements. It does not cover error handling for missing elements or whether the operation is additive or overwriting, but the core behavioral traits are disclosed.

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 paragraph of about 80 characters. It is front-loaded with the main purpose and every sentence adds value without redundancy. Ideal 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?

Given the complexity (4 params, no output schema), the description covers the main usage, special features, and a failure case. It could be more complete by mentioning the return value or supporting additional input types, but it is sufficient for an agent to use correctly in most scenarios.

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 low (25%), but the description adds meaning for all parameters: explains value types, selector usage with indexing, and innerSelector for custom components. This compensates for the schema gaps. However, more details on connection parameter could be 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?

The description clearly states it fills values into input-type elements (input/textarea) using element.input(). It specifies the verb and resource. It distinguishes from sibling tools like element_tap and element_setData by focusing on input elements, but could more explicitly contrast with element_setData which also modifies state.

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 when to use: for input-type elements, and provides guidance for custom components using innerSelector. It notes that calling on non-input elements will fail, giving a clear when-not. However, it does not mention alternatives among siblings, which would improve score.

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?

Despite no annotations, the description fully discloses that the tool only works on scroll-view, fails on others, and explains x/y are absolute pixel values, not incremental. No contradictions.

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?

Three concise sentences in Chinese, front-loaded with the main action, no redundant information. Every sentence adds 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 scroll tool with no output schema or annotations, the description covers target restriction, coordinate semantics, and component targeting adequately. No 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 only 20%, but the description adds significant meaning: explains x/y as absolute scrollLeft/scrollTop, selector targets scroll-view, innerSelector targets internal elements. Connection parameter is partially covered by schema description.

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 tool scrolls a scroll-view component to an absolute position, specifies it only works on scroll-view, and distinguishes from the sibling tool element_swipe for non-scroll-view scrolling.

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 (scroll-view components) and when not to (other elements, refer to element_swipe). Also provides guidance on targeting inner scroll-views using selector and innerSelector.

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; description covers merging behavior, key limit, path syntax, and innerSelector usage but lacks details on error handling, session requirements, or 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?

Single paragraph efficiently covers key points without fluff. Could be slightly more structured (e.g., bullet points) but not necessary.

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?

Covers core usage constraints and sibling differentiation, but omits return value description and does not explain the connection parameter. Adequate for a well-known operation but could be more 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?

Adds meaning beyond schema: explains data as key-value object with path syntax and 100-key limit, selector supports [index=N], and innerSelector for nesting. Does not detail selector format or connection parameter.

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 clearly states it writes rendering data to custom component instances, distinguishes from page_setData and element_getData, and specifies the scope of validity.

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 says when to use (custom components) and when to use alternatives (page_setData for pages, element_getData for reading). Also mentions constraints like max 100 keys and path syntax.

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?

Describes the gesture sequence, default parameters (distance 60% of element width/height, duration 300ms, start at center), and extra wait time. No annotations provided, so description carries the burden; no contradictions.

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?

Single paragraph with front-loaded purpose and parameter list. Efficient but dense; could be structured with bullet points for readability. No wasted words.

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?

Adequate for a swipe tool with 10 parameters and no output schema. Covers purpose, usage guidance, and parameter details. Does not mention return values or errors, but not required given lacking 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?

Adds meaning beyond schema by explaining direction enum, distance default, duration default, start coordinates default, waitMs, innerSelector, and selector index support. Schema coverage is only 10%, but description compensates well.

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 clearly states it performs real swipe gesture (touchstart→touchmove→touchend), specifies use case (lists, carousels, draggable areas), and distinguishes from sibling element_touch by recommending this tool for simplicity.

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 says to prefer this tool over element_touch for simple swipes and indicates suitable scenarios. However, does not specify when not to use it or mention 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 provided, so description fully covers behavioral traits: selector with index notation, innerSelector for custom components, waitMs behavior, conditional return of routeAfter/routeChanged, and warning about accuracy without waitMs. Thorough and transparent.

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?

Single paragraph with clear, front-loaded action and detailed explanations. Slightly long but every sentence adds value. No 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?

No output schema, but return values are fully explained. All parameters covered. Context of siblings addressed by distinguishing from page_* tools. Complete for complexity 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 coverage is only 25% (only connection described), but description adds rich meaning for selector, innerSelector, and waitMs, explaining their usage, syntax, and behavioral impact. Adds significant value beyond 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 clearly states this tool simulates taps on WXML elements, distinguishes it from page_* tools which cannot penetrate custom components, and is named element_tap, making its purpose 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?

Explicitly guides when to use this tool over page_* methods for custom components, and when to use waitMs for navigation detection. Lacks explicit when-not-to-use scenarios but provides sufficient contextual 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?

无注解，描述承担全部负担。说明触发底层触摸事件，区分 phase 和 sequence 的行为，以及参数如 holdMs（长按）、identifier（多指）等。但未提及返回值或潜在副作用，不过对于触摸工具而言已较充分。

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?

描述较长但每句都有信息量，没有浪费。先说明目的和替代方案，再解释参数。虽然可以更结构化（如分点），但整体清晰高效。

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?

对于有 10 个参数、嵌套对象、无输出 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?

描述覆盖了主要参数：phase 的选择、x/y 默认取中心、moves 仅用于 sequence、holdMs 表示长按、identifier 用于多指、waitMs、innerSelector 等。由于 schema 描述覆盖率仅 10%，描述有效补偿，为参数添加了使用语义。

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?

明确说明工具用于对元素派发底层触摸事件（touchstart/touchmove/touchend），并指出多数场景应使用 element_tap 或 element_swipe，从而与同类工具区分开。

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?

明确给出使用场景：只有需要自定义多点/长按/分段手势时才用本工具；简单点击用 element_tap，滑动/拖拽用 element_swipe。还解释了 phase 的两种模式（单次事件 vs sequence），提供清晰的指导。

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 full burden. It explains the method prefix removal, argument expansion, return format, and notes the evaluate injection channel fallback. However, it lacks details on error handling or side effects of the API call.

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 well-structured: core action first, then parameter details, then usage guidance. Every sentence adds value without redundancy. Efficient and 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?

Given 4 parameters and no output schema, the description covers the main parameters, return format, and usage scenarios. Minor omission: 'maxBytes' parameter not addressed. Overall sufficient for effective tool selection.

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 has low description coverage (25%), but the description substantially compensates by explaining the 'method' naming and 'args' structure with examples. The 'maxBytes' parameter is not explained, but its purpose is inferable from context.

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 tool calls WeChat Mini Program APIs, specifies the method naming convention (no 'wx.' prefix), and distinguishes from siblings like mp_evaluate (for page logic) and mp_pollUntil (for waiting). It directly addresses the verb+resource and differentiates from similar 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?

Explicitly states when to use (directly trigger wx.* capabilities) and when not to use (for page data or waiting), with fallback alternatives provided. The '何时用' section offers clear decision 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 provided; description compensates by discussing routing lag (snapshot behavior), truncation via maxBytes, and cross-validation with mp_evaluate. Does not explicitly state non-destructive nature but implies it. Lacks mention of error handling or permissions.

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?

Description is fairly long but well-structured with sections for purpose, usage, warnings, and parameter details. Front-loaded with main purpose. Could be slightly more concise but retains necessary detail.

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, but description mentions missingPaths and bytes without fully specifying return structure. For a tool of moderate complexity, it provides enough context for an agent, but explicit return format would improve completeness.

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 has 4 params with only 25% description coverage. Description adds meaning for dataPaths (path expressions, wildcards, missing), maxBytes (default 50000, truncation, bytes field), withData, and connection. Adequately compensates for low schema coverage.

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 clearly states it gets current page info (path, query, size, scrollTop) and optionally page.data. It distinguishes from siblings like page_getData, page_expectRoute, page_waitRoute.

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 says when to use (概览 of route, size, scroll, partial data) and when to use alternatives (page_getData for data only, page_expectRoute/page_waitRoute for route assertion). Also warns about routing lag and not using right after navigation.

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?

Without annotations, the description fully discloses behavior: does not modify state, does not start IDE, does not reconnect. Explains that red results are non-fatal and provides context for interpretation.

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?

Well-structured with sections: purpose, usage guidelines, warnings, return details. Every sentence adds unique value without 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?

Despite no output schema, the description adequately describes return as JSON with boolean/status fields. Parameter description is thorough. Slightly more detail on output structure could improve completeness.

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 only parameter 'connection' is fully described in schema, but the tool description adds valuable context: overridable fields, port meaning, and warning about IDE service port confusion.

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 it is a read-only diagnostic tool that probes connection status (port, devtools, ws, automator). It explicitly distinguishes from siblings like mp_ensureConnection, which is used to fix connections.

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 explicit guidance on when to use (snapshot, after failures) and when not to use (when fixing is needed, direct to mp_ensureConnection). Also clarifies that red results are not dead ends and next steps.

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 fully carries the burden. It discloses self-healing behavior, session management, retry logic, and details about the return JSON (e.g., projectPath being null in connect mode). No contradictions.

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 core purpose, then usage, failure recovery, and parameter details. Each section adds value without unnecessary repetition despite the length.

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 complexity, no annotations, and no output schema, the description covers purpose, usage, failure recovery, parameter semantics, and key return fields. It is sufficient for an agent to use 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 coverage is only 33%, but the description compensates by explaining each parameter in context: reconnect forces discard and reconnection, projectSelection accepts index/name/path for disambiguation, and connection details fields with a caution about the port.

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 tool ensures a mini-program automation session is ready and identifies itself as the default entry point before screenshot/page/element tools. It distinguishes itself from mp_diagnoseConnection by noting that it is read-only and can be skipped.

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 says to call this tool before other actions and not to call mp_diagnoseConnection first. Provides failure handling guidance: retry with reconnect=true or list projects first, and warns against retrying the same call or stopping.

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, but description fully discloses execution context, global objects, JSON serialization of return, timeout defaults and limits, and potential errors (prototype chain issues).

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?

Well-structured: starts with core purpose, then usage guidelines, then warnings. Every sentence adds value despite length.

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 5 parameters, no output schema, and nested objects, description covers input constraints, behavior, return, timeout, and edge cases. Minor gap: maxBytes not mentioned.

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 20% (only connection described). Description adds meaning for functionSource (full function expression), args (passed as arguments), timeoutMs (default and max), and connection (optional override). However, maxBytes parameter is not explained.

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?

Clear verb+resource: inject and execute a function in AppService, return result. Distinguished from siblings mp_callWx and mp_pollUntil by specifying alternate use cases.

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 (unstable page.data, state machine assertions) and when not (use mp_pollUntil for waiting, mp_callWx for wx.* APIs). Also warns against complex prototype traversal.

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 full burden. It discloses that the tool runs actual scenario steps (with side effects like navigation and input), that stopOnFailure defaults true, that markdown is always returned in the 'report' field, and specifies the return object fields. However, it does not explicitly state that the tool is destructive or that it requires an active connection, though these are implied. Slight gap but still transparent.

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 well-structured, front-loading the main purpose and sibling distinction, then explaining output mechanics, report content switches, and return format. Each sentence adds value, though it is relatively long. It could be slightly more concise but is clear and logically organized.

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 complexity (10 parameters, nested objects, no output schema), the description is fairly complete. It covers purpose, usage, parameter semantics, and return format. It lacks explicit error handling or details about the 'ok' field, but the essential context for correct invocation is present. High completeness for a complex 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 only 10% (only connection described in schema). The description compensates by explaining the meaning of steps (reference to mp_runScenario), title, outputPath, includePassedSteps, includeSnapshots, includeLogs, and stopOnFailure default. It does not detail maxBytes or scenarioTimeoutMs, but overall adds significant 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?

The description clearly states that the tool executes a scenario (same steps as mp_runScenario) and additionally generates a Markdown regression report. It explicitly distinguishes from mp_runScenario by stating when to use each, e.g., '只需要机器可读的 pass/fail 结果、不要报告时,用 mp_runScenario.' This provides clear purpose and sibling 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 description gives explicit when-to-use and when-not-to-use guidance by comparing with mp_runScenario. It explains the meaning of report content parameters (includePassedSteps, includeSnapshots, includeLogs) and output behavior (report always returned in 'report' field, optional file write with parent directory creation). This covers usage context comprehensively.

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?

Despite no annotations, the description discloses isolation by project/wsEndpoint, clear behavior (only current buffer), return fields with meaning of count/totalCount, and the listenerAttached flag indicating potential log loss. This is comprehensive.

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?

Well-structured with purpose, usage, parameter details, and return format. Slightly verbose but all information is valuable and 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?

Covers purpose, parameters, usage, return object, and edge cases (listenerAttached). No output schema exists, but return values are described. Complete for the tool's complexity.

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 low (14%), but the description explains all parameters in detail: contains substring matching, type enum values, since as relative ms, limit defaults, clear behavior, and connection object. Adds significant meaning beyond 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 clearly states it reads applet console logs with filtering support. It is distinct from sibling tools, which are primarily for element or page interactions.

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 a common usage pattern (clear buffer before operation, read after). Does not explicitly state when not to use, but given it is the only log-reading tool, the context is clear.

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 fully discloses behavior: it is read-only, does not fix anything, explains key fields like needsRecovery, and warns about serverVersion meaning. It also mentions potential warnings from failed probes. This sets clear expectations.

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 fairly long but well-structured with sections. It front-loads the essential purpose and usage. While every sentence adds value, some redundancy exists (e.g., repeating '不修复任何东西'). Could be slightly tighter, but still effective.

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 complexity (health check with multiple fields) and no output schema, the description thoroughly explains return fields (summary, needsRecovery, lastScreenshotOk, etc.), edge cases (degraded but no recovery), and parameter behavior. It is complete for an agent to use 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 description adds significant meaning beyond the schema. It explains the default values and effects of includeLogs and includePage, and details the connection parameter including the port warning. Schema coverage is low (33%), but the description compensates 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 clearly states it is a read-only aggregation of automation environment health status, listing specific components it checks (connections, page route, project, logs, last screenshot result). It distinguishes from sibling tools like mp_recoverConnection and mp_ensureConnection by stating it does not fix anything.

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 explicit when-to-use guidance: '操作出问题时先调它看全局状态' and after repeated screenshot failures. It also clarifies when not to use mp_recoverConnection (only when needsRecovery=true) and warns against looping reconnect. This is comprehensive.

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 discloses the return structure, confirms no parameters, and warns about what it does not do. It implies a read-only operation (listing), but does not explicitly state side effects or read-only nature. Still, it is very transparent.

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 well-structured, front-loading the return structure and then explaining usage. Every sentence is informative and earns its place. It is appropriately sized for the tool's simplicity.

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 no-parameter list tool, the description covers all necessary context: what it returns, how to use it in workflows with sibling tools, and what it does not provide. It is complete given the tool's complexity and lack of 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?

There are no parameters, and the description explicitly confirms this, adding value beyond the empty schema. The baseline for zero parameters is 4, and the description meets it.

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 it lists recent projects from WeChat DevTools and specifies the return structure. It distinguishes from sibling tools like mp_ensureConnection and mp_setDefaultProject by explaining how they relate, and notes it does not provide page routes, setting it apart from page-level 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?

The description provides three explicit scenarios for when to use this tool: after mp_ensureConnection prompts for project selection, to fix default connection, or to check available projects. It also clarifies when not to use it (for page routes) and suggests alternatives (mp_ensureConnection, mp_setDefaultProject).

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 fully discloses behavioral traits: navigation stack behavior, query handling, the nature of waitMs as a 'dumb sleep', error handling with currentRoute, and the reliability of the returned activePage. No contradictions present.

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 well-structured with sections and bullet points, but slightly lengthy. It front-loads the main purpose and each sentence adds value, though minor redundancy could be trimmed.

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 5 parameters, no output schema, and complex behaviors, the description covers all aspects: parameter details, edge cases (switchTab without query, navigateBack path omission), return value, and references to sibling tools. It is comprehensive and actionable.

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 20%, but the description adds extensive meaning for all parameters: path (omit for navigateBack), query (object, not hand-stitched), waitMs (dumb sleep, not condition), connection (nested object details), and transition (enum meanings with examples). This compensates 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 clearly states the tool's purpose: navigate within a mini-program and return the resulting activePage. It distinguishes from siblings like mp_currentPage and mp_evaluate by explaining that the returned page is trustworthy and eliminates the need for cross-validation.

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 explicit guidance on when to use each transition type (navigateTo, redirectTo, reLaunch, switchTab, navigateBack), including scenarios where switchTab fails and alternatives like navigateTo. It also advises on using mp_pollUntil for condition-based waits instead of waitMs.

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 fully discloses behavior: polling mechanism, predicate/action as function strings, dataPath fallback, snapshot feature with before/after, timeouts, size limits, and connection handling. It warns about edge cases like timeout being too short or evaluate unavailability.

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 lengthy but well-structured with markdown formatting and front-loaded summary. While there is some redundancy, it remains organized and each sentence adds value given the tool's complexity.

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 12 parameters, no output schema, and high complexity, the description is remarkably complete. It covers all major behaviors, parameter interactions, fallback logic, and edge cases, leaving little ambiguity for the agent.

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 only 8%, but the description adds extensive meaning to all 12 parameters: explains predicate/action as source strings, dataPath for direct polling, dataEquals for exact match, snapshotPaths with wildcard syntax, and parameter interactions. This compensates fully for the low schema coverage.

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 it is a '通用 wait-for-condition / waitData 工具' and lists typical scenarios like waiting for page.data field changes, async state switches, and SSE streaming. It distinguishes itself from sibling tools like page_waitElement and page_waitRoute by being a generic polling tool that can use predicates or data paths.

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 good guidance on when to use predicate vs dataPath (when evaluate is unavailable), typical scenarios, and constraints like timeoutMs and maxBytes. However, it does not explicitly compare to sibling wait tools, so usage context is clear but not exhaustive.

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?

Since no annotations are provided, the description fully covers behavioral traits. It explains side effects in launch mode (app exit and relaunch, loss of current page stack) versus connect mode (only WS reconnection). It also clarifies the meaning of recovery results, warnings about infinite retries, and the conditions under which health may remain degraded.

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 fairly long but well-structured with clear sections. Each sentence contributes meaningful information, and the structure aids readability. It could be slightly more concise, but the complexity of the tool justifies the length.

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 description is highly complete given the tool's complexity. It explains the return JSON structure, the meaning of recovery flags, and provides guidance on handling failures. It also addresses edge cases and potential pitfalls, leaving little ambiguity for the agent.

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 significant meaning beyond the input schema. It explains the default value and purpose of the reconnect parameter, and provides detailed explanations for fields in the connection object, including warnings about the port parameter. This is especially valuable given the nested object and the need to clarify parameter usage.

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 tool's purpose: to repair an existing but degraded or failed connection by following a standard sequence of steps. It explicitly lists the actions (rebuild automator session, remount log listener, restore project context) and mentions that it returns a before/after comparison. This differentiates it from sibling tools like mp_ensureConnection and mp_diagnoseConnection.

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 explicit guidance on when to use this tool (only when mp_healthCheck shows needsRecovery=true) and when not to use it (for first-time connections, or when needsRecovery=false). It also distinguishes between this tool and others like mp_ensureConnection and the ensure(reconnect=true) variant, clearly specifying the appropriate contexts.

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 full burden. It discloses extensive behavioral traits: step types (action vs assertion), return value structure, selector limitations (no custom component penetration, innerSelector, index syntax), screenshot not returning base64 without path, snapshot being weaker, channel failure short circuit, and timeout boundaries. Some details are buried, but overall transparent.

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 well-structured with bullet points and sections (action vs assertion, warnings at end), but it is lengthy and contains some redundancy (e.g., maxBytes mentioned twice). It is front-loaded with purpose but could be slightly more concise without losing detail.

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 (5 top-level parameters, nested step schemas, no output schema), the description is thorough. It explains all step types, return value, edge cases, and relationships with sibling tools. No missing critical information for agent 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 only 20% (only 'connection' has a description), but the tool's description adds immense value by enumerating all 12 step types with their parameters, defaults, and behavior. It compensates fully for the schema gaps, explaining each parameter's meaning beyond the schema definitions.

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 it executes a set of debug/regression steps sequentially, summarizes pass/fail per step, and distinguishes itself from single-use tools like page_*/element_* and from mp_generateScenarioReport for markdown output. The verb 'runScenario' and resource 'scenario' are well-defined.

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 (scripting a short chain of navigation->action->assertion) and when not to use (single interaction: use individual tools; generating report: use mp_generateScenarioReport). Also provides constraints like max 25 steps, suggests ≤10 steps for reliability, and clarifies stopOnFailure behavior.

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 full burden and excels: it discloses single-channel serial execution (no concurrency), timeout handling, failure reason codes with actionable advice, auto-retry only for RENDERER_NOT_READY, error counting leading to SCREENSHOT_UNAVAILABLE, and the effect of force. It also states that it does not read currentPage to avoid blocking the channel. This is comprehensive behavioral transparency.

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 fairly long but each sentence adds value. It is well-structured with warnings in bullet-style and a clear list of error codes. The main purpose is front-loaded, and details are organized logically. Slightly verbose but not 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?

Given the tool's complexity (multiple modes, error handling, concurrency constraints, no output schema), the description covers all critical aspects: input/output behavior, error codes and their meaning, auto-retry logic, error counting with force flag, environment limitations, and prerequisite checks. An agent can make an informed decision 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 coverage is only 25%, so the description must compensate. It thoroughly explains 'path' (inline vs file storage) and 'force' (reset error counter). 'timeoutMs' and 'connection' are not explained in the description, but 'connection' has a detailed description in the schema. The description adds significant meaning beyond the schema for the two key 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?

The description clearly states the action ('截取当前小程序视口截图') and resource, distinguishing it from all sibling tools (none of which are screenshot-related). It also explains two operational modes depending on the 'path' parameter, providing full clarity.

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 explicit when-to-use guidance: requires an active session (referencing mp_ensureConnection), warns against concurrency due to single-channel serialization, advises not to resend after timeout, and notes it only works in devtools simulator. It also explains the force flag for recovery. While it doesn't explicitly name alternatives, no other screenshot tool exists, so the guidance is sufficient.

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?

Discloses that it does not establish a connection on its own, only sets the default, and that invalid or non-existent paths return errors. With no annotations provided, the description fully covers behavioral traits.

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 well-structured into logical segments (purpose, usage, parameter details, distinction) but is slightly verbose. It effectively front-loads the core message.

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 no output schema and no annotations, the description provides comprehensive context: behavior, parameter usage, error handling, and relationship to sibling tools. No gaps remain.

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?

Despite 0% schema description coverage, the description adds critical meaning: projectPath is an absolute directory path from mp_listProjects projects[].path, and invalid values result in errors. This compensates fully for the lack of schema parameter 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 tool sets a persistent default project, using specific verbs ('set' and 'default project'), and distinguishes it from sibling mp_ensureConnection by emphasizing it only writes the default without establishing a connection.

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 indicates when to use: when only modifying the default project for future connections and not establishing a connection now. Contrasts with mp_ensureConnection's projectSelection and specifies that projectPath should come from mp_listProjects' output.

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 discloses key behaviors: the call is awaited, args are positional, return structure includes method/arguments/result, and errors return UserError. However, it does not mention potential side effects on page state, though this might be implicit for method calls.

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 (about 120 characters) and front-loads the main action. It could be more structured, but it avoids redundancy and waste.

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 no output schema, the description covers the return structure and error handling. It distinguishes from sibling tools and explains usage context. Missing details on maxBytes and connection semantics slightly reduce completeness.

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 25% (only connection field described). The description adds meaning: args are positional (not named), method is the method name. But it does not explain maxBytes or connection in detail beyond the schema, leaving some parameters under-documented.

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 tool 'calls a method exposed on the current page instance' and explicitly distinguishes from the sibling 'element_callMethod' for component instances. The verb 'call' and resource 'page method' are specific.

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 explicit guidance: use when triggering real page logic (better than page_setData) and use element_callMethod for component methods. It also mentions error handling with UserError for missing methods or internal errors.

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 fully discloses behavior: it does not throw errors, returns result in {pass,expected,actual,snapshot} format, and explains page.$$ limitations regarding custom components. The index behavior is also clearly documented.

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 dense paragraph. It front-loads the core purpose and then covers nuances. While it is concise and contains no fluff, it could benefit from slight structuring (e.g., separate lines for usage vs. behavior).

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 no output schema and the complexity of the tool (selector indexing, custom component isolation, non-throwing behavior), the description is remarkably complete. It covers edge cases, return structure, and side effects, ensuring an agent can use 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?

Schema coverage is low (33%, only 'connection' has description). The description adds meaning for 'selector' (index syntax, page.$$ behavior) and 'expected' (exact count, not >=). For 'connection', the schema already has a detailed description, so no duplication needed. Overall, it compensates for missing schema 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 explicitly states the tool asserts that the count of elements matching a selector exactly equals 'expected'. It uses specific verb ('断言...数量是否精确等于') and resource ('匹配选择器的元素'), distinguishing it from sibling tools like page_expectVisible or page_expectData.

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 explains when to use: for exact count assertion, not >=. It details special selector syntax (selector[index=N]) and behavior (index out of bounds counts 0). It warns that page.$$ does not penetrate custom components, guiding the user to avoid inaccurate counts.

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 present, but description thoroughly explains return value structure, path resolution behavior, truncation at maxBytes, and object key order insensitivity. Also mentions error case for omitted expected.

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?

Description is dense with relevant information, front-loaded with purpose, and each sentence adds value. Slightly long but efficient given complexity.

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, but description fully explains return object fields (pass, expected, actual, pathResolved, snapshot). Covers all parameters, error handling, comparison behavior, and truncation. Well-rounded for a tool of this complexity.

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 low (25%) but description compensates by explaining path (single, no wildcard), expected (required, deep equality), maxBytes (default 50000), and connection (optional override with field details).

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 clearly states the tool performs a one-time assertion on a data path value using deep equality. It distinguishes itself from siblings like page_getData (retrieval) and other page_expect* tools by focusing on data path assertion.

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 context on required expected parameter and why (previous silent failures), and specifies path format limitations. However, it lacks explicit guidance on when to use this tool vs alternatives like page_getData for inspection.

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 fully covers behavioral traits: error on missing element (contrasting with siblings), result truncation beyond maxBytes, mode behavior, return object fields (pass, expected, actual, snapshot). It also warns against misuse for input values, ensuring the agent understands invocation constraints.

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 paragraph but front-loaded with main assertion and mode details. Every sentence adds value, covering return format, truncation, edge cases, and cautions. Slightly dense but not overly verbose; could be split for readability but still 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?

Given 5 parameters, no output schema, and no annotations, the description is exceptionally complete. It covers purpose, all parameters with semantics, behavioral traits (error on missing element, truncation), return structure, and usage guidelines for distinguishing from siblings. An agent can reliably invoke this tool based on 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 low (20%). The description compensates thoroughly, explaining mode, expected, maxBytes purpose, and selector syntax (including index[N] usage). It adds practical meaning beyond the schema, especially for selector and mode, and clarifies that connection parameter's description is already in 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 clearly states that the tool asserts element text matches expected, with specific details on mode (equals/includes) and contrast with page_expectVisible/Count for missing elements. It explicitly distinguishes from input value checking, making the purpose 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?

The description provides clear context for when to use (asserting element text) and when not to use (input/textarea values, recommending element.get value instead). It also explains mode options but lacks explicit 'use this tool when' vs 'use sibling when' structure, though behavioral contrasts with page_expectVisible/Count offer practical 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?

Discloses all key behaviors: no polling, no error thrown, return format, path formatting requirement (no leading slash, no query). Without annotations, this fully informs agent of tool's 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?

Three concise sentences covering purpose, return value, and usage caveats. No wasted words, 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?

Given two parameters and no output schema, the description fully covers what, how, return format, preconditions, and alternatives. Complete for agent to select and invoke 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?

Adds meaning for 'path' parameter beyond schema by specifying formatting constraints. The 'connection' parameter already has schema description, so description adds less value there overall.

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 it's a one-time assertion for page path equality, with explicit behavior (no polling, no error thrown, returns pass:false on failure). It distinguishes from sibling tools like page_waitRoute.

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 direct when-to-use guidance: if route may be unstable, use page_waitRoute first. Also implies single check, not polling.

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 fully carries the burden of behavioral disclosure. It states that the tool does not check visual visibility, does not poll, never throws errors, and returns a specific shape ({pass, expected, actual, snapshot}). It also discloses the limitation regarding custom component penetration.

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 relatively long but every sentence adds important information. It is front-loaded with the core purpose. Minor redundancy could be trimmed, but overall it's well-structured and concise for the amount of detail provided.

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 no annotations or output schema, the description is fairly comprehensive. It covers purpose, behavior, return format, and limitations. It could be improved by explicitly listing all return fields, but the snapshot structure is hinted. The connection parameter is not justified in the description.

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 meaning to the 'selector' parameter by explaining how it works (based on page.$$ hit counts and optional [index=N] syntax). The 'connection' parameter is already described in the schema, but the description does not add extra semantics for it. Overall, it compensates for missing schema description on the required parameter.

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 tool's purpose: an assertion for whether a selector can locate elements on the page, based on page.$$ hit count or index range. It distinguishes itself from sibling tools like page_expectCount, page_expectElementText, etc., by focusing specifically on existence/locatability.

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 explicitly explains when to use this tool (for existence checks only) and when not to use it (e.g., for visual visibility or for elements inside custom components). It provides alternatives: 'element_getInnerElements' for inner component elements, implying other tools for visual checks.

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?

Without annotations, the description discloses key behaviors: three retrieval modes, wildcard/negative index support, default maxBytes with truncation, and the truncated flag. It doesn't cover error handling or permissions, but these are reasonable omissions for a getter 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 well-structured with enumerated modes. Every sentence adds value, no redundancy. Information is dense yet easy to parse.

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 getter with no required parameters and no output schema, the description adequately covers how to invoke it and what to expect (data object with possiblly truncated flag). It could be improved by specifying the return shape or error scenarios, but it's sufficient for an AI agent.

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 low (25% only for connection), but the description adds rich semantics for path, paths, and maxBytes, explaining wildcard syntax, negative indexing, default value, and truncation behavior. The connection parameter relies on its schema description.

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 tool retrieves the current page's data object and details three usage modes. While it doesn't explicitly differentiate from sibling tools like page_expectData, the purpose is well-defined and 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?

The description provides clear guidance on when to use each mode (no param for full tree, path for single sub-path, paths for multi-path projection with wildcards). It recommends paths for large objects and explains the truncation behavior, but lacks explicit alternatives or when-not-to-use scenarios.

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?

The description discloses behavioral traits: imputed null fields do not indicate absence, element not found throws error, selector supports index[N] but innerSelector does not, default maxBytes and truncation behavior. No annotations are present, so the description carries the full burden and meets it well.

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 long but well-structured with warnings and examples. It front-loads the core purpose and uses clear formatting. Minor reduction in length could be possible, but every sentence adds 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?

Given the complexity (5 parameters, nested objects, no output schema), the description covers return format, error handling, async considerations, component isolation, and truncation. It provides sufficient context 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 only 20%, but the description adds significant meaning for all parameters: selector syntax (index[N]), innerSelector purpose, withWxml effect, maxBytes behavior, and connection object details (including port warnings). This compensates fully for the low schema coverage.

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 tool gets a single page element by selector, equivalent to page.$(selector). It details the return summary fields and distinguishes from sibling tools like page_getElements (plural) and element_getInnerElement (for inner elements from an element handle).

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 explicit guidance on when to use the tool vs alternatives: it warns that elements from async rendering require page_waitElement first, and for non-element conditions use mp_pollUntil. It also explains innerSelector usage for custom components and mentions maxBytes truncation behavior.

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?

Without annotations, the description fully covers behavior: returns empty list on no match (no error), default limit and maximum, totalCount vs count, withWxml behavior, selector[index=N] syntax, maxBytes truncation, and penetration limitations of page.$$.

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 dense but well-structured, front-loading the main purpose and return structure. It covers many details without redundancy, though it could be slightly shorter.

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 no output schema, the description fully details the return format including all fields. It covers edge cases (no match, truncation) and links to sibling tools for component penetration. Complete and actionable.

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?

Despite low schema coverage (20%), the description explains all parameters: limit (default 100, max 100, reason), maxBytes (default 50000B, truncation), withWxml, connection (optional override), and selector (with special syntax). Adds context and examples beyond 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?

Clearly states it retrieves an array of page elements by selector, equivalent to page.$$(selector). Distinguishes from sibling page_getElement by noting that this tool returns an empty list on no match while the other throws an error.

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 advises when to use this tool (batch/count) vs page_getElement (single required element). Also explains that page.$$ does not penetrate custom components and directs users to element_getInnerElements for that case.

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 fully covers behavior: partial merge write, returns key names only, bypasses page logic/event handling, and the caution about direct state change.

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, focused, front-loaded paragraph with main action, constraints, return info, and usage warning. No redundant 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?

Complete for a mutation tool with no annotations and no output schema: covers parameter meaning, behavior, return value, and context for appropriate use.

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 data is 0% but description fully explains data parameter: object with up to 100 keys, path syntax, partial merge. Connection parameter has schema description, so description adds value beyond schema for the key parameter.

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 clearly states it updates current page data using page.setData, specifying constraints (max 100 keys, path syntax) and distinguishes from sibling tools like page_callMethod and element_tap by noting this is for direct state manipulation.

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 provides when-to-use (for forced test state construction) and when-not-to (for simulating real interaction, suggesting alternatives like page_callMethod, element_tap).

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?

Without annotations, description fully discloses behaviors: empty args return only route with hint, withData token bomb, default limits, maxBytes truncation, custom component handling, and return structure. No contradictions.

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?

Description is long but efficient, front-loading purpose. Could be slightly more structured (e.g., bullet points) but every sentence adds value. Very concise given the complexity.

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 8 parameters, nested objects, no output schema, and no annotations, the description covers essential behaviors, edge cases (empty args, limits, truncation), and alternatives. Highly 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?

Despite low schema description coverage (13%), description adds meaning to all key parameters: explains limit, withData, dataPaths, selectors, maxBytes, and their effects. Compensates 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?

Description clearly states it returns a lightweight structural snapshot of the current page, aggregating route, query, data paths, and element summaries. Distinguishes from siblings by mentioning alternatives like page_getData and page_getElement for specific use cases.

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: '最适合「不确定页面上有什么」时探查 DOM/状态（page_waitElement 超时排查也会指向它）.' Also provides alternatives: '单个已知字段用 page_getData,单个元素用 page_getElement.'

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?

Discloses polling behavior (timeout, retryInterval), return format (selector, index?, found:true, waitTime), that it does not return element summary, and timeout error includes troubleshooting suggestions. No annotations, so description carries full burden and does so thoroughly.

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?

Efficiently structured: purpose first, then usage scenarios, comparisons, parameter details, error handling. Every sentence adds useful information without 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 4 parameters, no output schema, and no annotations, the description is self-sufficient. It covers behavior, return value, parameter details, error handling, and use cases. Agent can confidently invoke this 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?

Only connection parameter has schema description (25% coverage). The description compensates by explaining selector's index notation, default timeout and retryInterval, and providing suggestions. Adds significant value beyond 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 clearly states it polls for element appearance, only confirms existence, and distinguishes from page_getElement (content retrieval) and mp_pollUntil (non-element conditions). Verb+resource specific.

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 describes when to use (async rendering, SSE, navigateTo) and when not to (element already exists → use page_getElement; non-element conditions → mp_pollUntil). Provides timeout recommendations (default 5000, suggest 10000+ for async).

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 transparency burden. It covers polling mechanism, default timeout (5000ms) and retryInterval (200ms), return format {selector,gone:true,waitTime}, index behavior, timeout error, and suggestions for connection issues. Missing details on what if element never existed, but overall transparent.

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 with the main purpose. It contains essential information without fluff, though it could be structured slightly better (e.g., separate lines for defaults and error handling).

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 (4 params, no output schema), the description covers the key points: when to use, how it works, defaults, index behavior, error handling, and alternatives. It lacks a full return schema specification but provides the essential return fields. It also mentions the connection parameter indirectly.

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 low (25%), so the description compensates by explaining default values for timeout and retryInterval, the meaning of the selector (with optional index=N), and the behavior of index out-of-bounds. The connection parameter is described in schema but not in description; however the description adds value for other 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?

The description clearly states the tool polls and waits for an element to disappear, with specific usage examples like toast/loading/popup/skeleton screen. It distinguishes itself from siblings like 'page_waitElement' (which waits for appearance) and 'mp_pollUntil' (for non-element conditions).

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 explicitly says when to use (verify disappearance of specific UI elements) and when not to (for non-element conditions, use 'mp_pollUntil'). It also explains special behavior with selector[index=N] where out-of-bounds counts as gone.

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, but description fully discloses behavioral traits: polling mechanism, success output format, error behavior with current path, default values for timeout and retryInterval. No contradictions.

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?

Description is well-structured: first sentence states purpose, then details path format, return behavior, usage note, and defaults. No wasted words, 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?

No output schema, but description explains return values and error behavior. Covers complex scenario of indirect navigation. With 4 parameters (one nested), description provides sufficient context for correct usage.

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 25% (only connection has description). Description adds critical meaning: path format (no leading '/', no query), default values for timeout (5000ms) and retryInterval (200ms). However, it does not describe the connection parameter beyond what 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?

Description clearly states the tool polls until page route matches specified value, used to verify navigation completion, especially for indirect jumps. It distinguishes from siblings like mp_navigate and page_expectRoute implicitly.

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 (indirect navigation via tap/callMethod) and when not to (after mp_navigate, since activePage is already latest). Mentions alternative mp_navigate.

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 full burden. It describes the tool as a 'dumb sleep' and warns about misuse. Discloses that it's not for conditional waits. Does not contradict any annotations.

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 with clear warning and alternative reference. No wasted words; front-loaded with key purpose.

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 and no annotations. Description covers basic purpose and usage guidelines but doesn't explain return value or behavior besides being a sleep. For a simple tool, this is adequate but could include more about side effects or default behavior.

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 50% (2 params, one with nested connection object). Description only mentions 'milliseconds' implicitly ('等待指定的毫秒数'), but doesn't add details about the connection parameter or provide syntax/format beyond schema. Does not compensate for low schema coverage.

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 ('毫秒数'), and clearly states it's a 'dumb sleep'. It distinguishes itself from the sibling tool 'mp_pollUntil' by specifying use cases: short waits with no clear signal vs. waiting for conditions.

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 (仅用于「渲染 tick 留白」等无明确信号的极短等待) and when not to use (等任意条件...请改用 mp_pollUntil). Also warns about risks of too short/timing issues.

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