legion-llm 0.12.3 → 0.12.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 733b0a06bf37557dfe7c661d6d63596e30ef5cde4b01c9ae12e801c5257b684e
-  data.tar.gz: f24cfe5b32ed137a47efaac7adf57f348d911cb1f511fbdfc5a769ce54d7c32a
+  metadata.gz: 7d61b50d6573478325baba59ea7b05a8e7a6bce2c66c453d15eec40b1380b891
+  data.tar.gz: e14038bcac7c816169e31bc2f8a08fb76331e0bc7b18766f029fe217c3b57d2d
 SHA512:
-  metadata.gz: c006671e6a1dc02bff77b18e3c31dc4cb771ffd1ba5a6b773e2d7a62a9e886b76e95fb1e9780b0c1285e0165a218112f239fe088ceae9296da440918bd682648
-  data.tar.gz: 14eaff3d563eb80e058f699bca53c79308642f745710c1a546b7e00ecfde049129d90e91a52cea5e13a0e19c39afb1282daf1228640680b8f7b94db777676f81
+  metadata.gz: e1abe73f183b7b6e135db20bb2bc2b875b6bb40234630c5327a906d38892b6ef83f35c2c9f8a8b0ee193451d1609f1e30c1ebc4b0ebf28e844b3a9e8044ffefa
+  data.tar.gz: bf44ad26a524c018b042dda702b076c98ef7068aaf48e638305776532d809036778c86a0e4e385974c2d59bffbdf61da4a20067b89d09cbc85a2e5a6b34f5203

data/.rubocop.yml

@@ -4,57 +4,45 @@ AllCops:
   SuggestExtensions: false
 
 Layout/LineLength:
-  Max: 160
-
+  Max: 195
 Layout/SpaceAroundEqualsInParameterDefault:
   EnforcedStyle: space
-
 Layout/HashAlignment:
   EnforcedHashRocketStyle: table
   EnforcedColonStyle: table
-
 Metrics/MethodLength:
-  Max: 60
-
+  Max: 150
 Metrics/ClassLength:
   Max: 1500
-
 Metrics/ModuleLength:
   Max: 1500
-
 Metrics/BlockLength:
-  Max: 40
+  Max: 150
   Exclude:
     - 'spec/**/*'
 
 Metrics/AbcSize:
-  Max: 85
-
+  Max: 110
+Metrics/BlockNesting:
+  Max: 4
 Metrics/CyclomaticComplexity:
-  Max: 35
+  Max: 50
 
 Metrics/PerceivedComplexity:
-  Max: 35
-
+  Max: 50
 Style/Documentation:
   Enabled: false
-
 Style/SymbolArray:
   Enabled: true
-
 Style/FrozenStringLiteralComment:
   Enabled: true
   EnforcedStyle: always
-
 Naming/FileName:
   Enabled: false
-
 Naming/PredicateMethod:
   Enabled: false
-
 Metrics/ParameterLists:
   Max: 9
-
 Style/RedundantConstantBase:
   Exclude:
     - 'spec/**/*'

data/AGENTS.md

@@ -35,3 +35,65 @@ bundle exec rubocop
 
 - Run targeted specs for modified router/pipeline/provider code.
 - Before handoff, run full `bundle exec rspec` and `bundle exec rubocop`.
+
+---
+
+## Client Request Headers Reference
+
+Verified from source code (Claude Code binary + Codex `codex-rs` Rust source).
+
+### Claude Code → `POST /v1/messages`
+
+| Header | Value | Always? |
+|---|---|---|
+| `X-Claude-Code-Session-Id` | Stable UUID for the CLI session | Yes |
+| `x-app` | `"cli"` (foreground) or `"cli-bg"` (background) | Yes |
+| `x-claude-remote-session-id` | Remote container session ID | Conditional |
+| `x-claude-remote-container-id` | Remote container ID | Conditional |
+| `x-claude-code-agent-id` | Agent UUID for multi-agent sessions | Conditional |
+| `x-claude-code-parent-agent-id` | Parent agent UUID (spawned subagent) | Conditional |
+| `x-client-app` | Additional client app identifier | Conditional |
+
+Conversation threading is **stateless** — full `messages[]` history sent in the body on every request. No conversation ID, turn ID, or `x-client-request-id` header is sent.
+
+In Rack/Sinatra env keys, headers arrive as `HTTP_X_CLAUDE_CODE_SESSION_ID`, `HTTP_X_APP`, etc.
+
+### Codex → `POST /v1/responses`
+
+| Header | Value | Always? |
+|---|---|---|
+| `session-id` | Stable UUID for the Codex session | Yes |
+| `thread-id` | Stable UUID for the thread/conversation | Yes |
+| `x-client-request-id` | Same value as `thread-id` | Yes |
+| `x-codex-installation-id` | Installation-scoped UUID | Yes |
+| `x-codex-window-id` | `"{thread_id}:{window_generation}"` | Yes |
+| `x-codex-turn-state` | Sticky-routing token returned by server, replayed by client | After first response |
+| `x-codex-turn-metadata` | Per-turn observability metadata | Conditional |
+| `x-codex-parent-thread-id` | Parent thread UUID (sub-agents) | Conditional |
+| `x-openai-subagent` | Sub-agent type (`"review"`, `"compact"`, `"memory_consolidation"`, etc.) | Conditional |
+| `x-openai-memgen-request` | `"true"` for memory generation requests | Conditional |
+
+In Rack/Sinatra env keys: `HTTP_SESSION_ID`, `HTTP_THREAD_ID`, `HTTP_X_CLIENT_REQUEST_ID`, `HTTP_X_CODEX_INSTALLATION_ID`, etc.
+
+**`HTTP_THREAD_ID` is the stable Codex thread/conversation ID** — it is stable for the lifetime of a thread, not per-request. `HTTP_X_CLIENT_REQUEST_ID` equals `HTTP_THREAD_ID` (Codex sets them to the same value).
+
+Conversation threading over HTTP uses full input in body (stateless like Anthropic). Over WebSocket, `previous_response_id` is sent in the request body to enable delta-only input.
+
+### Practical Usage in `/v1/messages` and `/v1/responses` Handlers
+
+```ruby
+# Stable request ID (Claude Code sends X-Claude-Code-Session-Id; Codex sends x-client-request-id = thread-id)
+request_id = env['HTTP_X_CLIENT_REQUEST_ID'] || "req_#{SecureRandom.hex(12)}"
+
+# Stable conversation/thread ID
+# Claude Code: no header — generate per-request or use Legion conversation tracking
+# Codex: HTTP_THREAD_ID is stable for the thread lifetime
+conversation_id = env['HTTP_THREAD_ID'] ||
+                  env['HTTP_X_LEGION_CONVERSATION_ID'] ||
+                  body[:conversation_id] ||
+                  "conv_#{SecureRandom.hex(8)}"
+
+# Identify the calling client
+claude_code_session = env['HTTP_X_CLAUDE_CODE_SESSION_ID']  # present only for Claude Code
+codex_installation  = env['HTTP_X_CODEX_INSTALLATION_ID']   # present only for Codex
+```

data/CHANGELOG.md

@@ -1,5 +1,146 @@
 # Legion LLM Changelog
 
+## [0.12.14] - 2026-06-10
+
+### Added
+- **Hint-based router scoring** — `tier`, `provider`, and `model` are now preference hints that bias rule scoring (+50 per matching hint) instead of hard overrides that bypass rule evaluation. This allows the router to apply policy (cost, privacy, health) and fall back to a better local match when the hinted provider is unavailable (router.rb)
+- **Context window filtering in router** — `estimated_tokens` is now computed from request messages + conversation history and passed to the router. Rules whose model's `context_length` cannot fit the estimated token count (at 90% threshold) are excluded from candidate selection (router.rb, executor.rb)
+- **Model-provider mismatch detection** — When an explicitly specified provider differs from the model's natural provider (e.g. "claude-sonnet-4-6" routed to vllm), the model is swapped to the provider's default to prevent dispatch failures. Auto-resolved providers (from tier/defaults) trust the caller's model choice (router.rb, executor.rb)
+- **Provider registry validation in explicit resolution** — Unregistered providers are cleared before tier-based fallback instead of committing to a dead-end resolution (router.rb)
+- **Repeat tool call detection in native tool loop** — The tool loop now tracks `(name, args_hash)` pairs and returns early with client passthrough results when repeated calls are detected, preventing infinite loops from stuck tool cycles (native_tool_loop.rb)
+- **Preserve recent turns in context curator** — `preserve_recent_turns` setting (default: 2) prevents tool result distillation from the most recent N turns so the model retains full context of recent work (context/curator.rb)
+- **Large JSON result summarization** — `summarize_result` now extracts top-level JSON keys from large results (>2000 chars) without full parsing, avoiding ParseError noise from truncated JSON (steps/tool_history.rb)
+
+### Changed
+- **Default settings adjustments** — `tool_result_max_dispatch_chars`: 4000→10000, `default_temperature`: 1.0→0.9, `context_curation.tool_result_max_chars`: 2000→10000, `thinking_eviction`: true→false, `exchange_folding`: true→false, `target_context_tokens`: 40000→60000, `conversation.summarize_threshold`: 50000→90000, `conversation.target_tokens`: 20000→60000, `structured_output.retry_on_parse_failure`: true→false (settings.rb)
+- **Router no longer short-circuits on tier/provider** — Tier and provider hints flow through rule matching with scoring bonuses instead of bypassing rules entirely. Fallback chain: rule match → explicit resolution → arbitrage (router.rb)
+- **Always inject LegionIO tools** — Removed `client_tools_only?` optimization; LegionIO tools (special + extension) are always injected regardless of client passthrough settings. Client passthrough is handled by the tool loop which executes LegionIO tools server-side (executor.rb)
+- **Server-side LegionIO tool execution in tool loop** — Tool calls are partitioned into server (LegionIO) and client (passthrough). Server tools execute in-place; client tools are returned without results. LegionIO tool results are populated from `@pending_tool_history` so translators see completed results and avoid `pause_turn` stop reasons (native_tool_loop.rb, steps/tool_calls.rb)
+- **Stop reason logic for completed LegionIO tools** — LegionIO tools with results no longer trigger `:pause_turn`; only tools without results (pending execution) pause the turn (steps/tool_calls.rb)
+
+### Fixed
+- **merge_defaults crash on nil intent** — Added safe navigation (`&.`) for `transform_keys`/`transform_values` on nil intent in `merge_defaults` (router.rb)
+- **structured_output retry_enabled? nil dereference** — Changed `[]` chain to `.dig()` so the setting check survives when the structured_output subtree is absent (call/structured_output.rb)
+- **Spec helper provider registration isolation** — Standard providers (anthropic, test, bedrock, openai, ollama, vllm, azure_foundry, gemini, xai) are now re-registered in `before(:each)` after `Registry.reset!` so router resolution works in every test (spec_helper.rb)
+
+## [0.12.13] - 2026-06-05
+
+### Added
+- **Runtime caller class detection via caller_locations** — `Transport::Message#encode_message` now walks the call stack to find the class/module that initiated an AMQP publish and injects `runtime_caller_class` into the caller hash. Works for any caller (Legion::LLM::API::Namespaces::Anthropic::Messages, Legion::Gaia::*, etc.) — the class name is derived from the file path so it always matches the actual calling module (lib/legion/llm/transport/message.rb)
+
+## [0.12.12] - 2026-06-05
+
+### Added
+- **Caller class and client detection** — `build_server_caller` now emits `runtime_caller_class` (codex, claude-code), `runtime_caller_client` (user-agent), `parent_request_ref` (Codex turn_id for ledger correlation), and `codex_turn_metadata` (parsed X_CODEX_TURN_METADATA JSON) in the caller hash so the ledger can populate caller identity, client attribution, and turn-level request correlation without DB queries at emit time (api/shared_helpers.rb)
+
+## [0.12.11] - 2026-06-05
+
+### Fixed
+- **Client request ID and conversation threading** — `/v1/messages` and `/v1/responses` now read `X-Client-Request-Id` from HTTP headers as the request ID instead of always generating new ones. `conversation_id` now uses `Thread-Id` (Codex) or `X-Claude-Code-Session-Id` (Claude Code) so the ledger groups messages from the same client session into one conversation row instead of random UUIDs (api/namespaces/anthropic/messages.rb, api/namespaces/openai/responses.rb)
+
+## [0.12.10] - 2026-06-05
+
+### Fixed
+- **OpenAI role normalization** — `:developer`, `:critic`, `:discriminator` roles now map to `:system` for non-OpenAI providers (Anthropic, vLLM, Ollama, Bedrock) so they don't raise `InvalidRoleError`. OpenAI messages preserve the original role because OpenAI natively supports all four. `normalize_role` runs at the adapter boundary per-provider (issue #147) (lib/legion/llm/call/lex_llm_adapter.rb)
+
+## [0.12.9] - 2026-06-05
+
+### Fixed
+- **Escalation attempts now individually recorded** — Every escalation attempt emits its own metering and audit events so each provider attempt gets a separate `inference_response` row and `metric` row. Per-attempt events include messages, response content, thinking, tokens, and cost. `emit_error_audit` now includes request messages so the ledger captures `request_json` even on total escalation exhaustion (issue #147) (lib/legion/llm/inference/executor.rb)
+
+## [0.12.8] - 2026-06-05
+
+### Fixed
+- **Async thread pool graceful shutdown** — `Legion::LLM.shutdown` now calls `shutdown` + `wait_for_termination(5)` on the executor's `ASYNC_THREAD_POOL` so background curation, reflection, and knowledge capture threads drain cleanly instead of being killed mid-operation (issue #143) (lib/legion/llm.rb)
+
+## [0.12.7] - 2026-06-05
+
+### Fixed
+- **Metering events now include request messages and response content** — Fixes 86% empty `request_json` rows in `llm_message_inference_requests` by including `messages`, `response_content`, and `response_thinking` in the metering event payload so the ledger captures complete data on the first synchronous write (issue #146) (inference/steps/metering.rb, inference/executor.rb)
+
+## [0.12.6] - 2026-06-05
+
+### Added
+- **Full thinking/reasoning support end-to-end** — Thinking blocks now flow through the entire pipeline: provider adapter accumulates thinking deltas and completed thinking, LexLLMAdapter extracts reasoning from Responses API output items, Anthropic translator emits thinking_content_block and redacted_thinking blocks, and the Response struct carries `thinking` through to all API formats. Anthropic streaming now emits `thinking_delta` and `signature_delta` events with proper content_block_start/stop lifecycle (api/namespaces/anthropic/messages.rb, api/translators/anthropic_response.rb, call/lex_llm_adapter.rb, inference/executor.rb)
+- **Responses API thinking + tool calls** — LexLLMAdapter now accumulates thinking (`response.reasoning_text.delta`, `response.reasoning_summary_text.delta`) and tool calls (`response.function_call_arguments.delta`) during Responses API streaming. Hash (non-streaming) responses also extract thinking from reasoning output items and top-level `reasoning.text`. `responses_usage` captures `output_tokens_details.reasoning_tokens` (call/lex_llm_adapter.rb)
+- **OpenAI Responses API namespace overhaul** — Rebuilt `/v1/responses` handler with full reasoning, tool call, thinking config, and provider routing support. Extracts `provider`/`tier`/`instance` from headers and body, builds proper routing hash, forwards `thinking` config to Request.build, and emits thinking blocks in streaming responses. Non-streaming path now returns thinking in the response payload (api/namespaces/openai/responses.rb, api/openai/responses.rb)
+- **Shared API completion summary logging** — New `log_api_completion_summary` helper in `api/shared_helpers.rb` emits structured completion logs across all API handlers (Anthropic, OpenAI chat, OpenAI Responses, native chat, native inference) with provider, model, tier, tokens (input/output/cache/thinking), latency, tool calls, and stop_reason. Replaces ad-hoc logging in each handler (api/shared_helpers.rb, api/namespaces/anthropic/messages.rb, api/namespaces/openai/responses.rb, api/namespaces/native/chat.rb, api/namespaces/native/inference.rb, api/native/chat.rb)
+- **`output_tokens_details` token breakdown** — `Usage` struct now carries `output_tokens_details` (reasoning_tokens). `NativeResponseAdapter` extracts it from provider usage hashes, and `extract_tokens` preserves it in the response tokens hash so downstream metering and API responses can report reasoning token counts (metering/usage.rb, call/dispatch.rb, inference/executor.rb)
+- **Tool loop message persistence** — Intermediate assistant/tool messages generated during the native tool loop are now persisted to the conversation store. `persist_tool_loop_messages` stores the intermediate exchanges (tool_use + tool_result pairs) between the original inputs and the final assistant response. `tool_loop_final_tool_calls` extracts tool_calls from the loop's final message for the assistant response record (inference/executor.rb)
+- **Client stream error detection** — New `client_stream_error?` predicate detects client-side disconnects (Puma::ConnectionError, EPIPE, closed IOError, ECONNRESET, ECONNABORTED) so escalation avoids retrying when the HTTP client has already disconnected (inference/executor.rb)
+- **Tool source resolution from registry** — Client-shaped tool declarations are now reclassified as registry/extension tools when a matching entry exists in `Legion::Settings::Extensions.find_tool`. `request_tool_source` and `resolve_registry_tool_source` look up tools by name (including `raw_name` from sanitized LegionIO dot-notation like `legion.microsoft_teams_create_chain`) and reclassify the source to `:registry` or `:extension` type with proper tool_class, runner, and function metadata. `client_tools_only?` was rewritten to only return true when ALL tools are truly client-side (none resolved to registry) (inference/executor.rb)
+
+### Changed
+- **Anthropic Messages API model no longer required** — `validate_anthropic_required!` no longer rejects requests without an explicit `model` field; the executor will auto-select a default. This matches the behavior expected by Claude Code and other clients that rely on server-side model resolution (api/namespaces/anthropic/messages.rb)
+- **Settings defaults** — `gaia.advisory_enabled` defaults to `false`, `fleet.enabled` to `false`, `routing.escalation.enabled` to `false`, `routing.arbitrage.enabled` to `false`, `rag.enabled` to `false`, `knowledge_capture.enabled` to `false`. Context window reduced to `128000`, local tool limit reduced to `50` (settings.rb)
+- **Empty response detection accounts for thinking** — Anthropic streaming no longer emits an overloaded_error when the provider returns thinking-only content (internal reasoning with no client-visible text). The error check now requires both `tool_calls.empty? && full_text.empty? && full_thinking.empty?` (api/namespaces/anthropic/messages.rb)
+- **Streaming stream error resilience** — Anthropic and OpenAI Responses streaming handlers now track `stream_closed` state and handle EPIPE/Puma::ConnectionError gracefully, exiting the stream loop without blowing up Puma (api/namespaces/anthropic/messages.rb, api/namespaces/openai/responses.rb)
+- **`provider_supports_responses?` fallback** — When the provider is not yet resolved, falls back to the request's routing hint so the decision can be made before pre-provider steps run (inference/executor.rb)
+- **Rubocop directive cleanup** — Removed unnecessary `Metrics/BlockLength` and `Metrics/MethodLength` disable comments throughout API files that no longer trigger violations (api/namespaces/*/). Line-length directives removed where guard-clause style fixes the violation (inference/executor.rb)
+
+### Fixed
+- **`Faraday::SSLError` not caught as provider_down** — SSL/TLS errors (certificate failures, handshake errors) were not handled in the provider_down rescue chain. Now `Faraday::SSLError` is caught alongside `ConnectionFailed` and `TimeoutError` in both `execute_provider_request_native` and `execute_provider_request_stream_native`, with audit status `provider_down` (inference/executor.rb)
+- **`client_tools_only?` returned wrong result** — The original implementation checked if any tool had `type: :client`, which returned true for mixed client+registry tool sets. Rewritten to check that ALL tools are client-side passthrough (none resolved to registry/extension tool classes). This fixes registry tool injection being suppressed when client and server tools are mixed (inference/executor.rb)
+- **Model resolution pins to unregistered remote providers** — `resolve_model_to_local_provider` now requires `Call::Registry.registered?(provider, instance: instance)` to pass before selecting a discovered model as healthy. Prevents pinning to providers like Anthropic when they only exist in the discovery cache (e.g. on a vLLM-only node) (inference/executor.rb)
+- **Quality checker thinking handling** — `Quality::Checker` now properly handles responses where content is nil but thinking is present, avoiding false quality failures (quality/checker.rb)
+- **RBAC step log level** — Downgraded RBAC step log from info to debug to reduce noise in production logs (inference/steps/rbac.rb)
+- **Compatibility alias** — `NativeResponseAdapter` alias now points to the correct nested class under `Call::Dispatch` (compat.rb)
+- **Knowledge capture step** — Handles nil thinking gracefully and respects the disabled default setting (inference/steps/knowledge_capture.rb)
+- **Post response step** — Properly passes thinking through post-response processing (inference/steps/post_response.rb)
+- **Trigger match step** — Now checks `ThinkingExtractor` availability before attempting extraction (inference/steps/trigger_match.rb)
+- **Sticky persist step** — Fixed tool call extraction for responses with thinking (inference/steps/sticky_persist.rb)
+- **Health tracker** — Removed unnecessary `Lint/DuplicateBranch` rubocop directive (router/health_tracker.rb)
+- **Route attempts** — Fixed `route_attempts` tracking for SSLError failures (inference/route_attempts.rb)
+
+## [0.12.6] - 2026-06-05
+
+### Added
+- **Full thinking/reasoning support end-to-end** — Thinking blocks now flow through the entire pipeline: provider adapters accumulate thinking deltas and completed thinking, LexLLMAdapter extracts reasoning from Responses API output items, Anthropic translator emits thinking_content_block and redacted_thinking blocks, and the Response struct carries `thinking` through to all API formats. Anthropic streaming now emits `thinking_delta` and `signature_delta` events with proper content_block_start/stop lifecycle (api/namespaces/anthropic/messages.rb, api/translators/anthropic_response.rb, call/lex_llm_adapter.rb, inference/executor.rb)
+- **Responses API thinking + tool calls in streaming** — LexLLMAdapter now accumulates thinking (`response.reasoning_text.delta`, `response.reasoning_summary_text.delta`) and tool calls (`response.function_call_arguments.delta`) during Responses API streaming. Hash (non-streaming) responses also extract thinking from reasoning output items and top-level `reasoning.text`. `responses_usage` captures `output_tokens_details.reasoning_tokens` (call/lex_llm_adapter.rb)
+- **OpenAI Responses API namespace overhaul** — Rebuilt `/v1/responses` handler with full reasoning, tool call, thinking config, and provider routing support. Extracts `provider`/`tier`/`instance` from headers and body, builds proper routing hash, forwards `thinking` config to Request.build, and emits thinking blocks in streaming responses. Non-streaming path now returns thinking in the response payload (api/namespaces/openai/responses.rb, api/openai/responses.rb)
+- **Shared API completion summary logging** — New `log_api_completion_summary` helper in `api/shared_helpers.rb` emits structured completion logs across all API handlers (Anthropic, OpenAI chat, OpenAI Responses, native chat, native inference) with provider, model, tier, tokens (input/output/cache/thinking), latency, tool calls, and stop_reason. Replaces ad-hoc logging in each handler (api/shared_helpers.rb, api/namespaces/anthropic/messages.rb, api/namespaces/openai/responses.rb, api/namespaces/native/chat.rb, api/namespaces/native/inference.rb, api/native/chat.rb)
+- **`output_tokens_details` token breakdown** — `Usage` struct now carries `output_tokens_details` (reasoning_tokens). `NativeResponseAdapter` extracts it from provider usage hashes, and `extract_tokens` preserves it in the response tokens hash so downstream metering and API responses can report reasoning token counts (metering/usage.rb, call/dispatch.rb, inference/executor.rb)
+- **Tool loop message persistence** — Intermediate assistant/tool messages generated during the native tool loop are now persisted to the conversation store. `persist_tool_loop_messages` stores the intermediate exchanges (tool_use + tool_result pairs) between the original inputs and the final assistant response. `tool_loop_final_tool_calls` extracts tool_calls from the loop's final message for the assistant response record (inference/executor.rb)
+- **Client stream error detection** — New `client_stream_error?` predicate detects client-side disconnects (Puma::ConnectionError, EPIPE, closed IOError, ECONNRESET, ECONNABORTED) so escalation avoids retrying when the HTTP client has already disconnected (inference/executor.rb)
+- **Tool source resolution from registry** — Client-shaped tool declarations are now reclassified as registry/extension tools when a matching entry exists in `Legion::Settings::Extensions.find_tool`. `request_tool_source` and `resolve_registry_tool_source` look up tools by name (including `raw_name` from sanitized LegionIO dot-notation like `legion.microsoft_teams_create_chain`) and reclassify the source to `:registry` or `:extension` type with proper tool_class, runner, and function metadata. `client_tools_only?` was rewritten to only return true when ALL tools are truly client-side (none resolved to registry) (inference/executor.rb)
+
+### Changed
+- **Anthropic Messages API model no longer required** — `validate_anthropic_required!` no longer rejects requests without an explicit `model` field; the executor will auto-select a default. This matches the behavior expected by Claude Code and other clients that rely on server-side model resolution (api/namespaces/anthropic/messages.rb)
+- **Settings defaults** — `gaia.advisory_enabled` defaults to `false`, `fleet.enabled` to `false`, `routing.escalation.enabled` to `false`, `routing.arbitrage.enabled` to `false`, `rag.enabled` to `false`, `knowledge_capture.enabled` to `false`. Context window reduced to `128000`, local tool limit reduced to `50` (settings.rb)
+- **Empty response detection accounts for thinking** — Anthropic streaming no longer emits an overloaded_error when the provider returns thinking-only content (internal reasoning with no client-visible text). The error check now requires `tool_calls.empty? && full_text.empty? && full_thinking.empty?` (api/namespaces/anthropic/messages.rb)
+- **Streaming stream error resilience** — Anthropic and OpenAI Responses streaming handlers now track `stream_closed` state and handle EPIPE/Puma::ConnectionError gracefully, exiting the stream loop without blowing up Puma (api/namespaces/anthropic/messages.rb, api/namespaces/openai/responses.rb)
+- **`provider_supports_responses?` fallback** — When the provider is not yet resolved, falls back to the request's routing hint so the decision can be made before pre-provider steps run (inference/executor.rb)
+- **Rubocop directive cleanup** — Removed unnecessary `Metrics/BlockLength` and `Metrics/MethodLength` disable comments throughout API files that no longer trigger violations (api/namespaces/*/). Line-length directives removed where guard-clause style fixes the violation (inference/executor.rb)
+
+### Fixed
+- **`Faraday::SSLError` not caught as provider_down** — SSL/TLS errors (certificate failures, handshake errors) were not handled in the provider_down rescue chain. Now `Faraday::SSLError` is caught alongside `ConnectionFailed` and `TimeoutError` in both `execute_provider_request_native` and `execute_provider_request_stream_native`, with audit status `provider_down` (inference/executor.rb)
+- **`client_tools_only?` returned wrong result** — The original implementation checked if any tool had `type: :client`, which returned true for mixed client+registry tool sets. Rewritten to check that ALL tools are client-side passthrough (none resolved to registry/extension tool classes). This fixes registry tool injection being suppressed when client and server tools are mixed (inference/executor.rb)
+- **Model resolution pins to unregistered remote providers** — `resolve_model_to_local_provider` now requires `Call::Registry.registered?(provider, instance: instance)` to pass before selecting a discovered model as healthy. Prevents pinning to providers like Anthropic when they only exist in the discovery cache (e.g. on a vLLM-only node) (inference/executor.rb)
+- **Quality checker thinking handling** — `Quality::Checker` now properly handles responses where content is nil but thinking is present, avoiding false quality failures (quality/checker.rb)
+- **RBAC step log level** — Downgraded RBAC step log from info to debug to reduce noise in production logs (inference/steps/rbac.rb)
+- **Compatibility alias** — `NativeResponseAdapter` alias now points to the correct nested class under `Call::Dispatch` (compat.rb)
+- **Knowledge capture step** — Handles nil thinking gracefully and respects the disabled default setting (inference/steps/knowledge_capture.rb)
+- **Post response step** — Properly passes thinking through post-response processing (inference/steps/post_response.rb)
+- **Trigger match step** — Now checks `ThinkingExtractor` availability before attempting extraction (inference/steps/trigger_match.rb)
+- **Sticky persist step** — Fixed tool call extraction for responses with thinking (inference/steps/sticky_persist.rb)
+- **Route attempts** — Fixed `route_attempts` tracking for SSLError failures (inference/route_attempts.rb)
+- **Health tracker** — Removed unnecessary `Lint/DuplicateBranch` rubocop directive (router/health_tracker.rb)
+
+## [0.12.5] - 2026-06-04
+
+### Fixed
+- **dispatch_extension fails when source uses :extension key** — `dispatch_extension` only checked `source[:lex]`, but `check_registry_override` and other callers sometimes set `:extension` instead. Now falls back to `source[:extension]` when `:lex` is absent (tools/dispatcher.rb)
+- **dispatch_client attempted server-side execution of client tools** — Client tools (Bash, Read, etc.) now always return `:passthrough` status instead of attempting server-side execution via `ClientToolMethods`. LegionIO should never execute client tools; that's the client's responsibility (tools/dispatcher.rb)
+- **OpenAI Responses API ignores explicit provider routing** — Both namespace (`api/namespaces/openai/responses.rb`) and legacy (`api/openai/responses.rb`) handlers only passed `{ model: model }` in the routing hash, dropping `HTTP_X_LEGION_PROVIDER`, `HTTP_X_LEGION_TIER`, and `HTTP_X_LEGION_INSTANCE` headers. Now extracts these headers and body fields, builds a proper routing hash with provider/instance/model, and passes tier via `Request.extra[:tier]` to match the Anthropic Messages handler behavior.
+- **Anthropic Messages API drops thinking config** — Both namespace (`api/namespaces/anthropic/messages.rb`) and legacy (`api/anthropic/messages.rb`) handlers never forwarded `body[:thinking]` to `Request.build`. Now passes through unchanged so all providers (Anthropic, Bedrock, etc.) receive the original thinking config. Anthropic provider now handles both `:budget_tokens` and `:budget` keys for compatibility.
+
+## [0.12.4] - 2026-06-04
+
+### Fixed
+- **Forced tool choice arguments emitted as text instead of structured tool_use** — When a tool choice is forced (e.g. vLLM/qwen with explicit tool name in user text), the provider may output tool arguments as plain text JSON (`{"file_path": "..."}`) in `delta['content']` instead of structured `delta['tool_calls']`. Added `maybe_synthesize_tool_call_from_content` to both `execute_native_tool_loop` and `execute_native_streaming_tool_loop`: when tool calls are empty but content is valid JSON and a tool choice is forced, parse the text and create a proper tool call. Also added `text_looks_like_tool_json?` guard to Anthropic and OpenAI response translators to skip emitting JSON blobs as text deltas. Client sees native tool_use/function_call blocks instead of raw JSON text (inference/native_tool_loop.rb, api/translators/anthropic_response.rb, api/translators/openai_response.rb, api/anthropic/messages.rb, api/openai/chat_completions.rb)
+- **Model discovery pins to unregistered remote providers** — `resolve_model_to_local_provider` found a model in the discovery cache and pinned it to a provider that isn't registered locally (e.g. `claude-haiku-4-5-20251001` → Anthropic on a vLLM-only node). Added `Call::Registry.registered?(provider, instance: instance)` check to the healthy candidate filter so unregistered providers are skipped and the request falls through to `auto_route` (inference/executor.rb)
+- **`client_tools_only?` method missing** — Restored `client_tools_only?` in executor to guard explicit tool choice forcing for client passthrough requests (inference/executor.rb, inference/native_tool_loop.rb)
+
 ## [0.12.3] - 2026-06-02
 
 ### Fixed

data/lib/legion/llm/api/anthropic/messages.rb

@@ -13,10 +13,10 @@ module Legion
         module Messages
           extend Legion::Logging::Helper
 
-          def self.registered(app) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+          def self.registered(app) # rubocop:disable Metrics/AbcSize
             log.debug('[llm][api][anthropic][messages] registering POST /v1/messages')
 
-            app.post '/v1/messages' do # rubocop:disable Metrics/BlockLength
+            app.post '/v1/messages' do
               require_llm!
 
               body = parse_request_body
@@ -40,6 +40,7 @@ module Legion
                 tools:    build_tool_classes(normalized[:tools] || []),
                 caller:   build_server_caller(source: 'anthropic_compat', path: request.path, env: env),
                 stream:   streaming,
+                thinking: body[:thinking],
                 cache:    { strategy: :default, cacheable: true }
               )
 
@@ -54,6 +55,7 @@ module Legion
 
                 stream do |out|
                   full_text = +''
+                  text_delta_lines = [] # buffer in-stream deltas until we know if tool calls exist
 
                   pipeline_response = executor.call_stream do |chunk|
                     text = chunk.respond_to?(:content) ? chunk.content.to_s : chunk.to_s
@@ -61,7 +63,7 @@ module Legion
 
                     full_text << text
                     delta_event = Legion::LLM::API::Translators::AnthropicResponse.format_chunk(text)
-                    out << "event: content_block_delta\ndata: #{Legion::JSON.dump(delta_event)}\n\n"
+                    text_delta_lines << "event: content_block_delta\ndata: #{Legion::JSON.dump(delta_event)}\n\n"
                   end
 
                   events = Legion::LLM::API::Translators::AnthropicResponse.streaming_events(
@@ -71,6 +73,16 @@ module Legion
                     full_text:  full_text
                   )
 
+                  # If tool calls are present and the text is just JSON arguments,
+                  # suppress the in-stream text deltas so the client only sees
+                  # tool_use content blocks — not text deltas of raw JSON.
+                  if Legion::LLM::API::Translators::AnthropicResponse.text_looks_like_tool_json?(full_text)
+                    pipeline_tools = pipeline_response.respond_to?(:tools) ? Array(pipeline_response.tools) : []
+                    text_delta_lines.clear if pipeline_tools.any?
+                  end
+
+                  text_delta_lines.each { |line| out << line }
+
                   events.each do |event_name, payload|
                     next if event_name == 'content_block_delta'
 

data/lib/legion/llm/api/namespaces/anthropic/files.rb

@@ -167,7 +167,6 @@ module Legion
               anthropic_error('api_error', e.message, status_code: 500)
             end
 
-            # rubocop:disable Metrics/BlockLength
             helpers do
               # ── Filename / MIME extraction ──────────────────────────────────
 
@@ -285,8 +284,6 @@ module Legion
                 sorted_list
               end
             end
-            # rubocop:enable Metrics/BlockLength
-
             # Thread-safe metadata store, re-initialized cleanly on each Sinatra::Extension register.
             def self.metadata_store
               @metadata_store ||= Concurrent::Map.new