activeagent 0.6.3 → 1.0.0.rc1

data/lib/active_agent/providers/open_ai/responses/requests/inputs/_types.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require_relative "content/_types"
+
+require_relative "base"
+require_relative "tool_call_base"
+require_relative "input_message"
+require_relative "output_message"
+require_relative "user_message"
+require_relative "system_message"
+require_relative "developer_message"
+require_relative "assistant_message"
+require_relative "tool_message"
+require_relative "function_call_output"
+require_relative "item_reference"
+require_relative "reasoning"
+
+# Tool call types
+require_relative "file_search_tool_call"
+require_relative "computer_tool_call"
+require_relative "computer_tool_call_output"
+require_relative "web_search_tool_call"
+require_relative "function_tool_call"
+require_relative "image_gen_tool_call"
+require_relative "code_interpreter_tool_call"
+require_relative "local_shell_tool_call"
+require_relative "local_shell_tool_call_output"
+require_relative "custom_tool_call"
+require_relative "custom_tool_call_output"
+
+# MCP types
+require_relative "mcp_list_tools"
+require_relative "mcp_approval_request"
+require_relative "mcp_approval_response"
+require_relative "mcp_tool_call"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Type for handling items (array of items - full Item types)
+            class ItemsType < ActiveModel::Type::Value
+              def initialize
+                super
+                @item_type = ItemType.new
+              end
+
+              def cast(value)
+                case value
+                when String
+                  # Plain text string becomes array with single user message
+                  [ UserMessage.new(text: value) ]
+                when Array
+                  value.map { |item| @item_type.cast(item) }
+                when Hash
+                  # Single hash becomes array with one item
+                  [ @item_type.cast(value) ]
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot cast #{value.class} to Items (expected String, Array, Hash, or nil)"
+                end
+              end
+
+              def serialize(value)
+                case value
+                when String
+                  value
+                when Array
+                  value.map { |v| @item_type.serialize(v) }
+                when Hash
+                  @item_type.serialize(value)
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot serialize #{value.class}"
+                end
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+            end
+
+            # Type for handling individual items (messages, tool calls, reasoning, etc.)
+            class ItemType < ActiveModel::Type::Value
+              def initialize
+                super
+                @content_type = Content::ContentType.new
+              end
+
+              def cast(value)
+                case value
+                when ::OpenAI::Internal::Type::BaseModel
+                  cast(value.to_h)
+                when Base
+                  value
+                when String
+                  # Plain text string becomes user message
+                  UserMessage.new(text: value)
+                when Hash
+                  hash = value.deep_symbolize_keys
+                  type = hash[:type]&.to_sym
+
+                  case type
+                  # Message types
+                  when :message, nil
+                    cast_message(hash)
+                  # Tool call types
+                  when :file_search_call
+                    FileSearchToolCall.new(**hash)
+                  when :computer_call
+                    ComputerToolCall.new(**hash)
+                  when :computer_call_output
+                    ComputerToolCallOutput.new(**hash)
+                  when :web_search_call
+                    WebSearchToolCall.new(**hash)
+                  when :function_call
+                    FunctionToolCall.new(**hash)
+                  when :function_call_output
+                    FunctionCallOutput.new(**hash)
+                  when :image_generation_call
+                    ImageGenToolCall.new(**hash)
+                  when :code_interpreter_call
+                    CodeInterpreterToolCall.new(**hash)
+                  when :local_shell_call
+                    LocalShellToolCall.new(**hash)
+                  when :local_shell_call_output
+                    LocalShellToolCallOutput.new(**hash)
+                  when :custom_tool_call
+                    CustomToolCall.new(**hash)
+                  when :custom_tool_call_output
+                    CustomToolCallOutput.new(**hash)
+                  # MCP types
+                  when :mcp_list_tools
+                    MCPListTools.new(**hash)
+                  when :mcp_approval_request
+                    MCPApprovalRequest.new(**hash)
+                  when :mcp_approval_response
+                    MCPApprovalResponse.new(**hash)
+                  when :mcp_call
+                    MCPToolCall.new(**hash)
+                  # Other types
+                  when :reasoning
+                    Reasoning.new(**hash)
+                  when :item_reference
+                    ItemReference.new(**hash)
+                  else
+                    raise ArgumentError, "Unknown item type: #{type.inspect}"
+                  end
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot cast #{value.class} to Item (expected Base, Hash, String, or nil)"
+                end
+              end
+
+              def serialize(value)
+                case value
+                when Base
+                  hash = value.serialize
+
+                  if hash[:content] in [ { type: "input_text", text: String } ]
+                    hash[:content] = hash[:content].first[:text]
+                  end
+
+                  hash
+                when Hash
+                  value
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot serialize #{value.class} as Item"
+                end
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+
+              private
+
+              def cast_message(hash)
+                role = hash[:role]&.to_sym
+
+                case role
+                when :system
+                  SystemMessage.new(**hash)
+                when :developer
+                  DeveloperMessage.new(**hash)
+                when :user, nil
+                  UserMessage.new(**hash)
+                when :assistant
+                  AssistantMessage.new(**hash)
+                when :tool
+                  ToolMessage.new(**hash)
+                else
+                  raise ArgumentError, "Unknown message role: #{role.inspect}"
+                end
+              end
+            end
+
+            # Type for handling messages (array of messages) - kept for backwards compatibility
+            class MessagesType < ActiveModel::Type::Value
+              def initialize
+                super
+                @item_type = ItemType.new
+              end
+
+              def cast(value)
+                case value
+                when String
+                  value
+                when Array
+                  value.map { |item| @item_type.cast(item) }
+                when Hash
+                  # Single hash becomes array with one message
+                  [ @item_type.cast(value) ]
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot cast #{value.class} to Input (expected String, Array, or Hash)"
+                end
+              end
+
+              def serialize(value)
+                case value
+                when String
+                  value
+                when Array
+                  grouped = []
+
+                  value.each do |message|
+                    if grouped.empty?
+                      grouped << message.deep_dup
+                    elsif grouped.last.role == message.role && grouped.last.type == message.type
+                      grouped.last.content += message.content.deep_dup
+                    else
+                      grouped << message.deep_dup
+                    end
+                  end
+
+                  grouped.map { |v| @item_type.serialize(v) }
+                when Hash
+                  @item_type.serialize(value)
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot serialize #{value.class}"
+                end
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/inputs/assistant_message.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "output_message"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Assistant message output for OpenAI Responses API.
+            #
+            # Represents an assistant message in the conversation history.
+            class AssistantMessage < OutputMessage
+              attribute :role, :string, as: "assistant"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/inputs/base.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+require_relative "content/_types"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Base class for input items in Responses API
+            class Base < Common::BaseModel
+              attribute :role, :string
+              attribute :content, Content::ContentsType.new
+
+              validates :role, inclusion: {
+                in: %w[system user assistant developer tool],
+                allow_nil: true
+              }
+
+              # Define content setter methods for different content types
+              %i[text image document].each do |content_type|
+                define_method(:"#{content_type}=") do |value|
+                  self.content ||= []
+                  self.content += [ { content_type => value } ]
+                end
+              end
+
+              # Converts to common format.
+              #
+              # @return [Hash] message in canonical format
+              def to_common
+                {
+                  role: map_role_to_common,
+                  content: extract_text_content,
+                  name: respond_to?(:name) ? name : nil,
+                  tool_call_id: respond_to?(:tool_call_id) ? tool_call_id : nil
+                }.compact
+              end
+
+              private
+
+              # Maps OpenAI roles to canonical roles.
+              #
+              # @return [String] canonical role name
+              def map_role_to_common
+                case role
+                when "developer", "system"
+                  "system"
+                when "user"
+                  "user"
+                when "assistant"
+                  "assistant"
+                when "tool", "function"
+                  "tool"
+                else
+                  role
+                end
+              end
+
+              # Extracts text content from OpenAI's content structure.
+              #
+              # @return [String, nil] extracted text content
+              def extract_text_content
+                return nil unless respond_to?(:content)
+
+                case content
+                when String
+                  content
+                when Array
+                  # For Responses API, content is an array of content objects (InputText, etc.)
+                  content.select { |part| part.respond_to?(:text) }
+                         .map(&:text)
+                         .compact
+                         .join("\n")
+                when nil
+                  nil
+                else
+                  content.to_s
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/inputs/code_interpreter_tool_call.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "tool_call_base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Code interpreter tool call - runs Python code
+            class CodeInterpreterToolCall < ToolCallBase
+              attribute :type, :string, as: "code_interpreter_call"
+              attribute :container_id, :string
+              attribute :code, :string # Can be null
+              attribute :outputs # Always an array of output objects, can be empty
+
+              validates :type, inclusion: { in: %w[code_interpreter_call], allow_nil: false }
+              validates :container_id, presence: true
+              validates :status, inclusion: {
+                in: %w[in_progress completed incomplete interpreting failed],
+                allow_nil: false
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/inputs/computer_tool_call.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "tool_call_base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Computer tool call - computer use tool
+            class ComputerToolCall < ToolCallBase
+              attribute :type, :string, as: "computer_call"
+              attribute :call_id, :string
+              attribute :action # ComputerAction object
+              attribute :pending_safety_checks # Always an array of safety check objects
+
+              validates :type, inclusion: { in: %w[computer_call], allow_nil: false }
+              validates :call_id, presence: true
+              validates :action, presence: true
+              validates :pending_safety_checks, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/inputs/computer_tool_call_output.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Computer tool call output
+            class ComputerToolCallOutput < Base
+              attribute :type, :string, as: "computer_call_output"
+              attribute :id, :string
+              attribute :call_id, :string
+              attribute :acknowledged_safety_checks # Always an array of safety check objects
+              attribute :output # ComputerScreenshotImage object
+              attribute :status, :string
+
+              validates :type, inclusion: { in: %w[computer_call_output], allow_nil: false }
+              validates :call_id, presence: true
+              validates :output, presence: true
+              validates :status, inclusion: {
+                in: %w[in_progress completed incomplete],
+                allow_nil: true
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/inputs/content/_types.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "input_audio"
+require_relative "input_file"
+require_relative "input_image"
+require_relative "input_text"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            module Content
+              # Type for handling content (string or array of content parts)
+              class ContentsType < ActiveModel::Type::Value
+                def initialize
+                  super
+                  @content_type = ContentType.new
+                end
+
+                def cast(value)
+                  case value
+                  when String
+                    # Plain text string - keep as string
+                    value
+                  when Array
+                    # Array of content parts - cast each part
+                    value.map { |part| @content_type.cast(part) }
+                  when nil
+                    nil
+                  else
+                    raise ArgumentError, "Cannot cast #{value.class} to Contents (expected String, Array, or nil)"
+                  end
+                end
+
+                def serialize(value)
+                  case value
+                  when String
+                    value
+                  when Array
+                    value.map { |part| @content_type.serialize(part) }
+                  when nil
+                    nil
+                  else
+                    raise ArgumentError, "Cannot serialize #{value.class} as Contents"
+                  end
+                end
+
+                def deserialize(value)
+                  cast(value)
+                end
+              end
+
+              # Type for individual content items
+              class ContentType < ActiveModel::Type::Value
+                def cast(value)
+                  case value
+                  when Base
+                    value
+                  when Hash
+                    hash = value.deep_symbolize_keys
+                    type = hash[:type]&.to_sym
+
+                    case type
+                    when :input_text, :output_text
+                      InputText.new(**hash.except(:annotations, :logprobs, :type))
+                    when :input_image
+                      InputImage.new(**hash)
+                    when :input_file
+                      InputFile.new(**hash)
+                    when nil
+                      # When type is nil, check for specific content keys to infer type
+                      if hash.key?(:text)
+                        InputText.new(**hash)
+                      elsif hash.key?(:image)
+                        InputImage.new(**hash.merge(image_url: hash.delete(:image)))
+                      elsif hash.key?(:document)
+                        cast_document_to_file(hash)
+                      else
+                        raise ArgumentError, "Cannot determine content type from hash keys: #{hash.keys.inspect}"
+                      end
+                    else
+                      raise ArgumentError, "Unknown content type: #{type.inspect}"
+                    end
+                  when String
+                    # Plain text string becomes input_text
+                    InputText.new(text: value)
+                  when nil
+                    nil
+                  else
+                    raise ArgumentError, "Cannot cast #{value.class} to Content (expected Base, Hash, String, or nil)"
+                  end
+                end
+
+                def serialize(value)
+                  case value
+                  when Base
+                    value.serialize
+                  when Hash
+                    value
+                  when String
+                    { type: "input_text", text: value }
+                  when nil
+                    nil
+                  else
+                    raise ArgumentError, "Cannot serialize #{value.class} as Content"
+                  end
+                end
+
+                def deserialize(value)
+                  cast(value)
+                end
+
+                private
+
+                def cast_document_to_file(hash)
+                  document_value = hash.delete(:document)
+
+                  case document_value
+                  when String
+                    if uri?(document_value)
+                      # It's a URI/URL (http/https)
+                      InputFile.new(**hash.merge(file_url: document_value))
+                    elsif data_uri?(document_value)
+                      # It's a data URI (e.g., data:application/pdf;base64,...)
+                      # NOTE: While the OpenAI docs say filename is optional, it is required with base64 format
+                      media_type, _data = parse_data_uri(document_value)
+                      filename = generate_filename_from_media_type(media_type)
+                      InputFile.new(**hash.merge(file_data: document_value, filename: filename))
+                    else
+                      raise ArgumentError, "Cannot determine source type for document value: #{document_value.inspect}"
+                    end
+                  else
+                    raise ArgumentError, "Expected String for document key, got #{document_value.class}"
+                  end
+                end
+
+                def uri?(value)
+                  # Check if it looks like a URI (http://, https://, etc.)
+                  value.match?(%r{\A(https?)://}i)
+                end
+
+                def data_uri?(value)
+                  # Check if it's a data URI (data:...)
+                  value.match?(/\Adata:/i)
+                end
+
+                def parse_data_uri(data_uri)
+                  # Parse data URI format: data:mime/type;base64,encoded_data
+                  match = data_uri.match(/\Adata:([^;,]+)(;base64)?,(.+)\z/i)
+                  raise ArgumentError, "Invalid data URI format: #{data_uri[0..50]}..." unless match
+
+                  media_type = match[1]
+                  is_base64 = !match[2].nil?
+                  data = match[3]
+
+                  unless is_base64
+                    raise ArgumentError, "Only base64-encoded data URIs are supported: #{data_uri[0..50]}..."
+                  end
+
+                  [ media_type, data ]
+                end
+
+                def generate_filename_from_media_type(media_type)
+                  # Map common media types to file extensions
+                  extension = case media_type
+                  when "application/pdf"
+                    "pdf"
+                  when "application/msword"
+                    "doc"
+                  when "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                    "docx"
+                  when "application/vnd.ms-excel"
+                    "xls"
+                  when "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    "xlsx"
+                  when "application/vnd.ms-powerpoint"
+                    "ppt"
+                  when "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+                    "pptx"
+                  when "text/plain"
+                    "txt"
+                  when "text/csv"
+                    "csv"
+                  when "text/html"
+                    "html"
+                  when "application/json"
+                    "json"
+                  when "application/xml", "text/xml"
+                    "xml"
+                  else
+                    # Try to extract extension from media type (e.g., "application/xyz" -> "xyz")
+                    media_type.split("/").last.split("+").first
+                  end
+
+                  "document.#{extension}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/inputs/content/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            module Content
+              # Base class for content parts
+              class Base < Common::BaseModel
+                attribute :type, :string
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end