legion-llm 0.8.49 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88524bf330ed22e6ac366d35ddccdbad4557b115c447d87d238ab2670ca8da7e
-  data.tar.gz: 68c0470f4c10ee885bd28d0486f487777ae3c9dc35ab0fea3cc4ab860c68a0c6
+  metadata.gz: 6a7ea4bbe972c340ca3ccaa0cf2478724c90bb8385f1d8129a21fc74981a4380
+  data.tar.gz: a7a8250e8c84835b3bf2ffefe9cdc25494b9be7deae4cb16375bd8bfa2d8dcf2
 SHA512:
-  metadata.gz: ba9ad2293c9e65db838aca3921ba291ef3bfd71798fc044bfdcdb90f3a04e0536fa5c562f00ea3e06eda88c41ee1659d23ef46382c69424940b4ff058f5cd978
-  data.tar.gz: c7feaf54a2a618eb5d45741269ba65d855bb478142a3b90702d29de9d23f3bbceadca26b5eb765bedf6c2476b97901dc59cc597242051d9500df9733174532f4
+  metadata.gz: be0a896d160b6824760d0361bb82e8e320f312fc23e8e9156cf9dfd924f3d264a48ff71bce0531b29f13913bf367c7eeca732cff477adc1c54310a4f4cbcce38
+  data.tar.gz: 210706b370e355606f342e506108b4ac13cb0e663c8203fe7b09afdeb643dba4e1ade3e5cb8e13b0efe4238b33656a73f7f57e74687413a6b0914821a31b0039

data/CHANGELOG.md

@@ -1,5 +1,122 @@
 # Legion LLM Changelog
 
+## [0.9.9] - 2026-05-07
+
+### Fixed
+- Initialized sticky-state persistence reads explicitly on cache misses to satisfy static analysis without changing runtime behavior.
+- Consume GAIA advisory `tool_hint`, `suppress`, and `context_window` data when building native tool definitions and sizing RAG retrieval, so GAIA advisory outputs affect provider calls instead of only appearing in enrichment summaries.
+
+## [0.9.8] - 2026-05-06
+
+### Fixed
+- Fixed Anthropic Messages request normalization for multi-block content.
+- Marked API-submitted client tools as non-executable server-side while preserving trusted registry/deferred tool injection.
+- Preferred explicit settings overrides over registry MCP overrides.
+- Added structured-output parse retries through alternate routes when an escalation route is available.
+- Added bounded metering spool writes, disabled-vs-dropped audit results, and warning logs for invalid settings paths and invalid inventory offerings.
+- Preserved non-text message content for audit/persistence and extracted string-keyed text blocks correctly.
+- Added trackable unknown caller identity defaults for audit/transport envelopes.
+- Used provider embedding usage tokens when formatting OpenAI-compatible embedding responses.
+- Serialized daemon-client cached state behind a shared mutex.
+- Added escalation transport exchange binding for escalation events.
+
+## [0.9.7] - 2026-05-06
+
+### Fixed
+- Enabled arbitrage by default, added zero-cost local/fleet offering coverage, and removed the dead `Quality::Checker.model_score` dependency from arbitrage eligibility.
+- Skipped debate when fewer than two distinct models are available and captured judge evaluation/confidence separately from the final answer.
+- Reused the shared context token estimator for billing preflight cost checks.
+- Logged dropped metering emissions at the inference metering call site.
+- Added resolved model metadata to routing span attributes.
+- Stopped treating standalone email addresses as PII by default while preserving contextual and opt-in email detection.
+- Allowed context curation to choose vLLM/MLX local or fleet models for LLM-assisted summarization.
+- Routed compressor summarization through standard low-cost/basic intent when no explicit compressor model is configured.
+
+## [0.9.6] - 2026-05-06
+
+### Fixed
+- Enforced privacy classification as a forced local routing constraint, even when callers request a cloud tier.
+- Made RAG faithfulness failures block caller-visible responses by default and record structured audit data.
+- Archived dropped conversation turns into Apollo with conversation-scoped tags and retrieved archived history during RAG context loading.
+- Reported escalation quality failures and low-confidence responses to `Router::HealthTracker` as quality signals.
+- Persisted conversation sticky state through the database path and restored it after in-memory LRU eviction.
+- Counted pending conversation-history and RAG enrichments in token-budget checks before provider dispatch.
+- Averaged provider health priority adjustments across instances while preserving worst-state circuit reporting.
+
+## [0.9.5] - 2026-05-06
+
+### Fixed
+- Fixed context curator cache invalidation and stored curated-summary replay so compacted messages are used on later turns.
+- Persisted curation marker records even when a pass does not rewrite individual messages, allowing structural curation to run for short-message turns.
+- Fixed compressor LLM summarization to call `Legion::LLM.chat_direct` with a prompt message instead of the obsolete session-style API.
+- Warn and omit misleading zero-dollar cost estimates when provider usage metadata collapses to zero tokens for a known model.
+
+## [0.9.4] - 2026-05-06
+
+### Changed
+- Added shared inference step logging helpers and debug-level step enter/complete/failure logs.
+- Added safe debug/info instrumentation across inference steps for routing actions, enrichment decisions, tool handling, RAG, skill injection, sticky runner state, billing, classification, debate, post-response audit, and metering emission.
+
+## [0.9.3] - 2026-05-06
+
+### Changed
+- Delegated responder-side fleet provider execution, token validation, and provider response publishing to the shared `lex-llm` fleet helpers.
+- Kept `legion-llm` as the request-side fleet dispatcher and token issuer while retaining compatibility aliases for old responder constants.
+- Bumped the `lex-llm` dependency floor to `>= 0.4.3` for shared responder execution helpers.
+
+## [0.9.2] - 2026-05-06
+
+### Fixed
+- Prefer namespaced caller ids over ambiguous display identities when publishing audit, metering, and transport identity metadata.
+
+## [0.9.1] - 2026-05-06
+
+### Changed
+- `legion-llm` now owns lex-llm provider registration by scanning loaded provider modules, constructing `LexLLMAdapter` instances, and writing `Call::Registry`.
+- Provider rediscovery now rebuilds registry entries after `Call::Registry.reset!`, supporting LegionIO reload/hot-update flows without relying on provider require-time side effects.
+- Bumped the `lex-llm` dependency floor to `>= 0.4.1` for pure provider discovery and alias metadata.
+
+### Fixed
+- Preserve streaming thinking chunks that providers emit as plain strings.
+- Normalize discovered provider instance ids from provider offerings before memory-gate and availability checks.
+- Use canonical offering aliases for metering cost estimates and fall back to caller agent metadata for fleet context.
+- Preserve extension, string, and top-level caller identity metadata in audit events and transport headers.
+
+## [0.9.0] - 2026-05-06
+
+### Changed
+- Added shared provider-owned fleet responder execution support for lex-llm provider gems.
+- Moved fleet dispatch defaults to top-level `fleet.dispatch`, removed legacy gateway defaults, and rejected `routing.use_fleet` / `openai_compat.gateways` settings during validation.
+- OpenAI-compatible routing now resolves through registered `lex-llm-openai` provider instances instead of gateway interceptor configuration.
+- Native dispatch now routes chat, stream, embed, image, and health calls through the canonical lex-llm provider-instance adapter contract.
+- Native inference now records direct/fleet route attempts with dispatch path, idempotency key, selected lane, failure reason, and escalation context.
+- Native inference and `/api/llm/inference` now strip provider thinking from caller-visible content and expose thinking only through explicit diagnostic fields/events.
+- Inventory and provider/model API reads now use cached discovery and non-live provider offerings, so explicit discovery refresh remains the only path that probes provider endpoints.
+- Fleet dispatch now publishes shared lex-llm protocol-v2 envelopes with canonical `operation`, `request_id`, `correlation_id`, `idempotency_key`, signed tokens, and strict reply matching.
+- Fleet worker handling now validates protocol-v2 envelopes, enforces token/idempotency policy, dispatches local providers through canonical lex-llm methods, and publishes shared lex-llm response/error envelopes.
+- Bumped dependency floors to `lex-llm >= 0.4.0` and `legion-transport >= 1.4.14` for shared provider contracts and fleet envelopes.
+
+### Removed
+- Removed the gateway interceptor runtime path and gateway metering fallback.
+- Retired `Legion::LLM::Transport::Messages::FleetRequest`, `FleetResponse`, and `FleetError` as fleet message authorities in favor of `Legion::Extensions::Llm::Transport::Messages::*`.
+
+## [0.8.51] - 2026-05-03
+
+### Changed
+- Native `/api/llm/inference` streaming hides provider thinking deltas by default, with `include_thinking: true` as the explicit diagnostic opt-in.
+- Pipeline metering events now carry wall-clock latency, estimated cost, conversation/correlation ids, billing, task, agent, identity, and routing context.
+- LLM transport messages now preserve caller identity, credential, and caller type headers from nested caller metadata, top-level identity metadata, and extension callers.
+
+### Fixed
+- Prompt audit events now include provider response thinking separately from assistant response content.
+- Native lex-llm dispatch now carries provider thinking separately from response content before API responses are emitted.
+- Native discovery now normalizes provider offering objects before generating routing candidates, preserving provider instance, tier, capabilities, context length, and parameter metadata.
+
+## [0.8.50] - 2026-05-03
+
+### Fixed
+- Native discovery now normalizes lex-llm `ModelOffering` objects before generating routing candidates, allowing auto-rules to populate from provider adapters again.
+
 ## [0.8.49] - 2026-04-29
 
 ### Changed

data/README.md

@@ -2,7 +2,7 @@
 
 LLM routing and provider orchestration for the [LegionIO](https://github.com/LegionIO/LegionIO) framework. Routes chat, embeddings, tool use, fleet dispatch, auditing, and provider metadata through Legion-native `lex-llm-*` provider extensions.
 
-**Version**: 0.8.49
+**Version**: 0.9.0
 
 ## Installation
 
@@ -60,7 +60,7 @@ Requests flow through the full Inference pipeline — routing, metering, audit,
 Both formats supported with correct SSE shapes:
 - **OpenAI**: `data: {"choices":[{"delta":{"content":"..."}}]}` chunks, terminated by `data: [DONE]`
 - **Anthropic**: Typed events — `message_start`, `content_block_start`, `content_block_delta`, `content_block_stop`, `message_delta`, `message_stop`
-- **Native**: `/api/llm/inference` streams `text-delta`, `thinking-delta`, tool lifecycle events, and a final `done` event. Structured provider content blocks are flattened to plain text in both streaming and non-streaming native responses so `content` remains a string for daemon clients.
+- **Native**: `/api/llm/inference` streams `text-delta`, optional `thinking-delta` events when `include_thinking: true`, tool lifecycle events, and a final `done` event. Structured provider content blocks are flattened to plain text in both streaming and non-streaming native responses so `content` remains a string for daemon clients.
 
 ### API Authentication
 
@@ -122,7 +122,7 @@ Credentials are resolved automatically by the universal secret resolver in `legi
 
 ### Provider Extensions (lex-llm-*)
 
-Each provider is a standalone `lex-llm-*` gem that ships its own `default_settings`, model catalog, and capability declarations. The provider registers itself with `legion-llm` at load time. Provider gems implement:
+Each provider is a standalone `lex-llm-*` gem that ships its own `default_settings`, model catalog, capability declarations, and optional provider-owned fleet worker actor. When a provider gem is loaded, `legion-llm` discovers it through the shared `lex-llm` provider contract and registers provider instances for routing. Provider gems implement:
 
 - **`default_settings`** -- Connection defaults (base_url, region, API key env vars)
 - **`model_allowed?(model_name)`** -- Provider-level model filtering
@@ -370,9 +370,9 @@ Legion::LLM (lib/legion/llm.rb)          # Thin facade — delegates to Inferenc
 │   ├── Arbitrage    # Cost-aware model selection when no rules match
 │   └── Escalation/
 │       └── History  # EscalationHistory mixin
-├── Fleet                                # Fleet RPC dispatch over AMQP (built-in)
+├── Fleet                                # Fleet dispatch over AMQP; provider responders live in lex-llm-* gems
 │   ├── Dispatcher   # Fleet RPC dispatch with routing key building, per-type timeouts
-│   ├── Handler      # Fleet request handler for GPU worker nodes
+│   ├── TokenIssuer  # Request-side JWT minting for provider-owned responders
 │   └── ReplyDispatcher # Correlation-based reply routing
 ├── API                                  # All external HTTP interfaces
 │   ├── Auth         # Config-driven Bearer/x-api-key auth for /v1/ routes
@@ -392,10 +392,10 @@ Legion::LLM (lib/legion/llm.rb)          # Thin facade — delegates to Inferenc
 │       ├── OpenAIRequest / OpenAIResponse
 │       └── AnthropicRequest / AnthropicResponse
 ├── Audit                                # Prompt, tool, and skill audit event emission
-├── Transport                            # Centralized AMQP exchange and message definitions
+├── Transport                            # Centralized AMQP exchange and non-fleet message definitions
 │   ├── Message      # LLM base message: context propagation, LLM headers
 │   ├── Exchanges/   # Fleet, Metering, Audit, Escalation
-│   └── Messages/    # FleetRequest, FleetResponse, FleetError, MeteringEvent, etc.
+│   └── Messages/    # MeteringEvent, prompt/tool audit, escalation, and compatibility wrappers
 ├── Scheduling                           # Deferred execution
 │   ├── Batch        # Non-urgent request batching with priority queue and auto-flush
 │   └── OffPeak      # Peak-hour deferral
@@ -497,8 +497,8 @@ legion-llm includes a dynamic weighted routing engine that dispatches requests a
 │  Tier 1: LOCAL  → Ollama on this machine (direct HTTP)   │
 │          Zero network overhead, no Transport              │
 │                                                          │
-│  Tier 2: FLEET  → vLLM/Ollama on GPU workers             │
-│          Built-in Fleet RPC over AMQP                     │
+│  Tier 2: FLEET  → provider-owned lex-llm-* responders     │
+│          Shared lex-llm fleet envelopes over AMQP         │
 │                                                          │
 │  Tier 3: CLOUD  → Bedrock / Azure / Gemini               │
 │  Tier 4: FRONTIER → Anthropic / OpenAI                   │
@@ -509,12 +509,12 @@ legion-llm includes a dynamic weighted routing engine that dispatches requests a
 | Tier | Target | Use Case |
 |------|--------|----------|
 | `local` | Ollama on localhost | Privacy-sensitive, offline, or low-latency workloads |
-| `fleet` | Shared hardware via built-in Fleet dispatcher (AMQP) | Larger vLLM/Ollama models on dedicated GPU servers |
-| `openai_compat` | OpenAI-compatible gateways | Self-hosted or proxy endpoints with OpenAI-compatible APIs |
+| `fleet` | Shared hardware via provider-owned lex-llm responders over AMQP | Larger vLLM/Ollama models on dedicated GPU servers |
+| `openai_compat` | OpenAI-compatible provider instances | Self-hosted or proxy endpoints with OpenAI-compatible APIs |
 | `cloud` | API providers (Bedrock, Azure, Gemini) | Managed cloud inference |
 | `frontier` | API providers (Anthropic, OpenAI) | Frontier models, full-capability inference |
 
-Fleet dispatch is built into legion-llm. The `Fleet::Dispatcher` publishes shared-lane requests to keys such as `llm.fleet.inference.qwen3-6-27b.ctx32000` or `llm.fleet.embed.nomic-embed-text`; `Fleet::Handler` processes them on GPU worker nodes and replies through correlated live responses. Keep `routing.tiers.fleet.routing_style` set to `shared_lane` for the default pooled model lanes, set it to `offering_lane` for exact provider-instance lanes such as `llm.fleet.offering.vllm-gpu-01.qwen3-6.inference`, or use any other value only for the legacy `llm.request.{provider}.{type}.{model}` keys.
+Fleet dispatch is built into `legion-llm`, but fleet consumption is provider-owned. `Fleet::Dispatcher` publishes shared `lex-llm` protocol-v2 `FleetRequest` envelopes to keys such as `llm.fleet.inference.qwen3-6-27b.ctx32000` or `llm.fleet.embed.nomic-embed-text`; the enabled provider gem actor consumes the request, validates the signed token and idempotency key through `Legion::Extensions::Llm::Fleet::ProviderResponder`, calls its local provider instance through the canonical `lex-llm` provider methods, and replies with shared `FleetResponse` or `FleetError` envelopes. Keep `routing.tiers.fleet.routing_style` set to `shared_lane` for the default pooled model lanes, or set it to `offering_lane` for exact provider-instance lanes such as `llm.fleet.offering.vllm-gpu-01.qwen3-6.inference`.
 
 #### Intent-Based Dispatch
 
@@ -585,7 +585,7 @@ Add routing configuration under the `llm` key:
           "timeout_seconds": 30,
           "timeouts": { "embed": 10, "chat": 30, "generate": 30, "default": 30 }
         },
-        "openai_compat": { "gateways": [] },
+        "openai_compat": { "providers": ["openai"] },
         "cloud": { "providers": ["bedrock", "azure", "gemini"] },
         "frontier": { "providers": ["anthropic", "openai"] }
       },
@@ -853,6 +853,8 @@ Legion::Service#initialize
   load_extensions      # LEX extensions (can use LLM if available)
 ```
 
+LegionIO hosts these routes through `mount_library_routes('llm', Routes::Llm, 'Legion::LLM::Routes')`. The route modules remain owned by `legion-llm`; LegionIO no longer registers provider gateway fallback routes when the library is available.
+
 - **Service**: `setup_llm` called between data and supervision in startup sequence
 - **Extensions**: `llm_required?` method on extension module, checked at load time
 - **Helpers**: `Legion::Extensions::Helpers::LLM` auto-loaded when gem is present
@@ -887,8 +889,9 @@ bundle exec rubocop -A
 | `legion-json` | Legion JSON serialization |
 | `legion-logging` | Logging |
 | `legion-settings` | Configuration defaults and file overrides |
+| `legion-transport` (>= 1.4.14) | AMQP transport for fleet dispatch, metering, and audit |
 | `lex-knowledge` | Optional knowledge chunking integration when loaded |
-| `lex-llm` (>= 0.1.6) | Provider-neutral model offering and adapter base |
+| `lex-llm` (>= 0.4.3) | Provider-neutral contract, model offerings, response normalization, fleet envelopes, and responder-side fleet execution helpers |
 | `pdf-reader` | PDF extraction support |
 | `tzinfo` (>= 2.0) | IANA timezone conversion for schedule windows |
 

data/legion-llm.gemspec

@@ -31,8 +31,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-json', '>= 1.2.0'
   spec.add_dependency 'legion-logging', '>= 1.2.8'
   spec.add_dependency 'legion-settings', '>= 1.4.0'
+  spec.add_dependency 'legion-transport', '>= 1.4.14'
   spec.add_dependency 'lex-knowledge'
-  spec.add_dependency 'lex-llm', '>= 0.1.6'
+  spec.add_dependency 'lex-llm', '>= 0.4.3'
   spec.add_dependency 'pdf-reader'
   spec.add_dependency 'tzinfo', '>= 2.0'
 end

data/lib/legion/llm/api/native/helpers.rb

@@ -301,7 +301,7 @@ module Legion
                   name:        tname,
                   description: tdesc,
                   parameters:  tschema || {},
-                  source:      { type: :client, executable: true }
+                  source:      { type: :client, executable: false }
                 )
               rescue StandardError => e
                 handle_exception(e, level: :warn, handled: true, operation: "llm.api.build_client_tool_class.#{tname}")

data/lib/legion/llm/api/native/inference.rb

@@ -26,6 +26,7 @@ module Legion
               caller_context  = body[:caller]
               conversation_id = body[:conversation_id]
               request_id      = body[:request_id] || SecureRandom.uuid
+              include_thinking = body[:include_thinking] == true
 
               unless messages.is_a?(Array)
                 halt 400, { 'Content-Type' => 'application/json' },
@@ -145,7 +146,7 @@ module Legion
 
                   pipeline_response = executor.call_stream do |chunk|
                     thinking = extract_text_content(chunk.thinking) if chunk.respond_to?(:thinking)
-                    emit_sse_event(out, 'thinking-delta', { delta: thinking }) unless thinking.to_s.empty?
+                    emit_sse_event(out, 'thinking-delta', { delta: thinking }) if include_thinking && !thinking.to_s.empty?
 
                     text = extract_text_content(chunk.respond_to?(:content) ? chunk.content : chunk)
                     next if text.empty?
@@ -161,14 +162,18 @@ module Legion
 
                   routing = pipeline_response.routing || {}
                   tokens = pipeline_response.tokens || {}
+                  done_payload = {
+                    request_id:      request_id,
+                    content:         full_text,
+                    model:           (routing[:model] || routing['model']).to_s,
+                    input_tokens:    token_value(tokens, :input),
+                    output_tokens:   token_value(tokens, :output),
+                    tool_calls:      extract_tool_calls(pipeline_response),
+                    conversation_id: pipeline_response.conversation_id
+                  }
+                  done_payload[:thinking] = pipeline_response.thinking if include_thinking && pipeline_response.thinking
                   emit_sse_event(out, 'done', {
-                                   request_id:      request_id,
-                                   content:         full_text,
-                                   model:           (routing[:model] || routing['model']).to_s,
-                                   input_tokens:    token_value(tokens, :input),
-                                   output_tokens:   token_value(tokens, :output),
-                                   tool_calls:      extract_tool_calls(pipeline_response),
-                                   conversation_id: pipeline_response.conversation_id
+                                   **done_payload
                                  })
 
                   log.info(
@@ -208,16 +213,18 @@ module Legion
                   "stop_reason=#{pipeline_response.stop&.dig(:reason) || 'unknown'} stream=false"
                 )
 
-                json_response({
-                                request_id:      request_id,
-                                content:         content,
-                                tool_calls:      tool_calls,
-                                stop_reason:     pipeline_response.stop&.dig(:reason)&.to_s,
-                                model:           (routing[:model] || routing['model']).to_s,
-                                input_tokens:    token_value(tokens, :input),
-                                output_tokens:   token_value(tokens, :output),
-                                conversation_id: pipeline_response.conversation_id
-                              }, status_code: 200)
+                payload = {
+                  request_id:      request_id,
+                  content:         content,
+                  tool_calls:      tool_calls,
+                  stop_reason:     pipeline_response.stop&.dig(:reason)&.to_s,
+                  model:           (routing[:model] || routing['model']).to_s,
+                  input_tokens:    token_value(tokens, :input),
+                  output_tokens:   token_value(tokens, :output),
+                  conversation_id: pipeline_response.conversation_id
+                }
+                payload[:thinking] = pipeline_response.thinking if include_thinking && pipeline_response.thinking
+                json_response(payload, status_code: 200)
               end
             rescue Legion::LLM::AuthError => e
               handle_exception(e, level: :error, handled: true, operation: 'llm.api.inference.auth', request_id: request_id)

data/lib/legion/llm/api/native/providers.rb

@@ -80,7 +80,8 @@ module Legion
           def self.instance_to_hash(entry)
             health = begin
               Legion::LLM::Router.health_tracker
-            rescue StandardError
+            rescue StandardError => e
+              handle_exception(e, level: :debug, handled: true, operation: 'api.providers.health_tracker')
               nil
             end
             provider_key = entry[:provider].to_sym

data/lib/legion/llm/api/openai/embeddings.rb

@@ -35,9 +35,10 @@ module Legion
                              when Hash  then vector[:vector] || vector['vector'] || vector[:embedding] || vector['embedding'] || []
                              else []
                              end
+              usage = vector.is_a?(Hash) ? (vector[:usage] || vector['usage'] || vector) : nil
 
               response_body = Legion::LLM::API::Translators::OpenAIResponse.format_embeddings(
-                vector_array, model: model, input_text: text
+                vector_array, model: model, input_text: text, usage: usage
               )
 
               log.info("[llm][api][openai][embeddings] action=complete model=#{model} dims=#{vector_array.size}")

data/lib/legion/llm/api/translators/anthropic_request.rb

@@ -84,7 +84,7 @@ module Legion
             return content if content.is_a?(String)
             return content unless content.is_a?(Array)
 
-            content.map do |block|
+            parts = content.map do |block|
               bs = block.respond_to?(:transform_keys) ? block.transform_keys(&:to_sym) : block
               type = bs[:type].to_s
               case type

data/lib/legion/llm/api/translators/openai_response.rb

@@ -70,8 +70,8 @@ module Legion
             }
           end
 
-          def format_embeddings(vector, model:, input_text:)
-            tokens = input_text.to_s.split.size
+          def format_embeddings(vector, model:, input_text:, usage: nil)
+            tokens = embedding_token_count(usage, input_text)
 
             {
               object: 'list',
@@ -134,6 +134,16 @@ module Legion
 
             nil
           end
+
+          def embedding_token_count(usage, input_text)
+            usage_hash = usage.respond_to?(:key?) ? usage : {}
+            token_count = usage_hash[:prompt_tokens] || usage_hash['prompt_tokens'] ||
+                          usage_hash[:input_tokens] || usage_hash['input_tokens'] ||
+                          usage_hash[:total_tokens] || usage_hash['total_tokens']
+            return token_count.to_i if token_count
+
+            input_text.to_s.split.size
+          end
         end
       end
     end

data/lib/legion/llm/audit.rb

@@ -24,8 +24,8 @@ module Legion
           log.info('[llm][audit] published prompt audit')
           :published
         else
-          log.warn('[llm][audit] dropped prompt audit: transport unavailable')
-          :dropped
+          log.warn('[llm][audit] disabled prompt audit: transport unavailable')
+          :disabled
         end
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'llm.audit.emit_prompt')
@@ -38,8 +38,8 @@ module Legion
           log.info('[llm][audit] published tool audit')
           :published
         else
-          log.warn('[llm][audit] dropped tool audit: transport unavailable')
-          :dropped
+          log.warn('[llm][audit] disabled tool audit: transport unavailable')
+          :disabled
         end
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'llm.audit.emit_tools')
@@ -52,8 +52,8 @@ module Legion
           log.info('[llm][audit] published skill audit')
           :published
         else
-          log.warn('[llm][audit] dropped skill audit: transport unavailable')
-          :dropped
+          log.warn('[llm][audit] disabled skill audit: transport unavailable')
+          :disabled
         end
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'llm.audit.emit_skill')

data/lib/legion/llm/call/daemon_client.rb

@@ -17,6 +17,10 @@ module Legion
 
         module_function
 
+        def state_mutex
+          @state_mutex ||= Mutex.new
+        end
+
         # Returns true if the daemon is reachable and healthy.
         # Returns false immediately if daemon_url is nil.
         # Caches a positive health check for HEALTH_CACHE_TTL seconds.
@@ -25,14 +29,13 @@ module Legion
           return false if daemon_url.nil?
 
           now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-
-          return true if @healthy == true && @health_checked_at && (now - @health_checked_at) < HEALTH_CACHE_TTL
+          cached_healthy = state_mutex.synchronize do
+            @healthy == true && @health_checked_at && (now - @health_checked_at) < HEALTH_CACHE_TTL
+          end
+          return true if cached_healthy
 
           result = check_health
-          if result
-            @healthy           = true
-            @health_checked_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-          end
+          record_health(result) if result
           result
         end
 
@@ -61,16 +64,20 @@ module Legion
         # Returns the daemon URL from settings, cached after first read.
         # Returns nil if settings are unavailable or the key is missing.
         def daemon_url
-          return @daemon_url if defined?(@daemon_url)
+          state_mutex.synchronize do
+            return @daemon_url if defined?(@daemon_url)
 
-          @daemon_url = fetch_daemon_url
+            @daemon_url = fetch_daemon_url
+          end
         end
 
         # Clears all cached state. Returns self for chaining.
         def reset!
-          remove_instance_variable(:@daemon_url) if defined?(@daemon_url)
-          @healthy           = nil
-          @health_checked_at = nil
+          state_mutex.synchronize do
+            remove_instance_variable(:@daemon_url) if defined?(@daemon_url)
+            @healthy           = nil
+            @health_checked_at = nil
+          end
           self
         end
 
@@ -79,8 +86,7 @@ module Legion
         def check_health
           response = http_get('/api/health')
           healthy = response.code == '200'
-          @healthy           = healthy
-          @health_checked_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+          record_health(healthy)
           log.info("Daemon health check result=#{healthy ? 'healthy' : 'unhealthy'} url=#{daemon_url}")
           healthy
         rescue StandardError => e
@@ -92,8 +98,7 @@ module Legion
         # Marks the daemon as unhealthy and records the timestamp.
         def mark_unhealthy
           log.warn("Daemon marked unhealthy url=#{daemon_url}")
-          @healthy           = false
-          @health_checked_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+          record_health(false)
         end
 
         # Builds and sends a GET request. Returns Net::HTTPResponse.
@@ -185,6 +190,13 @@ module Legion
           nil
         end
 
+        def record_health(healthy)
+          state_mutex.synchronize do
+            @healthy = healthy == true
+            @health_checked_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+          end
+        end
+
         def safe_parse(body)
           return {} if body.nil? || body.strip.empty?
 
@@ -242,7 +254,8 @@ module Legion
           end
         end
 
-        private_class_method :fetch_daemon_url, :safe_parse, :extract_retry_after, :interpret_inference_response
+        private_class_method :state_mutex, :fetch_daemon_url, :record_health, :safe_parse, :extract_retry_after,
+                             :interpret_inference_response
       end
     end
   end