activeagent 0.6.3 → 1.0.0.rc1

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Tool message input
+            class ToolMessage < Base
+              attribute :role, :string, as: "tool"
+              attribute :tool_call_id, :string
+
+              validates :tool_call_id, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "input_message"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # User message input
+            class UserMessage < InputMessage
+              attribute :role, :string, as: "user"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "tool_call_base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Web search tool call - results from web search
+            class WebSearchToolCall < ToolCallBase
+              attribute :type, :string, as: "web_search_call"
+              attribute :action # WebSearchAction object (search, open_page, or find)
+
+              validates :type, inclusion: { in: %w[web_search_call], allow_nil: false }
+              validates :action, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          class PromptReference < Common::BaseModel
+            # Prompt ID or name
+            attribute :id, :string
+
+            # Variables for the prompt template
+            attribute :variables # Hash of variables
+
+            validates :id, presence: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          class Reasoning < Common::BaseModel
+            # Effort level for reasoning (low, medium, high)
+            attribute :effort, :string
+
+            # Summary configuration
+            attribute :summary # Can be string or object with format/length
+
+            validates :effort, inclusion: { in: %w[low medium high] }, allow_nil: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          class StreamOptions < Common::BaseModel
+            # Include usage information in the stream
+            attribute :include_usage, :boolean
+
+            validates :include_usage, inclusion: { in: [ true, false ] }, allow_nil: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "plain"
+require_relative "json_object"
+require_relative "json_schema"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module TextFormats
+            # ActiveModel type for casting and serializing Text format objects
+            class FormatType < ActiveModel::Type::Value
+              def cast(value)
+                case value
+                when Plain, JsonObject, JsonSchema
+                  value
+                when Hash
+                  create_format_from_hash(value)
+                when String
+                  create_format_from_string(value)
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot cast #{value.class} to Format"
+                end
+              end
+
+              def serialize(value)
+                case value
+                when Plain, JsonObject, JsonSchema
+                  value.serialize
+                when Hash
+                  value
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot serialize #{value.class}"
+                end
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+
+              private
+
+              def create_format_from_hash(hash)
+                hash = hash.deep_symbolize_keys
+                type = hash[:type]
+
+                case type
+                when "text"
+                  Plain.new
+                when "json_object"
+                  JsonObject.new
+                when "json_schema"
+                  JsonSchema.new(
+                    name: hash[:name],
+                    description: hash[:description],
+                    schema: hash[:schema],
+                    strict: hash[:strict]
+                  )
+                else
+                  nil
+                end
+              end
+
+              def create_format_from_string(value)
+                case value
+                when "text"
+                  Plain.new
+                when "json_object"
+                  JsonObject.new
+                when "json_schema"
+                  JsonSchema.new
+                else
+                  nil
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/text/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 TextFormats
+            # Base class for text format configurations
+            class Base < Common::BaseModel
+              attribute :type, :string
+
+              validates :type, inclusion: { in: %w[text json_object json_schema] }, allow_nil: false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/text/json_object.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module TextFormats
+            # JSON object format (older method)
+            class JsonObject < Base
+              attribute :type, :string, as: "json_object"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/text/json_schema.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module TextFormats
+            # JSON schema format for structured outputs
+            class JsonSchema < Base
+              attribute :type, :string, as: "json_schema"
+
+              # Name of the response format
+              attribute :name, :string
+
+              # Description of what the response format is for
+              attribute :description, :string
+
+              # The JSON schema object
+              attribute :schema # Hash
+
+              # Whether to enable strict schema adherence
+              attribute :strict, :boolean, default: false
+
+              validates :name, presence: true
+              validates :schema, presence: true
+
+              validate :validate_schema_structure
+
+              private
+
+              def validate_schema_structure
+                return if schema.blank?
+                return unless schema.is_a?(Hash)
+
+                unless schema.key?("type") || schema.key?(:type)
+                  errors.add(:schema, "must include a 'type' property")
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/text/plain.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module TextFormats
+            # Plain text format
+            class Plain < Base
+              attribute :type, :string, as: "text"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+require_relative "text/_types"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          class Text < Common::BaseModel
+            # Format configuration for text output
+            attribute :format, TextFormats::FormatType.new
+
+            # Modalities for output
+            attribute :modalities, default: -> { [] } # Array of strings
+
+            # Verbosity setting
+            attribute :verbosity, :string
+
+            validates :verbosity, inclusion: { in: %w[concise default verbose] }, allow_nil: true
+
+            # Common Format compatibility - maps format.type to type
+            def type
+              format&.type
+            end
+
+            def type=(value)
+              self.format = value
+            end
+
+            # For Common Format
+            def json_schema=(value)
+              self.format = { type: "json_schema", **value }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          # Tool choice configuration for Responses API
+          # Controls how the model should select which tool (or tools) to use when generating a response.
+          class ToolChoice < Common::BaseModel
+            # Can be string ("none", "auto", "required") or object with type and tool details
+            attribute :mode, :string
+            attribute :type, :string
+            attribute :function # Hash with name
+            attribute :custom # Hash with name
+
+            validates :mode, inclusion: { in: %w[none auto required] }, allow_nil: true
+            validates :type, inclusion: { in: %w[function custom] }, allow_nil: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "code_interpreter_tool"
+require_relative "computer_tool"
+require_relative "custom_tool"
+require_relative "file_search_tool"
+require_relative "function_tool"
+require_relative "image_generation_tool"
+require_relative "local_shell_tool"
+require_relative "mcp_tool"
+require_relative "web_search_preview_tool"
+require_relative "web_search_tool"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Tools
+            # Type for collection of tools
+            class ToolsType < ActiveModel::Type::Value
+              def initialize
+                super
+                @tool_type = ToolType.new
+              end
+
+              def cast(value)
+                return nil if value.nil?
+                return [] if value == []
+
+                array = Array(value)
+                array.map { |tool| @tool_type.cast(tool) }
+              end
+
+              def serialize(value)
+                return nil if value.nil?
+                return [] if value == []
+
+                array = Array(value)
+                array.map { |tool| @tool_type.serialize(tool) }
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+            end
+
+            # Type for individual tool
+            class ToolType < 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 :function
+                    FunctionTool.new(**hash)
+                  when :custom
+                    CustomTool.new(**hash)
+                  when :web_search, :web_search_2025_08_26
+                    WebSearchTool.new(**hash)
+                  when :web_search_preview, :web_search_preview_2025_03_11
+                    WebSearchPreviewTool.new(**hash)
+                  when :code_interpreter
+                    CodeInterpreterTool.new(**hash)
+                  when :file_search
+                    FileSearchTool.new(**hash)
+                  when :computer_use_preview
+                    ComputerTool.new(**hash)
+                  when :mcp
+                    McpTool.new(**hash)
+                  when :image_generation
+                    ImageGenerationTool.new(**hash)
+                  when :local_shell
+                    LocalShellTool.new(**hash)
+                  else
+                    raise ArgumentError, "Unknown tool type: #{type.inspect}"
+                  end
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot cast #{value.class} to Tool (expected Base, Hash, or nil)"
+                end
+              end
+
+              def serialize(value)
+                case value
+                when Base
+                  value.serialize
+                when Hash
+                  value
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot serialize #{value.class} as Tool"
+                end
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Tools
+            # Base class for tools in Responses API
+            class Base < Common::BaseModel
+              attribute :type, :string
+
+              validates :type, inclusion: {
+                in: %w[function custom web_search web_search_2025_08_26 code_interpreter file_search computer_use_preview mcp image_generation local_shell web_search_preview web_search_preview_2025_03_11],
+                allow_nil: true
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/tools/code_interpreter_tool.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Tools
+            # Built-in code interpreter tool
+            class CodeInterpreterTool < Base
+              attribute :type, :string, as: "code_interpreter"
+              attribute :container # Required: can be string (container ID) or hash { type: "auto", file_ids: [] }
+
+              validates :container, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/tools/computer_tool.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Tools
+            # Built-in computer tool (note: type should be "computer_use_preview" per schema)
+            class ComputerTool < Base
+              attribute :type, :string, as: "computer_use_preview"
+              attribute :display_height, :integer # Required: height of the computer display
+              attribute :display_width, :integer # Required: width of the computer display
+              attribute :environment, :string # Required: type of computer environment to control
+
+              validates :display_height, presence: true, numericality: { greater_than: 0 }
+              validates :display_width, presence: true, numericality: { greater_than: 0 }
+              validates :environment, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/tools/custom_tool.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Tools
+            # Custom tool
+            class CustomTool < Base
+              attribute :type, :string, as: "custom"
+              attribute :name, :string # Required: name of the custom tool
+              attribute :description, :string # Optional: description
+              attribute :format # Optional: hash with input format
+              # Can be { type: "text" } for unconstrained text
+              # Or { type: "grammar", definition: string, syntax: "lark"|"regex" }
+
+              validates :name, presence: true, length: { maximum: 64 }
+              validates :name, format: { with: /\A[a-zA-Z0-9_-]+\z/, message: "must contain only a-z, A-Z, 0-9, underscores and dashes" }, if: -> { name.present? }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/tools/file_search_tool.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Tools
+            # Built-in file search tool
+            class FileSearchTool < Base
+              attribute :type, :string, as: "file_search"
+              attribute :vector_store_ids # Array - required: The IDs of the vector stores to search
+              attribute :filters # Hash - optional: A filter to apply
+              attribute :max_num_results, :integer # Optional: maximum number of results (1-50)
+              attribute :ranking_options # Hash - optional: { ranker: string, score_threshold: number }
+
+              validates :vector_store_ids, presence: true
+              validates :max_num_results, numericality: { greater_than_or_equal_to: 1, less_than_or_equal_to: 50 }, allow_nil: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/tools/function_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Tools
+            # Function tool for custom function calling
+            class FunctionTool < Base
+              attribute :type, :string, as: "function"
+              attribute :name, :string
+              attribute :parameters # Hash - JSON Schema object (required)
+              attribute :strict, :boolean # Required - whether to enforce strict parameter validation (default true)
+              attribute :description, :string # Optional description
+
+              validates :name, presence: true, length: { maximum: 64 }
+              validates :name, format: { with: /\A[a-zA-Z0-9_-]+\z/, message: "must contain only a-z, A-Z, 0-9, underscores and dashes" }, if: -> { name.present? }
+              validates :parameters, presence: true
+              validates :strict, inclusion: { in: [ true, false ] }, allow_nil: false
+            end
+          end
+        end
+      end
+    end
+  end
+end