openai 0.67.0 → 0.69.0

data/rbi/openai/models/beta/responses/input_token_count_response.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Beta
+      module Responses
+        class InputTokenCountResponse < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Models::Beta::Responses::InputTokenCountResponse,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Integer) }
+          attr_accessor :input_tokens
+
+          sig { returns(Symbol) }
+          attr_accessor :object
+
+          sig do
+            params(input_tokens: Integer, object: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(input_tokens:, object: :"response.input_tokens")
+          end
+
+          sig { override.returns({ input_tokens: Integer, object: Symbol }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/beta/threads/run_create_params.rbi

@@ -114,19 +114,12 @@ module OpenAI
           sig { params(parallel_tool_calls: T::Boolean).void }
           attr_writer :parallel_tool_calls
 
-          # Constrains effort on reasoning for
-          # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-          # supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
-          # Reducing reasoning effort can result in faster responses and fewer tokens used
-          # on reasoning in a response.
-          #
-          # - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
-          #   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
-          #   calls are supported for all reasoning values in gpt-5.1.
-          # - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
-          #   support `none`.
-          # - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
-          # - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+          # Constrains effort on reasoning for reasoning models. Currently supported values
+          # are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
+          # reasoning effort can result in faster responses and fewer tokens used on
+          # reasoning in a response. Not all reasoning models support every value. See the
+          # [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
+          # model-specific support.
           sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
           attr_accessor :reasoning_effort
 
@@ -342,19 +335,12 @@ module OpenAI
             # [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
             # during tool use.
             parallel_tool_calls: nil,
-            # Constrains effort on reasoning for
-            # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-            # supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
-            # Reducing reasoning effort can result in faster responses and fewer tokens used
-            # on reasoning in a response.
-            #
-            # - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
-            #   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
-            #   calls are supported for all reasoning values in gpt-5.1.
-            # - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
-            #   support `none`.
-            # - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
-            # - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+            # Constrains effort on reasoning for reasoning models. Currently supported values
+            # are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
+            # reasoning effort can result in faster responses and fewer tokens used on
+            # reasoning in a response. Not all reasoning models support every value. See the
+            # [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
+            # model-specific support.
             reasoning_effort: nil,
             # Specifies the format that the model must output. Compatible with
             # [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),

data/rbi/openai/models/chat/chat_completion_content_part.rbi

@@ -43,16 +43,42 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+          # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+          # token block.
+          sig do
+            returns(
+              T.nilable(
+                OpenAI::Chat::ChatCompletionContentPart::File::PromptCacheBreakpoint
+              )
+            )
+          end
+          attr_reader :prompt_cache_breakpoint
+
+          sig do
+            params(
+              prompt_cache_breakpoint:
+                OpenAI::Chat::ChatCompletionContentPart::File::PromptCacheBreakpoint::OrHash
+            ).void
+          end
+          attr_writer :prompt_cache_breakpoint
+
           # Learn about [file inputs](https://platform.openai.com/docs/guides/text) for text
           # generation.
           sig do
             params(
               file: OpenAI::Chat::ChatCompletionContentPart::File::File::OrHash,
+              prompt_cache_breakpoint:
+                OpenAI::Chat::ChatCompletionContentPart::File::PromptCacheBreakpoint::OrHash,
               type: Symbol
             ).returns(T.attached_class)
           end
           def self.new(
             file:,
+            # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+            # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+            # token block.
+            prompt_cache_breakpoint: nil,
             # The type of the content part. Always `file`.
             type: :file
           )
@@ -62,7 +88,9 @@ module OpenAI
             override.returns(
               {
                 file: OpenAI::Chat::ChatCompletionContentPart::File::File,
-                type: Symbol
+                type: Symbol,
+                prompt_cache_breakpoint:
+                  OpenAI::Chat::ChatCompletionContentPart::File::PromptCacheBreakpoint
               }
             )
           end
@@ -126,6 +154,34 @@ module OpenAI
             def to_hash
             end
           end
+
+          class PromptCacheBreakpoint < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletionContentPart::File::PromptCacheBreakpoint,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The breakpoint mode. Always `explicit`.
+            sig { returns(Symbol) }
+            attr_accessor :mode
+
+            # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+            # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+            # token block.
+            sig { params(mode: Symbol).returns(T.attached_class) }
+            def self.new(
+              # The breakpoint mode. Always `explicit`.
+              mode: :explicit
+            )
+            end
+
+            sig { override.returns({ mode: Symbol }) }
+            def to_hash
+            end
+          end
         end
 
         sig do

data/rbi/openai/models/chat/chat_completion_content_part_image.rbi

@@ -29,16 +29,42 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+        # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+        # token block.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Chat::ChatCompletionContentPartImage::PromptCacheBreakpoint
+            )
+          )
+        end
+        attr_reader :prompt_cache_breakpoint
+
+        sig do
+          params(
+            prompt_cache_breakpoint:
+              OpenAI::Chat::ChatCompletionContentPartImage::PromptCacheBreakpoint::OrHash
+          ).void
+        end
+        attr_writer :prompt_cache_breakpoint
+
         # Learn about [image inputs](https://platform.openai.com/docs/guides/vision).
         sig do
           params(
             image_url:
               OpenAI::Chat::ChatCompletionContentPartImage::ImageURL::OrHash,
+            prompt_cache_breakpoint:
+              OpenAI::Chat::ChatCompletionContentPartImage::PromptCacheBreakpoint::OrHash,
             type: Symbol
           ).returns(T.attached_class)
         end
         def self.new(
           image_url:,
+          # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+          # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+          # token block.
+          prompt_cache_breakpoint: nil,
           # The type of the content part.
           type: :image_url
         )
@@ -48,7 +74,9 @@ module OpenAI
           override.returns(
             {
               image_url: OpenAI::Chat::ChatCompletionContentPartImage::ImageURL,
-              type: Symbol
+              type: Symbol,
+              prompt_cache_breakpoint:
+                OpenAI::Chat::ChatCompletionContentPartImage::PromptCacheBreakpoint
             }
           )
         end
@@ -156,6 +184,34 @@ module OpenAI
             end
           end
         end
+
+        class PromptCacheBreakpoint < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Chat::ChatCompletionContentPartImage::PromptCacheBreakpoint,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The breakpoint mode. Always `explicit`.
+          sig { returns(Symbol) }
+          attr_accessor :mode
+
+          # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+          # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+          # token block.
+          sig { params(mode: Symbol).returns(T.attached_class) }
+          def self.new(
+            # The breakpoint mode. Always `explicit`.
+            mode: :explicit
+          )
+          end
+
+          sig { override.returns({ mode: Symbol }) }
+          def to_hash
+          end
+        end
       end
     end
   end

data/rbi/openai/models/chat/chat_completion_content_part_input_audio.rbi

@@ -32,16 +32,42 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+        # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+        # token block.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Chat::ChatCompletionContentPartInputAudio::PromptCacheBreakpoint
+            )
+          )
+        end
+        attr_reader :prompt_cache_breakpoint
+
+        sig do
+          params(
+            prompt_cache_breakpoint:
+              OpenAI::Chat::ChatCompletionContentPartInputAudio::PromptCacheBreakpoint::OrHash
+          ).void
+        end
+        attr_writer :prompt_cache_breakpoint
+
         # Learn about [audio inputs](https://platform.openai.com/docs/guides/audio).
         sig do
           params(
             input_audio:
               OpenAI::Chat::ChatCompletionContentPartInputAudio::InputAudio::OrHash,
+            prompt_cache_breakpoint:
+              OpenAI::Chat::ChatCompletionContentPartInputAudio::PromptCacheBreakpoint::OrHash,
             type: Symbol
           ).returns(T.attached_class)
         end
         def self.new(
           input_audio:,
+          # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+          # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+          # token block.
+          prompt_cache_breakpoint: nil,
           # The type of the content part. Always `input_audio`.
           type: :input_audio
         )
@@ -52,7 +78,9 @@ module OpenAI
             {
               input_audio:
                 OpenAI::Chat::ChatCompletionContentPartInputAudio::InputAudio,
-              type: Symbol
+              type: Symbol,
+              prompt_cache_breakpoint:
+                OpenAI::Chat::ChatCompletionContentPartInputAudio::PromptCacheBreakpoint
             }
           )
         end
@@ -142,6 +170,34 @@ module OpenAI
             end
           end
         end
+
+        class PromptCacheBreakpoint < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Chat::ChatCompletionContentPartInputAudio::PromptCacheBreakpoint,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The breakpoint mode. Always `explicit`.
+          sig { returns(Symbol) }
+          attr_accessor :mode
+
+          # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+          # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+          # token block.
+          sig { params(mode: Symbol).returns(T.attached_class) }
+          def self.new(
+            # The breakpoint mode. Always `explicit`.
+            mode: :explicit
+          )
+          end
+
+          sig { override.returns({ mode: Symbol }) }
+          def to_hash
+          end
+        end
       end
     end
   end

data/rbi/openai/models/chat/chat_completion_content_part_text.rbi

@@ -22,20 +22,88 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+        # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+        # token block.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Chat::ChatCompletionContentPartText::PromptCacheBreakpoint
+            )
+          )
+        end
+        attr_reader :prompt_cache_breakpoint
+
+        sig do
+          params(
+            prompt_cache_breakpoint:
+              OpenAI::Chat::ChatCompletionContentPartText::PromptCacheBreakpoint::OrHash
+          ).void
+        end
+        attr_writer :prompt_cache_breakpoint
+
         # Learn about
         # [text inputs](https://platform.openai.com/docs/guides/text-generation).
-        sig { params(text: String, type: Symbol).returns(T.attached_class) }
+        sig do
+          params(
+            text: String,
+            prompt_cache_breakpoint:
+              OpenAI::Chat::ChatCompletionContentPartText::PromptCacheBreakpoint::OrHash,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
         def self.new(
           # The text content.
           text:,
+          # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+          # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+          # token block.
+          prompt_cache_breakpoint: nil,
           # The type of the content part.
           type: :text
         )
         end
 
-        sig { override.returns({ text: String, type: Symbol }) }
+        sig do
+          override.returns(
+            {
+              text: String,
+              type: Symbol,
+              prompt_cache_breakpoint:
+                OpenAI::Chat::ChatCompletionContentPartText::PromptCacheBreakpoint
+            }
+          )
+        end
         def to_hash
         end
+
+        class PromptCacheBreakpoint < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Chat::ChatCompletionContentPartText::PromptCacheBreakpoint,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The breakpoint mode. Always `explicit`.
+          sig { returns(Symbol) }
+          attr_accessor :mode
+
+          # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+          # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+          # token block.
+          sig { params(mode: Symbol).returns(T.attached_class) }
+          def self.new(
+            # The breakpoint mode. Always `explicit`.
+            mode: :explicit
+          )
+          end
+
+          sig { override.returns({ mode: Symbol }) }
+          def to_hash
+          end
+        end
       end
     end
   end