llm_providers 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f834a22b64b2340ae461021d17a8dc2d0c65ff22182ea57f750c851686d4c152
-  data.tar.gz: 4c459fb08e001951fcd04343de74ffff1fb025325bf9ffdd90b95cd03ce5a0b8
+  metadata.gz: 39486a92a6fa6a631714e76c434ac822ff9ce3239e0947b0d562d12e48abc257
+  data.tar.gz: c76b7917bf45d857d37c8ac1bf725e80b88d5a8ab578cd3f1522b1a831a9d7cb
 SHA512:
-  metadata.gz: d4fede081164f7cb0eb33b954f81c912d514ae32cc71ff020e16dd6ec0c15f98cd98b3657bdbb92264c9760121f7b7c85a90ae58f840a55aacd65d35d6b48ff2
-  data.tar.gz: 77b512797ec93a5c08c85eb997bbccd769572ea5e1c901c4393acf0078a9ba8c6375a831bb034878a5a637b91fa83a0feb945611cb00e33353cb0561a9db2462
+  metadata.gz: 9f7fa21339fb2f323af4802cb1b9c8d5631b576036015212ac7969457c90a1f95a5874cff32cb5ba9d481f096093b27c896dd3eca866ad351890cac877321cd0
+  data.tar.gz: f6fb426095fd10973245392db4f079e8db8274269f2846ce9f942d60dd9df310da53989078e853f0ba0371a44b1a4698a81989c83a1eb6dc9348c83a9846caf7

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.3.0] - 2026-10-10
+
+### Breaking
+
+- `temperature` now defaults to `nil` and is sent only when given (it used to default to 0.7). Pass it explicitly to keep the old behavior on models that still accept it.
+- OpenAI reasoning detection is now "everything except the `gpt-3.5*` / `gpt-4*` families". Ids that do not start with those prefixes, such as `ft:gpt-4o-*` fine-tunes, `chatgpt-4o-latest` and `gpt-oss-*`, are now treated as reasoning models: they get `max_completion_tokens` and no `temperature`. OpenRouter is unaffected.
+
+### Changed
+
+- Anthropic non-streaming responses join all text blocks instead of taking the first.
+- Anthropic debug output goes through `LlmProviders.logger.debug` instead of `puts`.
+
+### Added
+
+- `effort:` option (`low`, `medium`, `high`, `xhigh`, `max`; `nil` for the provider default). Anthropic sends `output_config.effort`, OpenAI sends `reasoning_effort` (clamped to `high` below gpt-6), Google sends `thinkingConfig.thinkingLevel` (Gemini 3 and later only; xhigh and max become high), OpenRouter sends `reasoning.effort` (xhigh and max become high). Unknown values raise `ArgumentError`.
+
+### Fixed
+
+- GPT-6 and gpt-5.x models now get `max_completion_tokens` instead of `max_tokens`.
+- Claude 5.x no longer fails with "`temperature` is deprecated for this model".
+- Gemini usage `output` now includes thought tokens, so it is never nil; a response that hits MAX_TOKENS with no text returns empty content instead of raising.
+- Anthropic thinking blocks and `thinking_delta` / `signature_delta` events are ignored in results; Gemini thought-summary parts are left out of content.
+
 ## [0.2.2] - 2026-02-27
 
 ### Fixed

data/README.ja.md

@@ -68,11 +68,21 @@ end
 provider = LlmProviders::Providers.build(
   :openai,
   model: "gpt-4.1",
-  temperature: 0.7,
-  max_tokens: 4096
+  temperature: 0.7,   # 省略可。デフォルトは nil（送信しない）
+  max_tokens: 4096,
+  effort: "medium"    # 省略可。"low" / "medium" / "high" / "xhigh" / "max"
 )
 ```
 
+- `temperature` のデフォルトは `nil` で、指定したときだけ送信します。0.7 を固定で送っていた 0.2.x までと異なります。Claude 5.x や OpenAI の reasoning モデルは temperature を受け付けません。
+- `effort` は思考の深さの指定です（`nil` ならプロバイダーのデフォルト）。範囲外の値は `ArgumentError` になります。
+  - Anthropic: `output_config: { effort: ... }` にそのまま渡します。
+  - OpenAI: `reasoning_effort` に渡します。`gpt-6*` はそのまま、それ以前の reasoning モデル（gpt-5*、o 系）は `xhigh` / `max` を `high` に丸めます。`gpt-3.5*` / `gpt-4*` では無視されます。
+  - Google: `thinkingConfig.thinkingLevel` に変換します（low→low、medium→medium、high/xhigh/max→high）。Gemini 3 以降（と `*-latest`）にだけ送り、Gemini 2.x では無視します。
+  - OpenRouter: `reasoning: { effort: ... }` として送ります。`xhigh` / `max` は `high` に丸めます。
+- OpenAI は `gpt-3.5*` / `gpt-4*` 以外を reasoning モデルとして扱い、`max_completion_tokens` を使って temperature を送りません。OpenRouter は `vendor/model` 形式の ID なので従来どおり `max_tokens` を使い、temperature は指定時のみ送ります。
+- Google の usage の `output` は思考トークンを含みます。
+
 ### ツール呼び出し
 
 ```ruby

data/README.md

@@ -68,11 +68,21 @@ end
 provider = LlmProviders::Providers.build(
   :openai,
   model: "gpt-4.1",
-  temperature: 0.7,
-  max_tokens: 4096
+  temperature: 0.7,   # optional; defaults to nil (not sent)
+  max_tokens: 4096,
+  effort: "medium"    # optional; "low", "medium", "high", "xhigh" or "max"
 )
 ```
 
+- `temperature` defaults to `nil` and is sent only when you set it. Versions up to 0.2.x always sent 0.7. Claude 5.x and OpenAI reasoning models reject the parameter.
+- `effort` sets how hard the model thinks (`nil` means the provider default). Any other value raises `ArgumentError`.
+  - Anthropic: sent as `output_config: { effort: ... }`.
+  - OpenAI: sent as `reasoning_effort`. `gpt-6*` gets the value unchanged; older reasoning models (gpt-5*, o-series) get `xhigh` / `max` clamped to `high`. Ignored for `gpt-3.5*` / `gpt-4*`.
+  - Google: mapped to `thinkingConfig.thinkingLevel` (low, medium, high; xhigh and max become high). Only sent for Gemini 3 and later (and `*-latest` aliases); ignored for Gemini 2.x.
+  - OpenRouter: sent as `reasoning: { effort: ... }`, with xhigh and max clamped to `high`.
+- OpenAI treats every model except `gpt-3.5*` / `gpt-4*` as a reasoning model: it uses `max_completion_tokens` and sends no temperature. OpenRouter ids look like `vendor/model`, so it keeps using `max_tokens` and sends temperature only when given.
+- For Google, usage `output` includes thinking tokens.
+
 ### Tool Calling
 
 ```ruby

data/lib/llm_providers/providers/anthropic.rb

@@ -48,6 +48,7 @@ module LlmProviders
         end
 
         payload[:temperature] = @temperature if @temperature
+        payload[:output_config] = { effort: @effort } if @effort
 
         if tools && !tools.empty?
           formatted_tools = format_tools(tools)
@@ -131,8 +132,7 @@ module LlmProviders
         payload[:stream] = true
         started_at = Time.now
 
-        puts "[Anthropic] stream_response payload tools: #{payload[:tools]&.size || 0}"
-        puts "[Anthropic] payload[:tools] = #{payload[:tools].inspect}" if payload[:tools]
+        LlmProviders.logger.debug "[Anthropic] stream_response payload tools: #{payload[:tools]&.size || 0}"
 
         full_content = ""
         tool_calls = []
@@ -163,9 +163,9 @@ module LlmProviders
                 end
               end
             when "content_block_start"
-              puts "[Anthropic] content_block_start: #{event["content_block"]&.dig("type")}"
+              LlmProviders.logger.debug "[Anthropic] content_block_start: #{event["content_block"]&.dig("type")}"
               if event.dig("content_block", "type") == "tool_use"
-                puts "[Anthropic] Tool use started: #{event.dig("content_block", "name")}"
+                LlmProviders.logger.debug "[Anthropic] Tool use started: #{event.dig("content_block", "name")}"
                 tool_calls << {
                   id: event.dig("content_block", "id"),
                   name: event.dig("content_block", "name"),
@@ -262,7 +262,7 @@ module LlmProviders
         end
 
         body = response.body
-        content = body["content"]&.find { |c| c["type"] == "text" }&.dig("text") || ""
+        content = (body["content"] || []).select { |c| c["type"] == "text" }.map { |c| c["text"].to_s }.join
 
         tool_calls = body["content"]&.select { |c| c["type"] == "tool_use" }&.map do |tc|
           { id: tc["id"], name: tc["name"], input: tc["input"] }

data/lib/llm_providers/providers/base.rb

@@ -5,9 +5,17 @@ require "faraday"
 module LlmProviders
   module Providers
     class Base
-      def initialize(model: nil, temperature: nil, max_tokens: nil)
+      EFFORT_LEVELS = %w[low medium high xhigh max].freeze
+
+      # temperature: nil means "provider default" (not sent).
+      # effort: nil means "provider default"; otherwise one of EFFORT_LEVELS.
+      def initialize(model: nil, temperature: nil, max_tokens: nil, effort: nil)
         @model = model || default_model
-        @temperature = temperature || 0.7
+        @temperature = temperature
+        @effort = effort&.to_s
+        unless @effort.nil? || EFFORT_LEVELS.include?(@effort)
+          raise ArgumentError, "effort must be one of #{EFFORT_LEVELS.join(", ")} (got #{effort.inspect})"
+        end
         @max_tokens = max_tokens || 16_384
       end
 

data/lib/llm_providers/providers/google.rb

@@ -6,6 +6,9 @@ module LlmProviders
   module Providers
     class Google < Base
       BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models"
+      THINKING_LEVELS = {
+        "low" => "low", "medium" => "medium", "high" => "high", "xhigh" => "high", "max" => "high"
+      }.freeze
 
       def chat(messages:, system: nil, tools: nil, &block)
         payload = build_payload(messages, system, tools)
@@ -29,6 +32,15 @@ module LlmProviders
 
       private
 
+      # thinkingLevel exists from Gemini 3 on (and on *-latest aliases); Gemini 2.x
+      # uses thinkingBudget and would reject it, so effort is ignored there.
+      def thinking_level_supported?
+        return true if @model.match?(/-latest$/)
+
+        major = @model[/\Agemini-(\d+)/, 1]
+        !major.nil? && major.to_i >= 3
+      end
+
       def api_url(stream: false)
         action = stream ? "streamGenerateContent" : "generateContent"
         "#{BASE_URL}/#{@model}:#{action}?key=#{api_key}"
@@ -38,11 +50,15 @@ module LlmProviders
         payload = {
           contents: format_messages(messages),
           generationConfig: {
-            maxOutputTokens: @max_tokens,
-            temperature: @temperature
+            maxOutputTokens: @max_tokens
           }
         }
 
+        payload[:generationConfig][:temperature] = @temperature if @temperature
+        if @effort && thinking_level_supported?
+          payload[:generationConfig][:thinkingConfig] = { thinkingLevel: THINKING_LEVELS.fetch(@effort) }
+        end
+
         payload[:system_instruction] = { parts: [{ text: system }] } if system && !system.empty?
 
         payload[:tools] = format_tools(tools) if tools && !tools.empty?
@@ -186,7 +202,7 @@ module LlmProviders
           if candidate
             parts = candidate.dig("content", "parts") || []
             parts.each do |part|
-              yield(content: part["text"]) if part["text"]
+              yield(content: part["text"]) if part["text"] && !part["thought"]
               next unless part["functionCall"]
 
               tool_calls << {
@@ -198,16 +214,22 @@ module LlmProviders
           end
 
           if event["usageMetadata"]
-            yield(usage: {
-              input: event.dig("usageMetadata", "promptTokenCount"),
-              output: event.dig("usageMetadata", "candidatesTokenCount")
-            })
+            yield(usage: usage_from(event["usageMetadata"]))
           end
         rescue JSON::ParserError => e
           LlmProviders.logger.debug "[Google] JSON parse error: #{e.message}, data: #{data[0, 200]}"
         end
       end
 
+      # Thinking tokens are billed as output and consume maxOutputTokens, so count them.
+      def usage_from(meta)
+        meta ||= {}
+        {
+          input: meta["promptTokenCount"],
+          output: meta["candidatesTokenCount"].to_i + meta["thoughtsTokenCount"].to_i
+        }
+      end
+
       def sync_response(payload)
         started_at = Time.now
 
@@ -226,7 +248,7 @@ module LlmProviders
         candidate = body.dig("candidates", 0)
         parts = candidate&.dig("content", "parts") || []
 
-        content = parts.filter_map { |p| p["text"] }.join
+        content = parts.filter_map { |p| p["text"] unless p["thought"] }.join
         tool_calls = parts.filter_map do |p|
           next unless p["functionCall"]
 
@@ -240,10 +262,7 @@ module LlmProviders
         {
           content: content,
           tool_calls: tool_calls,
-          usage: {
-            input: body.dig("usageMetadata", "promptTokenCount"),
-            output: body.dig("usageMetadata", "candidatesTokenCount")
-          },
+          usage: usage_from(body["usageMetadata"]),
           latency_ms: ((Time.now - started_at) * 1000).to_i,
           raw_response: body
         }

data/lib/llm_providers/providers/openai.rb

@@ -31,25 +31,42 @@ module LlmProviders
 
       def build_payload(messages, system, tools)
         formatted = format_messages(messages, system)
-        reasoning_model = @model.match?(/^(o1|o3|o4|gpt-5)/)
-
         payload = {
           model: @model,
           messages: formatted
         }
 
-        payload[:temperature] = @temperature unless reasoning_model
-
-        if @model.match?(/^(gpt-4o|gpt-5|o1|o3|o4)/)
+        if reasoning_model?
           payload[:max_completion_tokens] = @max_tokens
+          effort = reasoning_effort
+          payload[:reasoning_effort] = effort if effort
         else
-          payload[:max_tokens] = @max_tokens
+          payload[:temperature] = @temperature if @temperature
+          if @model.match?(/^gpt-4o/)
+            payload[:max_completion_tokens] = @max_tokens
+          else
+            payload[:max_tokens] = @max_tokens
+          end
         end
 
         payload[:tools] = format_tools(tools) if tools && !tools.empty?
         payload
       end
 
+      # Everything except the legacy chat families (gpt-3.5*, gpt-4*) is a
+      # reasoning model: gpt-5*, gpt-6*, o-series and whatever comes next.
+      def reasoning_model?
+        !@model.match?(/^(gpt-3\.5|gpt-4)/)
+      end
+
+      # gpt-6* accepts the full effort range; older reasoning models top out at "high".
+      def reasoning_effort
+        return nil unless @effort
+        return @effort if @model.match?(/^gpt-6/)
+
+        %w[xhigh max].include?(@effort) ? "high" : @effort
+      end
+
       def format_messages(messages, system)
         result = []
         result << { role: "system", content: system } if system && !system.empty?

data/lib/llm_providers/providers/openrouter.rb

@@ -54,9 +54,18 @@ module LlmProviders
 
       private
 
+      # OpenRouter ids are "vendor/model" (e.g. "openai/gpt-6-luna"). OpenRouter
+      # normalizes max_tokens/temperature across vendors, so we never apply the
+      # OpenAI reasoning rule here: send max_tokens, and temperature only if given.
+      # `effort` is forwarded as `reasoning: { effort: ... }`, with xhigh/max clamped to "high".
+      def reasoning_model?
+        false
+      end
+
       def build_payload(messages, system, tools)
         payload = super
         payload[:provider] = @provider_preferences if @provider_preferences
+        payload[:reasoning] = { effort: %w[xhigh max].include?(@effort) ? "high" : @effort } if @effort
         payload
       end
 

data/lib/llm_providers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmProviders
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_providers
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - kaba
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -81,6 +82,7 @@ metadata:
   source_code_uri: https://github.com/kabaken/llm-providers
   changelog_uri: https://github.com/kabaken/llm-providers/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -95,7 +97,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Multi-provider LLM client for OpenAI, Anthropic, Google, OpenRouter
 test_files: []