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

Annotations are all false (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the description carries the burden of behavioral disclosure. It does disclose the return format (JSON with success, data, message, error_code?) which adds real value. However, it never warns about the side effects of mutating actions (tap, input, set_data, mock_wx) or states prerequisites such as needing to call start before other actions. No contradiction with 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?

The description is compact and front-loaded with the purpose statement, followed by a tight list of action annotations and the return format. Each action is one short line. It is appropriately concise for a multi-action dispatcher, though the long enumeration is inherent to the tool's design.

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

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

For a complex 13-action, 14-parameter tool, the description lists every action and the output schema, but omits operational sequencing (e.g., start must precede other actions), environment/connection requirements (device or IDE link), and error-handling behavior beyond the error_code field. The output schema presence mitigates the return-value gap, but an agent still lacks enough context to drive the tool through a real workflow.

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

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

The schema provides detailed descriptions for all 14 parameters (selector requirements, fn_source execution semantics, data_json for set_data, etc.), so the schema carries the heavy lifting and the baseline is 3. The description itself adds minimal parameter meaning beyond listing action names; it does not compensate for anything since the schema is already thorough.

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

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

The description states a specific purpose — WeChat mini-program automation interaction and runtime querying (小程序自动化交互与运行时查询) — and enumerates all 13 supported action modes. The verb+resource combination is clear and comprehensive, but it does not explicitly distinguish itself from the sibling tools (build, file, ide, inspector, navigate, screenshot), so it falls short of a 5.

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

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

The description lists actions and the per-param required conditions live in the schema (e.g., 'selector: tap/input/element_info 时必填'), but the description itself provides no guidance on when to use this tool versus alternatives, no use-case scenarios, and no exclusions. An agent gets no help deciding between this and wechat_inspector or wechat_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?

Annotations provide idempotentHint=true but no readOnlyHint or destructiveHint. The description states it returns a JSON structure, which adds behavioral context, and mentions that 'upload' requires 'version' (parameter semantics). However, the description does not disclose side effects, such as whether upload publishes to production, whether cache_clean is destructive, or authentication requirements. The idempotentHint is somewhat contradicted by non-idempotent actions like upload, though the description does not explicitly contradict the annotation.

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 compact, front-loaded with the core purpose and action list, and ends with the return format. No wasted words; fits within a few lines.

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

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

For a tool with a rich action enum and many parameters, the description covers the main actions and the return structure, but does not elaborate on prerequisites, side effects, or error handling. With 11 parameters and 5 actions, the description leaves about half the behavioral context to the schema and annotations. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, but the parameter descriptions in the schema are quite detailed (e.g., role of cdp_port, clean_type, version for upload). The tool description adds the grouping of actions and the JSON return shape, but most parameter explanations come from the schema itself, not the description. Baseline 3 is appropriate.

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

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

The description clearly states the action is a build/preview/upload tool for WeChat mini-programs and lists the specific actions it supports. It distinguishes itself from siblings by covering build-related operations, though it doesn't explicitly compare to sibling 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 implies usage contexts (build operations, npm management) but does not provide explicit when-to-use or when-not-to-use guidance. It lacks alternatives or exclusions, though the action enum provides some guidance on what each action does.

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?

Annotations already disclose readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the JSON return structure ({success, data, message, error_code?}) and enumerates the supported actions, which gives further behavioral clarity. No contradiction with annotations exists, and the description complements the safety profile without duplicating it.

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 front-loads the purpose, lists the actions, and states the return format. Every sentence contributes value, and there is no filler. It is concise and well-structured, though slightly compact for the amount of information.

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

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

With an output schema present, the description need not detail return fields extensively, and it does provide the top-level JSON shape. However, it does not explain parameter relationships or optionality (e.g., which paths are required for which actions), which an agent would need to call the tool correctly. Given the tool's multi-action nature and optional parameters, this is a noticeable gap, though not critical for a read-only tool.

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

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

The description explains the meaning of the 'action' enum values (project_info, list_pages, read_page, read_file) but does not clarify the roles of 'file_path', 'page_path', or 'project_path', nor the dependencies (e.g., read_page requires page_path). The schema provides descriptions for each field, but the context signal indicates 0% description coverage, meaning the tool description does not substitute for that. The description only partially compensates for the low 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 reads WeChat mini program project files and structure, and lists four distinct actions (project_info, list_pages, read_page, read_file). This distinguishes it from sibling tools like wechat_navigate or wechat_screenshot, which have different purposes. The verb '读取' and resource '小程序项目文件' make the purpose explicit and unmistakeable.

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 does not explicitly state when to use this tool versus alternatives, but the available actions imply its scope (reading project files). It does not mention exclusions or conditions that would steer an agent to a sibling tool. Context is clear but there is no comparative guidance, so it remains adequate rather than optimal.

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?

Annotations already provide idempotentHint=true and destructiveHint=false, and the description does not contradict them. The description adds a return envelope format ({success, data, message, error_code?}) and action semantics, but it does not disclose side effects such as launching a GUI application, blocking on QR code scanning, or requiring the IDE to be installed/running. With annotations covering safety, a 3 is appropriate.

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 exactly two sentences: the first states the overall purpose, the second lists actions and the return format. There is no filler, repetition, or unnecessary detail. The structure is front-loaded and every sentence earns its place.

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

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

This is a multi-action tool with 10 parameters, and the description does not map parameters to specific actions (e.g., open requires project_path, login uses qr_format/result_output). It also omits prerequisites and likely failure modes. The one-line JSON envelope covers the output shape, but for a lifecycle manager of this complexity, the description is incomplete.

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

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

The tool description only adds semantic meaning to the action enum by explaining what each action does. It says nothing about project_path, port, qr_format, qr_output, cdp_port, or result_output, which are all documented in the schema but not compensated for at the description level. Given schema_description_coverage is 0%, the description should carry more weight for parameters but does not.

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

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

The description clearly identifies the tool as WeChat Developer Tools IDE lifecycle management and enumerates six specific actions (open, login, is_login, close, quit, status) with brief semantic labels for each, such as '打开IDE/项目' and '扫码登录'. This makes it easy to distinguish from sibling tools like wechat_build or wechat_inspector, which target different aspects of the WeChat toolchain.

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

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

The description provides no explicit guidance on when to use this tool versus siblings. It does not mention alternatives, exclusions, prerequisites, or conditions such as 'use wechat_build for compilation' or 'use wechat_inspector for debugging'. The action list implies capability but does not help an agent decide between lifecycle management and other tool categories.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered. The description adds concrete behavioral context: two acquisition protocols, the cdp pre-condition, and the JSON response envelope {success, data:{logs, summary}, message}. No contradiction with 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?

Four sentences, no filler; purpose is front-loaded and the action/prerequisite/return-format sections are each one line. Easily scannable.

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?

Between the description, detailed nested parameter docs, and the available output schema, an agent has what it needs to invoke either action. Minor gap: the cdp port prerequisite is stated as a fixed 9222 rather than tied to the cdp_port parameter, but the default matches.

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

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

The schema already documents all nested parameters with descriptions, including duration behavior and log_type. The description adds semantic value by explaining what each action value means and reiterating the cdp port requirement, which the bare schema enum does not provide.

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?

Opens with '采集小程序运行时日志和异常' – a specific verb and object. The two actions (console vs cdp) map to distinct log sources, which separates it from siblings like wechat_build or wechat_screenshot. No ambiguity about what the tool does.

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 that the cdp action requires opening the project with cdp_enabled=true and a usable port 9222, and separates what each action collects (console/JS exceptions vs WXML/render/deprecated-API logs). It does not name sibling alternatives or exclusions, but the internal action guidance 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?

Annotations already carry idempotent/non-destructive flags, and the description adds the navigation-and-wait behavior plus the exact JSON return contract. It does not detail side effects like page-state changes or failure cases, but for an idempotent navigation tool the disclosure is adequate.

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 front-loaded sentences convey action, applicability, prerequisite, and return shape with no redundant filler. The structure is easy to scan.

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

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

For a parameter-rich CDP tool, the definition covers the prerequisite, use cases, and return contract while annotations cover safety/idempotency. It is missing only explicit disambiguation from siblings and error/failure behavior, which are not critical given the output schema and schema-level parameter docs.

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 prose only refers abstractly to '指定页面' and '指定时间' and does not document parameters itself. However, the nested schema fully describes page_path with a query-parameter example, timeout/wait_ms ranges, and clear_logs/check_data behavior, so an agent can still invoke the tool correctly without relying on the 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?

States a precise action—'跳转到指定页面' plus CDP log capture—and binds it to concrete use cases (onLoad/onShow lifecycle checks, page error verification). This is specific enough to tell wechat_navigate apart from siblings like wechat_screenshot or wechat_inspector.

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 gives the prerequisite call to wechat_automator with cdp_enabled=true and names the intended scenarios. It does not state when to prefer a different tool or define exclusions, so it stops short of a 5.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description reveals that the tool auto-scrolls and stitches long screenshots by default, that output_path can be omitted to save to screenshots/, and that the response is a JSON object with success, data.path/width/height/segments, and message. These behavioral details help the agent anticipate side effects and response shape. No contradiction with 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?

Four short sentences, each adding new information: purpose, long-screenshot default, output_path default, return format. The most important action and defaults are front-loaded. No redundant or marketing language.

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 read-only screenshot tool with a rich schema and an output schema, the description covers the key defaults and return format. It does not mention prerequisites like the simulator being open or the meaning of 'segments', but these are minor given the existing schema and annotations. The description is sufficient for an agent to 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?

The context signal reports 0% schema description coverage, so the description must compensate, but it only details output_path's default location and implicitly full_page's default. Parameters like overlap, auto_port, page_path, and scroll_top are not explained in the description, requiring the agent to inspect the nested $defs. The $defs do contain descriptions, which mitigates this, but the description itself adds little parametric meaning 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 opens with a specific verb and resource: '实时捕获当前小程序模拟器的界面截图' (capture the current mini-program simulator interface screenshot in real-time). It further clarifies the long-screenshot default and references the output path and return JSON, leaving no doubt about the tool's function. This clearly distinguishes it from sibling tools like wechat_build or wechat_navigate.

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 clear context that this is for capturing screenshots of the simulator and mentions default long-screenshot behavior. It does not, however, name any sibling tools or state when to prefer this over wechat_inspector or wechat_automator. A brief 'use this when you need a screenshot' would have been stronger, but the context is unambiguous enough.

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