llm_providers 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f834a22b64b2340ae461021d17a8dc2d0c65ff22182ea57f750c851686d4c152
-  data.tar.gz: 4c459fb08e001951fcd04343de74ffff1fb025325bf9ffdd90b95cd03ce5a0b8
+  metadata.gz: f3083a87542682bdd5de9b30dc4823466d607c9f46c1664ebef59af054f069b1
+  data.tar.gz: 1a76be65cb40caeb91cf0aafdd899df2b5f71fde80a0d02ddca7a13a00eb3c9e
 SHA512:
-  metadata.gz: d4fede081164f7cb0eb33b954f81c912d514ae32cc71ff020e16dd6ec0c15f98cd98b3657bdbb92264c9760121f7b7c85a90ae58f840a55aacd65d35d6b48ff2
-  data.tar.gz: 77b512797ec93a5c08c85eb997bbccd769572ea5e1c901c4393acf0078a9ba8c6375a831bb034878a5a637b91fa83a0feb945611cb00e33353cb0561a9db2462
+  metadata.gz: 168939cac343a5da282742689977d948a1d4b17d88e220034f1625135ae5a1cb866327c70d8690ad91c3b7af83089889a3e9d97245d5c5cbd3cc8e5c6679b56b
+  data.tar.gz: e71cd2f4822d47ce6425ad7519f4f4d6198bd083c91f0c653afb4447d50a1f61c353a8f98b88c0d124becc9012344251df1e1d23a5d6d0f9940239587cc82043

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [0.4.0] - 2026-10-10
+
+### Added
+
+- OpenAI `gpt-6*` models now use the Responses API (`/v1/responses`). On chat/completions, gpt-6-astra and gpt-6.1-sol reject function tools, and gpt-6-luna accepts them only with reasoning effort `none`. The system prompt goes in `instructions`, tools are sent as flat function tools with `strict: false`, `effort` becomes `reasoning.effort`, `max_tokens` becomes `max_output_tokens`, and `store` is `false`. Tool loops map to `function_call` / `function_call_output` items by call id. The return hash and streamed chunks keep their shape.
+
+### Known limitations
+
+- Reasoning items are not passed back between tool rounds, so the model does not keep its reasoning across a tool loop (tool loops still work). Usage `output` includes reasoning tokens.
+
+### Unchanged
+
+- Every other OpenAI model and all OpenRouter models still use chat/completions.
+
+## [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,22 @@ 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: `gpt-6*` は `reasoning: { effort: ... }` としてそのまま送ります（Responses API、下記参照）。ほかの reasoning モデル（gpt-5*、o 系）は `reasoning_effort` に渡し、`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-6*` は Responses API（`/v1/responses`）で呼びます。chat/completions では、gpt-6-astra と gpt-6.1-sol が function tools を受け付けず、gpt-6-luna は reasoning effort が `none` のときしか受け付けないためです。system プロンプトは `instructions`、上限トークン数は `max_output_tokens` で送り、tools には `strict: false` を付け、`store: false` でリクエストします。戻り値とストリーミングのチャンクの形は変わりません。ほかの OpenAI モデルと OpenRouter は、これまでどおり chat/completions を使います。ツール呼び出しの間で reasoning アイテムは引き継がず、usage の `output` には推論トークンも含まれます。
+- `gpt-6*` 以外の 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,22 @@ 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: `gpt-6*` sends it unchanged as `reasoning: { effort: ... }` (Responses API, see below). Other reasoning models (gpt-5*, o-series) send `reasoning_effort`, with `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 `gpt-6*` models use the Responses API (`/v1/responses`), because on chat/completions gpt-6-astra and gpt-6.1-sol reject function tools, and gpt-6-luna accepts them only with reasoning effort `none`. The system prompt goes in `instructions`, the token cap in `max_output_tokens`, tools are sent with `strict: false`, and requests use `store: false`. The return value and streamed chunks have the same shape as on chat/completions. All other OpenAI models stay on chat/completions, and OpenRouter always uses chat/completions. Reasoning items are not passed back between tool rounds, and usage `output` includes reasoning tokens.
+- OpenAI treats every other 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

@@ -6,8 +6,11 @@ module LlmProviders
   module Providers
     class Openai < Base
       API_URL = "https://api.openai.com/v1/chat/completions"
+      RESPONSES_API_URL = "https://api.openai.com/v1/responses"
 
       def chat(messages:, system: nil, tools: nil, &block)
+        return responses_chat(messages, system, tools, &block) if responses_api?
+
         payload = build_payload(messages, system, tools)
 
         if block_given?
@@ -31,25 +34,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?
@@ -126,53 +146,77 @@ module LlmProviders
         full_content = ""
         tool_calls = {}
         usage = {}
-        raw_chunks = ""
         stream_error = nil
-        line_buffer = ""
 
-        process_sse_line = proc do |line|
-          next unless line.start_with?("data: ")
+        response, raw_chunks = stream_sse(self.class::API_URL, payload) do |event|
+          if event["error"]
+            stream_error = format_stream_error(event)
+            next
+          end
 
-          data = line.sub("data: ", "").strip
-          next if data == "[DONE]" || data.empty?
+          if event["usage"]
+            usage = {
+              input: event.dig("usage", "prompt_tokens"),
+              output: event.dig("usage", "completion_tokens"),
+              cached_input: event.dig("usage", "prompt_tokens_details", "cached_tokens")
+            }
+          end
 
-          begin
-            event = JSON.parse(data)
+          choice = event.dig("choices", 0)
+          next unless choice
 
-            if event["error"]
-              stream_error = format_stream_error(event)
-              next
-            end
+          delta = choice["delta"]
+          next unless delta
 
-            if event["usage"]
-              usage = {
-                input: event.dig("usage", "prompt_tokens"),
-                output: event.dig("usage", "completion_tokens"),
-                cached_input: event.dig("usage", "prompt_tokens_details", "cached_tokens")
-              }
-            end
+          if delta["content"]
+            full_content += delta["content"]
+            block.call(content: delta["content"])
+          end
 
-            choice = event.dig("choices", 0)
-            next unless choice
+          delta["tool_calls"]&.each do |tc|
+            idx = tc["index"]
+            tool_calls[idx] ||= { id: "", name: "", arguments: "" }
+            tool_calls[idx][:id] = tc["id"] if tc["id"]
+            tool_calls[idx][:name] = tc.dig("function", "name") if tc.dig("function", "name")
+            tool_calls[idx][:arguments] += tc.dig("function", "arguments").to_s
+          end
+        end
 
-            delta = choice["delta"]
-            next unless delta
+        raise ProviderError.new(stream_error, code: error_code) if stream_error
 
-            if delta["content"]
-              full_content += delta["content"]
-              block.call(content: delta["content"])
-            end
+        raise_stream_http_error(response, raw_chunks) unless response.success?
 
-            delta["tool_calls"]&.each do |tc|
-              idx = tc["index"]
-              tool_calls[idx] ||= { id: "", name: "", arguments: "" }
-              tool_calls[idx][:id] = tc["id"] if tc["id"]
-              tool_calls[idx][:name] = tc.dig("function", "name") if tc.dig("function", "name")
-              tool_calls[idx][:arguments] += tc.dig("function", "arguments").to_s
-            end
+        final_tool_calls = tool_calls.values.map do |tc|
+          { id: tc[:id], name: tc[:name], input: parse_tool_input(tc[:arguments]) }
+        end
+
+        {
+          content: full_content,
+          tool_calls: final_tool_calls,
+          usage: usage,
+          latency_ms: ((Time.now - started_at) * 1000).to_i,
+          raw_response: { content: full_content, tool_calls: final_tool_calls }
+        }
+      end
+
+      # POSTs payload and yields each parsed SSE `data:` JSON event.
+      # Returns [faraday_response, raw_body].
+      def stream_sse(url, payload)
+        raw_chunks = +""
+        line_buffer = +""
+
+        process_sse_line = proc do |line|
+          next unless line.start_with?("data: ")
+
+          data = line.sub("data: ", "").strip
+          next if data == "[DONE]" || data.empty?
+
+          begin
+            event = JSON.parse(data)
           rescue JSON::ParserError
-            # Skip invalid JSON
+            next # Skip invalid JSON
           end
+          yield event
         end
 
         conn = Faraday.new do |f|
@@ -182,14 +226,14 @@ module LlmProviders
           f.adapter Faraday.default_adapter
         end
 
-        response = conn.post(self.class::API_URL) do |req|
+        response = conn.post(url) do |req|
           request_headers.each { |k, v| req.headers[k] = v }
           req.body = payload.to_json
           req.options.on_data = proc do |chunk, _|
-            raw_chunks += chunk
-            line_buffer += chunk
+            raw_chunks << chunk
+            line_buffer << chunk
             lines = line_buffer.split("\n", -1)
-            line_buffer = lines.pop || ""
+            line_buffer = lines.pop || +""
 
             lines.each(&process_sse_line)
           end
@@ -198,32 +242,18 @@ module LlmProviders
         # Process any remaining data in the buffer
         process_sse_line.call(line_buffer) unless line_buffer.empty?
 
-        raise ProviderError.new(stream_error, code: error_code) if stream_error
-
-        unless response.success?
-          error_body = begin
-            JSON.parse(raw_chunks.empty? ? response.body : raw_chunks)
-          rescue StandardError
-            {}
-          end
-          error_msg = error_body.dig("error", "message") || (raw_chunks.empty? ? nil : raw_chunks) || response.body.to_s
-          raise ProviderError.new(
-            error_msg[0, 500],
-            code: error_code
-          )
-        end
+        [response, raw_chunks]
+      end
 
-        final_tool_calls = tool_calls.values.map do |tc|
-          { id: tc[:id], name: tc[:name], input: parse_tool_input(tc[:arguments]) }
+      def raise_stream_http_error(response, raw_chunks)
+        error_body = begin
+          JSON.parse(raw_chunks.empty? ? response.body : raw_chunks)
+        rescue StandardError
+          {}
         end
-
-        {
-          content: full_content,
-          tool_calls: final_tool_calls,
-          usage: usage,
-          latency_ms: ((Time.now - started_at) * 1000).to_i,
-          raw_response: { content: full_content, tool_calls: final_tool_calls }
-        }
+        error_body = {} unless error_body.is_a?(Hash)
+        error_msg = error_body.dig("error", "message") || (raw_chunks.empty? ? nil : raw_chunks) || response.body.to_s
+        raise ProviderError.new(error_msg[0, 500], code: error_code)
       end
 
       def sync_response(payload)
@@ -266,6 +296,202 @@ module LlmProviders
         }
       end
 
+      # --- Responses API (/v1/responses) -------------------------------------
+      #
+      # gpt-6* rejects function tools combined with reasoning_effort on
+      # /v1/chat/completions, so those models go through /v1/responses.
+      # Everything else (and every OpenRouter model) stays on chat/completions.
+      def responses_api?
+        @model.match?(/^gpt-6/)
+      end
+
+      def responses_chat(messages, system, tools, &block)
+        payload = build_responses_payload(messages, system, tools)
+
+        if block
+          responses_stream(payload, &block)
+        else
+          responses_sync(payload)
+        end
+      end
+
+      def build_responses_payload(messages, system, tools)
+        payload = {
+          model: @model,
+          input: format_input_items(messages),
+          max_output_tokens: @max_tokens,
+          # chat/completions does not store by default; keep the same behavior.
+          store: false
+        }
+        payload[:instructions] = system if system && !system.empty?
+        payload[:reasoning] = { effort: @effort } if @effort
+        payload[:tools] = format_responses_tools(tools) if tools && !tools.empty?
+        payload
+      end
+
+      # Translates the gem's message format into Responses input items.
+      # Assistant tool_calls become function_call items and tool results become
+      # function_call_output items, linked by call_id (= the tool call id we
+      # returned). Item ids (fc_...) are deliberately not sent: we don't replay
+      # reasoning items, and the API rejects fc ids without their reasoning item.
+      def format_input_items(messages)
+        items = []
+        valid_call_ids = Set.new
+
+        messages.each do |msg|
+          msg = stringify_keys(msg)
+          case msg["role"]
+          when "tool"
+            call_id = msg["tool_call_id"]
+            next unless call_id && !call_id.empty? && valid_call_ids.include?(call_id)
+
+            output = msg["content"]
+            items << {
+              type: "function_call_output",
+              call_id: call_id,
+              output: output.is_a?(String) ? output : output.to_json
+            }
+          when "assistant"
+            content = msg["content"]
+            items << { role: "assistant", content: content } if content.is_a?(String) && !content.empty?
+
+            (msg["tool_calls"] || []).each do |tc|
+              tc = stringify_keys(tc)
+              next unless tc["name"] && !tc["name"].empty? && tc["id"] && !tc["id"].empty?
+
+              valid_call_ids << tc["id"]
+              items << {
+                type: "function_call",
+                call_id: tc["id"],
+                name: tc["name"],
+                arguments: tc["input"].is_a?(String) ? tc["input"] : (tc["input"] || {}).to_json
+              }
+            end
+          else
+            items << { role: msg["role"], content: msg["content"] }
+          end
+        end
+
+        items
+      end
+
+      # Responses function tools are flat. strict: false keeps the non-strict,
+      # best-effort behavior of chat/completions (Responses would otherwise try
+      # to coerce schemas into strict mode).
+      def format_responses_tools(tools)
+        tools.map do |tool|
+          {
+            type: "function",
+            name: tool[:name],
+            description: tool[:description],
+            parameters: tool[:parameters],
+            strict: false
+          }
+        end
+      end
+
+      def responses_stream(payload, &block)
+        payload[:stream] = true
+        started_at = Time.now
+
+        full_content = +""
+        calls = {} # item_id => { id: call_id, name:, arguments: }
+        usage = {}
+        stream_error = nil
+
+        response, raw_chunks = stream_sse(RESPONSES_API_URL, payload) do |event|
+          case event["type"]
+          when "response.output_text.delta"
+            delta = event["delta"].to_s
+            next if delta.empty?
+
+            full_content << delta
+            block.call(content: delta)
+          when "response.output_item.added", "response.output_item.done"
+            item = event["item"] || {}
+            next unless item["type"] == "function_call"
+
+            call = (calls[item["id"]] ||= { id: "", name: "", arguments: +"" })
+            call[:id] = item["call_id"] if item["call_id"]
+            call[:name] = item["name"] if item["name"]
+            call[:arguments] = +item["arguments"] if item["arguments"] && !item["arguments"].empty?
+          when "response.function_call_arguments.delta"
+            call = (calls[event["item_id"]] ||= { id: "", name: "", arguments: +"" })
+            call[:arguments] << event["delta"].to_s
+          when "response.function_call_arguments.done"
+            call = (calls[event["item_id"]] ||= { id: "", name: "", arguments: +"" })
+            call[:arguments] = +event["arguments"].to_s
+          when "response.completed", "response.incomplete"
+            usage = responses_usage(event.dig("response", "usage"))
+          when "response.failed"
+            stream_error = event.dig("response", "error", "message") || "Response failed"
+          when "error"
+            stream_error = event["message"] || event.dig("error", "message") || "Stream error"
+          end
+        end
+
+        raise ProviderError.new(stream_error, code: error_code) if stream_error
+
+        raise_stream_http_error(response, raw_chunks) unless response.success?
+
+        tool_calls = calls.values.map do |tc|
+          { id: tc[:id], name: tc[:name], input: parse_tool_input(tc[:arguments]) }
+        end
+
+        {
+          content: full_content,
+          tool_calls: tool_calls,
+          usage: usage,
+          latency_ms: ((Time.now - started_at) * 1000).to_i,
+          raw_response: { content: full_content, tool_calls: tool_calls }
+        }
+      end
+
+      def responses_sync(payload)
+        started_at = Time.now
+
+        response = http_client.post(RESPONSES_API_URL) do |req|
+          request_headers.each { |k, v| req.headers[k] = v }
+          req.body = payload
+        end
+
+        raise ProviderError.new(parse_sync_error(response), code: error_code) unless response.success?
+
+        body = response.body
+        if body["status"] == "failed"
+          raise ProviderError.new(body.dig("error", "message") || "Response failed", code: error_code)
+        end
+
+        output = body["output"] || []
+        content = output.select { |item| item["type"] == "message" }
+                        .flat_map { |item| item["content"] || [] }
+                        .select { |part| part["type"] == "output_text" }
+                        .map { |part| part["text"].to_s }
+                        .join
+        tool_calls = output.select { |item| item["type"] == "function_call" }.map do |item|
+          { id: item["call_id"], name: item["name"], input: parse_tool_input(item["arguments"]) }
+        end
+
+        {
+          content: content,
+          tool_calls: tool_calls,
+          usage: responses_usage(body["usage"]),
+          latency_ms: ((Time.now - started_at) * 1000).to_i,
+          raw_response: body
+        }
+      end
+
+      # output_tokens already includes reasoning tokens.
+      def responses_usage(usage)
+        return {} unless usage
+
+        {
+          input: usage["input_tokens"],
+          output: usage["output_tokens"],
+          cached_input: usage.dig("input_tokens_details", "cached_tokens")
+        }
+      end
+
       def error_code
         "openai_error"
       end

data/lib/llm_providers/providers/openrouter.rb

@@ -54,9 +54,23 @@ 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
+
+      # OpenRouter always speaks chat/completions, even for OpenAI gpt-6 ids.
+      def responses_api?
+        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.4.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.4.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: []