openai 0.97.0 → 0.98.0

data/rbi/openai/models/responses/response_output_text.rbi

@@ -133,7 +133,7 @@ module OpenAI
             sig { returns(String) }
             attr_accessor :filename
 
-            # The index of the file in the list of files.
+            # The index in the output text at which to insert the file citation.
             sig { returns(Integer) }
             attr_accessor :index
 
@@ -163,7 +163,7 @@ module OpenAI
               # The filename of the file cited.
               filename:,
 
-              # The index of the file in the list of files.
+              # The index in the output text at which to insert the file citation.
               index:,
 
               # The type of the file citation. Always `file_citation`.

data/rbi/openai/models/responses/response_output_text_annotation_added_event.rbi

@@ -140,7 +140,7 @@ module OpenAI
             sig { returns(String) }
             attr_accessor :filename
 
-            # The index of the file in the list of files.
+            # The index in the output text at which to insert the file citation.
             sig { returns(Integer) }
             attr_accessor :index
 
@@ -170,7 +170,7 @@ module OpenAI
               # The filename of the file cited.
               filename:,
 
-              # The index of the file in the list of files.
+              # The index in the output text at which to insert the file citation.
               index:,
 
               # The type of the file citation. Always `file_citation`.

data/rbi/openai/resources/beta/agents/environments/files.rbi

@@ -10,6 +10,37 @@ module OpenAI
         class Environments
 
           class Files
+            # Beta file helpers.
+            sig {
+              params(files: T::Hash[String, T.any(String, Pathname)], request_options: OpenAI::RequestOptions::OrHash)
+                .returns(OpenAI::Helpers::Beta::Agents::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(OpenAI::Helpers::Beta::Agents::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(OpenAI::Helpers::Beta::Agents::PreparedFiles)
+            }
+            def upload(environment_id, file:, path:, request_options: {})
+            end
 
             # Copies inline bytes or a Files API file into a connected execution environment.
             # See

data/rbi/openai/resources/beta/agents/sessions/artifacts.rbi

@@ -10,6 +10,14 @@ module OpenAI
         class Sessions
 
           class Artifacts
+            # Beta result-scoped downloads.
+            sig {
+              params(result: OpenAI::Helpers::Beta::Agents::TurnResult).returns(
+                OpenAI::Helpers::Beta::Agents::ResultArtifacts
+              )
+            }
+            def for_result(result)
+            end
 
             # Retrieves immutable metadata for one durable session artifact. See
             # [session artifacts](https://developers.openai.com/api/docs/guides/agents-api/environments/files#openai-hosted-artifacts).

data/rbi/openai/resources/beta/agents/sessions/events.rbi

@@ -11,11 +11,12 @@ module OpenAI
 
           class Events
 
-            # Submits message, cancellation, or tool-result events to a managed agent session.
-            # Cancellation can recover a still-open turn whose backend execution has ended by
-            # marking it cancelled and abandoning unpublished outputs. Saved results,
-            # published files, and existing terminal outcomes are preserved. HTTP 202 confirms
-            # acceptance, not durable completion. See
+            # Submits message, cancellation, tool-result, or computer-use approval-response
+            # events to a managed agent session. Cancellation can recover a still-open turn
+            # whose backend execution has ended by marking it cancelled and abandoning
+            # unpublished outputs. Saved results, published files, and existing terminal
+            # outcomes are preserved. HTTP 202 confirms acceptance, not durable completion.
+            # See
             # [session events](https://developers.openai.com/api/docs/guides/agents-api/sessions/events).
             sig {
               params(

data/rbi/openai/resources/beta/agents/sessions/traces.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+
+    class Beta
+
+      class Agents
+
+        class Sessions
+
+          class Traces
+
+            # Lists published root-turn traces as OTLP JSON, ordered by turn creation time and
+            # ID. Unpublished traces are skipped. Each page returns data available when read;
+            # it does not wait for late traces. Trace reads and the JSON response are limited
+            # to 16 MiB per request. If the limit is exceeded, request fewer traces.
+            sig {
+              params(
+                session_id: String,
+                after: String,
+                limit: Integer,
+                order: OpenAI::Beta::Agents::Sessions::TraceListParams::Order::OrSymbol,
+                request_options: OpenAI::RequestOptions::OrHash
+              )
+                .returns(OpenAI::Internal::CursorPage[OpenAI::Beta::Agents::Sessions::SessionTrace])
+            }
+            def list(
+              # The ID of the session.
+              session_id,
+              # Return resources after this resource ID in the selected order.
+              after: nil,
+              # The maximum number of resources to return, between 1 and 100. Defaults to 20.
+              limit: nil,
+              # The order in which resources are returned. Defaults to `desc`.
+              order: 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
+end

data/rbi/openai/resources/beta/agents/sessions.rbi

@@ -21,6 +21,9 @@ module OpenAI
           sig { returns(OpenAI::Resources::Beta::Agents::Sessions::Events) }
           attr_reader :events
 
+          sig { returns(OpenAI::Resources::Beta::Agents::Sessions::Traces) }
+          attr_reader :traces
+
           sig { returns(OpenAI::Resources::Beta::Agents::Sessions::Turns) }
           attr_reader :turns
 
@@ -88,13 +91,14 @@ module OpenAI
               ),
               agent: OpenAI::Beta::Agents::SessionCreateParams::Agent::OrHash,
               agent_id: String,
+              output_type: T.nilable(T.class_of(OpenAI::Helpers::StructuredOutput::BaseModel)),
               input: T.nilable(OpenAI::Beta::Agents::SessionCreateParams::Input::Variants),
               metadata: T.nilable(T::Hash[Symbol, String]),
               vault_ids: T.nilable(T::Array[String]),
               stream: T.noreturn,
               request_options: OpenAI::RequestOptions::OrHash
             )
-              .returns(OpenAI::Internal::Stream[OpenAI::Beta::AgentSessionEvent::Variants])
+              .returns(OpenAI::Helpers::Beta::Agents::CreationStream)
           }
           def create_streaming(
             # An inline execution environment or a reference to an environment template.
@@ -105,6 +109,7 @@ module OpenAI
             # The ID of a saved reusable agent. Omit `agent` to use its configuration
             # unchanged.
             agent_id: nil,
+            output_type: nil,
             # Initial input to submit when the session is created. A string is shorthand for a
             # single user message. Required when `environment.type` is `none`, or when
             # `stream` is `true` for an environment that is not `self_hosted`; optional for

data/rbi/openai/resources/realtime/translations/client_secrets.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+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`.
+          sig {
+            params(
+              session: OpenAI::Realtime::RealtimeTranslationSessionCreateRequest::OrHash,
+              expires_after: OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::OrHash,
+              request_options: OpenAI::RequestOptions::OrHash
+            )
+              .returns(OpenAI::Realtime::RealtimeTranslationClientSecretCreateResponse)
+          }
+          def create(
+            # Realtime translation session configuration. Translation sessions stream source
+            # audio in and translated audio plus transcript deltas out continuously.
+            session:,
+            # 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.
+            expires_after: 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/realtime/translations.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+
+    class Realtime
+
+      class Translations
+
+        sig { returns(OpenAI::Resources::Realtime::Translations::ClientSecrets) }
+        attr_reader :client_secrets
+
+        # @api private
+        sig { params(client: OpenAI::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/resources/realtime.rbi

@@ -11,6 +11,9 @@ module OpenAI
       sig { returns(OpenAI::Resources::Realtime::Calls) }
       attr_reader :calls
 
+      sig { returns(OpenAI::Resources::Realtime::Translations) }
+      attr_reader :translations
+
       # @api private
       sig { params(client: OpenAI::Client).returns(T.attached_class) }
       def self.new(client:)

data/sig/openai/helpers/agents.rbs

@@ -16,6 +16,12 @@ module OpenAI
           | -> Enumerator[OpenAI::Models::Beta::agent_session_event, self]
         def close: -> void
         def until_done: -> self
+
+        # @beta
+        def get_final_result: -> OpenAI::Helpers::Beta::Agents::TurnResult
+
+        # @beta
+        def with_result_collection: -> self
       end
     end
   end
@@ -30,6 +36,7 @@ module OpenAI
             | Hash[Symbol, untyped]],
             ?tool_handlers: Hash[String, OpenAI::Helpers::Agents::tool_handler],
             ?idempotency_key: String?,
+            ?output_type: singleton(OpenAI::Helpers::StructuredOutput::BaseModel)?,
             ?request_options: OpenAI::RequestOptions
             | Hash[Symbol, untyped]
             | nil

data/sig/openai/helpers/beta/agents/artifacts.rbs

@@ -0,0 +1,20 @@
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        class ResultArtifacts
+          def initialize: (
+            artifacts: OpenAI::Resources::Beta::Agents::Sessions::Artifacts,
+            client: OpenAI::Client,
+            result: TurnResult
+          ) -> void
+          def download: (
+            path: String,
+            to: untyped,
+            ?request_options: OpenAI::request_opts
+          ) -> OpenAI::Models::Beta::Agents::Sessions::SessionArtifact
+        end
+      end
+    end
+  end
+end

data/sig/openai/helpers/beta/agents/files.rbs

@@ -0,0 +1,41 @@
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        class PreparedFiles
+          attr_reader files: Array[OpenAI::Models::Beta::HostedEnvironmentFileParam::FileID]
+          attr_reader upload_ids: Array[String]
+          def initialize: (Array[Hash[Symbol, untyped]] files) -> void
+        end
+        class FilePreparationError < OpenAI::Errors::Error
+          attr_reader prepared: PreparedFiles
+          def initialize: (prepared: PreparedFiles) -> void
+        end
+
+        # @api private
+        class FilePreparation
+          def initialize: (
+            client: OpenAI::Client,
+            environment_files: OpenAI::Resources::Beta::Agents::Environments::Files
+          ) -> void
+          def prepare: (
+            Hash[String, String | Pathname] files,
+            ?request_options: OpenAI::request_opts
+          ) -> PreparedFiles
+          def prepare_directory: (
+            String | Pathname directory,
+            destination: String,
+            include: Array[String],
+            ?request_options: OpenAI::request_opts
+          ) -> PreparedFiles
+          def upload: (
+            String environment_id,
+            file: String | Pathname,
+            path: String,
+            ?request_options: OpenAI::request_opts
+          ) -> PreparedFiles
+        end
+      end
+    end
+  end
+end

data/sig/openai/helpers/beta/agents/function_tool.rbs

@@ -0,0 +1,24 @@
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        class FunctionTool
+          attr_reader name: String
+
+          def initialize: (
+            name: String,
+            arguments: Class,
+            ?description: String
+          ) {
+            (untyped) -> OpenAI::Helpers::Agents::tool_output
+          } -> void
+          def definition: -> Hash[Symbol, untyped]
+          def handlers: -> Hash[String, OpenAI::Helpers::Agents::tool_handler]
+          def call: (
+            String | Hash[String | Symbol, untyped]
+          ) -> OpenAI::Helpers::Agents::tool_output
+        end
+      end
+    end
+  end
+end

data/sig/openai/helpers/beta/agents/model_adapter.rbs

@@ -0,0 +1,16 @@
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        module ModelAdapter
+          def self.validate!: (untyped model, parameter: String) -> void
+          def self.coerce: (
+            singleton(OpenAI::BaseModel) model,
+            untyped value,
+            ?memoize: bool
+          ) -> OpenAI::BaseModel?
+        end
+      end
+    end
+  end
+end

data/sig/openai/helpers/beta/agents.rbs

@@ -0,0 +1,71 @@
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        class TurnResult
+          attr_reader turn: OpenAI::Models::Beta::Agents::Sessions::Turn
+          attr_reader messages: Array[OpenAI::Models::Beta::AgentSessionMessage]
+          def session_id: -> String
+          def turn_id: -> String
+          def output_text: -> String
+          def output_parsed: -> untyped
+          def parse: (
+            output_type: singleton(OpenAI::Helpers::StructuredOutput::BaseModel)
+          ) -> ParsedTurnResult
+        end
+
+        class ResultError < OpenAI::Errors::Error
+          attr_reader reason: Symbol
+          attr_reader session_id: String?
+          attr_reader turn: OpenAI::Models::Beta::Agents::Sessions::Turn?
+          attr_reader messages: Array[OpenAI::Models::Beta::AgentSessionMessage]
+          attr_reader required_actions: Array[OpenAI::Models::Beta::AgentSession::required_action
+          | Hash[Symbol, untyped]]
+          def turn_id: -> String?
+        end
+
+        # @api private
+        class ResultCollector
+          def initialize: (
+            ?session_id: String?,
+            ?handler_names: Array[String]
+          ) -> void
+          def enable: -> void
+          def observe: (
+            OpenAI::Models::Beta::agent_session_event
+            | Hash[Symbol, untyped] event
+          ) -> void
+          def stopped?: -> bool?
+          def observe_error: (StandardError error) -> void
+          def result: -> TurnResult
+        end
+
+        class ParsedTurnResult < TurnResult
+          attr_reader raw_result: TurnResult
+          attr_reader output_parsed: untyped
+        end
+
+        class OutputParseError < OpenAI::Errors::Error
+          attr_reader raw_result: TurnResult
+        end
+
+        # @api private
+        class OutputParser
+          def initialize: (
+            singleton(OpenAI::Helpers::StructuredOutput::BaseModel) model
+          ) -> void
+          def prepare_request: (Hash[Symbol, untyped] params) -> void
+          def parse: (TurnResult result) -> ParsedTurnResult
+        end
+
+        class CreationStream < OpenAI::Internal::Stream[OpenAI::Models::Beta::agent_session_event]
+          def get_final_result: -> TurnResult
+          def with_result_collection: -> self
+
+          # @api private
+          def configure_output_parser: (OutputParser? parser) -> self
+        end
+      end
+    end
+  end
+end

data/sig/openai/helpers/structured_output.rbs

@@ -0,0 +1,12 @@
+module OpenAI
+  module Helpers
+    module StructuredOutput
+      class BaseModel < OpenAI::Internal::Type::BaseModel
+        def self.optional: -> bot
+        def self.to_json_schema: -> Hash[Symbol, untyped]
+      end
+    end
+  end
+
+  class BaseModel = OpenAI::Helpers::StructuredOutput::BaseModel
+end

data/sig/openai/internal/transport/base_client.rbs

@@ -162,6 +162,14 @@ module OpenAI
           OpenAI::Internal::Transport::BaseClient::request_components req
         ) -> top
 
+        # @api private
+        def request_streaming_body: (
+          request_components req,
+          ?(^-> untyped)? on_response
+        ) {
+          (String chunk) -> untyped
+        } -> void
+
         private def perform_request: (
           OpenAI::Internal::Transport::BaseClient::request_components req
         ) ?{

data/sig/openai/internal/type/base_model.rbs

@@ -13,7 +13,9 @@ module OpenAI
         def self.known_fields: -> ::Hash[Symbol, (OpenAI::Internal::Type::BaseModel::known_field
         & { type_fn: (^-> OpenAI::Internal::Type::Converter::input) })]
 
-        def self.fields: -> ::Hash[Symbol, (OpenAI::Internal::Type::BaseModel::known_field
+        def self.fields: (
+          ?state: OpenAI::Internal::Type::Converter::coerce_state?
+        ) -> ::Hash[Symbol, (OpenAI::Internal::Type::BaseModel::known_field
         & { type: OpenAI::Internal::Type::Converter::input })]
 
         private def self.add_field: (

data/sig/openai/internal/type/converter.rbs

@@ -13,7 +13,8 @@ module OpenAI
             strictness: bool,
             exactness: { yes: Integer, no: Integer, maybe: Integer },
             error: StandardError?,
-            branched: Integer
+            branched: Integer,
+            memo: Hash[untyped, untyped]?
           }
 
         type dump_state = { can_retry: bool }
@@ -59,7 +60,8 @@ module OpenAI
 
         def self.new_coerce_state: (
           ?translate_names: bool,
-          ?request_only: bool
+          ?request_only: bool,
+          ?memoize: bool
         ) -> OpenAI::Internal::Type::Converter::coerce_state
 
         def self.coerce: (
@@ -68,6 +70,18 @@ module OpenAI
           ?state: OpenAI::Internal::Type::Converter::coerce_state
         ) -> top
 
+        # @api private
+        def self.resolve_type: (
+          ^-> untyped type_fn,
+          ?state: coerce_state?
+        ) -> untyped
+
+        def self.coerce_cached: (
+          OpenAI::Internal::Type::Converter target,
+          Hash[untyped, untyped] | Array[untyped] value,
+          state: OpenAI::Internal::Type::Converter::coerce_state
+        ) -> untyped
+
         def self.coerce_with_error: (
           OpenAI::Internal::Type::Converter::input target,
           top value,

data/sig/openai/internal/type/union.rbs

@@ -24,7 +24,8 @@ module OpenAI
         ) -> void
 
         private def self.resolve_variant: (
-          top value
+          top value,
+          ?state: OpenAI::Internal::Type::Converter::coerce_state?
         ) -> OpenAI::Internal::Type::Converter::input?
 
         def ===: (top other) -> bool

data/sig/openai/models/beta/agents/sessions/session_trace.rbs

@@ -0,0 +1,65 @@
+module OpenAI
+  module Models
+    module Beta
+      module Agents
+        class SessionTrace = Sessions::SessionTrace
+
+        module Sessions
+          type session_trace =
+            {
+              id: String,
+              created_at: Integer,
+              ?object: :"agent.session.trace",
+              otlp: ::Hash[Symbol, top],
+              session_id: String
+            }
+
+          class SessionTrace < OpenAI::Internal::Type::BaseModel
+            # The root turn ID. Use this ID as the pagination anchor.
+            attr_accessor id: String
+
+            # The Unix timestamp in seconds when the root turn was created.
+            attr_accessor created_at: Integer
+
+            # The object type, which is always `agent.session.trace`.
+            attr_accessor object: :"agent.session.trace"
+
+            # An OTLP JSON ExportTraceServiceRequest containing resourceSpans. Only currently
+            # published data is returned; later trace updates are not awaited.
+            attr_accessor otlp: ::Hash[Symbol, top]
+
+            # The session that owns this trace.
+            attr_accessor session_id: String
+
+            # @param id
+            #   The root turn ID. Use this ID as the pagination anchor.
+            # @param created_at
+            #   The Unix timestamp in seconds when the root turn was created.
+            # @param otlp
+            #   An OTLP JSON ExportTraceServiceRequest containing resourceSpans. Only currently
+            #   published data is returned; later trace updates are not awaited.
+            # @param session_id
+            #   The session that owns this trace.
+            # @param object
+            #   The object type, which is always `agent.session.trace`.
+            def initialize: (
+              id: String,
+              created_at: Integer,
+              otlp: ::Hash[Symbol, top],
+              session_id: String,
+              ?object: :"agent.session.trace"
+            ) -> void
+
+            def to_hash: -> {
+              id: String,
+              created_at: Integer,
+              ?object: :"agent.session.trace",
+              otlp: ::Hash[Symbol, top],
+              session_id: String
+            }
+          end
+        end
+      end
+    end
+  end
+end