openai 0.68.0 → 0.70.0

data/rbi/openai/models/responses/tool.rbi

@@ -16,6 +16,7 @@ module OpenAI
               OpenAI::Responses::ComputerUsePreviewTool,
               OpenAI::Responses::Tool::Mcp,
               OpenAI::Responses::Tool::CodeInterpreter,
+              OpenAI::Responses::Tool::ProgrammaticToolCalling,
               OpenAI::Responses::Tool::ImageGeneration,
               OpenAI::Responses::Tool::LocalShell,
               OpenAI::Responses::FunctionShellTool,
@@ -42,6 +43,16 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The tool invocation context(s).
+          sig do
+            returns(
+              T.nilable(
+                T::Array[OpenAI::Responses::Tool::Mcp::AllowedCaller::OrSymbol]
+              )
+            )
+          end
+          attr_accessor :allowed_callers
+
           # List of allowed tool names or a filter object.
           sig do
             returns(
@@ -147,6 +158,12 @@ module OpenAI
           sig do
             params(
               server_label: String,
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Responses::Tool::Mcp::AllowedCaller::OrSymbol
+                  ]
+                ),
               allowed_tools:
                 T.nilable(
                   T.any(
@@ -174,6 +191,8 @@ module OpenAI
           def self.new(
             # A label for this MCP server, used to identify it in tool calls.
             server_label:,
+            # The tool invocation context(s).
+            allowed_callers: nil,
             # List of allowed tool names or a filter object.
             allowed_tools: nil,
             # An OAuth access token that can be used with a remote MCP server, either with a
@@ -221,6 +240,12 @@ module OpenAI
               {
                 server_label: String,
                 type: Symbol,
+                allowed_callers:
+                  T.nilable(
+                    T::Array[
+                      OpenAI::Responses::Tool::Mcp::AllowedCaller::OrSymbol
+                    ]
+                  ),
                 allowed_tools:
                   T.nilable(
                     T.any(
@@ -249,6 +274,37 @@ module OpenAI
           def to_hash
           end
 
+          module AllowedCaller
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, OpenAI::Responses::Tool::Mcp::AllowedCaller)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DIRECT =
+              T.let(
+                :direct,
+                OpenAI::Responses::Tool::Mcp::AllowedCaller::TaggedSymbol
+              )
+            PROGRAMMATIC =
+              T.let(
+                :programmatic,
+                OpenAI::Responses::Tool::Mcp::AllowedCaller::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::Tool::Mcp::AllowedCaller::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
           # List of allowed tool names or a filter object.
           module AllowedTools
             extend OpenAI::Internal::Type::Union
@@ -675,6 +731,18 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The tool invocation context(s).
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::OrSymbol
+                ]
+              )
+            )
+          end
+          attr_accessor :allowed_callers
+
           # A tool that runs Python code to help generate a response to a prompt.
           sig do
             params(
@@ -683,6 +751,12 @@ module OpenAI
                   String,
                   OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::OrHash
                 ),
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::OrSymbol
+                  ]
+                ),
               type: Symbol
             ).returns(T.attached_class)
           end
@@ -691,6 +765,8 @@ module OpenAI
             # specifies uploaded file IDs to make available to your code, along with an
             # optional `memory_limit` setting.
             container:,
+            # The tool invocation context(s).
+            allowed_callers: nil,
             # The type of the code interpreter tool. Always `code_interpreter`.
             type: :code_interpreter
           )
@@ -704,7 +780,13 @@ module OpenAI
                     String,
                     OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto
                   ),
-                type: Symbol
+                type: Symbol,
+                allowed_callers:
+                  T.nilable(
+                    T::Array[
+                      OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::OrSymbol
+                    ]
+                  )
               }
             )
           end
@@ -907,6 +989,65 @@ module OpenAI
             def self.variants
             end
           end
+
+          module AllowedCaller
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DIRECT =
+              T.let(
+                :direct,
+                OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::TaggedSymbol
+              )
+            PROGRAMMATIC =
+              T.let(
+                :programmatic,
+                OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class ProgrammaticToolCalling < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::Tool::ProgrammaticToolCalling,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The type of the tool. Always `programmatic_tool_calling`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # The type of the tool. Always `programmatic_tool_calling`.
+            type: :programmatic_tool_calling
+          )
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
         end
 
         class ImageGeneration < OpenAI::Internal::Type::BaseModel

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

@@ -29,6 +29,8 @@ module OpenAI
                 project_id: String,
                 after: String,
                 limit: Integer,
+                owner_project_access:
+                  OpenAI::Admin::Organization::Projects::APIKeyListParams::OwnerProjectAccess::OrSymbol,
                 request_options: OpenAI::RequestOptions::OrHash
               ).returns(
                 OpenAI::Internal::ConversationCursorPage[
@@ -47,6 +49,12 @@ module OpenAI
               # A limit on the number of objects to be returned. Limit can range between 1 and
               # 100, and the default is 20.
               limit: nil,
+              # Filter API keys by whether the owner currently has effective access to the
+              # project. Use `active` for owners with access, `inactive` for owners without
+              # access, or `any` for all enabled project API keys. If omitted, the endpoint
+              # applies its existing membership-based visibility rules, which may exclude some
+              # enabled keys.
+              owner_project_access: nil,
               request_options: {}
             )
             end

data/rbi/openai/resources/beta/assistants.rbi

@@ -61,19 +61,12 @@ module OpenAI
           metadata: nil,
           # The name of the assistant. The maximum length is 256 characters.
           name: 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),
@@ -196,19 +189,12 @@ module OpenAI
           model: nil,
           # The name of the assistant. The maximum length is 256 characters.
           name: 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/resources/beta/responses/input_items.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+    class Beta
+      class Responses
+        class InputItems
+          # Returns a list of input items for a given response.
+          sig do
+            params(
+              response_id: String,
+              after: String,
+              include: T::Array[OpenAI::Beta::BetaResponseIncludable::OrSymbol],
+              limit: Integer,
+              order:
+                OpenAI::Beta::Responses::InputItemListParams::Order::OrSymbol,
+              betas:
+                T::Array[
+                  OpenAI::Beta::Responses::InputItemListParams::Beta::OrSymbol
+                ],
+              request_options: OpenAI::RequestOptions::OrHash
+            ).returns(
+              OpenAI::Internal::CursorPage[
+                OpenAI::Beta::BetaResponseItem::Variants
+              ]
+            )
+          end
+          def list(
+            # Path param: The ID of the response to retrieve input items for.
+            response_id,
+            # Query param: An item ID to list items after, used in pagination.
+            after: nil,
+            # Query param: Additional fields to include in the response. See the `include`
+            # parameter for Response creation above for more information.
+            include: nil,
+            # Query param: A limit on the number of objects to be returned. Limit can range
+            # between 1 and 100, and the default is 20.
+            limit: nil,
+            # Query param: The order to return the input items in. Default is `desc`.
+            #
+            # - `asc`: Return the input items in ascending order.
+            # - `desc`: Return the input items in descending order.
+            order: nil,
+            # Header param: Optional beta features to enable for this request.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: OpenAI::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+    class Beta
+      class Responses
+        class InputTokens
+          # Returns input token counts of the request.
+          #
+          # Returns an object with `object` set to `response.input_tokens` and an
+          # `input_tokens` count.
+          sig do
+            params(
+              conversation:
+                T.nilable(
+                  T.any(
+                    String,
+                    OpenAI::Beta::BetaResponseConversationParam::OrHash
+                  )
+                ),
+              input:
+                T.nilable(
+                  OpenAI::Beta::Responses::InputTokenCountParams::Input::Variants
+                ),
+              instructions: T.nilable(String),
+              model: T.nilable(String),
+              parallel_tool_calls: T.nilable(T::Boolean),
+              personality:
+                T.any(
+                  String,
+                  OpenAI::Beta::Responses::InputTokenCountParams::Personality::OrSymbol
+                ),
+              previous_response_id: T.nilable(String),
+              reasoning:
+                T.nilable(
+                  OpenAI::Beta::Responses::InputTokenCountParams::Reasoning::OrHash
+                ),
+              text:
+                T.nilable(
+                  OpenAI::Beta::Responses::InputTokenCountParams::Text::OrHash
+                ),
+              tool_choice:
+                T.nilable(
+                  T.any(
+                    OpenAI::Beta::BetaToolChoiceOptions::OrSymbol,
+                    OpenAI::Beta::BetaToolChoiceAllowed::OrHash,
+                    OpenAI::Beta::BetaToolChoiceTypes::OrHash,
+                    OpenAI::Beta::BetaToolChoiceFunction::OrHash,
+                    OpenAI::Beta::BetaToolChoiceMcp::OrHash,
+                    OpenAI::Beta::BetaToolChoiceCustom::OrHash,
+                    OpenAI::Beta::Responses::InputTokenCountParams::ToolChoice::BetaSpecificProgrammaticToolCallingParam::OrHash,
+                    OpenAI::Beta::BetaToolChoiceApplyPatch::OrHash,
+                    OpenAI::Beta::BetaToolChoiceShell::OrHash
+                  )
+                ),
+              tools:
+                T.nilable(
+                  T::Array[
+                    T.any(
+                      OpenAI::Beta::BetaFunctionTool::OrHash,
+                      OpenAI::Beta::BetaFileSearchTool::OrHash,
+                      OpenAI::Beta::BetaComputerTool::OrHash,
+                      OpenAI::Beta::BetaComputerUsePreviewTool::OrHash,
+                      OpenAI::Beta::BetaTool::Mcp::OrHash,
+                      OpenAI::Beta::BetaTool::CodeInterpreter::OrHash,
+                      OpenAI::Beta::BetaTool::ProgrammaticToolCalling::OrHash,
+                      OpenAI::Beta::BetaTool::ImageGeneration::OrHash,
+                      OpenAI::Beta::BetaTool::LocalShell::OrHash,
+                      OpenAI::Beta::BetaFunctionShellTool::OrHash,
+                      OpenAI::Beta::BetaCustomTool::OrHash,
+                      OpenAI::Beta::BetaNamespaceTool::OrHash,
+                      OpenAI::Beta::BetaToolSearchTool::OrHash,
+                      OpenAI::Beta::BetaApplyPatchTool::OrHash,
+                      OpenAI::Beta::BetaWebSearchTool::OrHash,
+                      OpenAI::Beta::BetaWebSearchPreviewTool::OrHash
+                    )
+                  ]
+                ),
+              truncation:
+                OpenAI::Beta::Responses::InputTokenCountParams::Truncation::OrSymbol,
+              betas:
+                T::Array[
+                  OpenAI::Beta::Responses::InputTokenCountParams::Beta::OrSymbol
+                ],
+              request_options: OpenAI::RequestOptions::OrHash
+            ).returns(OpenAI::Models::Beta::Responses::InputTokenCountResponse)
+          end
+          def count(
+            # Body param: The conversation that this response belongs to. Items from this
+            # conversation are prepended to `input_items` for this response request. Input
+            # items and output items from this response are automatically added to this
+            # conversation after this response completes.
+            conversation: nil,
+            # Body param: Text, image, or file inputs to the model, used to generate a
+            # response
+            input: nil,
+            # Body param: A system (or developer) message inserted into the model's context.
+            # When used along with `previous_response_id`, the instructions from a previous
+            # response will not be carried over to the next response. This makes it simple to
+            # swap out system (or developer) messages in new responses.
+            instructions: nil,
+            # Body param: Model ID used to generate the response, like `gpt-4o` or `o3`.
+            # OpenAI offers a wide range of models with different capabilities, performance
+            # characteristics, and price points. Refer to the
+            # [model guide](https://platform.openai.com/docs/models) to browse and compare
+            # available models.
+            model: nil,
+            # Body param: Whether to allow the model to run tool calls in parallel.
+            parallel_tool_calls: nil,
+            # Body param: A model-owned style preset to apply to this request. Omit this
+            # parameter to use the model's default style. Supported values may expand over
+            # time. Values must be at most 64 characters.
+            personality: nil,
+            # Body param: The unique ID of the previous response to the model. Use this to
+            # create multi-turn conversations. Learn more about
+            # [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+            # Cannot be used in conjunction with `conversation`.
+            previous_response_id: nil,
+            # Body param: **gpt-5 and o-series models only** Configuration options for
+            # [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+            reasoning: nil,
+            # Body param: Configuration options for a text response from the model. Can be
+            # plain text or structured JSON data. Learn more:
+            #
+            # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+            # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+            text: nil,
+            # Body param: Controls which tool the model should use, if any.
+            tool_choice: nil,
+            # Body param: An array of tools the model may call while generating a response.
+            # You can specify which tool to use by setting the `tool_choice` parameter.
+            tools: nil,
+            # Body param: The truncation strategy to use for the model response. - `auto`: If
+            # the input to this Response exceeds the model's context window size, the model
+            # will truncate the response to fit the context window by dropping items from the
+            # beginning of the conversation. - `disabled` (default): If the input size will
+            # exceed the context window size for a model, the request will fail with a 400
+            # error.
+            truncation: nil,
+            # Header param: Optional beta features to enable for this request.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: OpenAI::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end