omni_agent 0.1.8 → 0.1.10

data/lib/omni_agent/providers/mock.rb

@@ -3,9 +3,16 @@ module OmniAgent
     class Mock < Base
       LOREM_IPSUM = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
 
-      def chat(messages:, tools: [], **_options)
+      def chat(messages:, tools: [], stream: nil, **_options)
         validate_messages!(messages, allowed_roles: %i[system user assistant tool])
 
+        if stream
+          LOREM_IPSUM.split(" ").each_with_index do |word, index|
+            chunk = index.zero? ? word : " #{word}"
+            stream.call(OmniAgent::Streaming::Event.text(chunk))
+          end
+        end
+
         OmniAgent::Providers::Response.new(
           content: LOREM_IPSUM,
           raw_request: {

data/lib/omni_agent/providers/ollama.rb

@@ -0,0 +1,30 @@
+# lib/omni_agent/providers/ollama.rb
+module OmniAgent
+  module Providers
+    class Ollama < OpenAI
+      protected
+
+      def provider_label
+        "Ollama"
+      end
+
+      def client
+        @client ||= ::OpenAI::Client.new(api_key: @api_key, base_url: base_url)
+      end
+
+      def default_api_key
+        ENV.fetch("OLLAMA_API_KEY", "ollama")
+      end
+
+      def default_model
+        ENV.fetch("OLLAMA_MODEL", "llama3.1")
+      end
+
+      private
+
+      def base_url
+        "#{ENV.fetch('OLLAMA_HOST', 'http://localhost:11434')}/v1"
+      end
+    end
+  end
+end

data/lib/omni_agent/providers/openai.rb

@@ -12,7 +12,7 @@ module OmniAgent
               "Please add `gem 'openai'` to your Gemfile."
       end
 
-      def chat(messages:, tools: [], **options)
+      def chat(messages:, tools: [], stream: nil, **options)
         validate_messages!(messages, allowed_roles: %i[system user assistant tool])
 
         messages = messages.map do |msg|
@@ -44,15 +44,23 @@ module OmniAgent
         payload[:tools] = openai_tools if openai_tools.any?
         payload.merge!(options) if options.any?
 
-        response = with_retries { client.chat.completions.create(**payload) }
+        response = if stream
+          stream_chat(payload: payload, stream: stream)
+        else
+          with_retries { client.chat.completions.create(**payload) }
+        end
 
         parse_response(response, payload)
       rescue => e
-        raise OmniAgent::Error, "Error during OpenAI chat: #{e.message}"
+        raise OmniAgent::Error, "Error during #{provider_label} chat: #{e.message}"
       end
 
       protected
 
+      def provider_label
+        "OpenAI"
+      end
+
       def retryable_error?(error)
         defined?(::OpenAI::Errors) &&
           (error.is_a?(::OpenAI::Errors::RateLimitError) ||
@@ -74,6 +82,18 @@ module OmniAgent
 
       private
 
+      def stream_chat(payload:, stream:)
+        chat_stream = with_retries { client.chat.completions.stream(**payload) }
+
+        chat_stream.each do |event|
+          next unless event.is_a?(::OpenAI::Helpers::Streaming::ChatContentDeltaEvent)
+
+          stream.call(OmniAgent::Streaming::Event.text(event.delta))
+        end
+
+        chat_stream.get_final_completion
+      end
+
       def format_tool(tool_class)
         schema = tool_class.json_schema.dup
 

data/lib/omni_agent/providers.rb

@@ -4,6 +4,7 @@ module OmniAgent
     def self.registry
       {
         openai: OmniAgent::Providers::OpenAI,
+        ollama: OmniAgent::Providers::Ollama,
         mock: OmniAgent::Providers::Mock,
         mock_judge: OmniAgent::Providers::MockJudge
       }

data/lib/omni_agent/streaming/event.rb

@@ -0,0 +1,54 @@
+module OmniAgent
+  module Streaming
+    class Event
+      attr_reader :type, :text, :tool_name, :tool_arguments, :tool_id, :content, :error, :response
+
+      def self.text(delta)
+        new(type: :text, text: delta)
+      end
+
+      def self.tool_call(name:, arguments:, id:)
+        new(type: :tool_call, tool_name: name, tool_arguments: arguments, tool_id: id)
+      end
+
+      def self.tool_result(name:, id:, content:, error: false)
+        new(type: :tool_result, tool_name: name, tool_id: id, content: content, error: error)
+      end
+
+      def self.done(response)
+        new(type: :done, response: response)
+      end
+
+      def initialize(type:, text: nil, tool_name: nil, tool_arguments: nil, tool_id: nil, content: nil, error: false, response: nil)
+        @type = type
+        @text = text
+        @tool_name = tool_name
+        @tool_arguments = tool_arguments
+        @tool_id = tool_id
+        @content = content
+        @error = error
+        @response = response
+      end
+
+      def text?
+        type == :text
+      end
+
+      def tool_call?
+        type == :tool_call
+      end
+
+      def tool_result?
+        type == :tool_result
+      end
+
+      def done?
+        type == :done
+      end
+
+      def error?
+        @error == true
+      end
+    end
+  end
+end

data/lib/omni_agent/streaming/proxy.rb

@@ -0,0 +1,17 @@
+module OmniAgent
+  module Streaming
+    class Proxy
+      def initialize(agent)
+        @agent = agent
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        @agent.public_send(name, *args, **kwargs, &block)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @agent.respond_to?(name, include_private) || super
+      end
+    end
+  end
+end

data/lib/omni_agent/tool/schema_builder.rb

@@ -1,26 +1,46 @@
 module OmniAgent
   class Tool
     class SchemaBuilder
-      attr_reader :properties, :required_fields
+      attr_reader :properties, :required_fields, :validators, :polymorphics
 
       def initialize
         @properties = {}
         @required_fields = []
+        @validators = {}
+        @polymorphics = {}
       end
 
-      def string(name, description: nil, required: true)
-        add_property(name, type: "string", description: description, required: required)
+      def string(name, description: nil, required: true, min_length: nil, max_length: nil, pattern: nil, format: nil, validate: nil)
+        constraints = {}
+        constraints[:minLength] = min_length if min_length
+        constraints[:maxLength] = max_length if max_length
+        constraints[:pattern] = pattern.is_a?(Regexp) ? pattern.source : pattern if pattern
+        constraints[:format] = format if format
+
+        add_property(name, type: "string", description: description, required: required, constraints: constraints, validate: validate)
+      end
+
+      def integer(name, description: nil, required: true, min: nil, max: nil, validate: nil)
+        constraints = {}
+        constraints[:minimum] = min if min
+        constraints[:maximum] = max if max
+
+        add_property(name, type: "integer", description: description, required: required, constraints: constraints, validate: validate)
       end
 
-      def integer(name, description: nil, required: true)
-        add_property(name, type: "integer", description: description, required: required)
+      def number(name, description: nil, required: true, min: nil, max: nil, validate: nil)
+        constraints = {}
+        constraints[:minimum] = min if min
+        constraints[:maximum] = max if max
+
+        add_property(name, type: "number", description: description, required: required, constraints: constraints, validate: validate)
       end
 
-      def boolean(name, description: nil, required: true)
-        add_property(name, type: "boolean", description: description, required: required)
+      def boolean(name, description: nil, required: true, validate: nil)
+        add_property(name, type: "boolean", description: description, required: required, validate: validate)
       end
 
-      def array(name, items_type: nil, description: nil, required: true, &block)
+      def array(name, items_type: nil, description: nil, required: true, min_items: nil, max_items: nil, validate: nil, &block)
         property = { type: "array" }
         property[:description] = description if description
 
@@ -38,11 +58,15 @@ module OmniAgent
           property[:items] = { type: items_type || "string" }
         end
 
+        property[:minItems] = min_items if min_items
+        property[:maxItems] = max_items if max_items
+
         @properties[name] = property
         @required_fields << name.to_s if required
+        @validators[name] = validate if validate
       end
 
-      def hash(name, description: nil, required: true, &block)
+      def hash(name, description: nil, required: true, validate: nil, &block)
         property = { type: "object" }
         property[:description] = description if description
 
@@ -59,16 +83,112 @@ module OmniAgent
 
         @properties[name] = property
         @required_fields << name.to_s if required
+        @validators[name] = validate if validate
+      end
+
+      def enum(name, values:, description: nil, required: true, validate: nil)
+        raise ArgumentError, "enum requires at least one value" if values.empty?
+
+        normalized_values = values.map { |v| v.is_a?(Symbol) ? v.to_s : v }
+        value_data_type = enum_data_type(normalized_values)
+
+        property = { type: value_data_type, enum: normalized_values }
+        property[:description] = description if description
+        @properties[name] = property
+        @required_fields << name.to_s if required
+        @validators[name] = validate if validate
+      end
+
+      def polymorphic(name, types: nil, description: nil, id_type: "string", required: true, resolve: false, &block)
+        if resolve && (types.nil? || types.empty?)
+          raise ArgumentError, "polymorphic resolve: true requires types:"
+        end
+
+        type_values = types
+        type_description = description ? "#{description} (type)" : nil
+        id_type_value = id_type
+        id_description = description ? "#{description} (id)" : nil
+
+        if block_given?
+          field_builder = PolymorphicFieldBuilder.new
+          field_builder.instance_eval(&block)
+
+          type_values = field_builder.type_values || type_values
+          type_description = field_builder.type_description || type_description
+          id_type_value = field_builder.id_type || id_type_value
+          id_description = field_builder.id_description || id_description
+        end
+
+        type_field = :"#{name}_type"
+        id_field = :"#{name}_id"
+        id_json_type = id_type_value.to_s == "integer" ? "integer" : "string"
+
+        if type_values && !type_values.empty?
+          enum(type_field, values: type_values, description: type_description, required: required)
+        else
+          string(type_field, description: type_description, required: required)
+        end
+
+        if id_json_type == "integer"
+          integer(id_field, description: id_description, required: required)
+        else
+          string(id_field, description: id_description, required: required)
+        end
+
+        @polymorphics[name] = {
+          type_field: type_field,
+          id_field: id_field,
+          types: type_values,
+          id_type: id_json_type,
+          resolve: resolve
+        }
       end
 
       private
 
-      def add_property(name, type:, description:, required:)
+      def enum_data_type(values)
+        types = values.map { |v| json_type_for(v) }.uniq
+
+        if types.size > 1
+          raise ArgumentError, "enum values must all be the same type, got: #{types.join(', ')}"
+        end
+
+        types.first
+      end
+
+      def json_type_for(value)
+        case value
+        when Integer then "integer"
+        when Float then "number"
+        when String then "string"
+        when true, false then "boolean"
+        else
+          raise ArgumentError, "unsupported enum value type: #{value.class}"
+        end
+      end
+
+      def add_property(name, type:, description:, required:, constraints: {}, validate: nil)
         property = { type: type }
         property[:description] = description if description
+        property.merge!(constraints)
 
         @properties[name] = property
         @required_fields << name.to_s if required
+        @validators[name] = validate if validate
+      end
+
+      class PolymorphicFieldBuilder
+        attr_reader :type_values, :type_description, :id_type, :id_description
+
+        def type(values: nil, description: nil)
+          @type_values = values
+          @type_description = description
+        end
+
+        def id(type: "string", description: nil)
+          @id_type = type
+          @id_description = description
+        end
       end
     end
   end

data/lib/omni_agent/tool.rb

@@ -11,6 +11,31 @@ module OmniAgent
         @metadata || {}
       end
 
+      def title(text = nil)
+        @title = text if text
+        @title
+      end
+
+      def annotations(read_only: nil, destructive: nil, idempotent: nil, open_world: nil)
+        @annotations = {
+          read_only: read_only,
+          destructive: destructive,
+          idempotent: idempotent,
+          open_world: open_world
+        }.compact
+      end
+
+      def mcp_annotations
+        hints = @annotations || {}
+
+        {
+          readOnlyHint: hints[:read_only],
+          destructiveHint: hints[:destructive],
+          idempotentHint: hints[:idempotent],
+          openWorldHint: hints[:open_world]
+        }.compact
+      end
+
       def tags(*tag_names)
         return @tags || [] if tag_names.empty?
 
@@ -28,6 +53,8 @@ module OmniAgent
 
           @properties = builder.properties
           @required = builder.required_fields
+          @validators = builder.validators
+          @polymorphics = builder.polymorphics
         end
       end
 
@@ -43,7 +70,15 @@ module OmniAgent
       def parse_arguments(arguments_hash)
         kwargs = arguments_hash.transform_keys(&:to_sym)
         valid_keys = (@properties || {}).keys.map(&:to_sym)
-        kwargs.slice(*valid_keys)
+        filtered = kwargs.slice(*valid_keys)
+
+        validate_required!(filtered)
+        validate_enums!(filtered)
+        validate_constraints!(filtered)
+        run_custom_validators!(filtered)
+        resolve_polymorphics!(filtered)
+
+        filtered
       end
 
       def stops_generation(value = true)
@@ -56,6 +91,87 @@ module OmniAgent
 
       private
 
+      def validate_required!(kwargs)
+        missing = (@required || []).map(&:to_sym) - kwargs.keys
+        return if missing.empty?
+
+        raise ArgumentError, "missing required argument(s): #{missing.join(', ')}"
+      end
+
+      def validate_enums!(kwargs)
+        (@properties || {}).each do |name, property|
+          allowed_values = property[:enum]
+          next unless allowed_values
+
+          key = name.to_sym
+          next unless kwargs.key?(key)
+
+          unless allowed_values.include?(kwargs[key])
+            raise ArgumentError, "invalid value for #{name}: #{kwargs[key].inspect} (must be one of: #{allowed_values.join(', ')})"
+          end
+        end
+      end
+
+      def validate_constraints!(kwargs)
+        (@properties || {}).each do |name, property|
+          key = name.to_sym
+          next unless kwargs.key?(key)
+
+          check_constraints!(name, property, kwargs[key])
+        end
+      end
+
+      def check_constraints!(name, property, value)
+        if property[:minLength] && value.is_a?(String) && value.length < property[:minLength]
+          raise ArgumentError, "#{name} must be at least #{property[:minLength]} characters"
+        end
+        if property[:maxLength] && value.is_a?(String) && value.length > property[:maxLength]
+          raise ArgumentError, "#{name} must be at most #{property[:maxLength]} characters"
+        end
+        if property[:pattern] && value.is_a?(String) && !value.match?(Regexp.new(property[:pattern]))
+          raise ArgumentError, "#{name} does not match required pattern #{property[:pattern]}"
+        end
+        if property[:minimum] && value.is_a?(Numeric) && value < property[:minimum]
+          raise ArgumentError, "#{name} must be >= #{property[:minimum]}"
+        end
+        if property[:maximum] && value.is_a?(Numeric) && value > property[:maximum]
+          raise ArgumentError, "#{name} must be <= #{property[:maximum]}"
+        end
+        if property[:minItems] && value.is_a?(Array) && value.length < property[:minItems]
+          raise ArgumentError, "#{name} must have at least #{property[:minItems]} items"
+        end
+        if property[:maxItems] && value.is_a?(Array) && value.length > property[:maxItems]
+          raise ArgumentError, "#{name} must have at most #{property[:maxItems]} items"
+        end
+      end
+
+      def run_custom_validators!(kwargs)
+        (@validators || {}).each do |name, validator|
+          key = name.to_sym
+          next unless kwargs.key?(key)
+
+          result = validator.call(kwargs[key])
+          raise ArgumentError, "invalid value for #{name}" if result == false
+        end
+      end
+
+      def resolve_polymorphics!(kwargs)
+        (@polymorphics || {}).each do |name, group|
+          next unless group[:resolve]
+
+          type_field = group[:type_field]
+          id_field = group[:id_field]
+          next unless kwargs.key?(type_field) && kwargs.key?(id_field)
+
+          type_value = kwargs.delete(type_field)
+          id_value = kwargs.delete(id_field)
+
+          klass = Object.const_get(type_value.to_s)
+          record = klass.find(id_value)
+          kwargs[name.to_sym] = record
+        end
+      end
+
       def normalize_tags(tag_names)
         raise ArgumentError, "tags requires at least one tag" if tag_names.empty?
 

data/lib/omni_agent/version.rb

@@ -1,3 +1,3 @@
 module OmniAgent
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 end

data/lib/omni_agent.rb

@@ -3,7 +3,7 @@ require "omni_agent/engine" if defined?(Rails)
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
-loader.inflector.inflect("openai" => "OpenAI", "cli" => "CLI")
+loader.inflector.inflect("openai" => "OpenAI", "cli" => "CLI", "mcp" => "MCP")
 loader.ignore(File.expand_path("generators", __dir__))
 loader.setup
 

data/lib/tasks/omni_agent_mcp_tasks.rake

@@ -0,0 +1,9 @@
+namespace :omni_agent do
+  desc 'Run an MCP server over stdio. Usage: rake "omni_agent:mcp[SupportServer]"'
+  task :mcp, [ :server ] => :environment do |_task, args|
+    server = args[:server].to_s.strip
+    abort 'Please provide a server class. Example: bin/rails "omni_agent:mcp[SupportServer]"' if server.empty?
+
+    OmniAgent::MCP::Stdio.start(server)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omni_agent
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - ACR1209
@@ -62,6 +62,7 @@ files:
 - lib/generators/omni_agent/agent/agent_generator.rb
 - lib/generators/omni_agent/eval/eval_generator.rb
 - lib/generators/omni_agent/install/install_generator.rb
+- lib/generators/omni_agent/mcp_server/mcp_server_generator.rb
 - lib/omni_agent.rb
 - lib/omni_agent/agent.rb
 - lib/omni_agent/configuration.rb
@@ -81,18 +82,31 @@ files:
 - lib/omni_agent/eval/run.rb
 - lib/omni_agent/eval/runner.rb
 - lib/omni_agent/eval/tool_call_assertion.rb
+- lib/omni_agent/mcp.rb
+- lib/omni_agent/mcp/authenticator.rb
+- lib/omni_agent/mcp/handler.rb
+- lib/omni_agent/mcp/rack_app.rb
+- lib/omni_agent/mcp/request.rb
+- lib/omni_agent/mcp/routing.rb
+- lib/omni_agent/mcp/server.rb
+- lib/omni_agent/mcp/stdio.rb
+- lib/omni_agent/mcp/tool_adapter.rb
 - lib/omni_agent/providers.rb
 - lib/omni_agent/providers/base.rb
 - lib/omni_agent/providers/mock.rb
 - lib/omni_agent/providers/mock_judge.rb
+- lib/omni_agent/providers/ollama.rb
 - lib/omni_agent/providers/openai.rb
 - lib/omni_agent/providers/response.rb
 - lib/omni_agent/railtie.rb
+- lib/omni_agent/streaming/event.rb
+- lib/omni_agent/streaming/proxy.rb
 - lib/omni_agent/tasks/omni_agent_tasks.rake
 - lib/omni_agent/tool.rb
 - lib/omni_agent/tool/schema_builder.rb
 - lib/omni_agent/version.rb
 - lib/tasks/omni_agent_eval_tasks.rake
+- lib/tasks/omni_agent_mcp_tasks.rake
 homepage: https://github.com/ACR1209/omni_agent
 licenses:
 - MIT