Provider Reasoning Behavior¶

The Reasoning / Thinking guide describes how LLM-Rosetta normalizes reasoning parameters through its IR layer. This page documents how each provider actually behaves — which effort values it accepts, how it handles disabled reasoning, what thinking_type semantics it enforces, and how reasoning metadata survives cross-provider round-trips.

All data below comes from empirical probing against live provider APIs, not documentation alone. See Probing methodology for details.

Effort Value Acceptance¶

Which reasoning_effort / output_config.effort values each provider accepts. Values not listed are rejected with a 400 error unless otherwise noted.

Official Upstream APIs¶

Probed 2026-06-10 against official endpoints with real API keys (#185).

Argo Gateway¶

Probed 2026-05-23 and 2026-06-09 (#220).

Argo proxies requests to upstream providers but applies its own validation. The Anthropic endpoint uses output_config.effort:

Only sonnet46, opus46, and opus47 support thinking + output_config coexistence.

Disabled Behavior¶

How each provider disables reasoning. The shim disabled field controls which strategy LLM-Rosetta uses.

Thinking Type¶

Whether the provider uses thinking.type = "enabled" (requires budget_tokens) or "adaptive" (model decides). Some providers and models only accept one or the other.

Provider-Level Defaults¶

Argo Anthropic Model-Level Overrides¶

Probed 2026-05-23 (#220). Argo's Anthropic endpoint has model-specific thinking behavior:

Automatic Fallback¶

When a shim declares thinking_type: enabled but the request has no budget_tokens (required by Anthropic for type: "enabled"), the converter automatically falls back to type: "adaptive". This prevents invalid payloads without requiring the client to know about provider constraints.

Provider Metadata Round-Trip¶

Reasoning blocks carry provider-specific metadata that must survive cross-provider conversions. LLM-Rosetta preserves these in the IR provider_metadata field on content parts.

Cross-Provider Signature Handling¶

When routing between providers (e.g. Anthropic client → Google backend), signatures from the source provider must be preserved so that:

1. The source client can replay conversation history with valid signatures
2. The target provider receives its own signature format (if applicable)

LLM-Rosetta achieves this by storing signatures in provider_metadata on each content part during IR conversion. The Anthropic converter serializes provider_metadata as _provider_metadata on thinking, tool_use, tool_result, and text blocks (PR #257, PR #263).

Unsigned Reasoning Blocks¶

Some clients send conversation history containing thinking blocks without valid signatures. This happens when:

• The client strips or never received signatures (e.g. Claude CLI with signature: "")
• The conversation crossed providers and the original signature is not applicable

The Problem¶

Providers that validate signatures (like Argo's Anthropic endpoint) reject these blocks:

messages.61.content.0.thinking.signature: Field required
messages.9.content.0: Invalid `signature` in `thinking` block

Shim Policy: unsigned_reasoning_blocks¶

ReasoningCapability supports an unsigned_reasoning_blocks field with two values:

Currently only argo--anthropic uses preserve. Direct Anthropic API calls use as_is because the official API handles unsigned blocks differently from Argo's proxy layer.

When preserve filters all reasoning parts from an assistant message, the message is skipped entirely (with a warning) rather than sending an empty content: [] array.

See #268 and PR #269 for the implementation.

Shim Configuration Reference¶

How ReasoningCapability fields in provider.yaml map to the behaviors documented above.

reasoning:
  disabled: thinking_disabled  # "omit" | "thinking_disabled" | "thinking_budget_zero"
  effort_field: output_config.effort  # Where effort value is placed
  thinking_type: enabled       # Force thinking.type: "enabled" | "adaptive"
  max_effort: high             # Cap IR effort at this level
  unsigned_reasoning_blocks: preserve  # "as_is" | "preserve"
  effort_map:                  # IR effort → provider effort string
    minimal: low
    low: low
    medium: medium
    high: high
    xhigh: xhigh
    max: max
  model_overrides:             # Per-model overrides (keyed by upstream model ID)
    claudeopus47:
      thinking_type: adaptive

Field Reference¶

Provider Shim Summary¶

Probing Methodology¶

All behavior data on this page was obtained by sending real API requests to live provider endpoints and observing accept/reject responses. This approach catches undocumented constraints that provider documentation may not cover.

Sources¶

• Argo parameter probing — #220: 24 non-embedding models probed across both OpenAI Chat and Anthropic endpoints. Covered sampling, thinking modes, effort values, tool schemas, and field constraints.
• Official API effort probing — #185 comment: Effort value acceptance tested against OpenAI, Anthropic (via OpenRouter), DeepSeek, Volcengine, and MiniMax.
• Unsigned reasoning block discovery — #268: Dev-test replay of Claude CLI session revealed Argo Anthropic rejecting thinking blocks with empty signatures.

Discrepancies Found¶

Provider documentation does not always match actual API behavior. Notable examples from Argo probing:

These discrepancies are why empirical probing is essential — and why shim configuration exists to encode the actual behavior rather than the documented behavior.