llm_providers 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39486a92a6fa6a631714e76c434ac822ff9ce3239e0947b0d562d12e48abc257
-  data.tar.gz: c76b7917bf45d857d37c8ac1bf725e80b88d5a8ab578cd3f1522b1a831a9d7cb
+  metadata.gz: f3083a87542682bdd5de9b30dc4823466d607c9f46c1664ebef59af054f069b1
+  data.tar.gz: 1a76be65cb40caeb91cf0aafdd899df2b5f71fde80a0d02ddca7a13a00eb3c9e
 SHA512:
-  metadata.gz: 9f7fa21339fb2f323af4802cb1b9c8d5631b576036015212ac7969457c90a1f95a5874cff32cb5ba9d481f096093b27c896dd3eca866ad351890cac877321cd0
-  data.tar.gz: f6fb426095fd10973245392db4f079e8db8274269f2846ce9f942d60dd9df310da53989078e853f0ba0371a44b1a4698a81989c83a1eb6dc9348c83a9846caf7
+  metadata.gz: 168939cac343a5da282742689977d948a1d4b17d88e220034f1625135ae5a1cb866327c70d8690ad91c3b7af83089889a3e9d97245d5c5cbd3cc8e5c6679b56b
+  data.tar.gz: e71cd2f4822d47ce6425ad7519f4f4d6198bd083c91f0c653afb4447d50a1f61c353a8f98b88c0d124becc9012344251df1e1d23a5d6d0f9940239587cc82043

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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

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/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.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_providers
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - kaba