llm_providers 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39486a92a6fa6a631714e76c434ac822ff9ce3239e0947b0d562d12e48abc257
-  data.tar.gz: c76b7917bf45d857d37c8ac1bf725e80b88d5a8ab578cd3f1522b1a831a9d7cb
+  metadata.gz: 65eb7fcee6973ec4cd31c06f1c9b0a04f82682cab0f2799d711dda78d4d09f0d
+  data.tar.gz: 9c5ea371c80193690d08e5b412ae1adb9872b2b6b39cb845ef09364dd9abc272
 SHA512:
-  metadata.gz: 9f7fa21339fb2f323af4802cb1b9c8d5631b576036015212ac7969457c90a1f95a5874cff32cb5ba9d481f096093b27c896dd3eca866ad351890cac877321cd0
-  data.tar.gz: f6fb426095fd10973245392db4f079e8db8274269f2846ce9f942d60dd9df310da53989078e853f0ba0371a44b1a4698a81989c83a1eb6dc9348c83a9846caf7
+  metadata.gz: 6c5bd8f0e9eaa26830433d938322eee4cf4292a68a16031a6c088f819b6b311433ebfe5780dd9f95dbbbc7e7ca9eb4dfd08bc43a88f02e8c3552ade590984019
+  data.tar.gz: 10fed167a8f5835f60d3a4d475ec46ee81a80eab2e7a774b6fc3a864b016d0a7a823a5101d986ec20dfeab1d49fab985e877a18998d2b52fab237479f481bf9e

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.4.1] - 2026-10-11
+
+### Fixed
+
+- Gemini tool loops failed on the second round with `Role 'function' is not supported`. Tool results are now sent as a `user` turn of `functionResponse` parts, and results for parallel calls share one turn.
+- When a tool message has no `tool_name`, the function response is named after the call it answers (looked up by `tool_call_id`). It used to fall back to `"function"`.
+- Gemini 3 returns a `thoughtSignature` on function calls and rejects the next request without it. Tool calls now carry it as `thought_signature`, and it goes back on the matching `functionCall` part.
+
+## [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

data/README.ja.md

@@ -77,10 +77,11 @@ provider = LlmProviders::Providers.build(
 - `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*` では無視されます。
+  - 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-3.5*` / `gpt-4*` 以外を reasoning モデルとして扱い、`max_completion_tokens` を使って temperature を送りません。OpenRouter は `vendor/model` 形式の ID なので従来どおり `max_tokens` を使い、temperature は指定時のみ送ります。
+- 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` は思考トークンを含みます。
 
 ### ツール呼び出し

data/README.md

@@ -77,10 +77,11 @@ provider = LlmProviders::Providers.build(
 - `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*`.
+  - 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 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.
+- 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

data/lib/llm_providers/providers/google.rb

@@ -65,40 +65,54 @@ module LlmProviders
         payload
       end
 
+      # Gemini only accepts user/model roles. Tool results go back as a user turn of
+      # functionResponse parts (one turn per batch of calls), named after the call they
+      # answer. Gemini 3 also rejects a functionCall replayed without its thoughtSignature.
       def format_messages(messages)
-        messages.filter_map do |msg|
+        call_names = {}
+
+        messages.each_with_object([]) do |msg, contents|
           msg = stringify_keys(msg)
           next if msg["role"] == "system"
 
-          role = msg["role"] == "assistant" ? "model" : msg["role"]
-
           if msg["role"] == "tool"
-            {
-              role: "function",
-              parts: [{
-                functionResponse: {
-                  name: msg["tool_name"] || "function",
-                  response: { content: msg["content"] }
-                }
-              }]
+            part = {
+              functionResponse: {
+                name: msg["tool_name"] || call_names[msg["tool_call_id"]] || "function",
+                response: { content: msg["content"] }
+              }
             }
+            if contents.last && contents.last[:function_responses]
+              contents.last[:parts] << part
+            else
+              contents << { role: "user", parts: [part], function_responses: true }
+            end
           elsif msg["tool_calls"] && !msg["tool_calls"].empty?
             parts = []
             parts << { text: msg["content"] } if msg["content"] && !msg["content"].empty?
             msg["tool_calls"].each do |tc|
               tc = stringify_keys(tc)
-              parts << {
-                functionCall: {
-                  name: tc["name"],
-                  args: tc["input"]
-                }
-              }
+              call_names[tc["id"]] = tc["name"] if tc["id"]
+              part = { functionCall: { name: tc["name"], args: tc["input"] || {} } }
+              part[:thoughtSignature] = tc["thought_signature"] if tc["thought_signature"]
+              parts << part
             end
-            { role: role, parts: parts }
+            contents << { role: "model", parts: parts }
           else
-            { role: role, parts: [{ text: msg["content"] }] }
+            role = msg["role"] == "assistant" ? "model" : msg["role"]
+            contents << { role: role, parts: [{ text: msg["content"] }] }
           end
-        end
+        end.map { |content| content.except(:function_responses) }
+      end
+
+      def tool_call_from(part)
+        call = {
+          id: SecureRandom.hex(12),
+          name: part.dig("functionCall", "name"),
+          input: part.dig("functionCall", "args") || {}
+        }
+        call[:thought_signature] = part["thoughtSignature"] if part["thoughtSignature"]
+        call
       end
 
       def format_tools(tools)
@@ -205,11 +219,7 @@ module LlmProviders
               yield(content: part["text"]) if part["text"] && !part["thought"]
               next unless part["functionCall"]
 
-              tool_calls << {
-                id: SecureRandom.hex(12),
-                name: part.dig("functionCall", "name"),
-                input: part.dig("functionCall", "args") || {}
-              }
+              tool_calls << tool_call_from(part)
             end
           end
 
@@ -249,15 +259,7 @@ module LlmProviders
         parts = candidate&.dig("content", "parts") || []
 
         content = parts.filter_map { |p| p["text"] unless p["thought"] }.join
-        tool_calls = parts.filter_map do |p|
-          next unless p["functionCall"]
-
-          {
-            id: SecureRandom.hex(12),
-            name: p.dig("functionCall", "name"),
-            input: p.dig("functionCall", "args") || {}
-          }
-        end
+        tool_calls = parts.filter_map { |p| tool_call_from(p) if p["functionCall"] }
 
         {
           content: content,

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?
@@ -143,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|
@@ -199,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
@@ -215,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)
@@ -283,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

@@ -62,6 +62,11 @@ module LlmProviders
         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

data/lib/llm_providers/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_providers
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - kaba
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-10 00:00:00.000000000 Z
+date: 2026-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday