openai 0.85.0 → 0.87.0

data/rbi/openai/helpers/streaming/chat_completion_stream.rbi

@@ -0,0 +1,214 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Chat
+      class ParsedChoice < OpenAI::Models::Chat::ChatCompletion::Choice
+        sig { returns(T.nilable(OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol)) }
+        attr_accessor :finish_reason
+
+        sig do
+          params(
+            index: Integer,
+            logprobs: T.nilable(OpenAI::Chat::ChatCompletion::Choice::Logprobs::OrHash),
+            message: OpenAI::Chat::ChatCompletionMessage::OrHash,
+            finish_reason: T.nilable(OpenAI::Chat::ChatCompletion::Choice::FinishReason::OrSymbol)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(index:, logprobs:, message:, finish_reason: nil)
+        end
+
+        sig { returns(OpenAI::Internal::AnyHash) }
+        def to_hash
+        end
+      end
+
+      class ParsedChatCompletion < OpenAI::Models::Chat::ChatCompletion
+        sig { returns(T::Array[OpenAI::Models::Chat::ParsedChoice]) }
+        attr_accessor :choices
+
+        sig { returns(OpenAI::Internal::AnyHash) }
+        def to_hash
+        end
+      end
+    end
+  end
+
+  module Helpers
+    module Streaming
+      class ChatCompletionStream
+        include OpenAI::Internal::Type::BaseStream
+
+        ChatCompletionStreamEvent = T.type_alias do
+          T.any(
+            ChatChunkEvent,
+            ChatContentDeltaEvent,
+            ChatContentDoneEvent,
+            ChatRefusalDeltaEvent,
+            ChatRefusalDoneEvent,
+            ChatFunctionToolCallArgumentsDeltaEvent,
+            ChatFunctionToolCallArgumentsDoneEvent,
+            ChatLogprobsContentDeltaEvent,
+            ChatLogprobsContentDoneEvent,
+            ChatLogprobsRefusalDeltaEvent,
+            ChatLogprobsRefusalDoneEvent
+          )
+        end
+
+        Message = type_member { {fixed: ChatCompletionStreamEvent} }
+        Elem = type_member { {fixed: ChatCompletionStreamEvent} }
+
+        sig do
+          params(
+            raw_stream: T.untyped,
+            response_format: T.untyped,
+            input_tools: T.untyped
+          )
+            .void
+        end
+        def initialize(raw_stream:, response_format: nil, input_tools: nil)
+        end
+
+        sig { returns(OpenAI::Chat::ParsedChatCompletion) }
+        def get_final_completion
+        end
+
+        sig { returns(String) }
+        def get_output_text
+        end
+
+        sig { returns(T.self_type) }
+        def until_done
+        end
+
+        sig { returns(T.nilable(OpenAI::Chat::ParsedChatCompletion)) }
+        def current_completion_snapshot
+        end
+
+        sig { returns(T::Enumerator[String]) }
+        def text
+        end
+      end
+    end
+  end
+
+  module Resources
+    class Chat
+      class Completions
+        sig do
+          params(
+            messages: T::Array[
+              T.any(
+                OpenAI::Chat::ChatCompletionDeveloperMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionSystemMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionUserMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionAssistantMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionToolMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionFunctionMessageParam::OrHash
+              )
+            ],
+            model: T.any(String, OpenAI::ChatModel::OrSymbol),
+            audio: T.nilable(OpenAI::Chat::ChatCompletionAudioParam::OrHash),
+            frequency_penalty: T.nilable(Float),
+            function_call: T.any(
+              OpenAI::Chat::CompletionCreateParams::FunctionCall::FunctionCallMode::OrSymbol,
+              OpenAI::Chat::ChatCompletionFunctionCallOption::OrHash
+            ),
+            functions: T::Array[OpenAI::Chat::CompletionCreateParams::Function::OrHash],
+            logit_bias: T.nilable(T::Hash[Symbol, Integer]),
+            logprobs: T.nilable(T::Boolean),
+            max_completion_tokens: T.nilable(Integer),
+            max_tokens: T.nilable(Integer),
+            metadata: T.nilable(T::Hash[Symbol, String]),
+            modalities: T.nilable(T::Array[OpenAI::Chat::CompletionCreateParams::Modality::OrSymbol]),
+            moderation: T.nilable(OpenAI::Chat::CompletionCreateParams::Moderation::OrHash),
+            n: T.nilable(Integer),
+            parallel_tool_calls: T::Boolean,
+            prediction: T.nilable(OpenAI::Chat::ChatCompletionPredictionContent::OrHash),
+            presence_penalty: T.nilable(Float),
+            prompt_cache_key: T.nilable(String),
+            prompt_cache_options: OpenAI::Chat::CompletionCreateParams::PromptCacheOptions::OrHash,
+            prompt_cache_retention: T.nilable(OpenAI::Chat::CompletionCreateParams::PromptCacheRetention::OrSymbol),
+            reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
+            response_format: T.any(
+              OpenAI::ResponseFormatText::OrHash,
+              OpenAI::ResponseFormatJSONSchema::OrHash,
+              OpenAI::StructuredOutput::JsonSchemaConverter,
+              OpenAI::ResponseFormatJSONObject::OrHash
+            ),
+            safety_identifier: T.nilable(String),
+            seed: T.nilable(Integer),
+            service_tier: T.nilable(OpenAI::Chat::CompletionCreateParams::ServiceTier::OrSymbol),
+            stop: T.nilable(OpenAI::Chat::CompletionCreateParams::Stop::Variants),
+            store: T.nilable(T::Boolean),
+            stream_options: T.nilable(OpenAI::Chat::ChatCompletionStreamOptions::OrHash),
+            temperature: T.nilable(Float),
+            tool_choice: T.any(
+              OpenAI::Chat::ChatCompletionToolChoiceOption::Auto::OrSymbol,
+              OpenAI::Chat::ChatCompletionAllowedToolChoice::OrHash,
+              OpenAI::Chat::ChatCompletionNamedToolChoice::OrHash,
+              OpenAI::Chat::ChatCompletionNamedToolChoiceCustom::OrHash
+            ),
+            tools: T::Array[
+              T.any(
+                OpenAI::StructuredOutput::JsonSchemaConverter,
+                OpenAI::Chat::ChatCompletionFunctionTool::OrHash,
+                OpenAI::Chat::ChatCompletionCustomTool::OrHash
+              )
+            ],
+            top_logprobs: T.nilable(Integer),
+            top_p: T.nilable(Float),
+            user: String,
+            verbosity: T.nilable(OpenAI::Chat::CompletionCreateParams::Verbosity::OrSymbol),
+            web_search_options: OpenAI::Chat::CompletionCreateParams::WebSearchOptions::OrHash,
+            stream: T.noreturn,
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(OpenAI::Streaming::ChatCompletionStream)
+        end
+        def stream(
+          messages:,
+          model:,
+          audio: nil,
+          frequency_penalty: nil,
+          function_call: nil,
+          functions: nil,
+          logit_bias: nil,
+          logprobs: nil,
+          max_completion_tokens: nil,
+          max_tokens: nil,
+          metadata: nil,
+          modalities: nil,
+          moderation: nil,
+          n: nil,
+          parallel_tool_calls: nil,
+          prediction: nil,
+          presence_penalty: nil,
+          prompt_cache_key: nil,
+          prompt_cache_options: nil,
+          prompt_cache_retention: nil,
+          reasoning_effort: nil,
+          response_format: nil,
+          safety_identifier: nil,
+          seed: nil,
+          service_tier: nil,
+          stop: nil,
+          store: nil,
+          stream_options: nil,
+          temperature: nil,
+          tool_choice: nil,
+          tools: nil,
+          top_logprobs: nil,
+          top_p: nil,
+          user: nil,
+          verbosity: nil,
+          web_search_options: nil,
+          stream: nil,
+          request_options: {}
+        )
+        end
+      end
+    end
+  end
+end

data/rbi/openai/helpers/streaming/events.rbi

@@ -28,6 +28,10 @@ module OpenAI
       end
 
       class ChatChunkEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(T.untyped) }
         def chunk
         end
@@ -38,6 +42,10 @@ module OpenAI
       end
 
       class ChatContentDeltaEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(String) }
         def delta
         end
@@ -52,6 +60,10 @@ module OpenAI
       end
 
       class ChatContentDoneEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(String) }
         def content
         end
@@ -62,6 +74,10 @@ module OpenAI
       end
 
       class ChatRefusalDeltaEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(String) }
         def delta
         end
@@ -72,12 +88,20 @@ module OpenAI
       end
 
       class ChatRefusalDoneEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(String) }
         def refusal
         end
       end
 
       class ChatFunctionToolCallArgumentsDeltaEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(String) }
         def name
         end
@@ -95,11 +119,15 @@ module OpenAI
         end
 
         sig { returns(T.untyped) }
-        def parsed_arguments
+        def parsed
         end
       end
 
       class ChatFunctionToolCallArgumentsDoneEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(String) }
         def name
         end
@@ -113,29 +141,53 @@ module OpenAI
         end
 
         sig { returns(T.untyped) }
-        def parsed_arguments
+        def parsed
         end
       end
 
       class ChatLogprobsContentDeltaEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(T.untyped) }
         def content
         end
+
+        sig { returns(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob]) }
+        def snapshot
+        end
       end
 
       class ChatLogprobsContentDoneEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(T.untyped) }
         def content
         end
       end
 
       class ChatLogprobsRefusalDeltaEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(T.untyped) }
         def refusal
         end
+
+        sig { returns(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob]) }
+        def snapshot
+        end
       end
 
       class ChatLogprobsRefusalDoneEvent < OpenAI::Internal::Type::BaseModel
+        sig { returns(Symbol) }
+        def type
+        end
+
         sig { returns(T.untyped) }
         def refusal
         end
@@ -154,8 +206,13 @@ module OpenAI
         def last_response
         end
 
-        sig { returns(T.untyped) }
-        def each
+        sig do
+          params(
+            blk: T.proc.params(event: ChatCompletionStream::ChatCompletionStreamEvent).void
+          )
+            .void
+        end
+        def each(&blk)
         end
       end
     end

data/rbi/openai/helpers/streaming/exceptions.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module OpenAI
+  module Helpers
+    module Streaming
+      class StreamError < StandardError
+      end
+
+      class LengthFinishReasonError < OpenAI::Helpers::Streaming::StreamError
+        sig { returns(OpenAI::Chat::ParsedChatCompletion) }
+        attr_reader :completion
+
+        sig do
+          params(completion: OpenAI::Chat::ParsedChatCompletion).returns(T.attached_class)
+        end
+        def self.new(completion:)
+        end
+      end
+
+      class ContentFilterFinishReasonError < OpenAI::Helpers::Streaming::StreamError
+        sig { returns(T.attached_class) }
+        def self.new
+        end
+      end
+    end
+  end
+
+  LengthFinishReasonError = Helpers::Streaming::LengthFinishReasonError
+  ContentFilterFinishReasonError = Helpers::Streaming::ContentFilterFinishReasonError
+end

data/rbi/openai/helpers/streaming/response_stream.rbi

@@ -49,7 +49,7 @@ module OpenAI
         def get_output_text
         end
 
-        sig { returns(T::Enumerator::Lazy[String]) }
+        sig { returns(T::Enumerator[String]) }
         def text
         end
 
@@ -82,8 +82,8 @@ module OpenAI
         def initialize(text_format:, starting_after: nil)
         end
 
-        sig { params(event: T.untyped).returns(T::Array[T.untyped]) }
-        def handle_event(event)
+        sig { params(event: T.untyped, text_only: T::Boolean).returns(T::Array[T.untyped]) }
+        def handle_event(event, text_only: false)
         end
 
         sig do
@@ -98,6 +98,10 @@ module OpenAI
 
         private
 
+        sig { params(value: String, delta: String).returns(String) }
+        def append_delta(value, delta)
+        end
+
         sig { params(text: T.nilable(String)).returns(T.untyped) }
         def parse_structured_text(text)
         end

data/rbi/openai/helpers/structured_output/response_parser.rbi

@@ -16,6 +16,17 @@ module OpenAI
         def self.parse!(raw, model, tool_models)
         end
 
+        sig do
+          params(
+            raw: OpenAI::Internal::AnyHash,
+            model: T.nilable(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::Input),
+            tool_models: T::Hash[String, OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::Input]
+          )
+            .returns(OpenAI::Internal::AnyHash)
+        end
+        def self.parse_retrieved!(raw, model, tool_models)
+        end
+
         sig do
           params(parsed: OpenAI::Internal::AnyHash)
             .returns(
@@ -27,6 +38,18 @@ module OpenAI
         end
         def self.get_models(parsed)
         end
+
+        sig do
+          params(parsed: OpenAI::Internal::AnyHash)
+            .returns(
+              [
+                T.nilable(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::Input),
+                T::Hash[String, OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::Input]
+              ]
+            )
+        end
+        def self.get_retrieval_models(parsed)
+        end
       end
     end
   end

data/rbi/openai/helpers/websocket.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module OpenAI
+  module Errors
+    class WebSocketConnectionError < OpenAI::Errors::Error
+      sig { returns(URI::Generic) }
+      attr_reader :url
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :http_status
+
+      sig { returns(T.nilable(Exception)) }
+      def cause
+      end
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          message: T.nilable(String),
+          cause: T.nilable(Exception),
+          http_status: T.nilable(Integer)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(url:, message: nil, cause: nil, http_status: nil)
+      end
+    end
+
+    class WebSocketProtocolError < OpenAI::Errors::Error
+    end
+  end
+end

data/rbi/openai/internal/transport/base_client.rbi

@@ -265,6 +265,17 @@ module OpenAI
         private def request_replayable?(request)
         end
 
+        # @api private
+        sig do
+          params(
+            request: OpenAI::Internal::Transport::BaseClient::RequestInput,
+            error: OpenAI::Errors::APIConnectionError
+          )
+            .returns(T::Boolean)
+        end
+        private def request_retryable_after_connection_error?(request, error:)
+        end
+
         # @api private
         sig do
           params(

data/rbi/openai/internal/type/base_stream.rbi

@@ -18,6 +18,10 @@ module OpenAI
         sig { returns(T::Hash[String, String]) }
         attr_reader :headers
 
+        sig { returns(T.nilable(String)) }
+        def _request_id
+        end
+
         sig { returns(OpenAI::ResponseMetadata) }
         attr_reader :last_response
 

data/rbi/openai/internal/util.rbi

@@ -268,6 +268,7 @@ module OpenAI
         %r{\Aapplication/(?:x-[nl]djson|(?:x-)?jsonl)[ \t]*(?:;|\z)}i,
         Regexp
       )
+      MULTIPART_CONTENT = T.let(%r{\Amultipart/form-data[ \t]*(?:;|\z)}i, Regexp)
 
       class << self
         # @api private

data/rbi/openai/models/admin/organization/projects/service_accounts/api_key_create_params.rbi

@@ -31,6 +31,10 @@ module OpenAI
               sig { returns(String) }
               attr_accessor :service_account_id
 
+              # Number of seconds until the API key expires.
+              sig { returns(T.nilable(Integer)) }
+              attr_accessor :expires_in_seconds
+
               # API key name.
               sig { returns(T.nilable(String)) }
               attr_reader :name
@@ -52,6 +56,8 @@ module OpenAI
 
                   service_account_id: String,
 
+                  expires_in_seconds: T.nilable(Integer),
+
                   name: String,
 
                   scopes: T::Array[String],
@@ -68,6 +74,9 @@ module OpenAI
                 # The ID of the service account.
                 service_account_id:,
 
+                # Number of seconds until the API key expires.
+                expires_in_seconds: nil,
+
                 # API key name.
                 name: nil,
 
@@ -83,6 +92,7 @@ module OpenAI
                   {
                     project_id: String,
                     service_account_id: String,
+                    expires_in_seconds: T.nilable(Integer),
                     name: String,
                     scopes: T::Array[String],
                     request_options: OpenAI::RequestOptions

data/rbi/openai/models/admin/organization/projects/service_accounts/api_key_create_response.rbi

@@ -40,6 +40,11 @@ module OpenAI
               sig { returns(String) }
               attr_accessor :value
 
+              # The Unix timestamp (in seconds) when the API key expires, or null if it does not
+              # expire.
+              sig { returns(T.nilable(Integer)) }
+              attr_accessor :expires_at
+
               sig do
                 params(
 
@@ -51,6 +56,8 @@ module OpenAI
 
                   value: String,
 
+                  expires_at: T.nilable(Integer),
+
                   object: Symbol
                 )
                   .returns(T.attached_class)
@@ -69,6 +76,10 @@ module OpenAI
                 # The unredacted API key value.
                 value:,
 
+                # The Unix timestamp (in seconds) when the API key expires, or null if it does not
+                # expire.
+                expires_at: nil,
+
                 # The object type, which is always `organization.project.service_account.api_key`
 
                 object: :"organization.project.service_account.api_key"
@@ -77,7 +88,14 @@ module OpenAI
 
               sig do
                 override.returns(
-                  {id: String, created_at: Integer, name: String, object: Symbol, value: String}
+                  {
+                    id: String,
+                    created_at: Integer,
+                    name: String,
+                    object: Symbol,
+                    value: String,
+                    expires_at: T.nilable(Integer)
+                  }
                 )
               end
               def to_hash