openai 0.20.0 → 0.21.0

data/rbi/openai/models/realtime/response_created_event.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseCreatedEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseCreatedEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The response resource.
+        sig { returns(OpenAI::Realtime::RealtimeResponse) }
+        attr_reader :response
+
+        sig do
+          params(response: OpenAI::Realtime::RealtimeResponse::OrHash).void
+        end
+        attr_writer :response
+
+        # The event type, must be `response.created`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when a new Response is created. The first event of response creation,
+        # where the response is in an initial state of `in_progress`.
+        sig do
+          params(
+            event_id: String,
+            response: OpenAI::Realtime::RealtimeResponse::OrHash,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The response resource.
+          response:,
+          # The event type, must be `response.created`.
+          type: :"response.created"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              response: OpenAI::Realtime::RealtimeResponse,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_done_event.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseDoneEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseDoneEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The response resource.
+        sig { returns(OpenAI::Realtime::RealtimeResponse) }
+        attr_reader :response
+
+        sig do
+          params(response: OpenAI::Realtime::RealtimeResponse::OrHash).void
+        end
+        attr_writer :response
+
+        # The event type, must be `response.done`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when a Response is done streaming. Always emitted, no matter the final
+        # state. The Response object included in the `response.done` event will include
+        # all output Items in the Response but will omit the raw audio data.
+        sig do
+          params(
+            event_id: String,
+            response: OpenAI::Realtime::RealtimeResponse::OrHash,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The response resource.
+          response:,
+          # The event type, must be `response.done`.
+          type: :"response.done"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              response: OpenAI::Realtime::RealtimeResponse,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_function_call_arguments_delta_event.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseFunctionCallArgumentsDeltaEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseFunctionCallArgumentsDeltaEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The ID of the function call.
+        sig { returns(String) }
+        attr_accessor :call_id
+
+        # The arguments delta as a JSON string.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the function call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The ID of the response.
+        sig { returns(String) }
+        attr_accessor :response_id
+
+        # The event type, must be `response.function_call_arguments.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when the model-generated function call arguments are updated.
+        sig do
+          params(
+            call_id: String,
+            delta: String,
+            event_id: String,
+            item_id: String,
+            output_index: Integer,
+            response_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The ID of the function call.
+          call_id:,
+          # The arguments delta as a JSON string.
+          delta:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the function call item.
+          item_id:,
+          # The index of the output item in the response.
+          output_index:,
+          # The ID of the response.
+          response_id:,
+          # The event type, must be `response.function_call_arguments.delta`.
+          type: :"response.function_call_arguments.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              call_id: String,
+              delta: String,
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              response_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_function_call_arguments_done_event.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseFunctionCallArgumentsDoneEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseFunctionCallArgumentsDoneEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The final arguments as a JSON string.
+        sig { returns(String) }
+        attr_accessor :arguments
+
+        # The ID of the function call.
+        sig { returns(String) }
+        attr_accessor :call_id
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the function call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The ID of the response.
+        sig { returns(String) }
+        attr_accessor :response_id
+
+        # The event type, must be `response.function_call_arguments.done`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when the model-generated function call arguments are done streaming.
+        # Also emitted when a Response is interrupted, incomplete, or cancelled.
+        sig do
+          params(
+            arguments: String,
+            call_id: String,
+            event_id: String,
+            item_id: String,
+            output_index: Integer,
+            response_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The final arguments as a JSON string.
+          arguments:,
+          # The ID of the function call.
+          call_id:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the function call item.
+          item_id:,
+          # The index of the output item in the response.
+          output_index:,
+          # The ID of the response.
+          response_id:,
+          # The event type, must be `response.function_call_arguments.done`.
+          type: :"response.function_call_arguments.done"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              arguments: String,
+              call_id: String,
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              response_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_mcp_call_arguments_delta.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseMcpCallArgumentsDelta < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseMcpCallArgumentsDelta,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The JSON-encoded arguments delta.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the MCP tool call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The ID of the response.
+        sig { returns(String) }
+        attr_accessor :response_id
+
+        # The event type, must be `response.mcp_call_arguments.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # If present, indicates the delta text was obfuscated.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :obfuscation
+
+        # Returned when MCP tool call arguments are updated during response generation.
+        sig do
+          params(
+            delta: String,
+            event_id: String,
+            item_id: String,
+            output_index: Integer,
+            response_id: String,
+            obfuscation: T.nilable(String),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The JSON-encoded arguments delta.
+          delta:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the MCP tool call item.
+          item_id:,
+          # The index of the output item in the response.
+          output_index:,
+          # The ID of the response.
+          response_id:,
+          # If present, indicates the delta text was obfuscated.
+          obfuscation: nil,
+          # The event type, must be `response.mcp_call_arguments.delta`.
+          type: :"response.mcp_call_arguments.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delta: String,
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              response_id: String,
+              type: Symbol,
+              obfuscation: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_mcp_call_arguments_done.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseMcpCallArgumentsDone < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseMcpCallArgumentsDone,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The final JSON-encoded arguments string.
+        sig { returns(String) }
+        attr_accessor :arguments
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the MCP tool call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The ID of the response.
+        sig { returns(String) }
+        attr_accessor :response_id
+
+        # The event type, must be `response.mcp_call_arguments.done`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when MCP tool call arguments are finalized during response generation.
+        sig do
+          params(
+            arguments: String,
+            event_id: String,
+            item_id: String,
+            output_index: Integer,
+            response_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The final JSON-encoded arguments string.
+          arguments:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the MCP tool call item.
+          item_id:,
+          # The index of the output item in the response.
+          output_index:,
+          # The ID of the response.
+          response_id:,
+          # The event type, must be `response.mcp_call_arguments.done`.
+          type: :"response.mcp_call_arguments.done"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              arguments: String,
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              response_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_mcp_call_completed.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseMcpCallCompleted < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseMcpCallCompleted,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the MCP tool call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The event type, must be `response.mcp_call.completed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when an MCP tool call has completed successfully.
+        sig do
+          params(
+            event_id: String,
+            item_id: String,
+            output_index: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the MCP tool call item.
+          item_id:,
+          # The index of the output item in the response.
+          output_index:,
+          # The event type, must be `response.mcp_call.completed`.
+          type: :"response.mcp_call.completed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_mcp_call_failed.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseMcpCallFailed < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseMcpCallFailed,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the MCP tool call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The event type, must be `response.mcp_call.failed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when an MCP tool call has failed.
+        sig do
+          params(
+            event_id: String,
+            item_id: String,
+            output_index: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the MCP tool call item.
+          item_id:,
+          # The index of the output item in the response.
+          output_index:,
+          # The event type, must be `response.mcp_call.failed`.
+          type: :"response.mcp_call.failed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_mcp_call_in_progress.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ResponseMcpCallInProgress < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ResponseMcpCallInProgress,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the MCP tool call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The event type, must be `response.mcp_call.in_progress`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when an MCP tool call has started and is in progress.
+        sig do
+          params(
+            event_id: String,
+            item_id: String,
+            output_index: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the MCP tool call item.
+          item_id:,
+          # The index of the output item in the response.
+          output_index:,
+          # The event type, must be `response.mcp_call.in_progress`.
+          type: :"response.mcp_call.in_progress"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end