FEATURE: optionally support OpenAI responses API (#1423)

OpenAI ship a new API for completions called "Responses API"

Certain models (o3-pro) require this API.
Additionally certain features are only made available to the new API.

This allow enabling it per LLM.

see: https://platform.openai.com/docs/api-reference/responses

Author: SamSaffron

app/models/llm_model.rb

@@ -52,6 +52,7 @@ def self.provider_params
         disable_temperature: :checkbox,
         disable_top_p: :checkbox,
         disable_streaming: :checkbox,
+        enable_responses_api: :checkbox,
         reasoning_effort: {
           type: :enum,
           values: %w[default low medium high],

config/locales/client.en.yml

@@ -579,6 +579,7 @@ en:
           reasoning_tokens: "Number of tokens used for reasoning"
           disable_temperature: "Disable temperature (some thinking models don't support temperature)"
           disable_top_p: "Disable top P (some thinking models don't support top P)"
+          enable_responses_api: "Enable responses API (required on certain OpenAI models)"
 
       related_topics:
         title: "Related topics"

lib/completions/dialects/chat_gpt.rb

@@ -20,12 +20,19 @@ def native_tool_support?
         def embed_user_ids?
           return @embed_user_ids if defined?(@embed_user_ids)
 
-          @embed_user_ids =
+          @embed_user_ids = true if responses_api?
+
+          @embed_user_ids ||=
             prompt.messages.any? do |m|
               m[:id] && m[:type] == :user && !m[:id].to_s.match?(VALID_ID_REGEX)
             end
         end
 
+        def responses_api?
+          return @responses_api if defined?(@responses_api)
+          @responses_api = llm_model.lookup_custom_param("enable_responses_api")
+        end
+
         def max_prompt_tokens
           # provide a buffer of 120 tokens - our function counting is not
           # 100% accurate and getting numbers to align exactly is very hard
@@ -51,7 +58,11 @@ def tools_dialect
           if disable_native_tools?
             super
           else
-            @tools_dialect ||= DiscourseAi::Completions::Dialects::OpenAiTools.new(prompt.tools)
+            @tools_dialect ||=
+              DiscourseAi::Completions::Dialects::OpenAiTools.new(
+                prompt.tools,
+                responses_api: responses_api?,
+              )
           end
         end
 
@@ -120,7 +131,7 @@ def user_msg(msg)
             to_encoded_content_array(
               content: content_array.flatten,
               image_encoder: ->(details) { image_node(details) },
-              text_encoder: ->(text) { { type: "text", text: text } },
+              text_encoder: ->(text) { text_node(text) },
               allow_vision: vision_support?,
             )
 
@@ -136,13 +147,21 @@ def no_array_if_only_text(content_array)
           end
         end
 
+        def text_node(text)
+          if responses_api?
+            { type: "input_text", text: text }
+          else
+            { type: "text", text: text }
+          end
+        end
+
         def image_node(details)
-          {
-            type: "image_url",
-            image_url: {
-              url: "data:#{details[:mime_type]};base64,#{details[:base64]}",
-            },
-          }
+          encoded_image = "data:#{details[:mime_type]};base64,#{details[:base64]}"
+          if responses_api?
+            { type: "input_image", image_url: encoded_image }
+          else
+            { type: "image_url", image_url: { url: encoded_image } }
+          end
         end
 
         def per_message_overhead

lib/completions/dialects/open_ai_tools.rb

@@ -4,20 +4,32 @@ module DiscourseAi
   module Completions
     module Dialects
       class OpenAiTools
-        def initialize(tools)
+        def initialize(tools, responses_api: false)
+          @responses_api = responses_api
           @raw_tools = tools
         end
 
         def translated_tools
-          raw_tools.map do |tool|
-            {
-              type: "function",
-              function: {
+          if @responses_api
+            raw_tools.map do |tool|
+              {
+                type: "function",
                 name: tool.name,
                 description: tool.description,
                 parameters: tool.parameters_json_schema,
-              },
-            }
+              }
+            end
+          else
+            raw_tools.map do |tool|
+              {
+                type: "function",
+                function: {
+                  name: tool.name,
+                  description: tool.description,
+                  parameters: tool.parameters_json_schema,
+                },
+              }
+            end
           end
         end
 
@@ -30,20 +42,37 @@ def from_raw_tool_call(raw_message)
           call_details[:arguments] = call_details[:arguments].to_json
           call_details[:name] = raw_message[:name]
 
-          {
-            role: "assistant",
-            content: nil,
-            tool_calls: [{ type: "function", function: call_details, id: raw_message[:id] }],
-          }
+          if @responses_api
+            {
+              type: "function_call",
+              call_id: raw_message[:id],
+              name: call_details[:name],
+              arguments: call_details[:arguments],
+            }
+          else
+            {
+              role: "assistant",
+              content: nil,
+              tool_calls: [{ type: "function", function: call_details, id: raw_message[:id] }],
+            }
+          end
         end
 
         def from_raw_tool(raw_message)
-          {
-            role: "tool",
-            tool_call_id: raw_message[:id],
-            content: raw_message[:content],
-            name: raw_message[:name],
-          }
+          if @responses_api
+            {
+              type: "function_call_output",
+              call_id: raw_message[:id],
+              output: raw_message[:content],
+            }
+          else
+            {
+              role: "tool",
+              tool_call_id: raw_message[:id],
+              content: raw_message[:content],
+              name: raw_message[:name],
+            }
+          end
         end
 
         private

lib/completions/endpoints/open_ai.rb

@@ -89,26 +89,47 @@ def prepare_payload(prompt, model_params, dialect)
             # We'll fallback to guess this using the tokenizer.
             payload[:stream_options] = { include_usage: true } if llm_model.provider == "open_ai"
           end
+
           if !xml_tools_enabled?
             if dialect.tools.present?
               payload[:tools] = dialect.tools
               if dialect.tool_choice.present?
                 if dialect.tool_choice == :none
                   payload[:tool_choice] = "none"
                 else
-                  payload[:tool_choice] = {
-                    type: "function",
-                    function: {
-                      name: dialect.tool_choice,
-                    },
-                  }
+                  if responses_api?
+                    payload[:tool_choice] = { type: "function", name: dialect.tool_choice }
+                  else
+                    payload[:tool_choice] = {
+                      type: "function",
+                      function: {
+                        name: dialect.tool_choice,
+                      },
+                    }
+                  end
                 end
               end
             end
           end
+
+          convert_payload_to_responses_api!(payload) if responses_api?
+
           payload
         end
 
+        def responses_api?
+          return @responses_api if defined?(@responses_api)
+          @responses_api = llm_model.lookup_custom_param("enable_responses_api")
+        end
+
+        def convert_payload_to_responses_api!(payload)
+          payload[:input] = payload.delete(:messages)
+          completion_tokens = payload.delete(:max_completion_tokens) || payload.delete(:max_tokens)
+          payload[:max_output_tokens] = completion_tokens if completion_tokens
+          # not supported in responses api
+          payload.delete(:stream_options)
+        end
+
         def prepare_request(payload)
           headers = { "Content-Type" => "application/json" }
           api_key = llm_model.api_key
@@ -159,7 +180,12 @@ def xml_tools_enabled?
         private
 
         def processor
-          @processor ||= OpenAiMessageProcessor.new(partial_tool_calls: partial_tool_calls)
+          @processor ||=
+            if responses_api?
+              OpenAiResponsesMessageProcessor.new(partial_tool_calls: partial_tool_calls)
+            else
+              OpenAiMessageProcessor.new(partial_tool_calls: partial_tool_calls)
+            end
         end
       end
     end