openai 0.16.0 → 0.17.0

data/rbi/openai/models/responses/custom_tool.rbi

@@ -0,0 +1,96 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class CustomTool < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(OpenAI::Responses::CustomTool, OpenAI::Internal::AnyHash)
+          end
+
+        # The name of the custom tool, used to identify it in tool calls.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The type of the custom tool. Always `custom`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional description of the custom tool, used to provide more context.
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        # The input format for the custom tool. Default is unconstrained text.
+        sig do
+          returns(
+            T.nilable(
+              T.any(
+                OpenAI::CustomToolInputFormat::Text,
+                OpenAI::CustomToolInputFormat::Grammar
+              )
+            )
+          )
+        end
+        attr_reader :format_
+
+        sig do
+          params(
+            format_:
+              T.any(
+                OpenAI::CustomToolInputFormat::Text::OrHash,
+                OpenAI::CustomToolInputFormat::Grammar::OrHash
+              )
+          ).void
+        end
+        attr_writer :format_
+
+        # A custom tool that processes input using a specified format. Learn more about
+        # [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools).
+        sig do
+          params(
+            name: String,
+            description: String,
+            format_:
+              T.any(
+                OpenAI::CustomToolInputFormat::Text::OrHash,
+                OpenAI::CustomToolInputFormat::Grammar::OrHash
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The name of the custom tool, used to identify it in tool calls.
+          name:,
+          # Optional description of the custom tool, used to provide more context.
+          description: nil,
+          # The input format for the custom tool. Default is unconstrained text.
+          format_: nil,
+          # The type of the custom tool. Always `custom`.
+          type: :custom
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: String,
+              type: Symbol,
+              description: String,
+              format_:
+                T.any(
+                  OpenAI::CustomToolInputFormat::Text,
+                  OpenAI::CustomToolInputFormat::Grammar
+                )
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response.rbi

@@ -116,8 +116,10 @@ module OpenAI
         #   Learn more about
         #   [built-in tools](https://platform.openai.com/docs/guides/tools).
         # - **Function calls (custom tools)**: Functions that are defined by you, enabling
-        #   the model to call your own code. Learn more about
+        #   the model to call your own code with strongly typed arguments and outputs.
+        #   Learn more about
         #   [function calling](https://platform.openai.com/docs/guides/function-calling).
+        #   You can also use custom tools to call your own code.
         sig { returns(T::Array[OpenAI::Responses::Tool::Variants]) }
         attr_accessor :tools
 
@@ -308,7 +310,8 @@ module OpenAI
                   OpenAI::Responses::ResponseOutputItem::LocalShellCall::OrHash,
                   OpenAI::Responses::ResponseOutputItem::McpCall::OrHash,
                   OpenAI::Responses::ResponseOutputItem::McpListTools::OrHash,
-                  OpenAI::Responses::ResponseOutputItem::McpApprovalRequest::OrHash
+                  OpenAI::Responses::ResponseOutputItem::McpApprovalRequest::OrHash,
+                  OpenAI::Responses::ResponseCustomToolCall::OrHash
                 )
               ],
             parallel_tool_calls: T::Boolean,
@@ -316,9 +319,11 @@ module OpenAI
             tool_choice:
               T.any(
                 OpenAI::Responses::ToolChoiceOptions::OrSymbol,
+                OpenAI::Responses::ToolChoiceAllowed::OrHash,
                 OpenAI::Responses::ToolChoiceTypes::OrHash,
                 OpenAI::Responses::ToolChoiceFunction::OrHash,
-                OpenAI::Responses::ToolChoiceMcp::OrHash
+                OpenAI::Responses::ToolChoiceMcp::OrHash,
+                OpenAI::Responses::ToolChoiceCustom::OrHash
               ),
             tools:
               T::Array[
@@ -330,6 +335,7 @@ module OpenAI
                   OpenAI::Responses::Tool::CodeInterpreter::OrHash,
                   OpenAI::Responses::Tool::ImageGeneration::OrHash,
                   OpenAI::Responses::Tool::LocalShell::OrHash,
+                  OpenAI::Responses::CustomTool::OrHash,
                   OpenAI::Responses::WebSearchTool::OrHash
                 )
               ],
@@ -413,8 +419,10 @@ module OpenAI
           #   Learn more about
           #   [built-in tools](https://platform.openai.com/docs/guides/tools).
           # - **Function calls (custom tools)**: Functions that are defined by you, enabling
-          #   the model to call your own code. Learn more about
+          #   the model to call your own code with strongly typed arguments and outputs.
+          #   Learn more about
           #   [function calling](https://platform.openai.com/docs/guides/function-calling).
+          #   You can also use custom tools to call your own code.
           tools:,
           # An alternative to sampling with temperature, called nucleus sampling, where the
           # model considers the results of the tokens with top_p probability mass. So 0.1
@@ -684,9 +692,11 @@ module OpenAI
             T.type_alias do
               T.any(
                 OpenAI::Responses::ToolChoiceOptions::TaggedSymbol,
+                OpenAI::Responses::ToolChoiceAllowed,
                 OpenAI::Responses::ToolChoiceTypes,
                 OpenAI::Responses::ToolChoiceFunction,
-                OpenAI::Responses::ToolChoiceMcp
+                OpenAI::Responses::ToolChoiceMcp,
+                OpenAI::Responses::ToolChoiceCustom
               )
             end
 

data/rbi/openai/models/responses/response_create_params.rbi

@@ -208,6 +208,24 @@ module OpenAI
         sig { returns(T.nilable(T::Boolean)) }
         attr_accessor :store
 
+        # Options for streaming responses. Only set this when you set `stream: true`.
+        sig do
+          returns(
+            T.nilable(OpenAI::Responses::ResponseCreateParams::StreamOptions)
+          )
+        end
+        attr_reader :stream_options
+
+        sig do
+          params(
+            stream_options:
+              T.nilable(
+                OpenAI::Responses::ResponseCreateParams::StreamOptions::OrHash
+              )
+          ).void
+        end
+        attr_writer :stream_options
+
         # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
         # make the output more random, while lower values like 0.2 will make it more
         # focused and deterministic. We generally recommend altering this or `top_p` but
@@ -242,9 +260,11 @@ module OpenAI
             T.nilable(
               T.any(
                 OpenAI::Responses::ToolChoiceOptions::OrSymbol,
+                OpenAI::Responses::ToolChoiceAllowed,
                 OpenAI::Responses::ToolChoiceTypes,
                 OpenAI::Responses::ToolChoiceFunction,
-                OpenAI::Responses::ToolChoiceMcp
+                OpenAI::Responses::ToolChoiceMcp,
+                OpenAI::Responses::ToolChoiceCustom
               )
             )
           )
@@ -256,9 +276,11 @@ module OpenAI
             tool_choice:
               T.any(
                 OpenAI::Responses::ToolChoiceOptions::OrSymbol,
+                OpenAI::Responses::ToolChoiceAllowed::OrHash,
                 OpenAI::Responses::ToolChoiceTypes::OrHash,
                 OpenAI::Responses::ToolChoiceFunction::OrHash,
-                OpenAI::Responses::ToolChoiceMcp::OrHash
+                OpenAI::Responses::ToolChoiceMcp::OrHash,
+                OpenAI::Responses::ToolChoiceCustom::OrHash
               )
           ).void
         end
@@ -276,8 +298,10 @@ module OpenAI
         #   Learn more about
         #   [built-in tools](https://platform.openai.com/docs/guides/tools).
         # - **Function calls (custom tools)**: Functions that are defined by you, enabling
-        #   the model to call your own code. Learn more about
+        #   the model to call your own code with strongly typed arguments and outputs.
+        #   Learn more about
         #   [function calling](https://platform.openai.com/docs/guides/function-calling).
+        #   You can also use custom tools to call your own code.
         sig do
           returns(
             T.nilable(
@@ -290,6 +314,7 @@ module OpenAI
                   OpenAI::Responses::Tool::CodeInterpreter,
                   OpenAI::Responses::Tool::ImageGeneration,
                   OpenAI::Responses::Tool::LocalShell,
+                  OpenAI::Responses::CustomTool,
                   OpenAI::Responses::WebSearchTool
                 )
               ]
@@ -310,6 +335,7 @@ module OpenAI
                   OpenAI::Responses::Tool::CodeInterpreter::OrHash,
                   OpenAI::Responses::Tool::ImageGeneration::OrHash,
                   OpenAI::Responses::Tool::LocalShell::OrHash,
+                  OpenAI::Responses::CustomTool::OrHash,
                   OpenAI::Responses::WebSearchTool::OrHash
                 )
               ]
@@ -386,14 +412,20 @@ module OpenAI
                 OpenAI::Responses::ResponseCreateParams::ServiceTier::OrSymbol
               ),
             store: T.nilable(T::Boolean),
+            stream_options:
+              T.nilable(
+                OpenAI::Responses::ResponseCreateParams::StreamOptions::OrHash
+              ),
             temperature: T.nilable(Float),
             text: OpenAI::Responses::ResponseTextConfig::OrHash,
             tool_choice:
               T.any(
                 OpenAI::Responses::ToolChoiceOptions::OrSymbol,
+                OpenAI::Responses::ToolChoiceAllowed::OrHash,
                 OpenAI::Responses::ToolChoiceTypes::OrHash,
                 OpenAI::Responses::ToolChoiceFunction::OrHash,
-                OpenAI::Responses::ToolChoiceMcp::OrHash
+                OpenAI::Responses::ToolChoiceMcp::OrHash,
+                OpenAI::Responses::ToolChoiceCustom::OrHash
               ),
             tools:
               T::Array[
@@ -405,6 +437,7 @@ module OpenAI
                   OpenAI::Responses::Tool::CodeInterpreter::OrHash,
                   OpenAI::Responses::Tool::ImageGeneration::OrHash,
                   OpenAI::Responses::Tool::LocalShell::OrHash,
+                  OpenAI::Responses::CustomTool::OrHash,
                   OpenAI::Responses::WebSearchTool::OrHash
                 )
               ],
@@ -521,6 +554,8 @@ module OpenAI
           service_tier: nil,
           # Whether to store the generated model response for later retrieval via API.
           store: nil,
+          # Options for streaming responses. Only set this when you set `stream: true`.
+          stream_options: nil,
           # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
           # make the output more random, while lower values like 0.2 will make it more
           # focused and deterministic. We generally recommend altering this or `top_p` but
@@ -548,8 +583,10 @@ module OpenAI
           #   Learn more about
           #   [built-in tools](https://platform.openai.com/docs/guides/tools).
           # - **Function calls (custom tools)**: Functions that are defined by you, enabling
-          #   the model to call your own code. Learn more about
+          #   the model to call your own code with strongly typed arguments and outputs.
+          #   Learn more about
           #   [function calling](https://platform.openai.com/docs/guides/function-calling).
+          #   You can also use custom tools to call your own code.
           tools: nil,
           # An integer between 0 and 20 specifying the number of most likely tokens to
           # return at each token position, each with an associated log probability.
@@ -608,14 +645,20 @@ module OpenAI
                   OpenAI::Responses::ResponseCreateParams::ServiceTier::OrSymbol
                 ),
               store: T.nilable(T::Boolean),
+              stream_options:
+                T.nilable(
+                  OpenAI::Responses::ResponseCreateParams::StreamOptions
+                ),
               temperature: T.nilable(Float),
               text: OpenAI::Responses::ResponseTextConfig,
               tool_choice:
                 T.any(
                   OpenAI::Responses::ToolChoiceOptions::OrSymbol,
+                  OpenAI::Responses::ToolChoiceAllowed,
                   OpenAI::Responses::ToolChoiceTypes,
                   OpenAI::Responses::ToolChoiceFunction,
-                  OpenAI::Responses::ToolChoiceMcp
+                  OpenAI::Responses::ToolChoiceMcp,
+                  OpenAI::Responses::ToolChoiceCustom
                 ),
               tools:
                 T::Array[
@@ -627,6 +670,7 @@ module OpenAI
                     OpenAI::Responses::Tool::CodeInterpreter,
                     OpenAI::Responses::Tool::ImageGeneration,
                     OpenAI::Responses::Tool::LocalShell,
+                    OpenAI::Responses::CustomTool,
                     OpenAI::Responses::WebSearchTool
                   )
                 ],
@@ -739,6 +783,47 @@ module OpenAI
           end
         end
 
+        class StreamOptions < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ResponseCreateParams::StreamOptions,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # When true, stream obfuscation will be enabled. Stream obfuscation adds random
+          # characters to an `obfuscation` field on streaming delta events to normalize
+          # payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+          # fields are included by default, but add a small amount of overhead to the data
+          # stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+          # you trust the network links between your application and the OpenAI API.
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :include_obfuscation
+
+          sig { params(include_obfuscation: T::Boolean).void }
+          attr_writer :include_obfuscation
+
+          # Options for streaming responses. Only set this when you set `stream: true`.
+          sig do
+            params(include_obfuscation: T::Boolean).returns(T.attached_class)
+          end
+          def self.new(
+            # When true, stream obfuscation will be enabled. Stream obfuscation adds random
+            # characters to an `obfuscation` field on streaming delta events to normalize
+            # payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+            # fields are included by default, but add a small amount of overhead to the data
+            # stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+            # you trust the network links between your application and the OpenAI API.
+            include_obfuscation: nil
+          )
+          end
+
+          sig { override.returns({ include_obfuscation: T::Boolean }) }
+          def to_hash
+          end
+        end
+
         # How the model should select which tool (or tools) to use when generating a
         # response. See the `tools` parameter to see how to specify which tools the model
         # can call.
@@ -749,9 +834,11 @@ module OpenAI
             T.type_alias do
               T.any(
                 OpenAI::Responses::ToolChoiceOptions::TaggedSymbol,
+                OpenAI::Responses::ToolChoiceAllowed,
                 OpenAI::Responses::ToolChoiceTypes,
                 OpenAI::Responses::ToolChoiceFunction,
-                OpenAI::Responses::ToolChoiceMcp
+                OpenAI::Responses::ToolChoiceMcp,
+                OpenAI::Responses::ToolChoiceCustom
               )
             end
 

data/rbi/openai/models/responses/response_custom_tool_call.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ResponseCustomToolCall < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseCustomToolCall,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # An identifier used to map this custom tool call to a tool call output.
+        sig { returns(String) }
+        attr_accessor :call_id
+
+        # The input for the custom tool call generated by the model.
+        sig { returns(String) }
+        attr_accessor :input
+
+        # The name of the custom tool being called.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The type of the custom tool call. Always `custom_tool_call`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The unique ID of the custom tool call in the OpenAI platform.
+        sig { returns(T.nilable(String)) }
+        attr_reader :id
+
+        sig { params(id: String).void }
+        attr_writer :id
+
+        # A call to a custom tool created by the model.
+        sig do
+          params(
+            call_id: String,
+            input: String,
+            name: String,
+            id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # An identifier used to map this custom tool call to a tool call output.
+          call_id:,
+          # The input for the custom tool call generated by the model.
+          input:,
+          # The name of the custom tool being called.
+          name:,
+          # The unique ID of the custom tool call in the OpenAI platform.
+          id: nil,
+          # The type of the custom tool call. Always `custom_tool_call`.
+          type: :custom_tool_call
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              call_id: String,
+              input: String,
+              name: String,
+              type: Symbol,
+              id: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response_custom_tool_call_input_delta_event.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ResponseCustomToolCallInputDeltaEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseCustomToolCallInputDeltaEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The incremental input data (delta) for the custom tool call.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # Unique identifier for the API item associated with this event.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output this delta applies to.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The sequence number of this event.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The event type identifier.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Event representing a delta (partial update) to the input of a custom tool call.
+        sig do
+          params(
+            delta: String,
+            item_id: String,
+            output_index: Integer,
+            sequence_number: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The incremental input data (delta) for the custom tool call.
+          delta:,
+          # Unique identifier for the API item associated with this event.
+          item_id:,
+          # The index of the output this delta applies to.
+          output_index:,
+          # The sequence number of this event.
+          sequence_number:,
+          # The event type identifier.
+          type: :"response.custom_tool_call_input.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delta: String,
+              item_id: String,
+              output_index: Integer,
+              sequence_number: Integer,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response_custom_tool_call_input_done_event.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ResponseCustomToolCallInputDoneEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseCustomToolCallInputDoneEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The complete input data for the custom tool call.
+        sig { returns(String) }
+        attr_accessor :input
+
+        # Unique identifier for the API item associated with this event.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output this event applies to.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The sequence number of this event.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The event type identifier.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Event indicating that input for a custom tool call is complete.
+        sig do
+          params(
+            input: String,
+            item_id: String,
+            output_index: Integer,
+            sequence_number: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The complete input data for the custom tool call.
+          input:,
+          # Unique identifier for the API item associated with this event.
+          item_id:,
+          # The index of the output this event applies to.
+          output_index:,
+          # The sequence number of this event.
+          sequence_number:,
+          # The event type identifier.
+          type: :"response.custom_tool_call_input.done"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              input: String,
+              item_id: String,
+              output_index: Integer,
+              sequence_number: Integer,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response_custom_tool_call_output.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ResponseCustomToolCallOutput < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseCustomToolCallOutput,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The call ID, used to map this custom tool call output to a custom tool call.
+        sig { returns(String) }
+        attr_accessor :call_id
+
+        # The output from the custom tool call generated by your code.
+        sig { returns(String) }
+        attr_accessor :output
+
+        # The type of the custom tool call output. Always `custom_tool_call_output`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The unique ID of the custom tool call output in the OpenAI platform.
+        sig { returns(T.nilable(String)) }
+        attr_reader :id
+
+        sig { params(id: String).void }
+        attr_writer :id
+
+        # The output of a custom tool call from your code, being sent back to the model.
+        sig do
+          params(
+            call_id: String,
+            output: String,
+            id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The call ID, used to map this custom tool call output to a custom tool call.
+          call_id:,
+          # The output from the custom tool call generated by your code.
+          output:,
+          # The unique ID of the custom tool call output in the OpenAI platform.
+          id: nil,
+          # The type of the custom tool call output. Always `custom_tool_call_output`.
+          type: :custom_tool_call_output
+        )
+        end
+
+        sig do
+          override.returns(
+            { call_id: String, output: String, type: Symbol, id: String }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response_input_item.rbi

@@ -32,6 +32,8 @@ module OpenAI
               OpenAI::Responses::ResponseInputItem::McpApprovalRequest,
               OpenAI::Responses::ResponseInputItem::McpApprovalResponse,
               OpenAI::Responses::ResponseInputItem::McpCall,
+              OpenAI::Responses::ResponseCustomToolCallOutput,
+              OpenAI::Responses::ResponseCustomToolCall,
               OpenAI::Responses::ResponseInputItem::ItemReference
             )
           end

data/rbi/openai/models/responses/response_output_item.rbi

@@ -21,7 +21,8 @@ module OpenAI
               OpenAI::Responses::ResponseOutputItem::LocalShellCall,
               OpenAI::Responses::ResponseOutputItem::McpCall,
               OpenAI::Responses::ResponseOutputItem::McpListTools,
-              OpenAI::Responses::ResponseOutputItem::McpApprovalRequest
+              OpenAI::Responses::ResponseOutputItem::McpApprovalRequest,
+              OpenAI::Responses::ResponseCustomToolCall
             )
           end