openai 0.85.0 → 0.86.0

data/rbi/openai/resources/admin/organization/projects/service_accounts/api_keys.rbi

@@ -18,6 +18,7 @@ module OpenAI
                 params(
                   service_account_id: String,
                   project_id: String,
+                  expires_in_seconds: T.nilable(Integer),
                   name: String,
                   scopes: T::Array[String],
                   request_options: OpenAI::RequestOptions::OrHash
@@ -29,6 +30,8 @@ module OpenAI
                 service_account_id,
                 # Path param: The ID of the project.
                 project_id:,
+                # Body param: Number of seconds until the API key expires.
+                expires_in_seconds: nil,
                 # Body param: API key name.
                 name: nil,
                 # Body param: API key scopes.

data/rbi/openai/resources/audio/speech.rbi

@@ -26,7 +26,7 @@ module OpenAI
             stream_format: OpenAI::Audio::SpeechCreateParams::StreamFormat::OrSymbol,
             request_options: OpenAI::RequestOptions::OrHash
           )
-            .returns(StringIO)
+            .returns(T.all(StringIO, OpenAI::ResponseCarrier))
         }
         def create(
           # The text to generate audio for. The maximum length is 4096 characters.

data/rbi/openai/resources/beta/responses.rbi

@@ -825,12 +825,13 @@ module OpenAI
           # request will be processed with the Flex Processing service tier. - To opt-in to
           # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
           # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
-          # Completions. The response will show `service_tier=priority` regardless of if you
-          # specify `service_tier=fast` or `priority` in your request. - When not set, the
-          # default behavior is 'auto'. When the `service_tier` parameter is set, the
-          # response body will include the `service_tier` value based on the processing mode
-          # actually used to serve the request. This response value may be different from
-          # the value set in the parameter.
+          # Completions. For models with a dedicated Fast tier, either value resolves to
+          # `service_tier=fast`; for other models, either value resolves to
+          # `service_tier=priority`. - When not set, the default behavior is 'auto'. When
+          # the `service_tier` parameter is set, the response body will include the
+          # `service_tier` value based on the processing mode actually used to serve the
+          # request. This response value may be different from the value set in the
+          # parameter.
           service_tier: nil,
           # Header param: Optional beta features to enable for this request.
           betas: nil,

data/rbi/openai/resources/containers/files/content.rbi

@@ -12,7 +12,7 @@ module OpenAI
           # Retrieve Container File Content
           sig {
             params(file_id: String, container_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(
-              StringIO
+              T.all(StringIO, OpenAI::ResponseCarrier)
             )
           }
           def retrieve(file_id, container_id:, request_options: {})

data/rbi/openai/resources/files.rbi

@@ -114,7 +114,11 @@ module OpenAI
       end
 
       # Returns a response containing the contents of the specified file.
-      sig { params(file_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(StringIO) }
+      sig {
+        params(file_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(
+          T.all(StringIO, OpenAI::ResponseCarrier)
+        )
+      }
       def content(
         # The ID of the file to use for this request.
         file_id,

data/rbi/openai/resources/responses.rbi

@@ -651,10 +651,12 @@ module OpenAI
           prompt: T.nilable(OpenAI::Responses::ResponsePrompt::OrHash),
           prompt_cache_key: String,
           reasoning: T.nilable(OpenAI::Reasoning::OrHash),
+          response_id: T.nilable(String),
           safety_identifier: String,
           service_tier: T.nilable(
             OpenAI::Responses::ResponseCreateParams::ServiceTier::OrSymbol
           ),
+          starting_after: T.nilable(Integer),
           store: T.nilable(T::Boolean),
           temperature: T.nilable(Float),
           text: T.nilable(
@@ -772,6 +774,8 @@ module OpenAI
         # Configuration options for
         # [reasoning models](https://platform.openai.com/docs/guides/reasoning).
         reasoning: nil,
+        # The ID of the response whose stream to resume.
+        response_id: nil,
         # A stable identifier used to help detect users of your application that may be
         # violating OpenAI's usage policies. The IDs should be a string that uniquely
         # identifies each user. We recommend hashing their username or email address, in
@@ -796,6 +800,9 @@ module OpenAI
         # request. This response value may be different from the value set in the
         # parameter.
         service_tier: nil,
+        # The sequence number of the event after which to resume streaming. Can only be
+        # used with `response_id`.
+        starting_after: nil,
         # Whether to store the generated model response for later retrieval via API.
         store: nil,
         # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
@@ -872,6 +879,20 @@ module OpenAI
           include: T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol],
           include_obfuscation: T::Boolean,
           starting_after: Integer,
+          text: T.nilable(
+            T.any(
+              OpenAI::Responses::ResponseTextConfig::OrHash,
+              OpenAI::StructuredOutput::JsonSchemaConverter::Input
+            )
+          ),
+          tools: T.nilable(
+            T::Array[
+              T.any(
+                OpenAI::Responses::FunctionTool::OrHash,
+                OpenAI::StructuredOutput::JsonSchemaConverter::Input
+              )
+            ]
+          ),
           stream: T.noreturn,
           request_options: OpenAI::RequestOptions::OrHash
         )
@@ -892,6 +913,12 @@ module OpenAI
         include_obfuscation: nil,
         # The sequence number of the event after which to start streaming.
         starting_after: nil,
+        # The structured-output model used to parse retrieved text output. This is a
+        # local parsing hint and is not sent to the API.
+        text: nil,
+        # Structured-output models used to parse retrieved function tool calls. These
+        # are local parsing hints and are not sent to the API.
+        tools: nil,
         # There is no need to provide `stream:`. Instead, use `#retrieve_streaming` or
         # `#retrieve` for streaming and non-streaming use cases, respectively.
         stream: false,
@@ -1027,12 +1054,13 @@ module OpenAI
         # request will be processed with the Flex Processing service tier. - To opt-in to
         # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
         # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
-        # Completions. The response will show `service_tier=priority` regardless of if you
-        # specify `service_tier=fast` or `priority` in your request. - When not set, the
-        # default behavior is 'auto'. When the `service_tier` parameter is set, the
-        # response body will include the `service_tier` value based on the processing mode
-        # actually used to serve the request. This response value may be different from
-        # the value set in the parameter.
+        # Completions. For models with a dedicated Fast tier, either value resolves to
+        # `service_tier=fast`; for other models, either value resolves to
+        # `service_tier=priority`. - When not set, the default behavior is 'auto'. When
+        # the `service_tier` parameter is set, the response body will include the
+        # `service_tier` value based on the processing mode actually used to serve the
+        # request. This response value may be different from the value set in the
+        # parameter.
         service_tier: nil,
         request_options: {}
       )
@@ -1046,3 +1074,121 @@ module OpenAI
 
   end
 end
+
+module OpenAI
+  module Models
+    module Responses
+      module ConnectionResources
+        class Response
+          sig do
+            params(
+              background: T.nilable(T::Boolean),
+              context_management: T.nilable(
+                T::Array[OpenAI::Responses::ResponsesClientEvent::ResponseCreate::ContextManagement::OrHash]
+              ),
+              conversation: T.nilable(T.any(String, OpenAI::Responses::ResponseConversationParam::OrHash)),
+              include: T.nilable(T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol]),
+              input: OpenAI::Responses::ResponsesClientEvent::ResponseCreate::Input::Variants,
+              instructions: T.nilable(String),
+              max_output_tokens: T.nilable(Integer),
+              max_tool_calls: T.nilable(Integer),
+              metadata: T.nilable(T::Hash[Symbol, String]),
+              model: T.any(String, OpenAI::ChatModel::OrSymbol, OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol),
+              moderation: T.nilable(OpenAI::Responses::ResponsesClientEvent::ResponseCreate::Moderation::OrHash),
+              parallel_tool_calls: T.nilable(T::Boolean),
+              previous_response_id: T.nilable(String),
+              prompt: T.nilable(OpenAI::Responses::ResponsePrompt::OrHash),
+              prompt_cache_key: T.nilable(String),
+              prompt_cache_options: OpenAI::Responses::ResponsesClientEvent::ResponseCreate::PromptCacheOptions::OrHash,
+              prompt_cache_retention: T.nilable(
+                OpenAI::Responses::ResponsesClientEvent::ResponseCreate::PromptCacheRetention::OrSymbol
+              ),
+              reasoning: T.nilable(OpenAI::Reasoning::OrHash),
+              safety_identifier: T.nilable(String),
+              service_tier: T.nilable(OpenAI::Responses::ResponsesClientEvent::ResponseCreate::ServiceTier::OrSymbol),
+              store: T.nilable(T::Boolean),
+              stream: T.nilable(T::Boolean),
+              stream_id: String,
+              stream_options: T.nilable(OpenAI::Responses::ResponsesClientEvent::ResponseCreate::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::ToolChoiceCustom::OrHash,
+                OpenAI::Responses::ResponsesClientEvent::ResponseCreate::ToolChoice::SpecificProgrammaticToolCallingParam::OrHash,
+                OpenAI::Responses::ToolChoiceApplyPatch::OrHash,
+                OpenAI::Responses::ToolChoiceShell::OrHash
+              ),
+              tools: T::Array[
+                T.any(
+                  OpenAI::Responses::FunctionTool::OrHash,
+                  OpenAI::Responses::FileSearchTool::OrHash,
+                  OpenAI::Responses::ComputerTool::OrHash,
+                  OpenAI::Responses::ComputerUsePreviewTool::OrHash,
+                  OpenAI::Responses::Tool::Mcp::OrHash,
+                  OpenAI::Responses::Tool::CodeInterpreter::OrHash,
+                  OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
+                  OpenAI::Responses::Tool::ImageGeneration::OrHash,
+                  OpenAI::Responses::Tool::LocalShell::OrHash,
+                  OpenAI::Responses::FunctionShellTool::OrHash,
+                  OpenAI::Responses::CustomTool::OrHash,
+                  OpenAI::Responses::NamespaceTool::OrHash,
+                  OpenAI::Responses::ToolSearchTool::OrHash,
+                  OpenAI::Responses::ApplyPatchTool::OrHash,
+                  OpenAI::Responses::WebSearchTool::OrHash,
+                  OpenAI::Responses::WebSearchPreviewTool::OrHash
+                )
+              ],
+              top_logprobs: T.nilable(Integer),
+              top_p: T.nilable(Float),
+              truncation: T.nilable(OpenAI::Responses::ResponsesClientEvent::ResponseCreate::Truncation::OrSymbol),
+              user: String,
+              params: T.anything
+            )
+              .void
+          end
+          def create(
+            background: nil,
+            context_management: nil,
+            conversation: nil,
+            include: nil,
+            input: nil,
+            instructions: nil,
+            max_output_tokens: nil,
+            max_tool_calls: nil,
+            metadata: nil,
+            model: nil,
+            moderation: nil,
+            parallel_tool_calls: nil,
+            previous_response_id: nil,
+            prompt: nil,
+            prompt_cache_key: nil,
+            prompt_cache_options: nil,
+            prompt_cache_retention: nil,
+            reasoning: nil,
+            safety_identifier: nil,
+            service_tier: nil,
+            store: nil,
+            stream: nil,
+            stream_id: nil,
+            stream_options: nil,
+            temperature: nil,
+            text: nil,
+            tool_choice: nil,
+            tools: nil,
+            top_logprobs: nil,
+            top_p: nil,
+            truncation: nil,
+            user: nil,
+            **params
+          )
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/resources/skills/content.rbi

@@ -8,7 +8,11 @@ module OpenAI
       class Content
 
         # Download a skill zip bundle by its ID.
-        sig { params(skill_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(StringIO) }
+        sig {
+          params(skill_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(
+            T.all(StringIO, OpenAI::ResponseCarrier)
+          )
+        }
         def retrieve(
           # The identifier of the skill to download.
           skill_id,

data/rbi/openai/resources/skills/versions/content.rbi

@@ -11,7 +11,9 @@ module OpenAI
 
           # Download a skill version zip bundle.
           sig {
-            params(version: String, skill_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(StringIO)
+            params(version: String, skill_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(
+              T.all(StringIO, OpenAI::ResponseCarrier)
+            )
           }
           def retrieve(
             # The skill version number.

data/rbi/openai/resources/videos.rbi

@@ -109,7 +109,7 @@ module OpenAI
           variant: OpenAI::VideoDownloadContentParams::Variant::OrSymbol,
           request_options: OpenAI::RequestOptions::OrHash
         )
-          .returns(StringIO)
+          .returns(T.all(StringIO, OpenAI::ResponseCarrier))
       }
       def download_content(
         # The identifier of the video whose media to download.

data/rbi/openai/response_carrier.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module OpenAI
+  # Shared response metadata interface for SDK values that are not model
+  # objects, such as binary StringIO responses.
+  module ResponseCarrier
+    sig { returns(T.nilable(String)) }
+    def _request_id
+    end
+
+    sig { returns(T.nilable(OpenAI::ResponseMetadata)) }
+    def last_response
+    end
+
+    # @api private
+    sig { params(response: OpenAI::ResponseMetadata).returns(T.self_type) }
+    def _set_last_response(response)
+    end
+
+    # @api private
+    sig { params(coder: T.untyped).void }
+    def encode_with(coder)
+    end
+  end
+end

data/sig/openai/auth/subject_token_providers.rbs

@@ -0,0 +1,42 @@
+module OpenAI
+  module Auth
+    module SubjectTokenProviders
+      class K8sServiceAccountTokenProvider
+        include OpenAI::Auth::SubjectTokenProvider
+
+        def initialize: (?token_path: String) -> void
+
+        def token_type: -> Symbol
+
+        def get_token: -> String
+      end
+
+      class AzureManagedIdentityTokenProvider
+        include OpenAI::Auth::SubjectTokenProvider
+
+        def initialize: (
+          ?resource: String,
+          ?object_id: String?,
+          ?client_id: String?,
+          ?msi_res_id: String?,
+          ?api_version: String,
+          ?timeout: Float
+        ) -> void
+
+        def token_type: -> Symbol
+
+        def get_token: -> String
+      end
+
+      class GCPIDTokenProvider
+        include OpenAI::Auth::SubjectTokenProvider
+
+        def initialize: (?audience: String, ?timeout: Float) -> void
+
+        def token_type: -> Symbol
+
+        def get_token: -> String
+      end
+    end
+  end
+end

data/sig/openai/errors.rbs

@@ -4,6 +4,9 @@ module OpenAI
       attr_reader cause: StandardError?
     end
 
+    class InvalidWebhookSignatureError < OpenAI::Errors::Error
+    end
+
     class PollingError < OpenAI::Errors::Error
     end
 
@@ -59,6 +62,9 @@ module OpenAI
     end
 
     class APIConnectionError < OpenAI::Errors::APIError
+      # @api private
+      def request_may_have_been_sent?: -> bool
+
       def initialize: (
         url: URI::Generic,
         ?status: nil,
@@ -66,7 +72,8 @@ module OpenAI
         ?body: nil,
         ?request: nil,
         ?response: nil,
-        ?message: String?
+        ?message: String?,
+        ?request_may_have_been_sent: bool
       ) -> void
     end
 
@@ -78,7 +85,8 @@ module OpenAI
         ?body: nil,
         ?request: nil,
         ?response: nil,
-        ?message: String?
+        ?message: String?,
+        ?request_may_have_been_sent: bool
       ) -> void
     end
 
@@ -135,5 +143,31 @@ module OpenAI
     class InternalServerError < OpenAI::Errors::APIStatusError
       HTTP_STATUS: Range[Integer]
     end
+
+    class OAuthError < OpenAI::Errors::APIStatusError
+      def status: -> Integer
+
+      def status=: (Integer) -> Integer
+
+      attr_reader error_code: OpenAI::Models::oauth_error_code?
+
+      def initialize: (
+        status: Integer,
+        body: Object?,
+        headers: ::Hash[String, String]?
+      ) -> void
+    end
+
+    class SubjectTokenProviderError < OpenAI::Errors::Error
+      attr_reader provider: String
+
+      attr_accessor cause: StandardError?
+
+      def initialize: (
+        message: String,
+        provider: String,
+        ?cause: StandardError?
+      ) -> void
+    end
   end
 end

data/sig/openai/file_part.rbs

@@ -26,5 +26,8 @@ module OpenAI
       ?filename: (Pathname | String)?,
       ?content_type: String?
     ) -> void
+
+    # @api private
+    private def strip_directories: (Pathname | String filename) -> String
   end
 end

data/sig/openai/helpers/realtime/extensions.rbs

@@ -23,7 +23,7 @@ module OpenAI
   end
 
   module Errors
-    class RealtimeConnectionError < OpenAI::Errors::Error
+    class RealtimeConnectionError < OpenAI::Errors::WebSocketConnectionError
       attr_reader url: URI::Generic
 
       # @api private
@@ -39,7 +39,7 @@ module OpenAI
       ) -> void
     end
 
-    class RealtimeProtocolError < OpenAI::Errors::Error
+    class RealtimeProtocolError < OpenAI::Errors::WebSocketProtocolError
       attr_reader data: String
       def cause: -> StandardError?
 

data/sig/openai/helpers/responses_websocket/connection.rbs

@@ -0,0 +1,48 @@
+module OpenAI
+  module Models
+    module Responses
+      type connection_server_event =
+        OpenAI::Models::Responses::responses_server_event
+        | OpenAI::Responses::UnknownServerEvent
+
+      type connection_client_event =
+        OpenAI::Models::Responses::responses_client_event
+        | ::Hash[Symbol | String, untyped]
+
+      class Connection
+        include Enumerable[OpenAI::Models::Responses::connection_server_event]
+
+        attr_reader url: URI::Generic
+        attr_reader response: OpenAI::Responses::ConnectionResources::Response
+
+        # @api private
+        def initialize: (socket: top, url: URI::Generic) -> void
+        def each:
+          -> Enumerator[OpenAI::Models::Responses::connection_server_event, self]
+          | {
+            (OpenAI::Models::Responses::connection_server_event event) -> void
+          } -> self
+        def receive: -> OpenAI::Models::Responses::connection_server_event?
+
+        # @api private
+        def receive_raw: -> String?
+
+        def send_event: (
+          OpenAI::Models::Responses::connection_client_event event
+        ) -> nil
+
+        # @api private
+        def send_raw: (String data) -> nil
+
+        def close: (?code: Integer, ?reason: String) -> nil
+
+        # @api private
+        def abort: -> nil
+        def closed?: -> bool
+
+        # @api private
+        def poisoned?: -> bool
+      end
+    end
+  end
+end

data/sig/openai/helpers/responses_websocket/connection_manager.rbs

@@ -0,0 +1,19 @@
+module OpenAI
+  module Models
+    module Responses
+      class ConnectionManager
+        # @api private
+        def initialize: (
+          client: OpenAI::Client,
+          websocket_base_url: String?,
+          transport: top,
+          request_options: OpenAI::request_opts?,
+          transport_options: ::Hash[Symbol, top]
+        ) -> void
+
+        # @api private
+        def open: { (OpenAI::Responses::Connection connection) -> top } -> top
+      end
+    end
+  end
+end

data/sig/openai/helpers/responses_websocket/connection_resources.rbs

@@ -0,0 +1,12 @@
+module OpenAI
+  module Models
+    module Responses
+      module ConnectionResources
+        class Response
+          # @api private
+          def initialize: (OpenAI::Responses::Connection connection) -> void
+        end
+      end
+    end
+  end
+end

data/sig/openai/helpers/responses_websocket/extensions.rbs

@@ -0,0 +1,55 @@
+module OpenAI
+  class Client
+    # @api private
+    def with_responses_websocket_connection_request: (
+      ?websocket_base_url: String?,
+      ?options: OpenAI::request_opts?
+    ) {
+      (
+        OpenAI::Internal::Transport::BaseClient::request_input request,
+        ^-> void mark_handshake_completed
+      ) -> top
+    } -> top
+  end
+
+  module Errors
+    class ResponsesConnectionError < OpenAI::Errors::WebSocketConnectionError
+      attr_reader url: URI::Generic
+      attr_reader http_status: Integer?
+      def cause: -> Exception?
+      def initialize: (
+        url: URI::Generic,
+        ?message: String?,
+        ?http_status: Integer?
+      ) -> void
+    end
+
+    class ResponsesProtocolError < OpenAI::Errors::WebSocketProtocolError
+      def cause: -> Exception?
+      def initialize: -> void
+    end
+
+    class ResponsesClientEventError < OpenAI::Errors::Error
+      def cause: -> Exception?
+      def initialize: -> void
+    end
+
+    class ResponsesSendError < ResponsesConnectionError
+      attr_reader outcome: Symbol
+      def initialize: (url: URI::Generic) -> void
+    end
+  end
+
+  module Resources
+    class Responses
+      def connect: (
+        ?websocket_base_url: String?,
+        ?request_options: OpenAI::request_opts?,
+        ?transport: top?,
+        ?transport_options: ::Hash[Symbol, top]
+      ) {
+        (OpenAI::Responses::Connection connection) -> top
+      } -> top
+    end
+  end
+end

data/sig/openai/helpers/responses_websocket/transports/async_websocket.rbs

@@ -0,0 +1,19 @@
+module OpenAI
+  module Models
+    module Responses
+      module Transports
+        class AsyncWebSocket
+          def initialize: -> void
+          def open: (
+            url: URI::Generic,
+            headers: ::Hash[String, String],
+            timeout: Float?,
+            **top options
+          ) {
+            (top socket) -> top
+          } -> top
+        end
+      end
+    end
+  end
+end

data/sig/openai/helpers/responses_websocket/unknown_server_event.rbs

@@ -0,0 +1,15 @@
+module OpenAI
+  module Models
+    module Responses
+      class UnknownServerEvent
+        # @api private
+        def initialize: (data: ::Hash[Symbol, top]) -> void
+
+        attr_reader type: Symbol
+        attr_reader data: ::Hash[Symbol, top]
+        attr_reader stream_id: top
+        def to_h: -> ::Hash[Symbol, top]
+      end
+    end
+  end
+end