ruby_llm-responses_api 0.6.1 → 1.0.0

data/lib/ruby_llm/providers/openai_responses/stream_accumulator_extension.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class OpenAIResponses
-      # Extends RubyLLM::StreamAccumulator to carry built_in_tool_events from
-      # chunks through to the final assembled Message. Without this the
-      # accumulator drops everything off the Chunk it does not know about.
-      module StreamAccumulatorExtension
-        def add(chunk)
-          super
-          events = chunk_built_in_events(chunk)
-          return if events.nil? || events.empty?
-
-          @built_in_tool_events ||= []
-          @built_in_tool_events.concat(events)
-        end
-
-        def to_message(response)
-          message = super
-          if @built_in_tool_events && !@built_in_tool_events.empty? && message.respond_to?(:built_in_tool_events=)
-            message.built_in_tool_events = @built_in_tool_events
-          end
-          message
-        end
-
-        private
-
-        def chunk_built_in_events(chunk)
-          return nil unless chunk.respond_to?(:built_in_tool_events)
-
-          chunk.built_in_tool_events
-        end
-      end
-    end
-  end
-end
-
-RubyLLM::StreamAccumulator.prepend(RubyLLM::Providers::OpenAIResponses::StreamAccumulatorExtension)

data/lib/ruby_llm/providers/openai_responses/streaming.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class OpenAIResponses
-      # Streaming methods for the OpenAI Responses API.
-      # Handles SSE events with typed event format.
-      module Streaming
-        module_function
-
-        def stream_url
-          'responses'
-        end
-
-        def build_chunk(data) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          event_type = data['type']
-
-          case event_type
-          when 'response.output_text.delta'
-            # Text content delta
-            Chunk.new(
-              role: :assistant,
-              content: data['delta'],
-              model_id: data.dig('response', 'model')
-            )
-
-          when 'response.function_call_arguments.delta'
-            # Function call arguments streaming
-            Chunk.new(
-              role: :assistant,
-              content: nil,
-              tool_calls: build_streaming_tool_call(data),
-              model_id: data.dig('response', 'model')
-            )
-
-          when 'response.completed'
-            # Final response with usage stats and any server-side built-in
-            # tool activity (web_search_call, code_interpreter_call, etc.) that
-            # the model executed. StreamAccumulatorExtension forwards
-            # built_in_tool_events onto the assembled Message.
-            response_data = data['response'] || {}
-            usage = response_data['usage'] || {}
-            cached_tokens = usage.dig('input_tokens_details', 'cached_tokens')
-            built_in_events = BuiltInTools.extract_events(response_data['output'] || [])
-
-            Chunk.new(
-              role: :assistant,
-              content: nil,
-              input_tokens: usage['input_tokens'],
-              output_tokens: usage['output_tokens'],
-              cached_tokens: cached_tokens,
-              cache_creation_tokens: 0,
-              model_id: response_data['model'],
-              response_id: response_data['id'],
-              built_in_tool_events: built_in_events.empty? ? nil : built_in_events
-            )
-
-          when 'response.output_item.added'
-            # New output item started (function call, message, etc.)
-            item = data['item'] || {}
-            if item['type'] == 'function_call'
-              stream_key = item['id'] || item['call_id']
-              Chunk.new(
-                role: :assistant,
-                content: nil,
-                tool_calls: {
-                  stream_key => ToolCall.new(
-                    id: item['call_id'],
-                    name: item['name'],
-                    arguments: ''
-                  )
-                }
-              )
-            else
-              # Other item types - return empty chunk
-              Chunk.new(role: :assistant, content: nil)
-            end
-
-          when 'response.content_part.added', 'response.content_part.done',
-               'response.output_item.done', 'response.output_text.done',
-               'response.function_call_arguments.done', 'response.created',
-               'response.in_progress'
-            # Status events - return empty chunk
-            Chunk.new(role: :assistant, content: nil)
-
-          when 'error'
-            # Error event
-            error_data = data['error'] || {}
-            raise RubyLLM::Error.new(nil, error_data['message'] || 'Unknown streaming error')
-
-          else
-            # Unknown event type - return empty chunk
-            Chunk.new(role: :assistant, content: nil)
-          end
-        end
-
-        def build_streaming_tool_call(data)
-          call_id = data['call_id'] || data['item_id']
-          return nil unless call_id
-
-          stream_key = data['item_id']
-          stream_key ||= data['call_id'] if data['call_id']&.start_with?('call_')
-
-          # Argument delta events usually carry an item_id, while the final
-          # function call id lives on output_item.added. When only an unmapped
-          # id is available, use nil so RubyLLM 1.16 appends to the latest call.
-          {
-            stream_key => ToolCall.new(
-              id: data['name'] ? call_id : nil,
-              name: data['name'],
-              arguments: data['delta'] || ''
-            )
-          }
-        end
-
-        def parse_streaming_error(data)
-          error_data = JSON.parse(data)
-          return unless error_data['error'] || error_data['type'] == 'error'
-
-          error = error_data['error'] || error_data
-          error_type = error['type'] || error['code']
-          error_message = error['message']
-
-          case error_type
-          when 'server_error', 'internal_error'
-            [500, error_message]
-          when 'rate_limit_exceeded', 'insufficient_quota'
-            [429, error_message]
-          when 'invalid_request_error', 'invalid_api_key'
-            [400, error_message]
-          else
-            [400, error_message]
-          end
-        rescue JSON::ParserError
-          [500, data]
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/openai_responses/tools.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class OpenAIResponses
-      # Tools/function calling methods for the OpenAI Responses API.
-      # Handles both custom function tools and built-in tools.
-      module Tools
-        module_function
-
-        EMPTY_PARAMETERS_SCHEMA = {
-          'type' => 'object',
-          'properties' => {},
-          'required' => [],
-          'additionalProperties' => false
-        }.freeze
-
-        # Built-in tool type constants
-        BUILT_IN_TOOLS = {
-          web_search: { type: 'web_search' },
-          web_search_preview: { type: 'web_search_preview' },
-          file_search: ->(vector_store_ids) { { type: 'file_search', vector_store_ids: vector_store_ids } },
-          code_interpreter: { type: 'code_interpreter', container: { type: 'auto' } },
-          image_generation: { type: 'image_generation' },
-          computer_use: ->(opts) { { type: 'computer_use_preview', **opts } },
-          shell: { type: 'shell', environment: { type: 'container_auto' } },
-          apply_patch: { type: 'apply_patch' }
-        }.freeze
-
-        def tool_for(tool)
-          # Check if it's a built-in tool specification
-          return tool if tool.is_a?(Hash) && tool[:type]
-
-          # Handle symbol references to built-in tools
-          if tool.is_a?(Symbol) && BUILT_IN_TOOLS.key?(tool)
-            built_in = BUILT_IN_TOOLS[tool]
-            return built_in.is_a?(Proc) ? built_in.call([]) : built_in
-          end
-
-          # Standard function tool
-          parameters_schema = parameters_schema_for(tool)
-
-          definition = {
-            type: 'function',
-            name: tool.name,
-            description: tool.description,
-            parameters: parameters_schema
-          }
-
-          # Add strict mode if schema supports it
-          definition[:strict] = true if parameters_schema['additionalProperties'] == false
-
-          return definition if tool.respond_to?(:provider_params) && tool.provider_params.empty?
-
-          if tool.respond_to?(:provider_params) && tool.provider_params.any?
-            RubyLLM::Utils.deep_merge(definition, tool.provider_params)
-          else
-            definition
-          end
-        end
-
-        def parameters_schema_for(tool)
-          if tool.respond_to?(:params_schema) && tool.params_schema
-            tool.params_schema
-          elsif tool.respond_to?(:parameters)
-            schema_from_parameters(tool.parameters)
-          else
-            EMPTY_PARAMETERS_SCHEMA
-          end
-        end
-
-        def schema_from_parameters(parameters)
-          return EMPTY_PARAMETERS_SCHEMA if parameters.nil? || parameters.empty?
-
-          if defined?(RubyLLM::Tool::SchemaDefinition)
-            schema_definition = RubyLLM::Tool::SchemaDefinition.from_parameters(parameters)
-            schema_definition&.json_schema || EMPTY_PARAMETERS_SCHEMA
-          else
-            # Fallback for older RubyLLM versions
-            build_schema_from_parameters(parameters)
-          end
-        end
-
-        def build_schema_from_parameters(parameters)
-          properties = {}
-          required = []
-
-          parameters.each do |name, param|
-            properties[name.to_s] = {
-              type: param.type || 'string',
-              description: param.description
-            }.compact
-
-            required << name.to_s if param.required
-          end
-
-          {
-            'type' => 'object',
-            'properties' => properties,
-            'required' => required,
-            'additionalProperties' => false
-          }
-        end
-
-        def format_tool_calls(tool_calls)
-          return nil unless tool_calls&.any?
-
-          tool_calls.map do |_, tc|
-            {
-              type: 'function_call',
-              call_id: tc.id,
-              name: tc.name,
-              arguments: tc.arguments.is_a?(String) ? tc.arguments : JSON.generate(tc.arguments)
-            }
-          end
-        end
-
-        def parse_tool_calls(tool_calls, parse_arguments: true)
-          return nil unless tool_calls&.any?
-
-          tool_calls.to_h do |tc|
-            call_id = tc['call_id'] || tc['id']
-            [
-              call_id,
-              ToolCall.new(
-                id: call_id,
-                name: tc['name'],
-                arguments: if parse_arguments
-                             parse_tool_call_arguments(tc)
-                           else
-                             tc['arguments']
-                           end
-              )
-            ]
-          end
-        end
-
-        def parse_tool_call_arguments(tool_call)
-          arguments = tool_call['arguments']
-
-          if arguments.nil? || arguments.empty?
-            {}
-          elsif arguments.is_a?(Hash)
-            arguments
-          else
-            JSON.parse(arguments)
-          end
-        rescue JSON::ParserError
-          { raw: arguments }
-        end
-
-        # Helper to create built-in tool configurations
-        def web_search_tool(search_context_size: nil, user_location: nil, preview: false)
-          tool = { type: preview ? 'web_search_preview' : 'web_search' }
-          tool[:search_context_size] = search_context_size if search_context_size
-          tool[:user_location] = user_location if user_location
-          tool
-        end
-
-        def web_search_preview_tool(search_context_size: nil, user_location: nil)
-          tool = { type: 'web_search_preview' }
-          tool[:search_context_size] = search_context_size if search_context_size
-          tool[:user_location] = user_location if user_location
-          tool
-        end
-
-        def file_search_tool(vector_store_ids:, max_num_results: nil, ranking_options: nil)
-          tool = {
-            type: 'file_search',
-            vector_store_ids: Array(vector_store_ids)
-          }
-          tool[:max_num_results] = max_num_results if max_num_results
-          tool[:ranking_options] = ranking_options if ranking_options
-          tool
-        end
-
-        def code_interpreter_tool(container_type: 'auto')
-          {
-            type: 'code_interpreter',
-            container: { type: container_type }
-          }
-        end
-
-        def image_generation_tool(partial_images: nil)
-          tool = { type: 'image_generation' }
-          tool[:partial_images] = partial_images if partial_images
-          tool
-        end
-
-        def mcp_tool(server_label:, server_url:, require_approval: 'never', allowed_tools: nil, headers: nil)
-          tool = {
-            type: 'mcp',
-            server_label: server_label,
-            server_url: server_url,
-            require_approval: require_approval
-          }
-          tool[:allowed_tools] = allowed_tools if allowed_tools
-          tool[:headers] = headers if headers
-          tool
-        end
-
-        def shell_tool(environment_type: 'container_auto', container_id: nil,
-                       network_policy: nil, memory_limit: nil)
-          env = if container_id
-                  { type: 'container_reference', container_id: container_id }
-                else
-                  { type: environment_type }
-                end
-
-          env[:network_policy] = network_policy if network_policy
-          env[:memory_limit] = memory_limit if memory_limit
-
-          { type: 'shell', environment: env }
-        end
-
-        def apply_patch_tool
-          { type: 'apply_patch' }
-        end
-      end
-    end
-  end
-end