activeagent 1.0.0.rc1 → 1.0.0

data/lib/active_agent/providers/open_ai/embedding/requests/_types.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Embedding
-        module Requests
-          # Custom type for handling embedding input
-          # Can be a string, array of strings, or array of token arrays
-          # Always stores internally as an array for consistency
-          class InputType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when String
-                [ value.presence ].compact
-              when Array
-                value.compact
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to Input (expected String or Array)"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when Array
-                # Return single string if array has only one string element
-                if value in [ String => string ]
-                  string
-                else
-                  value
-                end
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,231 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "inputs/_types"
-require_relative "tools/_types"
-
-require_relative "conversation"
-require_relative "prompt_reference"
-require_relative "reasoning"
-require_relative "stream_options"
-require_relative "text"
-require_relative "tool_choice"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Responses
-        module Requests
-          class ConversationType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when Conversation
-                value
-              when Hash
-                Conversation.new(**value.symbolize_keys)
-              when String
-                value # Can be a conversation ID string
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to Conversation"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when Conversation
-                value.serialize
-              when Hash
-                value
-              when String
-                value
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-
-          class PromptReferenceType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when PromptReference
-                value
-              when Hash
-                PromptReference.new(**value.symbolize_keys)
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to PromptReference"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when PromptReference
-                value.serialize
-              when Hash
-                value
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-
-          class ReasoningType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when Reasoning
-                value
-              when Hash
-                Reasoning.new(**value.symbolize_keys)
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to Reasoning"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when Reasoning
-                value.serialize
-              when Hash
-                value
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-
-          class StreamOptionsType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when StreamOptions
-                value
-              when Hash
-                StreamOptions.new(**value.symbolize_keys)
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to StreamOptions"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when StreamOptions
-                value.serialize
-              when Hash
-                value
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-
-          class TextType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when Text
-                value
-              when Hash
-                if value.key?(:json_schema)
-                  Text.new(**value.symbolize_keys.except(:type)) # Prevent Losing the Schema on Format setting
-                else
-                  Text.new(**value.symbolize_keys)
-                end
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to Text"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when Text
-                value.serialize
-              when Hash
-                value
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-
-          class ToolChoiceType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when ToolChoice
-                value
-              when Hash
-                ToolChoice.new(**value.symbolize_keys)
-              when String
-                ToolChoice.new(mode: value)
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to ToolChoice"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when ToolChoice
-                hash = value.serialize
-                # If it's just a mode string, return the string
-                if hash[:mode].present? && hash[:type].blank? && hash[:function].blank? && hash[:custom].blank?
-                  hash[:mode]
-                else
-                  hash
-                end
-              when Hash
-                value
-              when String
-                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

data/lib/active_agent/providers/open_ai/responses/requests/conversation.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "active_agent/providers/common/model"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Responses
-        module Requests
-          class Conversation < Common::BaseModel
-            # Conversation ID
-            attribute :id, :string
-
-            # Optional: Store conversation items
-            attribute :store, :boolean
-
-            validates :id, presence: true, if: -> { store.nil? }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,264 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,89 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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