CipherHUB Cryptography Toolkit

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

With no annotations provided, the description carries the full burden and handles it well. It discloses tolerated encoding variants (indefinite length, segmented octet strings, high tag numbers), the single-root/byte-closed requirement, and the important caveat that der_conformant is only a walker-level approximation, not a complete X.690 DER validator. It also lists truncated and warnings as possible outputs.

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 organized into clear sections (purpose, algorithm, parameters, output, notes) and front-loads the main purpose in the first sentence. Every section carries technically relevant information for invoking the tool, with no filler or repetition beyond the schema.

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

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

Because there is no output schema, the description compensates by enumerating the output fields, including structure_tree subfields, and by explaining the der_conformant approximation and BER feature list. It could be slightly more explicit about requiredness/error behavior for invalid or empty input, but for a single-parameter parser it is largely complete.

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

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

Schema description coverage is 100%, and the schema already documents asn1_in_hex as a hex string with size and tolerance constraints. The description's parameter section essentially repeats that information without adding new meaning, so the baseline 3 applies.

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

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

The opening sentence states a specific action and resource: dissect any ASN.1/BER bytes into a TLV structure and produce a per-node tree plus a DER verdict per X.690. This clearly distinguishes it from siblings such as der_encode or cert_parse because the focus is generic ASN.1/BER parsing, not encoding or certificate-specific parsing.

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 usage context: it is for arbitrary ASN.1/BER hex input and explicitly markets BER feature detection for non-standard encodings such as AWS KMS responses. However, it does not explicitly name sibling alternatives or state when not to use this tool, so it stops short of full when/when-not guidance.

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

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

No annotations are provided, but the description discloses important behaviors: automatic PKCS7 padding on encryption and auto-removal on decryption, fixed 16-byte IV, output fields (output_data_in_hex, output_length, output_sha256, algorithm), and the requirement that decryption ciphertext lengths be multiples of 16 bytes. This goes well beyond what the schema provides.

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 organized with labeled sections (算法, 参数, 自动行为, 输出, 注意) and front-loads the core operation. Every section conveys distinct operational information without redundancy or filler.

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

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

Even without an output schema, the description specifies the output fields and critical constraints (algorithm-key length mapping, IV length, input size, padding behavior, decryption length requirement). This is sufficient for correct invocation and use of the tool.

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

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

The input schema already documents all five parameters with 100% coverage, so the baseline is 3. The description adds useful semantic details such as key length per algorithm (16B vs 32B), IV fixed at 32 hex characters, and the decryption input length constraint, which are not fully obvious from the schema alone.

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 '分组密码 CBC 模式加解密' (block cipher CBC mode encryption/decryption), giving a specific verb and resource. It further distinguishes itself from siblings like stream_cipher and zuc_cipher by naming CBC mode and the supported algorithms AES128/AES256/SM4.

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 labels the tool as a symmetric block cipher in CBC mode and lists algorithm choices, making its intended use clear. However, it does not explicitly compare against sibling tools such as stream_cipher or state when not to use this tool, leaving usage guidance mostly implicit.

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

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

With no annotations, the description carries the full burden and delivers: input validation semantics (trailing bytes rejected), tolerance for indefinite-length items, and explicit truncation behavior (structure_tree truncated with truncated=true above 20000 nodes or depth 64). It also warns that cbor2 applies built-in semantic decoding for tags 0/1/2/3, so wire-level form should be read from structure_tree.

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?

Bracketed section labels (【算法】【参数】【输出】【注意】) front-load the algorithm and constraints before parameters and outputs, which suits an agent scanning for call preconditions. It is dense and repeats the size/closure constraint already in the schema, costing some 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?

No output schema exists, so the description must enumerate return values, and it does: decoded_json (with byte/tag/semantic-tag forms), decoded_type, decoded_length, structure_tree field list, truncated, and warnings. Nothing needed to interpret a successful or truncated response is missing.

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

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

There is only one parameter and schema description coverage is 100%; the schema already documents the hex-string format, the 1B~128KB range, and the single-item/byte-closed constraint. The description restates the same range and constraint rather than adding syntax or new semantics, so the baseline of 3 applies.

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

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

States a specific verb (decode) plus resource (CBOR byte stream) and the exact output artifact (JSON plus a per-field structure tree), citing RFC 8949. The decode direction is unambiguously distinct from the sibling cbor_encode.

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 【算法】 and 【注意】 sections define the operational preconditions clearly: definite/indefinite length both accepted, single data item required, byte-closed input, trailing bytes rejected. It never names an alternative tool (e.g. cbor_encode) or states when not to use it, 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?

No annotations are provided, so the description carries the full burden. It discloses the two encoding algorithms (canonical vs indefinite), the teaching markers, the mutual-exclusion constraint, and the output fields. It does not explicitly state that the operation is pure/read-only, but the absence of side effects is strongly implied by 'encode' and the output list. The main gap is not describing error behavior or the meaning of 'truncated' and 'warnings'.

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 core purpose, followed by algorithm, parameters, output, and caveats. The parameter section is a bit dense with inline examples, but every sentence earns its place. The structure is logical and 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?

For a 4-parameter encoding tool with no output schema, the description covers the input format, the two encoding modes, the integer-key coercion, and the output fields. It does not explain the structure_tree output or the meaning of truncated/warnings, but the core calling contract is complete. The sibling context (cbor_decode, der_encode) is implicitly handled by the description's references.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the teaching markers ($bytes, $tag) and the coerce_integer_keys use case (Nitro attestation protected header {1:-35}) beyond the schema's terse descriptions. It also clarifies the ≤65536 character limit. This is meaningful added semantics, though not exhaustive.

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: '把 JSON 载荷编码为 CBOR 字节流（RFC 8949）' (encode a JSON payload into a CBOR byte stream per RFC 8949). It clearly distinguishes this from the sibling cbor_decode (the inverse operation) and from der_encode (which is explicitly referenced for the DER DSL). The scope is unambiguous.

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

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

The description explicitly states the mutual exclusivity of canonical and prefer_indefinite, and explains when to use coerce_integer_keys (to replicate Nitro attestation protected headers). It also references der_encode for the DER variant, giving an agent a clear routing cue. This is explicit when/when-not guidance.

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

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

With no annotations present, the description carries the full burden and does it thoroughly: it discloses input size limit, automatic GM OID branch detection, dual fingerprinting, the 'informational only' nature of validity status, library implementation details, and the exact failure error code 'Certificate parse failed.' This goes well beyond minimal safety and operational 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 dense and long, yet each sentence serves a purpose: input constraints, output inventory, GM-specific behavior, implementation notes, and error handling. Some implementation/bibliographic detail could be trimmed, but the structure is front-loaded with the core purpose and remains organized, so the length is justified.

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

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

There is no output schema, so the description must fully disclose what will be returned. It enumerates all major return fields, specifies GM-only additions, gives exact hex formats for SM2 public keys, states validity status behavior, and provides the failure error code. For a complex certificate parser with one input string, this is complete enough for an agent to call and interpret the result.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description repeats the PEM input and size constraint already in the schema but adds no new parameter-level meaning such as accepted encoding variants or handling of empty input. The schema and description are aligned, but the description does not elevate parameter understanding beyond the schema.

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

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

Description begins with a specific verb and resource: parse X.509 certificates, and immediately distinguishes the two supported paths (international vs. GM SM2). The detailed list of returned fields makes the tool's scope unmistakable and differentiates it from sibling cert_verify by framing the operation as parsing rather than 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 use case is implied: 'parse X.509 certificate' clearly signals an analysis/parsing task rather than verification. However, the description never explicitly states when to prefer this over cert_verify or any other sibling, and there are no exclusionary conditions. It provides clear context but no formal when/when-not guidance.

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

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

With no annotations provided, the description carries the full burden, and it is exceptionally transparent. It explains the two cryptographic code paths (GmSSL for GM certs, cryptography for RSA/EC/Ed25519), defines verified=false as a successful response with a reason taxonomy, clarifies that validity only affects time_status, and discloses the exact error condition for 'Certificate verify failed'.

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 and scope, then adds dense but relevant implementation and response-semantics details. It is long, but nearly every clause contributes behavioral information an agent needs; there is only minor redundancy with the schema regarding sm2_id.

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 verification tool with no output schema and no annotations, the description covers the essential contract: accepted cert types, algorithm selection, response boolean/reason/time_status semantics, and error boundaries. It does not explicitly state that both PEM parameters are mandatory despite schema defaults of '', nor describe the exact output envelope, so a small gap remains.

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

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

Schema description coverage is 100%, and the schema already documents sm2_id's default, GM-only usage, size range, and PEM formatting for both certs. The prose adds algorithm-path context for sm2_id but does not materially change parameter semantics, so the baseline of 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 opens with a specific verb and resource — '用 CA 证书验证终端实体证书' — and immediately narrows scope to single-level direct issuance. It explicitly excludes chain building and revocation checking, which distinguishes it from cert_parse and any broader validation tool.

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

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

The description gives concrete context: use this tool for one-level direct CA issuance verification, and it explicitly states what it does not do (no chain building, no revocation checking). It does not name a sibling alternative or say 'use X instead', so it stops just short of the top 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?

No annotations exist, so the description carries the full burden and does so well: structural parse success yields success even when decryption fails (decrypted=false + reason, tree still returned), AEAD mac length must equal declared aes-ICVlen, authAttrs become AAD per RFC 5083 §3, and BER features are surfaced. This is exactly the behavioral disclosure an agent needs for a mutation-free but failure-tolerant crypto 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?

Uses clear 【算法】【参数】【输出】【注意】section headers with the purpose front-loaded in sentence one. It is dense and long, but for a multi-algorithm RFC-driven crypto tool nearly every clause (OAEP param reconstruction, CBC PKCS#7 vs GCM AEAD dispatch) earns its place; slight trimming of parenthetical RFC references is the only 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?

There is no output schema, so the description enumerates the return shape (decrypted, reason, plain_data_in_hex, version, wrap/CEA, recipients, ber_features, structure_tree) and explains the success/failure contract. Combined with full behavioral coverage despite absent annotations, an agent has everything needed to invoke and interpret 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?

Schema description coverage is 100%, so the baseline is 3, but the description adds real meaning: the private key is optional and its absence switches the tool to structure-only mode, and the password field is left blank for unencrypted keys. The 16MB size bound and explicit acceptance of KMS BER replies further clarify cms_in_hex beyond the schema text.

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

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

States a specific verb+resource: decrypt CMS EnvelopedData (RFC 5652 §6) / authEnvelopedData (RFC 5083) with BER/DER tolerance. The RFC citations and 'enveloped' qualifier make it clearly distinguishable from siblings like cms_enveloped_encrypt, cms_enveloped_parse, and cms_signed_verify without opening any schema.

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

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

Gives clear operational context: it reconstructs padding/content algorithms from the message declaration and does structural decomposition only when no private key is supplied ('不给则仅做结构拆解'). It also states a when-not case (GCM under EnvelopedData is undefined and rejected), but never names the sibling alternative (e.g. cms_enveloped_parse for structure-only work), so routing is inferred rather than explicit.

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

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

With no annotations, the description carries the full burden and delivers unusually rich detail: the 【注意】 section states CEK and IV are CSPRNG-generated server-side and never echoed, and it specifies version numbering (2 with SKI, 0 otherwise) and the authEnvelopedData shape for GCM. It stops short of covering failure modes, error behavior, or persistence/reversibility.

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?

Headers (【算法】【参数】【输出】【注意】) make it scannable and front-loaded, and the RFC citations are precise rather than filler. It is longer than strictly needed, with some algorithm-spec prose that duplicates enum values already in the schema.

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

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

There is no output schema and no annotations, so the description must explain the return shape — and it does, enumerating cms_in_hex, version, wrap/CEA OIDs, recipients digest, der_note, and structure_tree. Only the absence of error/auth-failure behavior keeps it from being fully complete.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes beyond it — explaining OAEP internals (hashFunc + MGF1 same hash + empty pSource), the 12B nonce and tag placement for GCM, and the 1B~16MB plaintext range that the schema omits. It maps directly onto all four 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 opening names a specific verb and resource ('构造 CMS EnvelopedData 信封 (RFC 5652 §6, KeyTransRecipientInfo)'), with a bracketed [cms_enveloped] tag that cleanly separates it from cms_enveloped_decrypt and cms_enveloped_parse. An agent can identify the operation without opening the schema.

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

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

The description establishes clear context: you supply a recipient RSA certificate plus hex plaintext and get a wrapped envelope back. It does not, however, name when to prefer this over cms_signed_sign or cms_enveloped_parse, nor state any prerequisites/exclusions explicitly.

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

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

With no annotations, the description carries the full burden and does so: it discloses that it never decrypts, the 16MB input ceiling, the two-layer parsing approach (custom ASN.1 TLV walker with BER tolerance + asn1crypto), and that recipient_info_supported is set False for non-KeyTrans recipients. These are real behavioral traits beyond anything structured.

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

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

Front-loaded with labeled sections 【算法】【参数】【输出】【注意】 that make scanning easy. The output enumeration is lengthy but justified by the absence of an output schema; overall every block 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?

There is no output schema, so the description must describe returns — and it enumerates them (content_type_oid, version, recipients, content_encryption_iv_hex, recipient_info_supported, ber_features, structure_tree with offset/length_form/rfc_note). Combined with the no-decryption and recipient-support caveats, an agent has everything needed to call it correctly.

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

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

Schema coverage is 100% for the single cms_in_hex parameter, and the description's parameter note (hex DER/BER, ≤16MB, BER indefinite-length accepted) largely restates what the schema already documents. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

States a precise verb+resource: pure decomposition of CMS EnvelopedData (RFC 5652 §6) / authEnvelopedData (RFC 5083), and immediately excludes decryption (不解密). This clearly separates it from the sibling cms_enveloped_decrypt without opening either schema.

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

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

The '不解密' boundary and the note that KARI/KEKRI/PWRI/ORI recipients can be parsed but not decrypted tell the agent when this tool applies and when to route to a decrypt tool. It stops short of naming the alternative explicitly, so it's clear context rather than a full when/when-not statement.

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

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

With no annotations, the description carries the full burden and does so richly: it discloses the exact authenticatedAttributes set (contentType, messageDigest, signingTime, SMIMECapabilities), the §5.4 untag/EXPLICIT SET OF re-encoding rule, attached vs detached payload behavior, input size bounds (1B–16MB), and concrete failure modes (signing failure error code for rejected algorithms, verify-side still accepts them).

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 bracketed 【算法】【参数】【输出】【注意】 structure is front-loaded with purpose and scannable, and nearly every line carries information. It is dense and somewhat long, but there is little filler to cut.

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

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

No output schema exists, so the description must explain returns, and it does: cms_in_hex, version, digest/signature algorithm OIDs, signer_sid, certificates_embedded, detached, and structure_tree. Combined with algorithm constraints, failure modes, and detached semantics, an agent has everything needed to invoke 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 100%, so the baseline is 3; most parameter text is duplicated from the schema. However, the description adds one genuinely new constraint absent from the schema — the 1B–16MB input range for data_in_hex — plus the sid-locator rationale for embedding the certificate, lifting it slightly above baseline.

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

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

States a precise verb+resource: 'construct CMS SignedData signature message (RFC 5652 §5)', with the exact standard clause. An agent can distinguish this from siblings such as cms_signed_verify, cose_sign1_sign, and rsa_sign without opening any schema.

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

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

The 【注意】 section gives real selection constraints: Ed25519 and SHA1 signing are rejected by the upstream builder, and RSA-PSS construction is not exposed (PSS artifacts must be verified via cms_signed_verify). This implicitly tells the agent when not to use the tool, but there is no explicit 'use this when you need a CMS structure rather than a bare signature' comparison against rsa_sign/cose_sign1_sign.

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

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

With no annotations, the description carries the full burden and does so: it discloses BER normalization behavior, per-algorithm padding reconstruction (PSS params, RSA PKCS#1 v1.5, ECDSA, Ed25519, SHA1), and the non-obvious failure semantics that verification failure returns verified=false + reason rather than an error code. It also flags that chain warnings are advisory, not failures.

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

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

Front-loaded with purpose and organized under clear 【算法】【参数】【输出】【注意】 headings, so it is scannable despite its length. It is dense but each section carries information an agent needs; there is mild overlap with the schema descriptions, which keeps it just short of a 5.

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

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

There is no output schema, so the description must enumerate returns, and it does (verified, reason, key_source, detached, content_in_hex, content_matches, algorithm OIDs, ber_features, structure_tree). Combined with algorithm coverage, failure semantics, and the cert_verify boundary, nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds real meaning beyond it: the ≤16MB bound, the attached-vs-detached rule that makes data_in_hex conditionally required despite the schema marking nothing required, and the sid-based fallback for the certificate 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?

States a specific verb (验签/verify) and resource (CMS SignedData, RFC 5652 §5) with a scope note that BER/DER inputs are both tolerated. It also draws an explicit boundary against the sibling cert_verify (chain validity is out of scope), so an agent can tell it apart from cms_signed_sign and cose_sign1_verify without opening the schema.

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

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

Gives clear conditional guidance: detached messages require data_in_hex, attached messages use the embedded eContent and ignore the field, and empty signer_certificate_in_pem triggers lookup from the certificates set by sid. It also names cert_verify as the owner of chain validity. No explicit exclusion of the signing sibling, but the context is unambiguous.

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

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

With no annotations, the description carries the full burden and does well: it discloses that no signature verification occurs, that the payload undergoes a nested CBOR decode attempt, the ≤128KB input cap, and even a signature_format_note about raw r||s semantics. It could still say more about malformed-input error behavior, but the behavioral profile is unusually well covered.

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?

Organized into labeled sections (算法/参数/输出/注意) with the core purpose front-loaded, and the enumerated output fields are useful. Slightly dense with some redundant restatement of the 4-element-array layout, but no padding.

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

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

No output schema exists, and the description fully enumerates the return fields (protected_header, payload_json, structure_tree, etc.), explains the decoding algorithm, and flags the cbor_decode isomorphism. An agent has everything needed to call and interpret 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?

Schema coverage is 100% and the single parameter's meaning (hex COSE_Sign1, 4-element array) is already documented in the schema. The description restates the ≤128KB constraint rather than adding new syntax, so this is the baseline 3.

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

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

States a specific verb (拆解/parse) and resource (COSE_Sign1 message), and immediately scopes it by distinguishing from verification ('不验签'). An agent can tell this apart from cose_sign1_verify and cose_sign1_sign without opening any schema.

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

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

The '不验签' framing plus the note that structure_tree is isomorphic with cbor_decode gives clear context for when this is the right tool versus cose_sign1_verify. There is no explicit when-not statement or a direct routing sentence naming the verify sibling, 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?

With no annotations, the description carries the disclosure burden and does well: it specifies the Sig_structure = ["Signature1", protected, external_aad, payload] coverage, the raw r||s padding convention, curve/key matching requirement, and password behavior. It omits any mention of permission preconditions or failure modes, keeping it short of a 5.

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 organized with bracketed section headers (算法/参数/输出/注意) that front-load the algorithm choices and constraints. It is verbose, but each line carries technical content an agent needs, with little filler.

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

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

No output schema exists, and the description compensates by enumerating every returned field (cose_sign1_in_hex, sig_structure, DER/raw signature forms). The detached-payload mode is only documented in the schema, leaving a small gap for a capable signing 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 coverage is 100% (baseline 3), and the description adds meaning beyond the schema: algorithm-to-curve mapping with RFC algorithm numbers, ES512's 66-byte coordinate/r||s layout, the 1B–256KB payload constraint, and the key-must-match-curve rule. Still, the 'detached' parameter is left entirely to the schema.

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

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

States a specific verb+resource ('构造并签名 COSE_Sign1 消息') with concrete RFC standards (9052 §4.2, 9053). The scope is unambiguous and clearly distinct from siblings cose_sign1_verify and cose_sign1_parse without needing to open a schema.

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

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

Usage is implied by the signing semantics and the note on what the signature actually covers, which helps an agent understand the operation. However, there is no explicit when-to-use/when-not guidance nor routing to alternatives like cms_signed_sign or cose_sign1_verify for the verify path.

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

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

With no annotations, the description carries the full behavioral burden and does it well: it discloses algorithm dispatch limits (-7/-35/-36 and -8), the success-response quirk that verified=false is a successful response with a reason, and the key-source fallback behavior. It could additionally clarify behavior for unsupported algorithms or missing certificate fields, but the disclosed traits are genuinely informative.

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 organized into labeled sections (algorithm, parameters, output, notes) and front-loads the tool's purpose before diving into details. Some parameter text repeats the schema, but every section contributes meaningful information and the structure aids scanning.

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 compensates by listing the return fields and explaining the unusual verified=false success semantics. It covers key behavior, key-source resolution, input size limits, and the output payload. Minor gaps remain around detached-payload handling and specific error cases, but overall the agent has enough context to call the tool correctly.

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

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

Schema coverage is 100%, so each parameter is already documented in the input schema. The description adds some useful nuance, such as the external AAD needing to match the signing-time value and the public-key fallback to the certificate, but these largely duplicate or only lightly extend the schema descriptions. It also omits detached_payload_in_hex from its parameter list, though the schema covers 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 opens with a specific verb-resource pair: '验证 COSE_Sign1 签名' (verify COSE_Sign1 signature) and anchors it to RFC 9052 §4.4 Sig_structure reconstruction. It also enumerates supported algorithms, which clearly distinguishes this tool from cose_sign1_parse and cose_sign1_sign.

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 operational context: when to provide a PEM key versus leaving it empty to extract from the payload certificate, and that external_aad_in_hex must match the value used at signing time. It does not explicitly state when to prefer this over siblings, but the verification purpose and parameter conditions make the intended usage 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: encryption and decryption are the same XOR operation, there is no padding, ciphertext is the same length as plaintext, input range is 1B–16MB, and CTR provides no authentication. It also specifies the key-length requirements and the IV semantics, so the agent understands side effects and security limitations.

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 every sentence contributes: mode semantics, key constraints, security caveat, and return fields. The only minor blemish is the duplicated leading tag '[symmetric_cipher] [symmetric_cipher]', which adds no value.

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

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

Despite lacking an output schema, it lists the expected return fields (output_data_in_hex, output_length, output_sha256, algorithm) and covers all operational constraints needed to call the tool correctly. The security caveat and alternative-tool routing make the context complete for an 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 schema already covers 100% of parameters, so the baseline is 3. The description adds meaningful beyond-schema detail by specifying exact key byte lengths, implementation origins (cryptography vs GmSSL, same source as eet sm4-ctr), and clarifying that iv_in_hex is the 16-byte initial counter block.

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 immediately states it performs CTR-mode encryption/decryption for AES-256-CTR and SM4-CTR, making the operation and scope explicit. It also distinguishes itself from stream_cipher's AEAD modes by naming them as the alternative when tamper resistance is required.

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 gives explicit guidance: use stream_cipher's AEAD modes when tamper resistance is needed, and use CTR only when there is already an independent authentication layer or an interoperability scenario. This clearly tells an agent when to select this tool versus its siblings.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It specifies the fixed 16-byte block size, the available actions (DoPadding/UnPadding), and the output fields (output_data_in_hex, output_length). It lacks details on edge-case behavior like invalid padding, but the core behavior is well covered.

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 tool's purpose. It is organized with clear sections (parameters, output, notes) and contains no fluff. Minor redundancy with the schema parameter descriptions prevents a perfect score.

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

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

Given the tool's simplicity (2 parameters, no output schema, no nested objects), the description is reasonably complete. It explains the expected output and provides important context about block size and integration with block_cipher, though it lacks examples or explicit error handling.

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

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

Schema coverage is 100%, and the schema already provides detailed descriptions for both parameters. The description mostly restates the same information (e.g., DoPadding/UnPadding definitions) without adding new parameter semantics, so it meets the baseline but does not exceed 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 identifies the tool as a PKCS7 padding/unpadding utility with a specific verb ('填充/去填充') and resource (data). It distinguishes itself from sibling tools by noting that block_cipher normally handles padding internally, which clarifies its specialized role.

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 this tool is not needed ('通常无需单独调用此工具') and names the alternative (block_cipher) that already performs padding automatically. This gives clear usage direction, preventing unnecessary invocation.

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 burden of behavioral disclosure, and it does so thoroughly. It explains the encoding algorithm, SET OF sorting behavior, indefinite-length construction with 0x80 + EOC, constraints on OID arcs and time formats, the raw escape hatch, and the mutually exclusive modes. It also lists output fields such as der_conformant, structure_tree, truncated, and warnings, giving the agent a clear picture of what will happen.

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 organized into labeled sections: algorithm, parameters, output, and notes. The core purpose is front-loaded, and each section earns its place given the complexity of the tool. Minor redundancy with the input schema description prevents a 5, but the structure is appropriate for the subject matter.

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 no output schema and no annotations, the description covers the critical calling context: input DSL forms, encoding modes, mutual exclusion, constraints, and output field names. It stops short of fully defining the semantics of every output field or error behavior, but it is complete enough for an agent to invoke the tool correctly and interpret the main results.

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

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

The input schema already provides 100% parameter coverage with detailed descriptions, so the baseline is 3. The description adds value beyond the schema by giving concrete DSL examples, explaining explicit vs implicit constructed forms, clarifying the meaning of both-false mode, and specifying constraints like OID arc limits and unused_bits range. This goes beyond the schema's own documentation.

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: '把 JSON 节点 DSL 编码为 DER 字节（X.690）'. It immediately distinguishes DER encoding from decoding or other encodings and further clarifies the two BER/DER modes. The purpose is unmistakable even without opening the schema.

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

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

The description clearly explains when to use DER mode, BER indefinite mode, or the teaching BER mode, and states that der and ber_indefinite are mutually exclusive. However, it never explicitly compares this tool with sibling tools such as cbor_encode or asn1_parse, so guidance for choosing this tool over alternatives is only implied rather than stated.

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

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

No annotations are present, so the description carries full weight. It discloses the algorithm, output fields (derived_key_in_hex and derived_key_length), optional salt/info, length bounds, encrypted-private-key password handling, and unsupported curves. This goes well beyond the schema and gives the agent realistic expectations of behavior.

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

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

The description is well-structured with clear section headers, a bullet list of parameters, an output section, and a curve-limitation note. It is front-loaded with the core purpose and every line adds relevant operational information without filler.

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

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

Given no annotations and no output schema, the description compensates by specifying both outputs and key constraints. It covers all parameters, encryption-password behavior, and curve support. The only notable gap is lack of explicit comparison with sibling key-derivation or hybrid-key-exchange tools, though this is not essential for basic invocation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description largely restates parameter meanings (e.g., private key, public key, hash algorithm, salt, info), adding only minimal extra context such as '不支持 Sm3' and '若私钥加密则传入'. This is useful but not a substantial semantic expansion 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 explicitly states the operation: ECDH + HKDF key agreement using a private key and the counterpart's public key to derive the same symmetric key. This distinguishes it from sibling tools like hybrid_kex and key_derivation by naming the specific protocol and intended outcome.

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?

Clear context is provided: it is for two parties performing ECDH key exchange, with each side using their own private key and the other's public key. Curve restrictions are explicitly noted (Ed25519 unavailable, X25519 available), but no explicit guidance is given about when to prefer this over related siblings such as hybrid_kex.

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 burden. It explains the algorithm selection, the raw/digest mode behavior, and the curve limitation, going beyond the schema. It also lists output fields. This is substantial behavioral context, though it omits error handling or response format details.

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-organized with clear sections (parameters, output, limitation), uses bullet points for readability, and is front-loaded with the core purpose. Every sentence adds relevant 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?

For a signing tool, the description covers the essential aspects: algorithm behavior, parameter semantics, output fields, and a critical limitation. It does not mention error conditions or response formatting, but given the absence of an output schema, the listed output fields are helpful. Overall, it is adequately complete for an agent to call it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by clarifying that hash_algorithm is ignored for EdDSA, that ecc_private_key_password is only needed if the key is encrypted, and the effect of sign_raw_data_mode. These details complement the 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 clearly states 'ECC 私钥签名' (ECC private key signing) and specifies the algorithm variants (ECDSA for SECP*, EdDSA for ED25519). This distinguishes it from sibling tools like ecc_key_verify, ecc_key_exchange, and generate_ecc, 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?

The description provides curve-specific behavior (EdDSA ignores hash_algorithm) and a limitation (X25519 not allowed), but does not explicitly mention when to choose this tool over alternative signing tools like rsa_sign or sm2_sign. Usage guidance is implied rather than directly stated.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses the output fields ('verified' bool and 'curve_name'), algorithm behavior based on curve type, and a hard limitation for X25519. It does not cover error/edge-case behavior, but for a verification operation the essential behavior is well conveyed.

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 well organized with clear sections for parameters, output, and curve restrictions. The purpose is front-loaded, and every line contributes either operational guidance or a constraint with no filler.

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

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

Given the tool's moderate complexity and the absence of an output schema and annotations, the description covers the essential context: algorithm mapping, output semantics, parameter consistency requirements, and an explicit unsupported curve. An agent has enough information to 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 100%, so the baseline is 3. The description adds important cross-parameter constraints—sign_raw_data_mode and hash_algorithm must match the original signing parameters—and links curve type to algorithm choice. It does not add per-parameter detail for data_in_hex or signature_in_hex, but the added constraints push it above baseline.

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

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

The description states a specific operation, 'ECC 公钥验签' (ECC public-key signature verification), and adds algorithm mapping (ECDSA for SECP*, EdDSA for ED25519). This clearly distinguishes it from other verify tools for RSA/SM2 and from ECC key generation/exchange siblings.

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

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

It gives clear operational guidance: SECP* curves use ECDSA, ED25519 uses EdDSA, X25519 is explicitly unusable, and sign_raw_data_mode/hash_algorithm must match the signing side. It does not explicitly name alternative tools, but the curve restrictions and ECC-specific context make appropriate usage 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 carries the full burden of behavioral disclosure. It explicitly lists the output fields (public_key_in_pem, private_key_in_pem, curve), mentions optional password protection for the private PEM, and details each curve's capabilities. This provides a solid picture of what happens when the tool is called, though it doesn't cover edge cases like error behavior or key format details.

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 clear sections for curve list, parameters, output, and capability matrix. Each line serves a purpose, and the format is front-loaded with the primary action. It is dense but not bloated, efficiently conveying necessary 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?

Given the tool has no output schema, the description compensates by explicitly listing the three output fields. It also covers all curve options, capability restrictions, and parameter details. The tool's complexity is fully addressed, and the description provides enough information for an agent to invoke it correctly without ambiguity.

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

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

Schema coverage is 100%, so parameters are already documented. The description adds value by explaining the meaning of the curve parameter through the capability matrix and clarifying that private_key_password provides PEM encryption protection. This goes beyond the raw enum values in 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 begins with '生成 ECC 密钥对' (generate ECC key pair), which is a specific verb+resource statement that clearly identifies the tool's purpose. It distinguishes from sibling tools like ecc_key_sign, ecc_key_verify, and ecc_key_exchange, which perform subsequent operations rather than generation.

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 a capability matrix mapping each curve to its supported operations (e.g., ED25519 only signing, X25519 only ECDH), giving clear context on when to use each variant. While it doesn't explicitly state 'use this instead of generate_rsa', the matrix effectively guides curve selection, which is the main usage decision for this tool.

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

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

No annotations are provided, so the description carries the burden. It discloses the source (OS CSPRNG), output encoding (Hex), and length limit. However, it does not mention error behavior on invalid input or other edge cases, leaving some behavioral opacity.

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 compact sentences that front-load the core purpose with a '[random]' tag, followed by parameter and return field details. No filler or redundant 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?

The description covers purpose, parameter, and return fields, which is sufficient for a simple one-parameter tool without an output schema. It lacks error-handling details but is otherwise complete.

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

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

Schema coverage is 100% with a description already covering the byte count range (1-128). The tool description repeats this and adds return field semantics, adding marginal value beyond the schema but not significantly clarifying parameter meaning.

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 'generates secure random bytes using OS CSPRNG' with a specific verb and resource, and specifies the data_length range and return format. This distinguishes it from sibling key generation and crypto operation 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 for generating random byte strings via '[random]' and details the length and output format. It does not explicitly state when not to use it or mention alternatives, but the sibling context makes its purpose 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 carries the full burden. It discloses that setting private_key_password encrypts the private key with AES-256-CBC, enumerates exact output field names, and explains the intended downstream use—behavior beyond what the schema provides.

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 uses clear labeled sections (parameters, output, follow-up) and every phrase provides necessary context. No filler or redundancy, and the main purpose is front-loaded.

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

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

For a tool with two optional parameters and no output schema, the description is fully self-contained: it lists all output fields, explains parameter effects, and links to related operations. An agent can select and invoke this tool without needing external documentation.

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 covers both parameters with 100% description coverage, but the description adds the crucial encryption behavior for private_key_password (AES-256-CBC) that is absent from the schema. key_size is adequately described in both, though the description adds no new semantics for 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 explicitly states '生成 RSA 密钥对' (generate RSA key pair), naming the exact resource and action. It distinguishes itself from sibling key generation tools like generate_ecc and generate_sm2 by specifying RSA and identifying the output keys as PEM.

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

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

Provides clear context by mapping the public key to rsa_encryption/rsa_verify and the private key to rsa_decryption/rsa_sign, telling the agent when this tool is appropriate. However, it does not explicitly contrast with alternative key generation tools or state when not to use it.

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 disclosure burden. It usefully states that the private key is exported only as an encrypted PEM and lists the output fields. However, it does not mention side effects, prerequisites, or operational constraints, and the claim that private_key_password is required contradicts the schema where it is optional.

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 organized with clear 【参数】, 【输出】, and 【后续操作】 sections. Every section earns its place and no filler is present.

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?

Because there is no output schema, the explicit list of output fields is valuable. The one-parameter tool is otherwise simple, but the required/optional contradiction about private_key_password leaves an agent uncertain whether the parameter can be omitted, which is a meaningful gap in 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 coverage is 100%, so the baseline is 3. The description adds meaningful constraints (password must be 1-64 bytes; private key is only exported as encrypted PEM), but it also states '必填' while the schema marks the parameter optional with a default of '', creating an inconsistency that hurts reliability.

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-resource pair: '生成 SM2（SM2P256V1 / 国密曲线）密钥对'. This clearly identifies the tool as SM2 key-pair generation and distinguishes it from siblings such as generate_rsa, generate_sm9, and generate_ecc without needing to inspect schemas.

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 downstream context: the public key should be used for sm2_encryption / sm2_verify and the private key for sm2_decryption / sm2_sign. It does not explicitly name alternatives or exclusion conditions, but the SM2-specific workflow is clear enough for an agent to infer when to select this tool.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly reveals that the public key is plaintext, the private key is ENCRYPTED, there is no plaintext private-key export, and the private key is KGC-held. It does not cover return mechanics like whether files or strings are emitted, but it covers the most critical operational 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 compact and information-dense, covering standard, key kinds, outputs, and password constraints. The duplicated '[sm9_ibc] [sm9_ibc]' prefix is redundant clutter and keeps it from a perfect score.

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

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

For a security-sensitive generation tool with no annotations and no output schema, it explains inputs, outputs, and private-key encryption constraints well. It falls short on exact return payload shape, whether the tool writes files, and resolving the required/optional password contradiction.

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 useful meaning to key_kind and specifies password length/encoding. However, it directly contradicts the schema and context signals by declaring private_key_password as required, while the schema marks it optional with default '' and indicates zero required 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 states it generates SM9 identity-based master keys (GM/T 0044), which is a specific verb and resource. It further distinguishes Sign vs Enc key kinds, making it easy to differentiate from siblings like sm9_extract_key or generate_sm2.

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 gives clear guidance for choosing key_kind (Sign vs Enc), states the default, and describes who holds the public key. However, it does not explicitly mention when to prefer this tool over sibling tools such as sm9_extract_key.

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

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

No annotations are provided, so the description carries the full burden. It fully discloses the output structure (Results dictionary with hash_sum_in_hex and hash_length), explains the SHAKE XOF behavior with variable output length and key derivation usage, and describes the conditional activation of shake_output_length. This goes far beyond the schema.

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

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

The description is well-structured using sections for algorithms, parameters, output, and SHAKE notes. It is front-loaded with purpose and every listed item adds value without unnecessary verbosity.

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

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

Given no annotations and no output schema, the description provides a complete standalone reference: it covers input constraints, default behaviors, conditional parameters, exact output format, and edge-case explanations for SHAKE. Very few 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?

Schema coverage is 100%, providing baseline 3. The description adds extra meaning: required_hash_modes defaults to all algorithms, shake_output_length only takes effect when SHAKE modes are requested, and plain_in_hex has a size range. These enrich parameter understanding 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 explicitly states the tool '计算消息摘要' (computes message digest) and lists all supported algorithms (Sha1, Sha224, Sha256, etc.), clearly distinguishing it from sibling tools like hmac_sum which focus on HMAC. It has a specific verb and resource.

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

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

It provides clear context for when to use the tool (computing hashes) and describes batch computation and algorithm selection. However, it does not explicitly contrast with alternatives like hmac_sum or state when not to use this tool, so it lacks explicit exclusions.

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 the tool's behavior: it echoes client_msg and appends server_msg. It also explicitly lists the return fields (client_msg, server_msg), providing transparency beyond the schema alone. It does not explicitly state there are no side effects, but the utility nature 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 extremely concise: two well-structured sentences. It front-loads the tool type [utility] and health check purpose, then details the behavior and return fields. Every sentence earns its place with zero 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?

For a simple echo utility with one parameter and no output schema, the description is complete. It explains the purpose, the exact behavior, the parameter's role, and both return fields. An agent can confidently invoke this tool correctly based on the provided information.

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

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

Schema description coverage is 100%: client_msg is already described as '任意字符串，服务端原样回显（原始字符串，非编码格式）'. The tool description reiterates this same meaning without adding new parameter-level details, so it provides no additional value beyond the schema.

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

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

Description clearly states it is a health check / echo interface, with a specific verb ('回显' - echo back) and resource (client_msg). It explicitly distinguishes itself from sibling crypto tools by describing its utility purpose (verifying MCP channel connectivity).

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 the intended use case: '用于验证 MCP 通道连通性' (to verify MCP channel connectivity). It provides clear context for when to use the tool, though it doesn't describe exclusions or alternatives, which is acceptable given the sibling tools are unrelated crypto functions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It details the output format (a dictionary with hmac_sum_in_hex and hmac_length per algorithm), key length constraints, input size limits (1B-16MB), and default behavior (computes all 6 algorithms). It also explains key preprocessing per RFC 2104. This is transparent for a non-destructive pure computation 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 well-organized with labeled sections for algorithms, parameters, output, and typical use. It is clear and front-loaded with the core purpose, though it is somewhat verbose. The structure makes it easy to scan, and every section 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 no output schema, the description adequately explains the return format. It covers parameter constraints (key length, input size), algorithm options, and default behavior. The only gap is a lack of explicit comparison with sibling hash_sum, but the description is otherwise complete for an agent to 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 100%, so baseline is 3. The description adds meaningful context: key length dependencies on algorithm, SM3 block size limit, and clarification that SHAKE is unsupported. It also explains the default value for required_hash_modes. This goes beyond the schema's simple descriptions, justifying a 4.

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 computes HMAC (hash-based message authentication code) and lists the supported algorithms (Sha1/Sha224/Sha256/Sha384/Sha512/Sm3). It differentiates itself from simple hashing tools like hash_sum by emphasizing the keyed authentication aspect, 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?

The description mentions typical use cases (message integrity, API signatures, key confirmation) and excludes SHAKE algorithms, but it does not explicitly compare against sibling tools like hash_sum or state when to prefer this over alternatives. The context is implied but lacks explicit when-to-use and when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden, and it does so thoroughly: it discloses that blank keys are generated via CSPRNG, that ML-KEM public and private keys must be provided together, accepted encodings, the HKDF-SHA256 derivation flow, output including keys_match, and the claimed security level. It even warns that this is not the X-Wing combiner itself, preventing misuse.

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 clear sections: summary, design note, parameters, flow, output, and security level. It front-loads the purpose and keeps each section dense and relevant; the X-Wing caveat and security statement earn their place for a cryptographic demo tool.

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 8-parameter tool with no output schema, the description covers the flow, input optionality, key-format constraints, derivation process, and result verification through keys_match. It is slightly vague about exactly which 'intermediate values' are returned, but overall an agent has enough context to 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?

The description adds meaning by organizing the eight parameters by Alice/Bob side, explaining raw vs SPKI/PKCS#8 Base64 formats, and emphasizing the paired public/private key requirement. Much of this is already present in the schema description, so the added value is mostly consolidation and clearer framing rather than entirely new semantics.

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

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

The description clearly states a specific verb and resource: '执行 X25519 + ML-KEM-768 混合密钥交换全流程演示'. It distinguishes itself from sibling single-algorithm tools like ml_kem_encap, ml_kem_decap, and ecc_key_exchange by describing a hybrid full-flow demo. It also clarifies that it implements a generic concatenation combiner rather than the X-Wing specification.

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 strongly implies usage as a full hybrid key-exchange demo and explains the flow, but it never explicitly states when to prefer this tool over siblings such as ml_kem_encap/ml_kem_decap or ecc_key_exchange. It includes setup conditions, like 'all parameters optional' and 'keys generated randomly if blank', but lacks explicit when-to-use/when-not-to-use guidance.

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

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

无任何 annotations，描述承载了全部行为披露责任。它详细说明了 HKDF 的 extract-then-expand 过程、Pbkdf2Sm3 空盐时服务端生成随机盐并在响应回显、RFC 5869 空盐补零行为、iterations 受 8s 网关约束、输出字段等。行为透明度和副作用说明远超一般工具描述。

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?

描述结构清晰：先一句话概述目的，再用“【支持算法】【参数】【输出】【典型用途】”分节。内容密度高但每一条都有具体指导价值，没有任何冗余空话。虽长度可观，但鉴于工具本身涉及三种算法和 8 个参数，这种详尽程度是合理且必要的。

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?

工具复杂度高（8 参数、3 算法、算法间参数互斥），且无输出 schema，但描述提供了完整的输出字段清单（derived_key_in_hex、salt_used_in_hex、salt_generated 等），并补充了跨参数约束、长度范围、错误行为（错配被拒）和性能上限。即使没有输出 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 描述覆盖率为 100%，但描述在 schema 基础上补充了大量语义，如每个参数适用的算法（hash_algorithm 仅 HKDF、password 仅 Pbkdf2Sm3）、输入长度限制、默认值说明、Pbkdf2Sm3 空盐的服务端回显行为、iterations 的互通测试建议区间等。这些信息对正确构造参数至关重要，远非重复 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?

明确以动词“执行密钥派生（KDF）”开头，点明核心资源与目标（从高熵秘密或口令派生对称密钥材料），并列出三种支持算法。与同组工具（如 hash_sum、hmac_sum、sm2_decryption 等）明显区分，无歧义。

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?

描述给出了清晰的使用场景与算法选择依据，如“HKDF（默认）”“Sm3Kdf 适合对 SM2 ECDH 共享秘密派生密钥”“Pbkdf2Sm3 用于口令拉伸”，并提及“典型用途”和“参数按算法适用，错配会被拒”。虽未显式与兄弟工具做“何时不用”的对比，但对一个独立 KDF 工具而言，使用指引已足够充分。

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 takes on the full burden. It thoroughly discloses behavior: the exact formula, input validation (OID/length consistency check), constraints (max message 2048 bytes, max context 255 bytes), and all output fields. This is well beyond a mere 'compute mu' statement.

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 for purpose, usage, formula, parameters, and output. Every sentence adds value, and the most important information (what it does) is front-loaded. Length is justified given the technical 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 there is no output schema, the description appropriately lists all output fields. It covers the formula, input requirements, constraints, and purpose, making the tool fully usable without external documentation. This is a complete description for a computation 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 schema already covers 100% of parameters with basic descriptions, but the tool description adds meaningful semantics: public key can be SPKI DER or bare, message empty string means empty message, and size limits for message and context. This adds real 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 the tool's function: independently compute the 64-byte mu value for ML-DSA per FIPS 204 Section 6.2. It also distinguishes itself from siblings like ml_dsa_sign and ml_dsa_verify by specifying it is for EXTERNAL_MU mode intermediate values.

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 names the two use cases: verifying/debugging EXTERNAL_MU mode intermediate values and integrating with AWS KMS EXTERNAL_MU signing flow. It does not explicitly state when not to use it compared to sibling signing/verification tools, but the use cases are clear enough.

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 burden of behavioral disclosure. It thoroughly details all output fields and their formats (SPKI DER hex for public key, PKCS#8 DER hex for private key, base64 encodings, etc.). However, it does not explicitly state that a new random key pair is generated each time or discuss any side effects, though for a keygen tool the generation semantics are largely implicit.

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-organized with clear labeled sections (e.g., algorithm selection, security level reference, output, typical usage). It is dense but every sentence adds unique value, and nothing is redundant or filler. The structure makes the information 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 tool with only one optional parameter and no output schema, the description is remarkably complete: it lists all return fields, explains the algorithm variants, and connects to the typical key life-cycle with related tools. There are no significant informational gaps that would prevent 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?

The input schema already provides full coverage of the single `algorithm` parameter with enum values and a default. The description adds meaningful context by mapping each algorithm to NIST security levels and AES equivalents, which helps an agent choose an appropriate value. This goes beyond the schema's bare enum labels.

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 generates ML-DSA key pairs per FIPS 204, using a specific verb ('generates') and resource ('ML-DSA key pair'). It also differentiates from sibling tools by naming related sign/verify tools and other key generation tools, making its purpose unmistakable.

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 concrete usage context: 'after generating, the private key is used for ml_dsa_sign and the public key for ml_dsa_verify'. It also explains algorithm choices and security levels. It does not explicitly name alternatives or when NOT to use this tool, but the integration with sibling tools offers clear 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?

With no annotations, the description carries the full burden of behavioral disclosure and does so excellently. It reveals the exact message-length limits, the auto-switch behavior between RAW and EXTERNAL_MU, the acceptance of empty messages, the algorithm options, and the full output field set. This goes well beyond a simple 'sign' statement and gives the agent a reliable mental model.

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 well-structured with clear section headers and bullet points. It is front-loaded with the tool's purpose, then systematically covers modes, length policy, algorithm, parameters, and output. While some redundancy exists (e.g., length limits repeated for each mode), every sentence contributes necessary information, making it concise enough for its 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 six parameters, dual modes, length constraints, and no output schema, the description is remarkably complete. It explicitly lists all output fields, describes when each parameter is needed, covers edge cases like empty messages and oversize rejection, and even adds domain context (FIPS 204 and AWS KMS equivalence). There are no obvious missing pieces that an agent would need for successful 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?

Though schema coverage is 100%, the schema descriptions are generic (e.g., '十六进制字符串'). The tool description adds crucial semantics: private_key_in_hex is sourced from ml_dsa_keygen, public_key_spki_in_hex is mandatory only for EXTERNAL_MU, context_in_hex is capped at 255 bytes, and sign_mode values are explained with their behavioral consequences. This is essential for correct invocation.

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

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

The description opens with '使用 ML-DSA 私钥对消息签名（FIPS 204）', which is a clear and specific verb+resource statement. It distinguishes the tool from siblings like ml_dsa_verify and ml_dsa_compute_mu by clearly marking it as the signing operation, and even elaborates the two signing modes, leaving no doubt about its primary function.

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 usage guidance: RAW mode for messages up to 256 bytes, EXTERNAL_MU for up to 2048 bytes, an automatic switching rule for 256–2048 bytes, and a rejection rule above 2048 bytes. It also states that public_key_spki_in_hex is required only in EXTERNAL_MU mode, giving the agent clear when-to-use and prerequisite information.

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 burden of behavioral disclosure. It discloses byte limits (256/2048), legal empty messages, key format flexibility (SPKI DER or raw), OID/length validation, OpenSSL 3.5+ dependency for EXTERNAL_MU, and the exact output fields. This is rich, actionable behavioral context.

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

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

The description is well-structured with clearly labeled sections (双模式, 算法, 参数, 输出) and uses bullet points for readability. Every sentence carries important information with no repetition or fluff, making it efficient despite its 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?

For a tool with 6 parameters, multiple modes, and algorithm variants, the description covers all essential aspects: purpose, mode semantics, algorithm options, parameter details, constraints, and output structure. Since there is no output schema, it even lists output fields. This is a complete standalone reference.

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?

Although the schema covers 100% of parameters, the description adds critical semantics beyond field names: public_key_spki_in_hex accepts SPKI or raw and is validated against algorithm, message_in_hex empty means empty message, context_in_hex must match signing context, and sign_mode behavior is explained with byte limits. This elevates the parameter understanding well above the baseline.

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

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

The description clearly states '使用 ML-DSA 公钥验证签名' (verify signature using ML-DSA public key) and references FIPS 204. It distinguishes this tool from siblings like ml_dsa_sign and ml_dsa_compute_mu by explicitly scoping it to verification, and provides specific mode and algorithm details that reinforce its unique purpose.

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 guidance on when to use each sign_mode (RAW vs EXTERNAL_MU), including a concrete use case (AWS KMS EXTERNAL_MU signatures) and constraints like message size limits. It doesn't explicitly name alternative tools for exclusion, but the sibling list and algorithm scope make the intended usage 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 key behavioral traits: implicit rejection on tampered ciphertext (returns deterministic pseudo-random value, no exception), IND-CCA2 security, and no private key leakage. It also explicitly lists all output fields. This is rich behavioral context that goes well beyond the schema.

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

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

The description is well-structured with clear sections for algorithm, parameters, output, security, and full process. Every sentence adds value, and the purpose is front-loaded. It is appropriately sized for 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?

Despite having no output schema, the description enumerates all output fields and covers algorithm variants, parameter origins, security behavior, and the overall workflow. This is complete enough for an agent to understand and use 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?

Although schema coverage is 100%, the description adds critical provenance semantics: it specifies that algorithm must match keygen/encap, secret_key_in_hex comes from ml_kem_keygen, and ciphertext_in_hex from ml_kem_encap. This greatly aids correct tool invocation.

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

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

The description explicitly states the tool performs key decapsulation using an ML-KEM private key (FIPS 203), naming the specific algorithms (ML-KEM-512/768/1024). This clearly distinguishes it from sibling tools like ml_kem_encap and ml_kem_keygen.

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 the complete flow (keygen → encap → decap) and states that parameters must align with keygen/encap outputs. This gives clear context for when to use the tool, though it doesn't explicitly mention when not to use it or name 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?

With no annotations provided, the description discloses crucial runtime behavior: each encaps produces a different ciphertext due to randomization, and the shared secret is always 32 bytes. It also lists the exact output fields, which goes beyond a simple 'performs encapsulation' statement.

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 yet concise, front-loading the purpose, then organizing parameters, outputs, and usage notes in clearly labeled sections. Every sentence contributes value, with no redundant wording or filler.

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

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

The tool is complex (post-quantum KEM) and has no output schema, but the description enumerates all output fields, explains the randomized behavior, and states the intended usage with ml_kem_decap. This gives the agent everything needed to understand the tool's role within the sibling set.

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

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

Schema coverage is 100%, so the parameters are already documented, but the description adds critical cross-tool semantics: algorithm must match the keygen step, and public_key_in_hex is specifically the output of ml_kem_keygen. This connects the parameters to the actual workflow, exceeding the schema's generic descriptions.

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

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

The description states the exact action: '使用 ML-KEM 公钥执行密钥封装（FIPS 203）', specifying the algorithm variant (ML-KEM-512/768/1024) and naming the standard. It clearly distinguishes from siblings by explicitly referencing ml_kem_decap as the counterpart and ml_kem_keygen for key generation.

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: algorithm '必须与 keygen 时一致' and public_key_in_hex comes from 'ml_kem_keygen 返回的公钥 hex'. It also describes the intended workflow (send ciphertext, counterpart uses ml_kem_decap), but does not explicitly state when to use this tool instead of other key exchange or encryption tools.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses deterministic generation via a provided seed, the CSPRNG option when use_random_seed is true, and the complete set of output fields. It also names the standard and NIST security levels. However, it omits potential error conditions and side-effect behavior, which would be useful for a tool that generates sensitive key material.

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-organized into labeled sections (algorithm, parameters, outputs, subsequent operations), with every sentence contributing necessary information. It is compact enough for an agent to parse quickly while providing a complete overview of the tool's 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 there is no output schema, the description compensates by enumerating all nine output fields and explaining the downstream workflow. It covers algorithm selection, parameter semantics, and output formats. Minor gaps include lack of error-handling details, but overall the tool description is contextually complete for a key generation operation.

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 describes all three parameters with high coverage (100%), so the baseline is 3. The description adds value beyond the schema by noting that seed_in_hex enables deterministic generation, that use_random_seed overrides the seed, and by mapping each algorithm choice to a NIST security level—additional context not present in the 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 clearly states its core function with a specific verb and resource: '生成 ML-KEM 密钥对' (generate ML-KEM key pair) and names the FIPS 203 standard. This distinguishes it from sibling operations like ml_kem_encap and ml_kem_decap, which are explicitly referenced as downstream uses for the generated keys.

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 this tool by explaining the algorithm options (with a recommendation for ML-KEM-768) and specifying that the public key is used for ml_kem_encap and the private key for ml_kem_decap. It does not offer explicit 'when-not-to-use' exclusions, but the downstream workflow makes the usage context unmistakable.

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

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

With no annotations provided, the description carries the behavioral disclosure burden and does well by specifying cipher length requirements ('长度 = key_size/8 字节'), the need for padding-mode consistency, conditional password use, and the output fields ('plain_data_in_hex、plain_length'). It does not discuss failure modes, but the disclosed operational constraints are meaningful.

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 uses a clear structured parameter/output layout. Every line adds either a parameter meaning or an operational constraint, with no redundant filler.

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

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

Given there is no output schema, the description correctly specifies the return values (plain_data_in_hex, plain_length). It also clarifies key constraints such as cipher length and padding consistency. A minor gap is that it does not explicitly mark which parameters are mandatory despite the schema listing all 4 as optional, but the purpose and parameter notes largely compensate.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining that rsa_padding_mode must match encryption, that password is only needed for protected private keys, and that cipher_data_in_hex length must equal key_size/8 bytes.

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 'RSA 私钥解密', a specific verb and resource that clearly identifies this as a private-key decryption tool. It does not explicitly differentiate itself from siblings like rsa_encryption, rsa_sign, or rsa_verify, but the operation is clear enough to avoid confusion.

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: use this when RSA private-key decryption is needed, and it adds important operational guidance such as 'rsa_padding_mode 必须与加密时一致' and '若私钥有密码保护则传入'. However, it does not explicitly name alternatives or state when not to use the tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals output fields (cipher_data_in_hex, cipher_length), documents plaintext length limits per padding mode, and explains the trade-off between PKCS1v1.5 and OAEP. This is substantial operational detail beyond the schema, though it stops short of describing error behavior on invalid PEM or oversized input.

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 organized into labeled sections: parameters, length limits, output, and security advice. Every section delivers actionable information with no filler, and the most important purpose is front-loaded in the first sentence. It is detailed yet compact.

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

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

Given there is no output schema, the description compensates by naming the output fields. It covers all three parameters and adds operationally critical length constraints. The only notable omission is that it does not state that all three parameters are effectively required for the operation, while the schema lists required parameters as 0.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful semantics by tying parameters to behavior: it explains how rsa_padding_mode interacts with plaintext length limits and gives concrete byte caps (e.g., RSA-4096 + OAEP-SHA256 = 446 bytes). It reinforces the meaning of rsa_public_key_in_pem and plain_data_in_hex beyond the schema text.

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 'RSA 公钥加密' (RSA public-key encryption), a specific verb-resource pair that immediately distinguishes this tool from siblings like rsa_decryption and rsa_sign. The scope is unambiguous: encrypt plaintext with a PEM public key. This clearly differentiates it without needing to inspect sibling schemas.

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 frames the tool as public-key encryption, providing clear context for when to invoke it versus decryption/signing siblings. It also gives concrete guiding advice on padding choice ('推荐使用 OAEP 而非 PKCS1v1.5'). It does not explicitly name alternatives or exclusions, but the encryption-specific wording 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It explains the raw-data-mode behavior (internal hashing vs. pre-digest), the optional password handling, and the outputs signature_in_hex and signature_length. It does not discuss failure cases or side effects, but for a signing tool the disclosed behavior is substantial.

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 labeled sections for parameters, output, and security advice, and every section carries useful information. It avoids narrative padding and uses a compact notation for the padding-mode variants, making it easy for an agent 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?

Despite having no annotations or output schema, the description covers the key parameters, explains the raw-data distinction, lists outputs, and gives a security guideline. It could be slightly stronger by explicitly stating which parameters are mandatory (e.g., private key and data are logically required even though the schema marks all as optional), but it is otherwise complete enough 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?

The input schema already describes all five parameters at 100% coverage, so the baseline is 3. The description restates the parameter meanings in a compact reference format and adds the output section, but it does not materially add semantic meaning beyond the schema's existing 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 opens with a specific operation, 'RSA 私钥签名' (RSA private-key signing), which clearly identifies both the algorithm and the action. This distinguishes it from sibling tools like rsa_verify, rsa_encryption, and rsa_decryption without needing to inspect their schemas.

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 tool is for signing with an RSA private key and even adds a security recommendation to prefer PSS over PKCS1v1.5. It does not explicitly name alternatives or when-not-to-use conditions, so it stops short of a 5, but the usage context is clear enough.

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?

Description discloses the output format 'verified (bool, True=验签通过)' and the matching constraint. With no annotations, it does not describe behavior on invalid input (e.g., whether exceptions are thrown or simply returns False).

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, using a bulleted list to organize parameters and output. It contains no redundant prose and is 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?

The tool is relatively simple and all parameters are documented in the schema. The description provides the output type and key constraints, but lacks explicit error handling or return-code details. Given no output schema, it partially compensates with the bool output note.

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?

Input schema has 100% coverage, but the description adds a critical constraint that rsa_sign_padding_mode and rsa_sign_raw_data_mode must match the signing parameters, which is not in the schema. It also succinctly restates each parameter's purpose.

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

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

Description clearly states 'RSA 公钥验签' (RSA public key signature verification), which is a specific verb+resource. It distinguishes from sibling tools like rsa_sign (signing) and ecc_key_verify/sm2_verify (other algorithms).

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 notes that padding mode and raw data mode '必须与签名时一致' (must match signing time), which is important usage guidance. However, it does not explicitly state when to choose this tool over other verification tools (e.g., ecc_key_verify, sm2_verify).

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the output fields (plain_data_in_hex, plain_length) and warns that a mismatch in cipher_format leads to failure. It also covers the condition for providing a password, which is useful behavioral context beyond a bare function signature.

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 highly structured with sections for parameters, output, and notes. It is concise, with no wasted words, and front-loads the purpose. Each line serves a distinct function, making it 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 cryptographic tool with 4 parameters and no output schema, the description covers the essential aspects: purpose, parameter formats, output fields, and a critical failure condition. It is sufficient for an AI agent to 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 100%, so the baseline is 3. The description adds value by emphasizing that cipher_format is mandatory ('必须指定'), clarifying that the key is in PEM format, and explaining when the password is required. These details go beyond the 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 clearly states 'SM2 私钥解密' (SM2 private key decryption), specifying the exact operation and resource. It distinguishes from siblings like sm2_encryption and sm2_sign by focusing on decryption with private key.

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

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

Provides clear usage context: cipher_format must be specified and must match the encryption format, otherwise decryption fails. It also notes when the private key password is needed. However, it does not explicitly mention alternatives like sm2_encryption for the reverse operation, so it lacks explicit exclusions.

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 burden of disclosing behavior. It explains the output dictionary structure with four encoding formats and explicitly warns that ciphertexts vary due to a random k, which is a key behavioral trait. It does not mention potential input length limits or error cases, but the core behavior is well covered.

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 clear sections for parameters, output, and notes. It is concise, front-loads the purpose, and every sentence provides 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?

Given the absence of an output schema, the description thoroughly explains the return format (a dictionary with four encoding options) and highlights the non-deterministic nature of encryption. For a tool with two parameters and no output schema, this is complete enough for an agent to invoke and interpret results 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 input schema already provides complete descriptions for both parameters (100% schema coverage). The description reiterates the parameter names and formats but adds little beyond the schema. It does not introduce constraints or additional semantics, so it meets the baseline for high 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 'SM2 公钥加密' (SM2 public key encryption), specifying the verb (encrypt) and resource (SM2 public key). It effectively distinguishes this from sibling tools like sm2_decryption and sm2_sign.

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 that this tool performs SM2 public key encryption and explains the output formats. However, it does not explicitly mention when to use it versus alternatives (e.g., sm2_decryption) or any exclusions, so it lacks direct usage guidance relative to siblings.

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

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

With no annotations provided, the description carries the full burden. It clearly discloses that the tool does not reveal the private key value (a critical safety behavior), returns a JSON view of ASN.1 structure, and lists expected fields (OID, salt, iteration count). This goes beyond simple tautology and gives meaningful behavioral context.

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

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

The description is two short, front-loaded sentences. It starts with the tool's purpose, then covers safety and return format without any redundant or verbose language. Every sentence earns its place, making it highly concise and well-structured.

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?

Since there is no output schema, the description appropriately explains the return field 'structure' with details about its contents. It covers the input format (PEM), the tool's purpose, and a key safety guarantee. Minor gaps like error handling on malformed PEM are not addressed, but for a single-parameter parse tool, the description is sufficiently complete.

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

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

Schema description coverage is 100% for the single parameter, so the baseline is 3. The tool description does not add any parameter semantics beyond what the schema already provides; it only mentions the PEM format implicitly. No additional meaning or usage details are given.

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 specifies the verb '解析' (parse), the resource 'SM2 加密私钥 PEM 结构', and the outcome '返回 ASN.1 内部字段的 JSON 视图'. It clearly distinguishes this tool from sibling crypto operations by focusing on structural parsing rather than encryption/decryption/signing. The scope is well-defined and 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 states the intended usage context ('用于调试与教学') and implies it is not for extracting private key values ('不会解出私钥值'). However, it does not explicitly name alternative tools for key extraction or decryption, which would earn a 5. Still, the context is clear and the exclusion is present.

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

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

With no annotations available, the description carries the full burden and does well by disclosing the output format (130 hex chars, 65 bytes) and the 04||X||Y structure. It does not mention error behavior or input validation, but for a stateless conversion tool this is a minor gap.

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

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

Two short sentences deliver all core information without redundancy. The description is appropriately front-loaded and every clause 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 one-parameter conversion tool with no output schema, the description is nearly complete: it names the return field, gives the exact hex length, and specifies the encoding. It could optionally note that the input must be a valid SM2 key, but this is implied by the tool name and purpose.

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 the single parameter with a complete description (PEM text with BEGIN/END headers). The tool description adds no further parameter-level meaning, aligning with the baseline for 100% 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 converts an SM2 PEM public key into raw hex encoding (uncompressed point 04||X||Y), specifying the exact output field and byte length. This specific verb+resource+outcome strongly distinguishes it from sibling SM2 tools like sm2_sign or sm2_verify.

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

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

No explicit when-to-use guidance or alternatives are mentioned. The usage is implied from the description, but there is no comparison with similar tools (e.g., sm2_private_key_structure_parse) or exclusions for other key formats.

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 responsibility for behavioral disclosure. It fully explains that RAW mode performs an internal SM3 hash (e = SM3(ZA||M)) while DIGEST mode does not, describes output formats (RS and RS_ASN1), and warns that verification must use RS_ASN1 and the same mode. No annotation contradictions exist.

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 a parameter list and output section, using bold and bullets for readability. However, it repeats parameter names and schema descriptions, adding some redundancy. Still, it is compact enough and each section carries meaningful detail, hence a 4.

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 cryptographic signing tool with no output schema, the description is remarkably complete: it covers all input parameters, both operation modes, the exact output structure (RS and RS_ASN1), and a verification caveat. There is no missing behavioral context that an agent would need to invoke this 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?

Although schema coverage is 100%, the description adds critical meaning beyond the schema: it specifies that data_in_hex must be exactly 64 hex characters in DIGEST mode, clarifies that sm2_private_key_password is only needed if the key is encrypted, and explains how sign_raw_data_mode changes the interpretation of data_in_hex. This is substantial added value.

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

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

The description begins with 'SM2 私钥签名' (SM2 private key signing), clearly stating the operation and algorithm. It distinguishes from sibling tools like ECC/RSA signing by specifying SM2 and detailing the signing modes, leaving no ambiguity about scope.

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 RAW vs DIGEST modes, explicitly explaining the behavior of sign_raw_data_mode and the semantics of data_in_hex in each. It references that DIGEST mode aligns with other tools' DIGEST mode, but does not explicitly name alternative tools or state when NOT to use this tool, so it is not a full 5.

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

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

With no annotations provided, the description carries full responsibility and does an excellent job. It discloses that RAW mode triggers the server to internally compute e = SM3(ZA || M) before verification, while DIGEST mode performs no implicit SM3 and directly verifies the provided digest. It also specifies the fixed signature format and the boolean output, giving complete insight into the 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?

The description is well-structured with clear labels for parameters, output, and workflow. While it is longer than a simple two-liner, the complexity of the two-mode behavior justifies the length. The core purpose is front-loaded in the first sentence, and the bullet-style formatting improves readability. Some redundancy with the schema exists, but it remains tightly 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?

The tool has 5 parameters and no output schema, yet the description compensates fully. It states the output is 'verified (bool)' explicitly, covers all parameters with mode-specific explanations, and provides a complete workflow reference. For a cryptographic verification tool with this level of complexity, the description is exceptionally complete.

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

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

Schema coverage is 100%, setting the baseline at 3. The description significantly enhances the schema by explaining the exact hex length requirement for DIGEST mode (64 hex characters for a 32-byte SM3 digest), the internal transformation e = SM3(ZA || M), and the critical constraint that sign_raw_data_mode must align with the signing mode. These details add substantial practical meaning beyond the parameter titles.

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 starts with 'SM2 公钥验签' (SM2 public key verification), clearly stating the tool's specific action and resource. It distinguishes itself from sibling tools like sm2_sign and sm2_encryption by mentioning the complete flow 'generate_sm2 → sm2_sign → sm2_verify', placing it definitively as the verification step.

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 two operating modes (RAW and DIGEST) and explicitly warns that sign_raw_data_mode must match the mode used during signing. It also notes that DIGEST mode is semantically consistent with KMS/ECC/RSA DIGEST mode, providing comparative guidance. The '完整流程' line gives a clear usage sequence, though it doesn't explicitly state when to avoid this tool in favor of 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?

With no annotations, the description carries the full behavioral burden. It states the failure result for wrong password or identity, imposes a ciphertext size bound, lists the successful outputs, and describes the cryptographic relationship between inputs. This goes well beyond a bare operation name, though it does not cover every edge case such as invalid ciphertext structure.

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 information-dense and front-loaded with the operation type, but it carries a redundant duplicate '[sm9_ibc] [sm9_ibc]' prefix and is a long single run-on sentence. It is concise overall, but the waste and lack of structure prevent a higher score.

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

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

For a crypto tool with no output schema and no annotations, the description is quite complete: it covers inputs, expected key origin, consistency constraints, ciphertext size, outputs, and a known error string. The main gap is that the schema marks all parameters optional while the description implies all are needed, leaving required-ness ambiguous.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful cross-parameter context: user_private_key_in_pem must be an SM9ExtractKey output, the password must match extraction, the identity must match encryption, and cipher_data_in_hex is DER ciphertext limited to 367 bytes. This adds semantics the schema does not express.

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 operation as SM9 identity decryption, states the receiver role, and names all required inputs and outputs. The verb '解密' distinguishes it from sibling tools like sm9_encryption and sm9_sign.

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 gives explicit usage context: the receiver uses the KGC-issued user key, the key must come from SM9ExtractKey with key_kind=Enc, the password must match extraction, and the identity must match the encryption. It does not explicitly name when not to use it or enumerate alternatives, 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?

With no annotations provided, the description carries the full burden and does so well: it discloses that the operation is public-key encryption by anyone, binds the ciphertext to the identity, enforces a 1-255 byte plaintext limit due to KDF counter constraints, and specifies the output as DER-encoded C1/C3/C2 structure up to 367 bytes. This is rich behavioral context beyond a simple 'encrypt' statement.

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 key action and access model. However, it begins with a duplicated '[sm9_ibc] [sm9_ibc]' tag that adds noise and no informational 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 non-destructive encryption tool with no output schema and no annotations, the description is remarkably complete: it covers all three parameters, their constraints, the output fields, the output encoding, and the output size limit. An agent has enough context to call it correctly without extra lookups.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful semantics: master_public_key_in_pem must be the Enc-kind public key, identity is tied to the ciphertext, and plain_data_in_hex has explicit size limits and KDF constraints. This goes beyond the schema descriptions without fully replacing them.

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 operation as SM9 identity-based encryption ('SM9 标识加密') and states that anyone holding the master public key can encrypt, which distinguishes it from sibling operations like sm9_decryption, sm9_sign, and sm9_verify. It also specifies the required inputs and output format.

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 usage context: encrypt for a specific identity using the Enc-type master public key. It does not explicitly name alternative tools or provide exclusion criteria, but the identity-based encryption workflow is sufficiently clear for an agent to select it.

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 behavioral disclosure and does so thoroughly. It reveals that GmSSL encrypted PEM import has no password check, that wrong passwords may silently produce garbage keys, that a built-in N-1 probe performs a sign/encrypt round-trip verification (probe_verified=true) before output, and that a wrong password yields the error 'SM9 extract user key failed'. This is far beyond a typical description.

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 front-loaded with purpose and standard, then lists inputs, then explains the verification probe and outputs. Every sentence adds non-redundant information. It is slightly marred by the duplicated '[sm9_ibc]' prefix, which is a minor formatting flaw, but overall it is efficiently structured.

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 crypto key-extraction tool with no annotations and no output schema, the description is remarkably complete: it covers input semantics, the prerequisite relationship to GenerateSm9, the verification mechanism, the output (user_private_key_in_pem), and the failure mode. Nothing needed for a caller to use the tool correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema: master_private_key_in_pem must be GenerateSm9 output, private_key_password is reused to encrypt the extracted user key, and identity is the being-issued user's identifier bounded to 1-63 UTF-8 bytes. These extra details clarify parameter relationships that schema descriptions do not fully convey.

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 specifies a clear verb and resource: KGC extracts SM9 user private key by identifier (GM/T 0044). It differentiates from siblings by explicitly sourcing master_private_key_in_pem from GenerateSm9 output and by positioning the tool as the key-issuance step, distinct from sm9_sign/verify/encryption/decryption which consume the key.

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 conveys clear usage context: it is the KGC-side step to derive a user key from an already-generated encrypted master key, with identity and key_kind as the distinguishing inputs. It implicitly distinguishes from generate_sm9 by naming the master key as a required input, though it does not explicitly state when not to use this tool or name alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It goes beyond the basic operation by revealing that SM3 digesting is performed internally, processing is streaming, only original-message mode is supported, and the output is a DER-encoded signature fixed at 104 bytes in hex or base64. This gives an agent meaningful operational expectations without an output schema.

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

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

The description is compact and packs purpose, input semantics, processing behavior, and output format into a single dense paragraph. The duplicated '[sm9_ibc] [sm9_ibc]' prefix is unnecessary noise, but the content is otherwise efficiently organized with the standard first, then inputs, then behavior, then outputs.

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 and no output schema, the description is reasonably complete: it states the purpose, required input source, processing mode, and output characteristics. Minor gaps include not explicitly mentioning that the private key password may be required for encrypted keys despite the schema marking it optional, and not covering error scenarios. Still, an agent has enough 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?

Even though schema description coverage is 100%, the description adds important meaning: user_private_key_in_pem is specifically the output of SM9ExtractKey with key_kind=Sign, data_in_hex is the raw message (not a digest), and private_key_password is the user key passphrase. It also clarifies the output encoding and length, which the schema does not cover. This is a meaningful supplement to the schema fields.

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

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

The description states a specific verb and resource: SM9 identity-based signature (GM/T 0044), and clearly distinguishes this from sibling operations such as sm9_verify, sm9_encryption, and sm9_extract_key. It names the exact signer role and the KGC-issued user private key, so an agent can determine this tool is for signing, not verification or key extraction.

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 specifies how to use the tool: provide the user private key in PEM from SM9ExtractKey with key_kind=Sign, the private key password, and raw message hex. It also includes an important exclusion: only raw message mode is supported, with SM3 digest computed internally, which prevents misuse with pre-hashed digests. It does not explicitly name alternatives like sm9_verify, but the context is clear enough.

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 disclosure burden and does a strong job: it warns that verified=false is the normal response for a mismatching signature/identity, and that only malformed input raises the 'SM9 verify failed' error. This is genuinely useful, though the phrasing 'verified=false 是成功响应' is slightly ambiguous and it does not describe the full output shape.

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

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

The description is dense and mostly front-loaded, with the operation stated first and input constraints following. The repeated '[sm9_ibc] [sm9_ibc]' prefix is redundant but does not meaningfully harm readability.

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, it covers the essential call context: required inputs, exact signature length, success-vs-error behavior, and the error code string. It omits explicit mention of what verified=true indicates, but the agent can infer the boolean semantics from the verification context.

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

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

The schema already describes all four parameters at 100% coverage, so the baseline is 3. The description adds high-value constraints not in the schema: master_public_key_in_pem must be the key_kind=Sign public key and signature_in_hex must be exactly 104 bytes (208 hex characters).

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

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

The description names a specific operation, 'SM9 标识验签（GM/T 0044）', and immediately scopes it by stating that verification only requires the master public key and signer identity. This makes it clearly distinct from sm9_sign and the other verify siblings even without explicitly naming them.

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

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

It gives a clear usage context: use when verifying an SM9 identity signature with only the master public key and signer identity. It does not name alternatives or state when not to use it, 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?

With no annotations provided, the description carries the full burden and does well: it discloses output fields, key sizes, fixed nonce length, the 16-byte auth tag inclusion, and error behavior on tamper detection. However, it omits important crypto-behavioral guidance like nonce uniqueness requirements or explicit statement that ciphertext input for decryption includes the auth tag.

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 [algorithm], [parameters], [output], and [notes] sections. Every sentence provides essential information—algorithm variants, key lengths, nonce format, output fields, and tamper-detection behavior—with no filler or redundancy.

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

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

For a cryptographic tool with no output schema and no annotations, the description is quite complete: it covers input formats, output fields, authentication behavior, and error conditions. It falls short only in edge-case guidance (e.g., nonce uniqueness, exact handling of the auth tag during decryption), but overall it gives an agent enough context to 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 100%, so the baseline is 3, but the description adds extra meaning beyond the schema: it maps each algorithm to its required key byte length (AES256GCM=32B, ChaCha20Poly1305=32B, SM4GCM=16B), states the nonce is exactly 24 hex characters, constrains input size to 1B~16MB, and clarifies that associated data participates in MAC but is not encrypted.

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 this as a symmetric AEAD streaming encryption/decryption tool ('AEAD 流式加解密'), lists concrete algorithms (AES256GCM, ChaCha20Poly1305, SM4GCM), and distinguishes it from sibling tools like block_cipher and zuc_cipher by specifying the operation types (Encrypt/Decrypt) and algorithm families.

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 through the '[symmetric_cipher]' label and the word 'AEAD', suggesting it is for authenticated streaming encryption, but it does not explicitly state when to choose this over alternatives such as block_cipher or zuc_cipher, nor does it provide exclusion criteria.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly. It discloses input size limits, no padding, ciphertext stealing for non-16-byte tails, output fields, tweak reuse dangers, lack of authentication, and parallel/random-access behavior. This far exceeds what an annotation could provide.

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 dense, with every sentence adding substantive value: standards, parameter semantics, behavioral constraints, security caveats, use cases, and return fields. It is front-loaded with the operation and algorithm, making the core purpose immediately visible before the detailed caveats.

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 remarkably complete. It covers input constraints, output fields, algorithm selection, tweak requirements, security warnings, and real-world usage context. An agent has enough information to correctly select and invoke the 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?

Even though schema coverage is about 80%, the description adds critical meaning: exact key lengths per algorithm (32B vs 64B and their split into data/tweak keys), tweak_in_hex as a 16-byte value, the requirement to explicitly declare process_type, and input data range. The schema descriptions stay generic, so the tool description is the main source of parameter semantics.

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

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

The description clearly identifies the operation as AES-XTS tunable narrow-block encryption/decryption, names the exact standards (IEEE 1619 / NIST SP 800-38E), and distinguishes it from sibling symmetric tools like block_cipher, ctr_cipher, and stream_cipher by specifying the mode and key structure. It is specific about the resource (AES-XTS) and the two supported algorithms, leaving 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 provides strong contextual guidance by stating typical use cases (BitLocker, LUKS2, FileVault, AMD SEV-SNP, Intel TDX) and explaining the security properties that make XTS suitable for disk/memory encryption. It does not explicitly name sibling alternatives to exclude, but the use-case and mode characteristics make the intended application clear enough for an agent.

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

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

With no annotations provided, the description carries the full burden and does well by disclosing that encryption and decryption are identical operations, key and IV are fixed at 16 bytes, input length is 1B-16MB, and the return fields are output_data_in_hex and output_length. Missing details like output length equivalence or lack of authentication are left unstated, but the provided traits are valuable.

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 information-dense, covering algorithm type, operational symmetry, key/IV sizes, data length bounds, and return fields in a few sentences. No redundant wording or filler; every part 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?

Given the tool has no output schema, the description appropriately explains the return fields (output_data_in_hex, output_length) and states key length constraints. It does not provide an example or discuss error cases, but the core details are sufficient for a crypto utility with clear technical constraints.

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?

Although the schema already has 100% description coverage, the tool description clarifies a key ambiguity: the schema's key_in_hex description suggests variable lengths depending on algorithm (AES256=64, AES128/SM4=32), while the tool description fixes it to 16 bytes (32 hex chars) for ZUC-128. It also adds the input data length range and return fields, enhancing schema meaning.

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 this is a ZUC-128 stream cipher, a specific Chinese commercial algorithm, and clarifies that encryption and decryption are the same operation. This clearly identifies the tool's function and distinguishes it from generic siblings like stream_cipher by naming the algorithm.

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 that this tool is for ZUC-128 symmetric stream cipher operations, implying when to use it. However, it does not explicitly discuss exclusions or alternative tools, such as when to prefer the generic stream_cipher or block_cipher, so it falls short of the highest guidance level.

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