openai 0.96.0 → 0.98.0

data/lib/openai/resources/realtime/translations/client_secrets.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Resources
+    class Realtime
+      class Translations
+        class ClientSecrets
+          # Create a Realtime translation client secret with an associated translation
+          # session configuration.
+          #
+          # Client secrets are short-lived tokens that can be passed to a client app, such
+          # as a web frontend or mobile client, which grants access to the Realtime
+          # Translation API without leaking your main API key. You can configure a custom
+          # TTL for each client secret.
+          #
+          # Returns the created client secret and the effective translation session object.
+          # The client secret is a string that looks like `ek_1234`.
+          #
+          # @overload create(session:, expires_after: nil, request_options: {})
+          #
+          # @param session [OpenAI::Models::Realtime::RealtimeTranslationSessionCreateRequest]
+          #   Realtime translation session configuration. Translation sessions stream source
+          #   audio in and translated audio plus transcript deltas out continuously.
+          #
+          # @param expires_after [OpenAI::Models::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter]
+          #   Configuration for the client secret expiration. Expiration refers to the time
+          #   after which a client secret will no longer be valid for creating sessions. The
+          #   session itself may continue after that time once started. A secret can be used
+          #   to create multiple sessions until it expires.
+          #
+          # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [OpenAI::Models::Realtime::RealtimeTranslationClientSecretCreateResponse]
+          #
+          # @see OpenAI::Models::Realtime::Translations::ClientSecretCreateParams
+          def create(params)
+            parsed, options = OpenAI::Realtime::Translations::ClientSecretCreateParams.dump_request(params)
+            @client.request(
+              method: :post,
+              path: "realtime/translations/client_secrets",
+              body: parsed,
+              model: OpenAI::Realtime::RealtimeTranslationClientSecretCreateResponse,
+              security: {bearer_auth: true},
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [OpenAI::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openai/resources/realtime/translations.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Resources
+    class Realtime
+      class Translations
+        # @return [OpenAI::Resources::Realtime::Translations::ClientSecrets]
+        attr_reader :client_secrets
+
+        # @api private
+        #
+        # @param client [OpenAI::Client]
+        def initialize(client:)
+          @client = client
+          @client_secrets = OpenAI::Resources::Realtime::Translations::ClientSecrets.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/openai/resources/realtime.rb

@@ -9,6 +9,9 @@ module OpenAI
       # @return [OpenAI::Resources::Realtime::Calls]
       attr_reader :calls
 
+      # @return [OpenAI::Resources::Realtime::Translations]
+      attr_reader :translations
+
       # @api private
       #
       # @param client [OpenAI::Client]
@@ -16,6 +19,7 @@ module OpenAI
         @client = client
         @client_secrets = OpenAI::Resources::Realtime::ClientSecrets.new(client: client)
         @calls = OpenAI::Resources::Realtime::Calls.new(client: client)
+        @translations = OpenAI::Resources::Realtime::Translations.new(client: client)
       end
     end
   end

data/lib/openai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenAI
-  VERSION = "0.96.0"
+  VERSION = "0.98.0"
 end

data/lib/openai.rb

@@ -163,6 +163,7 @@ require_relative "openai/models/graders/python_grader"
 require_relative "openai/models/graders/text_similarity_grader"
 require_relative "openai/models/fine_tuning/fine_tuning_job_wandb_integration_object"
 require_relative "openai/models/realtime/realtime_session_create_request"
+require_relative "openai/models/realtime/realtime_translation_client_secret_create_request"
 require_relative "openai/models/responses/response_custom_tool_call"
 require_relative "openai/models/responses/response_custom_tool_call_output"
 require_relative "openai/models/responses/response_function_tool_call"
@@ -465,6 +466,9 @@ require_relative "openai/models/batch_request_counts"
 require_relative "openai/models/batch_retrieve_params"
 require_relative "openai/models/batch_usage"
 require_relative "openai/models/beta/agent"
+require_relative "openai/models/beta/agent_browser_authentication_cancel_param"
+require_relative "openai/models/beta/agent_browser_authentication_submit_param"
+require_relative "openai/models/beta/agent_browser_origin_access_param"
 require_relative "openai/models/beta/agent_close_subagent_call_item"
 require_relative "openai/models/beta/agent_command_execution_item"
 require_relative "openai/models/beta/agent_content"
@@ -512,12 +516,14 @@ require_relative "openai/models/beta/agents/sessions/event_stream_params"
 require_relative "openai/models/beta/agents/sessions/item_list_params"
 require_relative "openai/models/beta/agents/sessions/session_artifact"
 require_relative "openai/models/beta/agents/sessions/session_artifact_deleted"
+require_relative "openai/models/beta/agents/sessions/session_trace"
 require_relative "openai/models/beta/agents/sessions/subagent_list_params"
 require_relative "openai/models/beta/agents/sessions/subagent_retrieve_params"
 require_relative "openai/models/beta/agents/sessions/subagents/item_list_params"
 require_relative "openai/models/beta/agents/sessions/subagents/turn_list_params"
 require_relative "openai/models/beta/agents/sessions/subagents/turn_retrieve_params"
 require_relative "openai/models/beta/agents/sessions/subagents/turns/item_list_params"
+require_relative "openai/models/beta/agents/sessions/trace_list_params"
 require_relative "openai/models/beta/agents/sessions/turn"
 require_relative "openai/models/beta/agents/sessions/turn_list_params"
 require_relative "openai/models/beta/agents/sessions/turn_retrieve_params"
@@ -1201,7 +1207,6 @@ require_relative "openai/models/realtime/realtime_transcription_session_create_r
 require_relative "openai/models/realtime/realtime_transcription_session_create_response"
 require_relative "openai/models/realtime/realtime_transcription_session_turn_detection"
 require_relative "openai/models/realtime/realtime_translation_client_event"
-require_relative "openai/models/realtime/realtime_translation_client_secret_create_request"
 require_relative "openai/models/realtime/realtime_translation_client_secret_create_response"
 require_relative "openai/models/realtime/realtime_translation_input_audio_buffer_append_event"
 require_relative "openai/models/realtime/realtime_translation_input_transcript_delta_event"
@@ -1244,6 +1249,7 @@ require_relative "openai/models/realtime/session_updated_event"
 require_relative "openai/models/realtime/session_update_event"
 require_relative "openai/models/realtime/transcription_session_update"
 require_relative "openai/models/realtime/transcription_session_updated_event"
+require_relative "openai/models/realtime/translations/client_secret_create_params"
 require_relative "openai/models/reasoning"
 require_relative "openai/models/response_format_json_object"
 require_relative "openai/models/response_format_json_schema"
@@ -1518,6 +1524,7 @@ require_relative "openai/resources/beta/agents/sessions/subagents"
 require_relative "openai/resources/beta/agents/sessions/subagents/items"
 require_relative "openai/resources/beta/agents/sessions/subagents/turns"
 require_relative "openai/resources/beta/agents/sessions/subagents/turns/items"
+require_relative "openai/resources/beta/agents/sessions/traces"
 require_relative "openai/resources/beta/agents/sessions/turns"
 require_relative "openai/resources/beta/agents/vaults"
 require_relative "openai/resources/beta/agents/vaults/credentials"
@@ -1567,6 +1574,8 @@ require_relative "openai/resources/moderations"
 require_relative "openai/resources/realtime"
 require_relative "openai/resources/realtime/calls"
 require_relative "openai/resources/realtime/client_secrets"
+require_relative "openai/resources/realtime/translations"
+require_relative "openai/resources/realtime/translations/client_secrets"
 require_relative "openai/resources/responses"
 require_relative "openai/resources/responses/input_items"
 require_relative "openai/resources/responses/input_tokens"
@@ -1596,5 +1605,7 @@ require_relative "openai/helpers/realtime"
 require_relative "openai/helpers/responses_websocket"
 require_relative "openai/helpers/live/websocket"
 
+require_relative "openai/helpers/beta/agents/creation_stream"
 require_relative "openai/helpers/agents/session_stream"
+require_relative "openai/helpers/beta/agents/function_tool"
 require_relative "openai/helpers/agents/message"

data/rbi/openai/helpers/agents.rbi

@@ -26,6 +26,16 @@ module OpenAI
         def each(&block)
         end
 
+        # @beta
+        sig { returns(OpenAI::Helpers::Beta::Agents::TurnResult) }
+        def get_final_result
+        end
+
+        # @beta
+        sig { returns(T.self_type) }
+        def with_result_collection
+        end
+
         sig { void }
         def close
         end
@@ -47,12 +57,21 @@ module OpenAI
               input: T.any(String, T::Array[OpenAI::Models::Beta::AgentSessionInputMessageParam::OrHash]),
               tool_handlers: T::Hash[String, OpenAI::Helpers::Agents::ToolHandler],
               idempotency_key: T.nilable(String),
+              output_type: T.nilable(T.class_of(OpenAI::Helpers::StructuredOutput::BaseModel)),
               request_options: T.nilable(OpenAI::RequestOptions::OrHash),
               block: T.nilable(T.proc.params(stream: OpenAI::Helpers::Agents::SessionStream).void)
             )
               .returns(OpenAI::Helpers::Agents::SessionStream)
           end
-          def stream(session_id, input:, tool_handlers: {}, idempotency_key: nil, request_options: {}, &block)
+          def stream(
+            session_id,
+            input:,
+            tool_handlers: {},
+            idempotency_key: nil,
+            output_type: nil,
+            request_options: {},
+            &block
+          )
           end
         end
       end

data/rbi/openai/helpers/beta/agents/artifacts.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        class ResultArtifacts
+          sig {
+            params(
+              artifacts: OpenAI::Resources::Beta::Agents::Sessions::Artifacts,
+              client: OpenAI::Client,
+              result: TurnResult
+            )
+              .void
+          }
+          def initialize(artifacts:, client:, result:)
+          end
+
+          sig {
+            params(path: String, to: T.untyped, request_options: OpenAI::RequestOptions::OrHash).returns(
+              OpenAI::Models::Beta::Agents::Sessions::SessionArtifact
+            )
+          }
+          def download(path:, to:, request_options: {})
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/helpers/beta/agents/files.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        class PreparedFiles
+          sig { returns(T::Array[OpenAI::Models::Beta::HostedEnvironmentFileParam::FileID]) }
+          attr_reader :files
+          sig { returns(T::Array[String]) }
+          attr_reader :upload_ids
+          sig { params(files: T::Array[T::Hash[Symbol, T.untyped]]).void }
+          def initialize(files)
+          end
+        end
+
+        class FilePreparationError < OpenAI::Errors::Error
+          sig { returns(PreparedFiles) }
+          attr_reader :prepared
+          sig { params(prepared: PreparedFiles).returns(T.attached_class) }
+          def self.new(prepared:)
+          end
+        end
+        # @api private
+        class FilePreparation
+          sig {
+            params(client: OpenAI::Client, environment_files: OpenAI::Resources::Beta::Agents::Environments::Files).void
+          }
+          def initialize(client:, environment_files:)
+          end
+
+          sig {
+            params(files: T::Hash[String, T.any(String, Pathname)], request_options: OpenAI::RequestOptions::OrHash)
+              .returns(PreparedFiles)
+          }
+          def prepare(files, request_options: {})
+          end
+
+          sig {
+            params(
+              directory: T.any(String, Pathname),
+              destination: String,
+              include: T::Array[String],
+              request_options: OpenAI::RequestOptions::OrHash
+            )
+              .returns(PreparedFiles)
+          }
+          def prepare_directory(directory, destination:, include:, request_options: {})
+          end
+
+          sig {
+            params(
+              environment_id: String,
+              file: T.any(String, Pathname),
+              path: String,
+              request_options: OpenAI::RequestOptions::OrHash
+            )
+              .returns(PreparedFiles)
+          }
+          def upload(environment_id, file:, path:, request_options: {})
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/helpers/beta/agents/function_tool.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        class FunctionTool
+          sig { returns(String) }
+          attr_reader :name
+
+          sig do
+            params(
+              name: String,
+              arguments: T.class_of(OpenAI::BaseModel),
+              description: String,
+              handler: T.proc.params(arguments: T.untyped).returns(OpenAI::Helpers::Agents::ToolOutput)
+            )
+              .void
+          end
+          def initialize(name:, arguments:, description: "", &handler)
+          end
+
+          sig { returns(OpenAI::Internal::AnyHash) }
+          def definition
+          end
+
+          sig { returns(T::Hash[String, OpenAI::Helpers::Agents::ToolHandler]) }
+          def handlers
+          end
+
+          sig {
+            params(arguments: T.any(String, OpenAI::Internal::AnyHash)).returns(OpenAI::Helpers::Agents::ToolOutput)
+          }
+          def call(arguments)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/helpers/beta/agents/model_adapter.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        module ModelAdapter
+          sig { params(model: T.untyped, parameter: String).void }
+          def self.validate!(model, parameter:)
+          end
+
+          sig do
+            params(model: T.class_of(OpenAI::BaseModel), value: T.untyped, memoize: T::Boolean)
+              .returns(T.nilable(OpenAI::BaseModel))
+          end
+          def self.coerce(model, value, memoize: false)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/helpers/beta/agents.rbi

@@ -0,0 +1,146 @@
+# typed: strong
+
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        class TurnResult
+          sig { returns(OpenAI::Models::Beta::Agents::Sessions::Turn) }
+          def turn
+          end
+
+          sig { returns(T::Array[OpenAI::Models::Beta::AgentSessionMessage]) }
+          def messages
+          end
+
+          sig { returns(String) }
+          def session_id
+          end
+
+          sig { returns(String) }
+          def turn_id
+          end
+
+          sig { returns(String) }
+          def output_text
+          end
+
+          sig { returns(T.untyped) }
+          def output_parsed
+          end
+
+          sig {
+            params(output_type: T.class_of(OpenAI::Helpers::StructuredOutput::BaseModel)).returns(ParsedTurnResult)
+          }
+          def parse(output_type:)
+          end
+        end
+
+        class ResultError < OpenAI::Errors::Error
+          sig { returns(Symbol) }
+          def reason
+          end
+
+          sig { returns(T.nilable(String)) }
+          def session_id
+          end
+
+          sig { returns(T.nilable(OpenAI::Models::Beta::Agents::Sessions::Turn)) }
+          def turn
+          end
+
+          sig { returns(T::Array[OpenAI::Models::Beta::AgentSessionMessage]) }
+          def messages
+          end
+
+          sig {
+            returns(
+              T::Array[T.any(OpenAI::Models::Beta::AgentSession::RequiredAction::Variants, OpenAI::Internal::AnyHash)]
+            )
+          }
+          def required_actions
+          end
+
+          sig { returns(T.nilable(String)) }
+          def turn_id
+          end
+        end
+
+        # @api private
+        class ResultCollector
+          sig { params(session_id: T.nilable(String), handler_names: T::Array[String]).void }
+          def initialize(session_id: nil, handler_names: [])
+          end
+
+          sig { void }
+          def enable
+          end
+
+          sig {
+            params(event: T.any(OpenAI::Models::Beta::AgentSessionEvent::Variants, OpenAI::Internal::AnyHash)).void
+          }
+          def observe(event)
+          end
+
+          sig { returns(T.nilable(T::Boolean)) }
+          def stopped?
+          end
+
+          sig { params(error: StandardError).void }
+          def observe_error(error)
+          end
+
+          sig { returns(TurnResult) }
+          def result
+          end
+        end
+
+        class ParsedTurnResult < TurnResult
+          sig { returns(TurnResult) }
+          attr_reader :raw_result
+
+          sig { returns(T.untyped) }
+          attr_reader :output_parsed
+        end
+
+        class OutputParseError < OpenAI::Errors::Error
+          sig { returns(TurnResult) }
+          attr_reader :raw_result
+        end
+
+        # @api private
+        class OutputParser
+          sig { params(model: T.class_of(OpenAI::Helpers::StructuredOutput::BaseModel)).void }
+          def initialize(model)
+          end
+
+          sig { params(params: OpenAI::Internal::AnyHash).void }
+          def prepare_request(params)
+          end
+
+          sig { params(result: TurnResult).returns(ParsedTurnResult) }
+          def parse(result)
+          end
+        end
+
+        class CreationStream < OpenAI::Internal::Stream
+          Message = type_member(:in) { {fixed: OpenAI::Internal::Util::ServerSentEvent} }
+          Elem = type_member(:out) { {fixed: OpenAI::Models::Beta::AgentSessionEvent::Variants} }
+
+          sig { returns(TurnResult) }
+          def get_final_result
+          end
+
+          sig { returns(T.self_type) }
+          def with_result_collection
+          end
+
+          # @api private
+          sig { params(parser: T.nilable(OutputParser)).returns(T.self_type) }
+          def configure_output_parser(parser)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -409,6 +409,18 @@ module OpenAI
         )
         end
 
+        # @api private
+        sig {
+          params(
+            req: T.untyped,
+            on_response: T.nilable(T.proc.returns(T.untyped)),
+            blk: T.proc.params(chunk: String).returns(T.untyped)
+          )
+            .void
+        }
+        def request_streaming_body(req, on_response = nil, &blk)
+        end
+
         # @api private
         sig do
           params(

data/rbi/openai/internal/type/base_model.rbi

@@ -51,7 +51,7 @@ module OpenAI
 
           # @api private
           sig do
-            returns(
+            params(state: T.nilable(OpenAI::Internal::Type::Converter::CoerceState)).returns(
               T::Hash[
                 Symbol,
                 T.all(
@@ -61,7 +61,7 @@ module OpenAI
               ]
             )
           end
-          def fields
+          def fields(state: nil)
           end
 
           # @api private

data/rbi/openai/internal/type/converter.rbi

@@ -22,7 +22,8 @@ module OpenAI
               maybe: Integer
             },
             error: T.nilable(StandardError),
-            branched: Integer
+            branched: Integer,
+            memo: T.nilable(T::Hash[T.untyped, T.untyped])
           }
         end
 
@@ -123,11 +124,28 @@ module OpenAI
 
           # @api private
           sig do
-            params(translate_names: T::Boolean, request_only: T::Boolean).returns(
+            params(translate_names: T::Boolean, request_only: T::Boolean, memoize: T::Boolean).returns(
               OpenAI::Internal::Type::Converter::CoerceState
             )
           end
-          def self.new_coerce_state(translate_names: true, request_only: false)
+          def self.new_coerce_state(translate_names: true, request_only: false, memoize: false)
+          end
+
+          # @api private
+          sig {
+            params(type_fn: T.proc.returns(T.untyped), state: T.nilable(OpenAI::Internal::Type::Converter::CoerceState))
+              .returns(T.untyped)
+          }
+          def self.resolve_type(type_fn, state: nil)
+          end
+
+          # @api private
+          sig {
+            params(target: T.untyped, value: T.untyped, state: OpenAI::Internal::Type::Converter::CoerceState).returns(
+              T.untyped
+            )
+          }
+          def self.coerce_cached(target, value, state:)
           end
 
           # @api private

data/rbi/openai/internal/type/union.rbi

@@ -65,8 +65,12 @@ module OpenAI
         end
 
         # @api private
-        sig { params(value: T.anything).returns(T.nilable(T.anything)) }
-        private def resolve_variant(value)
+        sig {
+          params(value: T.anything, state: T.nilable(OpenAI::Internal::Type::Converter::CoerceState)).returns(
+            T.nilable(T.anything)
+          )
+        }
+        private def resolve_variant(value, state: nil)
         end
 
         sig { params(other: T.anything).returns(T::Boolean) }

data/rbi/openai/models/beta/agent.rbi

@@ -106,7 +106,8 @@ module OpenAI
                 OpenAI::Beta::PersistedAgentTool::ToolSearch::OrHash,
                 OpenAI::Beta::PersistedAgentTool::ProgrammaticToolCalling::OrHash,
                 OpenAI::Beta::PersistedAgentTool::Mcp::OrHash,
-                OpenAI::Beta::PersistedAgentTool::WebSearch::OrHash
+                OpenAI::Beta::PersistedAgentTool::WebSearch::OrHash,
+                OpenAI::Beta::PersistedAgentTool::ComputerUse::OrHash
               )
             ],
 

data/rbi/openai/models/beta/agent_browser_authentication_cancel_param.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentBrowserAuthenticationCancelParam < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentBrowserAuthenticationCancelParam,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(Symbol) }
+        attr_accessor :action
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+
+            action: Symbol,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          action: :cancel,
+
+          type: :browser_authentication
+        )
+        end
+
+        sig do
+          override.returns(
+            {action: Symbol, type: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end