Skip to main content
Glama

Preview a review (free)

kimi_dry_run
Read-only

Preview a paid Kimi review before running it—see scope, diff size, redactions, and truncation without a model call. Verify the review's coverage and redaction report to avoid unexpected output or omitted files.

Instructions

Preview what a kimi_review_changes call would send — scope, diff size, redactions, truncation. Free — no model call, no spend. Use it before a review to inspect the scope and the reported redactions; redaction is best-effort, so treat the preview as a check on scope, not as confirmation that no secret remains. Pass the same extra_context and untracked policy you would give the review so the preview matches it. would_call_model reports whether the paid call would actually run the model (False on an empty diff, where prompt_bytes is 0), and coverage discloses omitted untracked files just as the review would. The result echoes the effective model/reasoning_effort overrides the paid call would send (unvalidated). deadline_advisory is non-null when size or effort risks the synchronous deadline (null whenever would_call_model is False) and names kimi_review_changes_async verbatim — the async counterpart of the previewed call, not of this dry-run tool. A hint, not a refusal.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
baseNoBase git ref for scope='branch'; the review covers base...HEAD.
modelNoThe Kimi model slug the previewed paid call would use; defaults to the server default (MOONBRIDGE_MODEL) when unset, so the preview mirrors the paid call's resolution. This dry run does not call Kimi or validate the model.
pathsNoRepo-relative paths to narrow the review ('/' separators, no '..'); omit to review all changes in scope.
scopeNoWhich changes to review: 'working_tree' (tracked changes vs HEAD; untracked files follow the `untracked` policy, off by default), 'branch' (needs base), or 'commit' (needs commit).working_tree
commitNoCommit SHA or ref to review for scope='commit'.
isolationNoWhich skills Kimi loads: 'inherit' (own user/project discovery) or 'ignore-skills' (empty dir). Built-ins load either way; this reduces loading, not isolation. Default: server-configured, per kimi_status. More: kimi://params.
untrackedNoHow working_tree scope treats untracked files: 'explicit_only' (default) includes only those named in `paths`; 'include' reviews all non-ignored untracked files (SENDS their contents to your configured provider — opt-in egress); 'exclude' includes none. Omitted ones are disclosed in `coverage`. Inert for branch/commit scopes.explicit_only
extra_contextNoOptional author intent/background context, added as clearly-labeled UNTRUSTED prompt data. Redaction does NOT cover it — no live secrets. Full caveats and bounds: kimi://params.
workspace_rootNoAbsolute path to the target repo root — pass it to target the intended repo (MCP roots are unavailable); otherwise the call falls back to the server's own cwd and sets meta.workspace_warning.
reasoning_effortNoThe reasoning effort the previewed paid call would send (as a `model_reasoning_effort` config override); defaults to the server default (MOONBRIDGE_REASONING_EFFORT) when unset, so the preview mirrors the paid call's resolution. This dry run does not call Kimi or validate the value beyond the paid params' shape bounds (no control or surrogate characters, ≤128 chars).

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
okYes
Install Server

TDQS

A4.6/5.0
Behavior4/5

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

Annotations already declare readOnlyHint: true, so the 'Free — no model call, no spend' claim is consistent. The description goes beyond the annotation by detailing effective behavior: would_call_model is False on empty diff, prompt_bytes is 0, coverage discloses omitted untracked files, model/reasoning_effort are echoed unvalidated, and deadline_advisory is non-null only when size/effort risks the synchronous deadline. This meaningfully explains what the call will do and what side effects (none) it has, though some behaviors are described at a high level. No contradiction with the read-only/hint annotations exists.

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

Conciseness4/5

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

The description is long but informational; it front-loads the core purpose in the first sentence and the free/no-spend trait. Each sentence adds a distinct behavioral fact (would_call_model, coverage, unvalidated overrides, deadline_advisory). It is not tautological or bloated, but it is verbose and could be tightened around the deadline_advisory/async sentence. The structure earns a 4 not a 5 because some sentences are dense enough to require rereading, though all of them earn their place.

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

Completeness5/5

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

The description is complete for an agent to invoke correctly: it names the sibling alternatives, explains the free/read-only behavior, explains the return value semantics (would_call_model, prompt_bytes, coverage, deadline_advisory) even though an output schema exists, and it adheres to the annotation profile. For a 10-parameter tool with 100% schema coverage, the description fills the gaps the schema can't — when to use it, what the preview can't guarantee (redaction), and how parameters should be passed to match the paid call. No missing information for selecting or invoking this tool is apparent.

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

Parameters4/5

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 every parameter. However, the description adds important cross-parameter guidance: 'Pass the same extra_context and untracked policy you would give the review so the preview matches it', and it explains that model/reasoning_effort mirror the paid call's defaults. It also explains the relationship between deadline_advisory and would_call_model, which the schema alone does not convey. Slightly above the baseline 3 because the description explains how parameters interact, though it does not restate individual parameter meanings from the schema.

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

Purpose5/5

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

The description states a specific verb ('Preview what a kimi_review_changes call would send') plus a concrete resource (the review call's scope, diff size, redactions, truncation). It names the sibling it is not ('async counterpart of the previewed call, not of this dry-run tool') and distinguishes it from kimi_review_changes. This allows an agent to tell it apart from both the paid review and the dry-run sibling without opening schemas.

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

Usage Guidelines5/5

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

The description explicitly says 'Use it before a review to inspect the scope and the reported redactions', provides a concrete precondition, and warns about the redaction limitation. It also says to 'Pass the same extra_context and untracked policy you would give the review so the preview matches it', which is a direct how-to for correct invocation. The 'not a refusal' closing phrase clarifies the advisory hint semantics, further guiding use.

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

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/briandconnelly/moonbridge'

If you have feedback or need assistance with the MCP directory API, please join our Discord server