lex-llm 0.8.0 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6482361b65a465a6eb683fb1789cd47a6a1a80c709c344eefb57205321e90c12
-  data.tar.gz: b2dd262d310f469fd1c89fa0b00eb1199822397bdb762c17c056b05cbad1b1d6
+  metadata.gz: e2216f17aaf84164eccc09087fb78e2a52339c24ae67207a43e220de31927fc3
+  data.tar.gz: 143caaf03ac594ef2cf9fb298836b7226f67c8b43ee4e0c0e5cdc26aaeb9b4d0
 SHA512:
-  metadata.gz: 64cb921e6ccf8361704df0fe4846fb80b3d074ed09b6940f4cff2c2440c8260e36258acda18ed786415d8052a111e33dcd17ad0f1cef1240dd634f14c30f0172
-  data.tar.gz: e2bb88cc4d672f4a11a64cdc91cc922964e67eab8baa85ad3108c40cc269363dc8009684162c70d1f98dbf8d0a0757d0ca8790838eb066ddab59a1edf37cb28d
+  metadata.gz: 24b19766bdc02f567c50d2a76305cdbbc15252607ab02d46484811f9723164f6bb75dae86e5556901b675b235f750f14a3c41dc25e2b5d357cb52a7d81399c19
+  data.tar.gz: 7a65c4c5f65c5b43d123f408a6c399a983a5fbbbedbdc13dcd5e96ab16edf414e186266ae4c4e43f35927466303997d5b74d6cd95391eb6b8a64edf8702a55aa

data/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 0.8.5 - 2026-10-29
+
+### Changed
+- Make shared provider TLS certificate and hostname verification configurable through
+  `Legion::Settings` at `extensions.llm.ssl.verify`, defaulting to `false`. Set it to
+  `true` to enable verification with Typhoeus or Net::HTTP; explicitly trusted custom
+  certificate authorities remain supported. (#50)
+
+### Fixed
+- Correct asynchronous TCP probes that could report refused connections as open
+  on Darwin; inspect the completed socket's error status instead of reconnecting.
+
+## 0.8.4 - 2026-08-25
+
+### Changed
+- **OpenAI-compatible transposer routes thinking through the canonical bridge.**
+  `Provider::OpenAICompatible#openai_reasoning_effort` now returns `nil` (omitting
+  `reasoning_effort`) when thinking is absent or `enabled: false`, and uses
+  `Thinking::Config#resolved_effort` instead of the raw `effort` — so a budget-only
+  request derives an effort instead of being silently dropped. Added spec coverage.
+- **`Responses::ToolArguments.parse!` accepts every legitimate wire form (10 U2).**
+  An already-decoded `Hash` passes through unchanged (it is the canonical Hash); a
+  `null`/empty/whitespace-only string and a JSON `null` resolve to `{}` (the documented
+  no-arguments default, not tolerance). Genuinely corrupt arguments — a non-object JSON
+  value or invalid JSON — still raise; they are never fabricated into `{}`.
+
+## 0.8.3 - 2026-08-25
+
+### Removed
+- **Removed `Canonical::Params#max_thinking_tokens`.** Thinking budget now lives solely
+  on `Thinking::Config#budget`. The redundant dual-home on Params is deleted from the
+  `Data.define` member list, `.build`, `.from_hash`, and the strict `.new` validation
+  block. Any wire payload carrying `max_thinking_tokens` in params will now fold into
+  `metadata` as an unknown key (04 L5).
+
+## 0.8.2 - 2026-08-25
+
+### Changed
+- **Expand `Thinking::Config` to the common superset shape.** The canonical struct
+  is now `Data.define(:enabled, :effort, :budget, :summary, :metadata)`:
+  - `enabled` — explicit Boolean (true/false). Default true when a Config is built;
+    nil request.thinking means "client said nothing"; `enabled: false` means explicit
+    OFF. Validated strictly (non-boolean raises).
+  - `effort` — closed 6-level enum: `none`, `low`, `medium`, `high`, `xhigh`, `max`
+    (downcased strings). Unknown values raise at construction.
+  - `budget` — positive Integer or nil. Zero and negatives rejected at construction
+    (off rides `enabled: false`; dynamic rides `enabled: true` + no axis).
+  - `summary` — closed enum `{nil, :auto, :none, :concise, :detailed}` for
+    thought-visibility; independent of the effort/budget axes.
+  - `metadata` — unchanged passthrough Hash.
+  - `EFFORT_BUDGET` extended to the full ladder:
+    `{'low'=>1024,'medium'=>8192,'high'=>16384,'xhigh'=>24576,'max'=>32768}`.
+    `none` resolves to nil budget. `resolved_budget` and `resolved_effort` only FILL
+    an axis the client didn't supply — never overwrite a supplied one.
+  - `enabled?` returns the `enabled` member directly.
+
+## 0.8.1 - 2026-08-25
+
+### Changed
+- **Extract `Thinking::Config` to its own file.** `Canonical::Thinking::Config` (the
+  `Data.define` type and its constants) now lives in `canonical/thinking_config.rb`
+  instead of being nested inside `canonical/thinking.rb`. Spec coverage split into a
+  matching `thinking_config_spec.rb`. Pure refactor — no behavior changes.
+
 ## 0.8.0 - 2026-08-20
 
 **The SSOT v4 contract cut.** This is a complete contract line, not a patch wave:

data/README.md

@@ -489,10 +489,44 @@ Key settings paths:
 - `extensions.llm.fleet.endpoint` -- endpoint-style worker configuration
 - `extensions.llm.fleet.compliance.encrypt_fleet` -- encrypt fleet envelopes (default true)
 - `extensions.llm.fleet.auth.verify_issuer` -- validate JWT issuer (default true)
+- `extensions.llm.ssl.verify` -- verify provider HTTPS certificates and hostnames (default false)
 - `extensions.llm.security.credential_source_probing` -- gate credential probing (default true)
 - `extensions.llm.model_whitelist` / `model_blacklist` -- provider-level model filters
 - `extensions.llm.<family>.instance.<name>.model_whitelist` -- per-instance override
 
+### TLS verification and custom certificate authorities
+
+Shared provider connections read `extensions.llm.ssl.verify` from `Legion::Settings`
+when constructed. The default is `false` for both Typhoeus and Net::HTTP.
+With verification disabled, untrusted and wrong-host certificates are accepted,
+so credentials can be sent to an unauthenticated peer.
+
+Enable verification before creating provider connections:
+
+```json
+{
+  "extensions": {
+    "llm": {
+      "ssl": { "verify": true }
+    }
+  }
+}
+```
+
+With verification enabled, an untrusted certificate or hostname mismatch fails
+before an authenticated HTTP request is sent.
+
+When constructing a shared connection for a private or corporate CA, configure
+the underlying Faraday SSL options before making the first request:
+
+```ruby
+connection = Legion::Extensions::Llm::Connection.new(provider, config)
+connection.connection.ssl.ca_file = '/path/to/trusted-ca-bundle.pem'
+```
+
+When verification is enabled, private or self-signed HTTPS servers need explicit
+CA trust. Plain HTTP behavior is unchanged.
+
 ---
 
 ## Provider Dependencies

data/lib/legion/extensions/llm/canonical/chunk.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ParameterLists -- factory methods have many params
+# rubocop:disable-next Metrics/ParameterLists -- factory methods have many params
 module Legion
   module Extensions
     module Llm
@@ -207,4 +207,3 @@ module Legion
     end
   end
 end
-# rubocop:enable Metrics/ParameterLists

data/lib/legion/extensions/llm/canonical/content_block.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ParameterLists -- factory methods have many params
+# rubocop:disable-next Metrics/ParameterLists -- factory methods have many params
 module Legion
   module Extensions
     module Llm
@@ -149,4 +149,3 @@ module Legion
     end
   end
 end
-# rubocop:enable Metrics/ParameterLists

data/lib/legion/extensions/llm/canonical/message.rb

@@ -2,7 +2,7 @@
 
 require 'securerandom'
 
-# rubocop:disable Metrics/ParameterLists -- factory methods have many params
+# rubocop:disable-next Metrics/ParameterLists -- factory methods have many params
 module Legion
   module Extensions
     module Llm
@@ -138,4 +138,3 @@ module Legion
     end
   end
 end
-# rubocop:enable Metrics/ParameterLists

data/lib/legion/extensions/llm/canonical/params.rb

@@ -11,19 +11,19 @@ module Legion
         # Per G18: all standard/useful params are first-class, mapped per provider by translators.
         # Canonical keys only (O03a): provider spellings are translated at the edges.
         Params = ::Data.define(
-          :max_tokens, :max_thinking_tokens, :temperature, :top_p, :top_k,
+          :max_tokens, :temperature, :top_p, :top_k,
           :stop_sequences, :seed, :frequency_penalty, :presence_penalty,
           :response_format, :metadata
         ) do
           # rubocop:disable Metrics/ParameterLists -- factory methods have many params
           # Build from keyword args (primary constructor).
           def self.build(
-            max_tokens: nil, max_thinking_tokens: nil, temperature: nil, top_p: nil, top_k: nil,
+            max_tokens: nil, temperature: nil, top_p: nil, top_k: nil,
             stop_sequences: nil, seed: nil, frequency_penalty: nil, presence_penalty: nil,
             response_format: nil, metadata: {}
           )
             new(
-              max_tokens:, max_thinking_tokens:, temperature:, top_p:, top_k:,
+              max_tokens:, temperature:, top_p:, top_k:,
               stop_sequences:, seed:, frequency_penalty:, presence_penalty:,
               response_format:, metadata: Strict.metadata!(metadata, self::BUILD_SITE)
             )
@@ -39,7 +39,6 @@ module Legion
             metadata = Strict.fold_unknowns!(self, self::FROM_HASH_SITE, hash)
             build(
               max_tokens: hash[:max_tokens],
-              max_thinking_tokens: hash[:max_thinking_tokens],
               temperature: hash[:temperature],
               top_p: hash[:top_p],
               top_k: hash[:top_k],
@@ -73,7 +72,6 @@ module Legion
           # wire. The factories fill their defaults and delegate here.
           Strict.install_strict_new!(self) do |values, site|
             values[:max_tokens] = Strict.expect_type!(values[:max_tokens], [::Integer], site, :max_tokens)
-            values[:max_thinking_tokens] = Strict.expect_type!(values[:max_thinking_tokens], [::Integer], site, :max_thinking_tokens)
             values[:temperature] = Strict.expect_type!(values[:temperature], [::Numeric], site, :temperature)
             values[:top_p] = Strict.expect_type!(values[:top_p], [::Numeric], site, :top_p)
             values[:top_k] = Strict.expect_type!(values[:top_k], [::Integer], site, :top_k)

data/lib/legion/extensions/llm/canonical/request.rb

@@ -2,7 +2,7 @@
 
 require 'securerandom'
 
-# rubocop:disable Metrics/ParameterLists -- factory methods have many params
+# rubocop:disable-next Metrics/ParameterLists -- factory methods have many params
 module Legion
   module Extensions
     module Llm
@@ -136,4 +136,3 @@ module Legion
     end
   end
 end
-# rubocop:enable Metrics/ParameterLists

data/lib/legion/extensions/llm/canonical/response.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ParameterLists -- factory methods have many params
+# rubocop:disable-next Metrics/ParameterLists -- factory methods have many params
 module Legion
   module Extensions
     module Llm
@@ -115,4 +115,3 @@ module Legion
     end
   end
 end
-# rubocop:enable Metrics/ParameterLists

data/lib/legion/extensions/llm/canonical/thinking.rb

@@ -69,105 +69,9 @@ module Legion
         Thinking::BUILD_SITE = 'Canonical::Thinking.build'
         Thinking::FROM_HASH_SITE = 'Canonical::Thinking.from_hash'
         Thinking::NEW_SITE = 'Canonical::Thinking.new'
-
-        # Normalized config for thinking across providers — one name, one shape
-        # (04 §8): Canonical::Thinking::Config. # -- required for Data.define block scope
-        Thinking::Config = ::Data.define(:effort, :budget, :metadata) do
-          def self.build(effort: nil, budget: nil, metadata: {})
-            new(effort: effort_string!(effort, self::BUILD_SITE), budget:,
-                metadata: Strict.metadata!(metadata, self::BUILD_SITE))
-          end
-
-          # Build from a Hash.
-          def self.from_hash(source)
-            Strict.require_hash!(source, self::FROM_HASH_SITE)
-            hash = Strict.symbolize_keys(source)
-            metadata = Strict.fold_unknowns!(self, self::FROM_HASH_SITE, hash)
-            build(effort: hash[:effort], budget: hash[:budget], metadata:)
-          end
-
-          # M4: effort is a closed enum (the EFFORT_BUDGET keys), not an
-          # unbounded string — an unrecognized effort is a contract error at
-          # construction, never a silently-derived budget.
-          def self.effort_string!(effort, site)
-            return nil if effort.nil?
-
-            value = effort.is_a?(::Symbol) ? effort.to_s : Strict.expect_type!(effort, [::String], site, :effort)
-            normalized = value.downcase
-            allowed = self::EFFORT_BUDGET.keys
-            raise ArgumentError, "#{site}: Invalid effort: #{value.inspect}. Must be one of: #{allowed.join(', ')}" unless allowed.include?(normalized)
-
-            normalized
-          end
-
-          # Serialize to a Hash for AMQP/fleet/wire transport. Faithful to what was
-          # SET — never fabricates the missing axis (use resolved_* for that).
-          def to_h
-            super.compact
-          end
-
-          def as_json(*)
-            to_h
-          end
-
-          def to_json(*)
-            to_h.to_json(*)
-          end
-
-          # Whether thinking is configured.
-          def enabled?
-            !effort.nil? || !budget.nil?
-          end
-
-          # Budget for a provider that needs a token budget (e.g. Anthropic),
-          # derived from effort when budget was not explicitly set. nil only
-          # when neither axis is configured. M4: effort is enum-validated at
-          # construction, so the lookup cannot miss — the silent medium
-          # fallback is deleted.
-          def resolved_budget
-            return budget unless budget.nil?
-            return nil if effort.nil?
-
-            self.class::EFFORT_BUDGET[effort]
-          end
-
-          # Effort for a provider that needs an effort level (e.g. OpenAI),
-          # derived from budget when effort was not explicitly set. nil only
-          # when neither axis is configured.
-          def resolved_effort
-            return effort unless effort.nil?
-            return nil if budget.nil?
-
-            bands = self.class::EFFORT_BUDGET
-            if budget < bands['medium'] then 'low'
-            elsif budget < bands['high'] then 'medium'
-            else 'high'
-            end
-          end
-
-          # H1/M4: the single strict constructor — .new runs the same member
-          # contract as the factories (effort enum, Integer budget); the
-          # factories fill their defaults and delegate here.
-          Strict.install_strict_new!(self) do |values, site|
-            values[:effort] = effort_string!(values[:effort], site)
-            values[:budget] = Strict.expect_type!(values[:budget], [::Integer], site, :budget)
-            values[:metadata] = Strict.metadata!(values[:metadata], site)
-            values
-          end
-        end
-
-        # SSOT for the effort<->budget conversion. A client dialect supplies only
-        # ONE axis (Anthropic = budget_tokens only; OpenAI = effort only), but a
-        # provider translator may need the OTHER. This single map lets every
-        # provider ask for whichever axis it needs and always get a usable value,
-        # so thinking survives any client x provider pair (best-effort, never
-        # silently dropped). effort -> budget is exact; budget -> effort uses the
-        # band boundaries above.
-        Thinking::Config::EFFORT_BUDGET = { 'low' => 1024, 'medium' => 8192, 'high' => 16_384 }.freeze
-        Thinking::Config::BUILD_SITE = 'Canonical::Thinking::Config.build'
-        Thinking::Config::FROM_HASH_SITE = 'Canonical::Thinking::Config.from_hash'
-        Thinking::Config::NEW_SITE = 'Canonical::Thinking::Config.new'
       end
     end
   end
 end
+
+require_relative 'thinking_config'

data/lib/legion/extensions/llm/canonical/thinking_config.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# -- extracted from thinking.rb; depends on Thinking being defined first
+module Legion
+  module Extensions
+    # -- module doc is in canonical.rb entry point
+    module Llm
+      # -- required for Data.define block scope
+      module Canonical
+        # Normalized config for thinking across providers — one name, one shape
+        # (04 §8): Canonical::Thinking::Config.
+        # Members: enabled, effort, budget, summary, metadata
+        Thinking::Config = ::Data.define(:enabled, :effort, :budget, :summary, :metadata) do
+          def self.build(enabled: true, effort: nil, budget: nil, summary: nil, metadata: {})
+            new(enabled: enabled, effort: effort_string!(effort, self::BUILD_SITE), budget: budget,
+                summary: summary, metadata: Strict.metadata!(metadata, self::BUILD_SITE))
+          end
+
+          # Build from a Hash.
+          def self.from_hash(source)
+            Strict.require_hash!(source, self::FROM_HASH_SITE)
+            hash = Strict.symbolize_keys(source)
+            metadata = Strict.fold_unknowns!(self, self::FROM_HASH_SITE, hash)
+            build(enabled: hash.key?(:enabled) ? hash[:enabled] : true,
+                  effort: hash[:effort], budget: hash[:budget],
+                  summary: hash[:summary], metadata: metadata)
+          end
+
+          # M4: effort is a closed enum (the EFFORT_BUDGET keys), not an
+          # unbounded string — an unrecognized effort is a contract error at
+          # construction, never a silently-derived budget.
+          def self.effort_string!(effort, site)
+            return nil if effort.nil?
+
+            value = effort.is_a?(::Symbol) ? effort.to_s : Strict.expect_type!(effort, [::String], site, :effort)
+            normalized = value.downcase
+            allowed = self::EFFORT_LEVELS
+            raise ArgumentError, "#{site}: Invalid effort: #{value.inspect}. Must be one of: #{allowed.join(', ')}" unless allowed.include?(normalized)
+
+            normalized
+          end
+
+          # Validate summary is a closed enum.
+          def self.summary_enum!(value, site)
+            return nil if value.nil?
+
+            sym = value.is_a?(::String) ? value.to_sym : value
+            Strict.expect_type!(sym, [::Symbol], site, :summary)
+            allowed = self::SUMMARY_LEVELS
+            unless allowed.include?(sym)
+              raise ArgumentError,
+                    "#{site}: Invalid summary: #{value.inspect}. Must be one of: #{allowed.map(&:inspect).join(', ')}"
+            end
+
+            sym
+          end
+
+          # Serialize to a Hash for AMQP/fleet/wire transport. Faithful to what was
+          # SET — never fabricates the missing axis (use resolved_* for that).
+          def to_h
+            super.compact
+          end
+
+          def as_json(*)
+            to_h
+          end
+
+          def to_json(*)
+            to_h.to_json(*)
+          end
+
+          # Whether thinking is enabled (the enabled member).
+          def enabled?
+            enabled
+          end
+
+          # Budget for a provider that needs a token budget (e.g. Anthropic),
+          # derived from effort when budget was not explicitly set. nil when
+          # effort is 'none' or neither axis is configured. Only FILLS — never
+          # overwrites a supplied budget. Both axes may be carried together.
+          def resolved_budget
+            return budget unless budget.nil?
+            return nil if effort.nil?
+            return nil if effort == 'none'
+
+            self.class::EFFORT_BUDGET[effort]
+          end
+
+          # Effort for a provider that needs an effort level (e.g. OpenAI),
+          # derived from budget when effort was not explicitly set. nil only
+          # when neither axis is configured. Only FILLS — never overwrites a
+          # supplied effort.
+          def resolved_effort
+            return effort unless effort.nil?
+            return nil if budget.nil?
+
+            bands = self.class::EFFORT_BUDGET
+            if budget <= bands['low'] then 'low'
+            elsif budget <= bands['medium'] then 'medium'
+            elsif budget <= bands['high'] then 'high'
+            elsif budget <= bands['xhigh'] then 'xhigh'
+            else 'max'
+            end
+          end
+
+          # H1/M4: the single strict constructor — .new runs the same member
+          # contract as the factories (enabled bool, effort enum, Integer budget,
+          # summary enum); the factories fill their defaults and delegate here.
+          Strict.install_strict_new!(self) do |values, site|
+            # enabled: must be true or false
+            raise ArgumentError, "#{site}: enabled must be true or false, got #{values[:enabled].inspect}" unless [true, false].include?(values[:enabled])
+
+            values[:effort] = effort_string!(values[:effort], site)
+
+            # budget: must be a positive Integer or nil
+            values[:budget] = Strict.expect_type!(values[:budget], [::Integer], site, :budget)
+            raise ArgumentError, "#{site}: budget must be positive, got #{values[:budget]}" if values[:budget] && !values[:budget].positive?
+
+            values[:summary] = summary_enum!(values[:summary], site)
+            values[:metadata] = Strict.metadata!(values[:metadata], site)
+            values
+          end
+        end
+
+        # Closed set of valid effort levels.
+        Thinking::Config::EFFORT_LEVELS = %w[none low medium high xhigh max].freeze
+
+        # SSOT for the effort<->budget conversion. A client dialect supplies only
+        # ONE axis (Anthropic = budget_tokens only; OpenAI = effort only), but a
+        # provider translator may need the OTHER. This single map lets every
+        # provider ask for whichever axis it needs and always get a usable value,
+        # so thinking survives any client x provider pair (best-effort, never
+        # silently dropped). effort -> budget is exact; budget -> effort uses the
+        # band boundaries above. 'none' has no budget — resolves to nil.
+        Thinking::Config::EFFORT_BUDGET = {
+          'low' => 1024, 'medium' => 8192, 'high' => 16_384,
+          'xhigh' => 24_576, 'max' => 32_768
+        }.freeze
+
+        # Closed set of valid summary levels.
+        Thinking::Config::SUMMARY_LEVELS = %i[auto none concise detailed].freeze
+
+        Thinking::Config::BUILD_SITE = 'Canonical::Thinking::Config.build'
+        Thinking::Config::FROM_HASH_SITE = 'Canonical::Thinking::Config.from_hash'
+        Thinking::Config::NEW_SITE = 'Canonical::Thinking::Config.new'
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/canonical/tool_call.rb

@@ -2,7 +2,7 @@
 
 require 'securerandom'
 
-# rubocop:disable Metrics/ParameterLists -- factory methods have many params
+# rubocop:disable-next Metrics/ParameterLists -- factory methods have many params
 module Legion
   module Extensions
     module Llm
@@ -132,4 +132,3 @@ module Legion
     end
   end
 end
-# rubocop:enable Metrics/ParameterLists

data/lib/legion/extensions/llm/canonical.rb

@@ -2,6 +2,7 @@
 
 require_relative 'canonical/strict'
 require_relative 'canonical/thinking'
+require_relative 'canonical/thinking_config'
 require_relative 'canonical/usage'
 require_relative 'canonical/params'
 require_relative 'canonical/content_block'

data/lib/legion/extensions/llm/connection.rb

@@ -40,7 +40,7 @@ module Legion
           @config = config
 
           @connection ||= Faraday.new(provider.api_base) do |faraday|
-            faraday.ssl.verify = false
+            faraday.ssl.verify = Legion::Settings.dig(:extensions, :llm, :ssl, :verify) == true
             setup_timeout(faraday)
             setup_logging(faraday)
             setup_retry(faraday)

data/lib/legion/extensions/llm/credential_sources.rb

@@ -114,11 +114,7 @@ module Legion
           rescue IO::WaitWritable
             return false unless sock.wait_writable(timeout)
 
-            begin
-              sock.connect_nonblock(addr)
-            rescue Errno::EISCONN
-              # already connected — success
-            end
+            return sock.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).int.zero?
           end
           true
         rescue StandardError => e

data/lib/legion/extensions/llm/provider/open_ai_compatible.rb

@@ -154,10 +154,16 @@ module Legion
             { type: 'json_schema', json_schema: schema_hash }
           end
 
+          # Transpose canonical thinking -> OpenAI `reasoning_effort` (edge, O03a).
+          # Omit the key when there is no thinking or it is explicitly disabled
+          # (a reasoning model then uses its own default). resolved_effort fills
+          # the effort axis from budget when the client supplied only a budget,
+          # so a budget-only request is never silently dropped.
           def openai_reasoning_effort(thinking)
             return nil unless thinking.is_a?(Canonical::Thinking::Config)
+            return nil unless thinking.enabled
 
-            thinking.effort
+            thinking.resolved_effort
           end
 
           # One response-parse boundary (08 R2): returns Canonical::Response.

data/lib/legion/extensions/llm/responses/tool_arguments.rb

@@ -12,15 +12,29 @@ module Legion
         module ToolArguments
           module_function
 
-          # Parse assembled tool-call arguments JSON into a Hash.
-          # nil / empty string means "no arguments" and returns {} (documented
-          # default, not tolerance).
+          # Parse tool-call arguments into the canonical Hash (10 U2).
+          #
+          # The provider wire legitimately encodes the arguments in a few
+          # forms; this ONE parser maps every legitimate form to the canonical
+          # Hash so every lex-llm-* provider parses arguments identically:
+          #   - nil, empty/whitespace String, or JSON null  -> {} (no arguments;
+          #     documented default, not tolerance)
+          #   - an already-decoded wire object (Hash)       -> passed through
+          #     (it IS the canonical Hash)
+          #   - a JSON-object String                        -> parsed to Hash
+          #
+          # Genuinely corrupted arguments still raise — a non-object JSON value
+          # (array/number/string) or invalid JSON is a contract error, never a
+          # fabricated {} (04 L1/L7; the old rescue-to-{} policies are deleted).
           def parse!(raw)
             return {} if raw.nil?
-            return {} if raw.is_a?(::String) && raw.strip.empty?
-            raise ArgumentError, "tool call arguments expected JSON String, got #{raw.class}" unless raw.is_a?(::String)
+            return raw if raw.is_a?(::Hash)
+            return {} if raw.is_a?(::String) && (raw.strip.empty? || raw.strip.casecmp?('null'))
+
+            raise ArgumentError, "tool call arguments expected JSON String or Hash, got #{raw.class}" unless raw.is_a?(::String)
 
             parsed = ::Legion::JSON.parse(raw, symbolize_names: false)
+            return {} if parsed.nil?
             raise ArgumentError, "tool call arguments must be a JSON object, got #{parsed.class}" unless parsed.is_a?(::Hash)
 
             parsed

data/lib/legion/extensions/llm/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Llm
-      VERSION = '0.8.0'
+      VERSION = '0.8.5'
     end
   end
 end

data/lib/legion/extensions/llm.rb

@@ -156,6 +156,9 @@ module Legion
 
       def self.default_settings
         {
+          ssl: {
+            verify: false
+          },
           fleet: {
             consumer: {
               enabled: false,

data/spec/legion/extensions/llm/canonical/params_spec.rb

@@ -9,7 +9,6 @@ RSpec.describe Legion::Extensions::Llm::Canonical::Params do
   let(:type_source) do
     {
       max_tokens: 1024,
-      max_thinking_tokens: 512,
       temperature: 0.7,
       top_p: 0.9,
       top_k: 40,
@@ -28,7 +27,6 @@ RSpec.describe Legion::Extensions::Llm::Canonical::Params do
     it 'does not translate provider spellings (they fold into metadata)' do
       params = described_class.from_hash(max_output_tokens: 999, num_predict: 888, stop: ['x'])
       expect(params.max_tokens).to be_nil
-      expect(params.max_thinking_tokens).to be_nil
       expect(params.stop_sequences).to be_nil
       expect(params.metadata).to eq(max_output_tokens: 999, num_predict: 888, stop: ['x'])
     end