openai 0.113.0 → 0.115.0

data/lib/openai/helpers/responses_websocket/connection.rb

@@ -48,11 +48,20 @@ module OpenAI
       #
       # @return [nil]
       def send_event(event)
+        send_client_event(event)
+      end
+
+      # @api private
+      def send_response_create(event)
+        send_client_event(event, response_create: true)
+      end
+
+      private def send_client_event(event, response_create: false)
         assert_owner!
         raise connection_error("Cannot send on a closed Responses WebSocket.") if poisoned? || closed?
 
         encoded = begin
-          generate_json(encode_client_event(event))
+          generate_json(encode_client_event(event, response_create: response_create))
         rescue SystemStackError
           raise OpenAI::Errors::ResponsesClientEventError.new, cause: nil
         end
@@ -162,9 +171,12 @@ module OpenAI
       end
 
       # @api private
-      def encode_client_event(event)
-        validate_event_tree!(event)
-        payload = if event.is_a?(Hash)
+      def encode_client_event(event, response_create: false)
+        create_type = OpenAI::Responses::ResponsesClientEvent::ResponseCreate if response_create
+        validate_event_tree!(event, target: create_type)
+        payload = if response_create
+          OpenAI::Internal::Type::Converter.dump(create_type, event)
+        elsif event.is_a?(Hash)
           OpenAI::Internal::Type::Unknown.dump(event, state: {can_retry: true})
         else
           OpenAI::Internal::Type::Converter.dump(OpenAI::Responses::ResponsesClientEvent, event)
@@ -172,7 +184,7 @@ module OpenAI
 
         raise OpenAI::Errors::ResponsesClientEventError.new unless payload.is_a?(Hash)
 
-        normalize_event_keys(payload)
+        OpenAI::Helpers::StructuredOutput.prepare_configuration_updates!(normalize_event_keys(payload))
       rescue OpenAI::Errors::ResponsesClientEventError
         raise
       rescue StandardError
@@ -216,42 +228,68 @@ module OpenAI
         raise connection_error("Responses WebSocket connections are single-owner.")
       end
 
-      private def validate_event_tree!(value)
+      private def validate_event_tree!(value, target: nil)
         active = {}.compare_by_identity
-        pending = [[value, false]]
+        pending = [[value, false, target]]
         until pending.empty?
-          value, exiting = pending.pop
+          value, exiting, target = pending.pop
           if exiting
             active.delete(value)
             next
           end
 
+          # Use the serializer's selected type, so unknown extension hashes keep their
+          # wire keys even when they resemble Ruby aliases in another model.
+          while target.is_a?(OpenAI::Internal::Type::Union)
+            target = target.variant_for_dump(value)
+          end
+
           children = case value
           when OpenAI::Internal::Type::BaseModel
             data = value.to_h
             reject_duplicate_serialized_model_keys!(value.class, data)
-            [data]
+            unless target.is_a?(Class) && target <= OpenAI::Internal::Type::BaseModel
+              target = value.class
+            end
+
+            [[data, target]]
           when Hash
             reject_duplicate_semantic_keys!(value)
-            value.values
+            if target.is_a?(Class) && target <= OpenAI::Internal::Type::BaseModel
+              reject_duplicate_serialized_model_keys!(target, value, skip_coerce: true)
+              value.map do |key, child|
+                name = key.is_a?(String) ? key.to_sym : key
+                field = target.known_fields[name]
+                field = nil if field && field.fetch(:mode) == :coerce
+                [child, field && field.fetch(:type_fn).call]
+              end
+            elsif target.is_a?(OpenAI::Internal::Type::HashOf)
+              item_type = target.item_type
+              value.values.map { [_1, item_type] }
+            else
+              value.values.map { [_1, nil] }
+            end
+
           when Array
-            value
+            item_type = target.is_a?(OpenAI::Internal::Type::ArrayOf) ? target.item_type : nil
+            value.map { [_1, item_type] }
           else
             next
           end
 
           guard_cycle!(value, active)
-          pending << [value, true]
-          children.reverse_each { |child| pending << [child, false] }
+          pending << [value, true, nil]
+          children.reverse_each { |child, child_type| pending << [child, false, child_type] }
         end
 
         nil
       end
 
-      private def reject_duplicate_serialized_model_keys!(model, data)
-        serialized_keys = data.keys.map do |key|
+      private def reject_duplicate_serialized_model_keys!(model, data, skip_coerce: false)
+        serialized_keys = data.keys.filter_map do |key|
           name = key.is_a?(String) ? key.to_sym : key
           field = model.known_fields[name]
+          next if skip_coerce && field && field.fetch(:mode) == :coerce
           field ? field.fetch(:api_name) : name
         end
 

data/lib/openai/helpers/responses_websocket/connection_manager.rb

@@ -18,6 +18,7 @@ module OpenAI
         end
 
         super(
+          client: client,
           transport: transport,
           transport_options: transport_options,
           default_transport: -> { OpenAI::Responses::Transports::AsyncWebSocket.new },

data/lib/openai/helpers/responses_websocket/connection_resources.rb

@@ -14,7 +14,7 @@ module OpenAI
         # @return [nil]
         def create(**params)
           event_params = params.reject { |key, _value| key == :type || key == "type" }
-          @connection.send_event(**event_params, type: :"response.create")
+          @connection.send_response_create(**event_params, type: :"response.create")
         end
       end
     end

data/lib/openai/helpers/structured_output/response_parser.rb

@@ -136,6 +136,7 @@ module OpenAI
           else
           end
 
+          model = parsed.text_model if parsed.is_a?(RequestWithFormatUpdate)
           [model, tool_models]
         end
 

data/lib/openai/helpers/structured_output.rb

@@ -11,6 +11,64 @@ module OpenAI
     #
     # Supported types: {NilClass} {String} {Symbol} {Integer} {Float} {OpenAI::Boolean}, {OpenAI::EnumOf}, {OpenAI::UnionOf}, {OpenAI::ArrayOf}, {OpenAI::BaseModel}
     module StructuredOutput
+      # Carries a visible format update's local parser without adding a wire field.
+      # A nil model means the update explicitly cleared typed parsing.
+      # @api private
+      module RequestWithFormatUpdate
+        attr_accessor :text_model
+      end
+
+      private_constant :RequestWithFormatUpdate
+
+      # Convert schemas in input items after the SDK has copied the request or event.
+      #
+      # @api private
+      def self.prepare_configuration_updates!(request)
+        input = request[:input] || request["input"]
+        items = request[:items] || request["items"]
+        if input.is_a?(Array)
+          input.each do |item|
+            prepare_configuration_update!(item) do |model|
+              request.extend(RequestWithFormatUpdate) unless request.is_a?(RequestWithFormatUpdate)
+              request.text_model = model
+            end
+          end
+        end
+
+        items.each { |item| prepare_configuration_update!(item) } if items.is_a?(Array)
+        prepare_configuration_update!(request[:item] || request["item"])
+        request
+      end
+
+      def self.prepare_configuration_update!(item)
+        return unless item.is_a?(Hash)
+        type = item[:type] || item["type"]
+        return unless type == :configuration_update || type == "configuration_update"
+
+        text = item[:text] || item["text"]
+        return unless text.is_a?(Hash)
+        unless text.key?(:format) || text.key?("format")
+          key = text.key?(:format_) ? :format_ : "format_"
+          text[:format] = text.delete(key) if text.key?(key)
+        end
+
+        format = text[:format] || text["format"]
+        return unless format.is_a?(Hash)
+        type = format[:type] || format["type"]
+        model = nil
+        if type == :json_schema || type == "json_schema"
+          key = format.key?(:schema) ? :schema : "schema"
+          schema = format[key]
+          if schema.is_a?(JsonSchemaConverter)
+            model = schema
+            format[key] = JsonSchemaConverter.to_json_schema(schema)
+          end
+        end
+
+        yield model if block_given?
+      end
+
+      private_class_method :prepare_configuration_update!
     end
   end
 end

data/lib/openai/helpers/websocket/connection_manager.rb

@@ -20,6 +20,7 @@ module OpenAI
 
       # @api private
       def initialize(
+        client:,
         transport:,
         transport_options:,
         default_transport:,
@@ -32,6 +33,7 @@ module OpenAI
         reserved_options_error_message: nil,
         connection_options: {}
       )
+        @client = client
         @transport = transport
         @default_transport = default_transport
         @connection_class = connection_class
@@ -52,6 +54,15 @@ module OpenAI
         transport = @transport || @default_transport.call
         raise ArgumentError, @transport_error_message unless transport.respond_to?(:open)
 
+        requester = @client.requester
+        unless @transport || (requester.instance_of?(OpenAI::NetHTTPClient) && requester.default_configuration?)
+          raise(
+            ArgumentError,
+            "This HTTP transport's connection policy cannot be used by the default WebSocket " \
+              "transport. Pass a compatible WebSocket transport with its own connection settings."
+          )
+        end
+
         @request.call do |request, mark_handshake_completed|
           block_error = nil
           transport

data/lib/openai/helpers/websocket/resource.rb

@@ -21,6 +21,7 @@ module OpenAI
         error_factory = -> (url:, **options) { BindingConnectionError.new(url: url, **options) }
         ConnectionManager
           .new(
+            client: @client,
             transport: transport,
             transport_options: transport_options,
             default_transport: lambda do

data/lib/openai/helpers/websocket/typed_connection.rb

@@ -38,6 +38,7 @@ module OpenAI
           raise ArgumentError, client_event_error_message
         end
 
+        OpenAI::Helpers::StructuredOutput.prepare_configuration_updates!(payload) if @client_event
         payload = coerce_client_event(payload) if @client_event
         payload = OpenAI::Internal::Type::Converter.dump(@client_event, payload) if @client_event
         validate_event_tree!(payload, json_only: true)

data/lib/openai/internal/type/array_of.rb

@@ -146,7 +146,7 @@ module OpenAI
         # @api private
         #
         # @return [generic<Elem>]
-        protected def item_type = @item_type_fn.call
+        def item_type = @item_type_fn.call
 
         # @api private
         #

data/lib/openai/internal/type/hash_of.rb

@@ -153,7 +153,7 @@ module OpenAI
         # @api private
         #
         # @return [generic<Elem>]
-        protected def item_type = @item_type_fn.call
+        def item_type = @item_type_fn.call
 
         # @api private
         #

data/lib/openai/internal/type/request_parameters.rb

@@ -30,7 +30,8 @@ module OpenAI
             in Hash
               options = OpenAI::Internal::Util.coerce_hash!(dumped[:request_options]).to_h
               request_options = state.fetch(:can_retry) ? options : {**options, max_retries: 0}
-              [dumped.except(:request_options), request_options]
+              body = OpenAI::Helpers::StructuredOutput.prepare_configuration_updates!(dumped.except(:request_options))
+              [body, request_options]
             else
               [dumped, nil]
             end

data/lib/openai/internal/type/union.rb

@@ -216,6 +216,23 @@ module OpenAI
           state[:strictness] = strictness
         end
 
+        # @api private
+        #
+        # @param value [Object]
+        #
+        # @return [OpenAI::Internal::Type::Converter, Class, nil]
+        def variant_for_dump(value)
+          target = resolve_variant(value)
+          return target if target
+
+          known_variants.each do
+            target = _2.call
+            return target if target === value
+          end
+
+          nil
+        end
+
         # @api private
         #
         # @param value [Object]
@@ -226,15 +243,10 @@ module OpenAI
         #
         # @return [Object]
         def dump(value, state:)
-          if (target = resolve_variant(value))
+          if (target = variant_for_dump(value))
             return OpenAI::Internal::Type::Converter.dump(target, value, state: state)
           end
 
-          known_variants.each do
-            target = _2.call
-            return OpenAI::Internal::Type::Converter.dump(target, value, state: state) if target === value
-          end
-
           super
         end
 

data/lib/openai/models/admin/organization/external_key.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Admin
+      module Organization
+        # @see OpenAI::Resources::Admin::Organization::ExternalKeys#create
+        class ExternalKey < OpenAI::Internal::Type::BaseModel
+          # @!attribute id
+          #
+          #   @return [String]
+          required :id, String
+
+          # @!attribute api_project_ids
+          #
+          #   @return [Array<String>]
+          required :api_project_ids, OpenAI::Internal::Type::ArrayOf[String]
+
+          # @!attribute created_at
+          #
+          #   @return [Integer]
+          required :created_at, Integer
+
+          # @!attribute name
+          #
+          #   @return [String]
+          required :name, String
+
+          # @!attribute object
+          #
+          #   @return [String]
+          required :object, String
+
+          # @!attribute type
+          #
+          #   @return [String]
+          required :type, String
+
+          # @!attribute workspace_id
+          #
+          #   @return [String]
+          required :workspace_id, String
+
+          # @!attribute audience
+          #
+          #   @return [String, nil]
+          optional :audience, String
+
+          # @!attribute external_id
+          #
+          #   @return [String, nil]
+          optional :external_id, String
+
+          # @!attribute key_name
+          #
+          #   @return [String, nil]
+          optional :key_name, String
+
+          # @!attribute key_version
+          #
+          #   @return [String, nil]
+          optional :key_version, String
+
+          # @!attribute kms_arn
+          #
+          #   @return [String, nil]
+          optional :kms_arn, String
+
+          # @!attribute kms_key_location
+          #
+          #   @return [String, nil]
+          optional :kms_key_location, String
+
+          # @!attribute kms_key_name
+          #
+          #   @return [String, nil]
+          optional :kms_key_name, String
+
+          # @!attribute kms_key_ring_name
+          #
+          #   @return [String, nil]
+          optional :kms_key_ring_name, String
+
+          # @!attribute kms_key_version
+          #
+          #   @return [String, nil]
+          optional :kms_key_version, String
+
+          # @!attribute kms_project_id
+          #
+          #   @return [String, nil]
+          optional :kms_project_id, String
+
+          # @!attribute purpose
+          #
+          #   @return [Symbol, OpenAI::Models::Admin::Organization::ExternalKey::Purpose, nil]
+          optional :purpose, enum: -> { OpenAI::Admin::Organization::ExternalKey::Purpose }
+
+          # @!attribute role_arn
+          #
+          #   @return [String, nil]
+          optional :role_arn, String
+
+          # @!attribute tenant_id
+          #
+          #   @return [String, nil]
+          optional :tenant_id, String
+
+          # @!attribute vault_uri
+          #
+          #   @return [String, nil]
+          optional :vault_uri, String
+
+          # @!attribute workload_identity_pool_id
+          #
+          #   @return [String, nil]
+          optional :workload_identity_pool_id, String
+
+          # @!attribute workload_identity_project_number
+          #
+          #   @return [String, nil]
+          optional :workload_identity_project_number, String
+
+          # @!attribute workload_identity_provider_id
+          #
+          #   @return [String, nil]
+          optional :workload_identity_provider_id, String
+
+          # @!method initialize(id:, api_project_ids:, created_at:, name:, object:, type:, workspace_id:, audience: nil, external_id: nil, key_name: nil, key_version: nil, kms_arn: nil, kms_key_location: nil, kms_key_name: nil, kms_key_ring_name: nil, kms_key_version: nil, kms_project_id: nil, purpose: nil, role_arn: nil, tenant_id: nil, vault_uri: nil, workload_identity_pool_id: nil, workload_identity_project_number: nil, workload_identity_provider_id: nil)
+          #   @param id [String]
+          #   @param api_project_ids [Array<String>]
+          #   @param created_at [Integer]
+          #   @param name [String]
+          #   @param object [String]
+          #   @param type [String]
+          #   @param workspace_id [String]
+          #   @param audience [String]
+          #   @param external_id [String]
+          #   @param key_name [String]
+          #   @param key_version [String]
+          #   @param kms_arn [String]
+          #   @param kms_key_location [String]
+          #   @param kms_key_name [String]
+          #   @param kms_key_ring_name [String]
+          #   @param kms_key_version [String]
+          #   @param kms_project_id [String]
+          #   @param purpose [Symbol, OpenAI::Models::Admin::Organization::ExternalKey::Purpose]
+          #   @param role_arn [String]
+          #   @param tenant_id [String]
+          #   @param vault_uri [String]
+          #   @param workload_identity_pool_id [String]
+          #   @param workload_identity_project_number [String]
+          #   @param workload_identity_provider_id [String]
+
+          # @see OpenAI::Models::Admin::Organization::ExternalKey#purpose
+          module Purpose
+            extend OpenAI::Internal::Type::Enum
+
+            EKM = :ekm
+            PSP_DECRYPTION = :psp_decryption
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+      end
+    end
+  end
+end