PR #18898: Enable thinking/reasoning for kimi-for-coding via anthropic_messages

• Repository: NousResearch/hermes-agent
• Author: vokasug
• State: open | merged: False
• Link: https://github.com/NousResearch/hermes-agent/pull/18898

Description (problem / solution / changelog)

Summary

Enable reasoning/thinking for kimi-for-coding when using anthropic_messages transport. Closes #18823.

Problem

build_anthropic_kwargs() unconditionally skips the thinking parameter for all Kimi endpoints due to not _is_kimi_coding guard (line ~1869). This prevents reasoning from working even though Kimi's /coding endpoint fully supports Anthropic-style thinking with budget_tokens and returns signed thinking blocks.

Additionally, convert_messages_to_anthropic() strips all signed thinking blocks (including Kimi's own) because _preserve_unsigned_thinking assumes only unsigned blocks should be kept. Kimi generates and validates its own signatures; stripping them causes HTTP 400 on replay when tool-call messages lack reasoning_content.

Solution

Patch 1 — Narrow Kimi guard to non-/coding endpoints (anthropic_adapter.py)

Change the blanket not _is_kimi_coding guard (which matched ALL Kimi-family endpoints including Moonshot and custom proxies) to a precise not _is_kimi_non_coding check:

_is_kimi_non_coding = _is_kimi_family_endpoint(base_url, model) and not _is_kimi_coding_endpoint(base_url)
if reasoning_config and isinstance(reasoning_config, dict) and not _is_kimi_non_coding:

Rationale: Kimi /coding supports thinking parameter and validates its own signatures server-side. The original guard blocked reasoning for ALL Kimi-family endpoints, including /coding where it actually works. The new guard:

• Allows thinking for api.kimi.com/coding (tested via direct API calls + pytest)
• Preserves the old skip behavior for api.kimi.com/v1, Moonshot, custom proxies, and any other Kimi-family endpoint that does NOT match /coding

Patch 2 — Preserve Kimi-signed thinking blocks (anthropic_adapter.py)

In _preserve_unsigned_thinking branch, keep signed blocks when endpoint is Kimi /coding:

if b.get("signature") or b.get("data"):
    if _is_kimi_coding_endpoint(base_url):
        new_content.append(b)  # Kimi validates its own signatures
    continue  # DeepSeek/others: strip (can't validate Anthropic sigs)

Rationale: Kimi /coding generates ~12946-char signatures and validates them server-side. Using _is_kimi_coding_endpoint(base_url) (not the broader _is_kimi_family_endpoint) keeps the scope minimal and zero-risk for DeepSeek, Moonshot, or any other provider. Unsigned blocks are still preserved for all providers.

Note on the original comment

The codebase currently contains the following comment (lines ~1854-1865):

# We have to skip `thinking` for kimi because it doesn't work
# due to Kimi using anthropic as an intermediary and not supporting
# thinking signatures.  While DeepSeek will validate thinking signatures
# for DeepSeek reasoning models, Kimi does not support it, leading to
# HTTP 400 errors when thinking is enabled but reasoning_content is
# missing.  Kimi's reasoning is driven server-side on the /coding route,
# so skip Anthropic's thinking parameter entirely for that host.

This comment accurately described the original problem: unsigned Anthropic signatures caused HTTP 400 on tool-call replays because reasoning_content was missing. However, the comment became outdated after upstream commit 76edc40ab added _copy_reasoning_content_for_api() to inject reasoning_content: " " for Kimi tool-call messages. The comment now incorrectly justifies disabling reasoning entirely, even for simple conversations where the signature issue does not apply.

This PR addresses the root cause: by preserving Kimi's own signed blocks (Patch 2) and allowing the thinking parameter (Patch 1), the adapter no longer triggers the missing-reasoning_content error that the original comment warned about.

Recommended comment update (included in this PR):

# We used to skip `thinking` for all Kimi endpoints because unsigned
# Anthropic signatures triggered HTTP 400 on tool-call replays.
# This is now fixed upstream: run_agent.py commit `76edc40ab`
# injects `reasoning_content: " "` for Kimi tool-call messages,
# and `convert_messages_to_anthropic` preserves Kimi's own signed
# thinking blocks. Therefore we allow the `thinking` parameter
# for Kimi /coding when `reasoning_config` is provided.

What already works in upstream

run_agent.py commit 76edc40ab (2026-04-30) added _needs_kimi_tool_reasoning() and _copy_reasoning_content_for_api() which inject reasoning_content: " " for Kimi tool-call messages. This PR unblocks the adapter side so those fixes actually receive thinking responses to echo back.

Testing performed

Manual / CLI tests

20+ scenarios tested across two sessions (2026-05-02):

Unit tests (tests/agent/test_kimi_coding_anthropic_thinking.py)

pytest 19/19 passed (2026-05-02).

Known limitations

• DeepSeek/Anthropic regression: Zero risk. Patch 2 uses _is_kimi_coding_endpoint(base_url) which matches only https://api.kimi.com/coding. DeepSeek (api.deepseek.com), Moonshot, Anthropic, and all other providers fall through to the original behavior — signed blocks are stripped as before.
• high effort and enabled: false not explicitly tested (low effort thoroughly validated).

Checklist

• Kimi /coding direct API accepts thinking parameter (curl verified)
• Signed blocks survive round-trip (Kimi validates its own signatures)
• Tool-call chains work without HTTP 400
• compress and resume preserve reasoning state
• Zero-risk for non-Kimi providers (scope limited to _is_kimi_coding_endpoint)
• Unit tests updated for convert_messages_to_anthropic() — pytest 19/19 passed

Changed files

• agent/anthropic_adapter.py (modified, +29/-20)
• tests/agent/test_kimi_coding_anthropic_thinking.py (modified, +91/-22)