omni_agent 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53319cab79a557426f4a7a109a1627c425cffe49d56dc6f2d0baba58ab74b24d
-  data.tar.gz: 541ff86413a12fbf65f95c12945e45a74d9baac18f9f7d446f5dce3281ae93ce
+  metadata.gz: 66c390e526b0bd6176f8755538304d0e0e99d9cc36627be1ee9b63119b53ce34
+  data.tar.gz: 4918452fbba6d30772abbf9d072d0c16cf363d5220a099183e9caa04d7481220
 SHA512:
-  metadata.gz: 996ba6f8c9679fea087dccc4fc202de1b4fb2e8debece3fa63438719447819590294b0e965228ff4fb2e93eb25556283cce000dde2f04bba8fb2ee14a3b3ccfd
-  data.tar.gz: 8620ac25e792aa0213f00abbf717b814c4b3cca8a09af45a8659f9e557d9df5c0e33363ff109615f139403595630832cf8ff0c370d88a1a26bdfc74bb97ccd6e
+  metadata.gz: 522e4be90a757a9056e95cf45f5aafb1f18d7b6914e1ca667e32b3774ab70422f552e333ac2e340c4d1dab1c628350e04d494a9726b908467eb53723ae300dd6
+  data.tar.gz: c2c7939747237e554df0ac2569b84e36b164c1235f75fa876f04518cb644ad02579e18f4ee168c53ff55f32b75c8a58284ff921b217eda4b9148f67a8d5e4de7

data/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.9](https://github.com/ACR1209/omni_agent/compare/omni_agent/v0.1.8...omni_agent/v0.1.9) (2026-07-12)
+
+
+### Features
+
+* **agent:** support streaming responses via stream sink ([7cf1fba](https://github.com/ACR1209/omni_agent/commit/7cf1fba4fa378c5cee7f464354f760506a0ff513))
+* **docs:** add enum type for temperature unit in input schema ([d992658](https://github.com/ACR1209/omni_agent/commit/d99265836307ce8f863b060eff73c7acdbc8d2ff))
+* **providers:** add Ollama provider via OpenAI-compat endpoint ([4ae92ad](https://github.com/ACR1209/omni_agent/commit/4ae92ad0f549119b43c2e8a7381f4f7245aa2f68))
+* **tool:** add optional constraint validations and custom validate procs ([db8371a](https://github.com/ACR1209/omni_agent/commit/db8371a189f710e812c3c3ce15f200df1ba94902))
+* **tool:** add polymorphic reference datatype ([1686bbb](https://github.com/ACR1209/omni_agent/commit/1686bbbf41932622a5537c335da8c41c68a73f73))
+* **tool:** infer and validate enum value types in schema builder ([ceb3e78](https://github.com/ACR1209/omni_agent/commit/ceb3e780498caa1158e9fc8af3eb6e9b95c33ddb))
+* **tool:** validate required and enum arguments on invoke ([543c6e0](https://github.com/ACR1209/omni_agent/commit/543c6e08f9c394b84c73bc5957aff7058e0fab19))
+
+
+### Bug Fixes
+
+* **lint:** add space inside empty block braces ([9116b3f](https://github.com/ACR1209/omni_agent/commit/9116b3ff82e9fab9824347515b4c1cd40a40785e))
+* **spec:** redact OpenAI API key from recorded VCR cassettes ([53cecd5](https://github.com/ACR1209/omni_agent/commit/53cecd540b6dd52ddc5bf3da0550836fbfcfab88))
+
+## [0.1.8](https://github.com/ACR1209/omni_agent/compare/omni_agent/v0.1.7...omni_agent/v0.1.8) (2026-07-07)
+
+
+### Features
+
+* implement multi-agent delegation with context forwarding and depth control ([e9b5497](https://github.com/ACR1209/omni_agent/commit/e9b5497b0af89172701bf4c5d93b8d5dccc77a26))
+
 ## [0.1.7](https://github.com/ACR1209/omni_agent/compare/omni_agent-v0.1.6...omni_agent/v0.1.7) (2026-06-22)
 
 

data/README.md

@@ -11,7 +11,7 @@ tool schemas, and generation lifecycle callbacks.
 - Prompt composition from ERB files in `app/agents/<agent_name>/`
 - Agent callbacks (`before_generation`, `after_generation`)
 - Agent and tool tags to support filtering strategies
-- OpenAI provider integration out of the box
+- OpenAI provider integration out of the box, plus an Ollama provider for local models
 - Rake tasks and Rails generators for scaffolding
 
 ## Installation
@@ -27,6 +27,8 @@ Add the provider you're using to the Gemfile as well:
 gem "openai"
 ```
 
+The `ollama` provider also depends on the `openai` gem — it talks to Ollama's OpenAI-compatible endpoint, so no separate gem is needed.
+
 Then run:
 
 ```bash
@@ -53,6 +55,14 @@ bundle exec rails generate omni_agent:agent ResearchAgent --model gpt-4.1-mini -
 OPENAI_ACCESS_TOKEN=your_api_key_here
 ```
 
+To use Ollama instead, set `config.default_provider = :ollama` (see below) and, if needed, override its endpoint/model:
+
+```dotenv
+OLLAMA_HOST=http://localhost:11434   # defaults to this
+OLLAMA_MODEL=llama3.1                # defaults to this; pick a tool-calling-capable model
+OLLAMA_API_KEY=ollama                # unused by Ollama, but required by the openai client
+```
+
 4. Implement your agent prompt and optional tools under:
 
 ```text
@@ -97,6 +107,55 @@ module ResearchAgent::Tools
 end
 ```
 
+## Multi-Agent Delegation
+
+`delegate_to` turns an agent into a supervisor: it wraps another agent class as a tool, so the supervisor's LLM can decide when to hand off to it. The delegated agent is a normal, independently defined agent (e.g. `app/agents/research_agent.rb`) — no manual tool file needed.
+
+```ruby
+class SupervisorAgent < OmniAgent::Agent
+	use_model "gpt-4o"
+
+	delegate_to ResearchAgent, as: :research,  description: "Look up factual info"
+	delegate_to MathAgent,     as: :calculate, description: "Do arithmetic"
+end
+```
+
+Each delegated agent runs in isolation (its own fresh instance, no shared context) and returns its final answer as the tool result. Delegation depth is capped by `OmniAgent.configuration.max_delegation_depth` (default `5`) to guard against runaway recursive delegation; exceeding it raises `OmniAgent::MaxDelegationDepthError`.
+
+Pass `run_alias:` to call a `run_aliases` method (or any zero-arg run entrypoint) on the delegated agent instead of its default `#run` — useful when the sub-agent should render a different prompt file for delegated calls:
+
+```ruby
+class SupervisorAgent < OmniAgent::Agent
+	delegate_to SupportAgent, as: :triage_ticket, run_alias: :triage
+end
+```
+
+Pass `forward:` to share part (or all) of the supervisor's context with the delegated agent — an array of context keys, or `true` to forward everything. Omitted keys, and the default (`forward: []`), keep the delegated agent fully isolated:
+
+```ruby
+class SupervisorAgent < OmniAgent::Agent
+	delegate_to ResearchAgent, as: :research, forward: [ :user, :locale ]
+	delegate_to MathAgent,     as: :calculate, forward: true
+end
+```
+
+## Streaming
+
+Prefix any run entrypoint with `.stream` and pass a block to receive the response as it's generated instead of waiting for the full result:
+
+```ruby
+ResearchAgent.with(user_id: 42).stream.run("What's new?") do |event|
+	case event.type
+	when :text        then print event.text
+	when :tool_call   then puts "\n[using #{event.tool_name}...]"
+	when :tool_result then puts "[#{event.error? ? "failed" : "done"}]"
+	when :done        then puts "\n---"
+	end
+end
+```
+
+`.stream` must come before the call (`.stream.run(...)`, not `.run(...).stream`) — without it, or without a block, behavior is unchanged and the same `Response` is returned either way. Only the `openai`, `ollama`, and `mock` providers stream today. See [Streaming Responses](omniagent-docs/docs/agent/streaming.mdx) for the full event reference.
+
 ## Evals
 
 `OmniAgent::Eval` lets you test agent quality: deterministic assertions (tool calls, output matching) and pluggable LLM-as-judge scoring.

data/lib/omni_agent/agent.rb

@@ -20,7 +20,7 @@ module OmniAgent
         @_omni_agent_wrapping_method = true
         alias_method alias_name, method_name
 
-        define_method(method_name) do |input = nil, context: {}, **context_keywords|
+        define_method(method_name) do |input = nil, context: {}, **context_keywords, &block|
           if input.nil? && context == {} && context_keywords.empty?
             run_alias_entrypoint_logic(alias_name)
           else
@@ -29,7 +29,7 @@ module OmniAgent
 
             run_input = run_alias_entrypoint_logic(alias_name, fallback_input: input)
 
-            run(run_input, context: merged_context, prompt_method: method_name)
+            run(run_input, context: merged_context, prompt_method: method_name, &block)
           end
         end
       ensure
@@ -78,12 +78,27 @@ module OmniAgent
         aliases = normalize_callbacks(:run_aliases, method_names)
 
         aliases.each do |method_name|
-          define_method(method_name) do |input, context: {}|
-            run(input, context: context, prompt_method: method_name)
+          define_method(method_name) do |input, context: {}, &block|
+            run(input, context: context, prompt_method: method_name, &block)
           end
         end
       end
 
+      def delegate_to(agent_class, as:, description: nil, run_alias: nil, forward: [])
+        unless agent_class.is_a?(Class) && agent_class <= OmniAgent::Agent
+          raise ArgumentError, "delegate_to requires an OmniAgent::Agent subclass"
+        end
+
+        tool_class = build_delegated_tool_class(agent_class, description: description, run_alias: run_alias, forward: forward)
+        delegated_tools_module.const_set(delegated_tool_const_name(as), tool_class)
+
+        @delegated_tool_classes = configured_delegated_tool_classes + [ tool_class ]
+      end
+
+      def configured_delegated_tool_classes
+        @delegated_tool_classes || []
+      end
+
       def with(context = nil, provider_override: nil, model_override: nil, options_override: {}, **context_keywords)
         merged_context = {}
         merged_context.merge!(context) if context.is_a?(Hash)
@@ -112,6 +127,58 @@ module OmniAgent
 
       private
 
+      def delegated_tools_module
+        @delegated_tools_module ||= const_set(:DelegatedTools, Module.new)
+      end
+
+      def delegated_tool_const_name(as)
+        as.to_s.split(/[_\s]+/).reject(&:empty?).map { |part| part[0].upcase + part[1..] }.join
+      end
+
+      def build_delegated_tool_class(agent_class, description:, run_alias:, forward:)
+        tool_description = description || "Delegate to #{agent_class.name}."
+
+        Class.new(OmniAgent::Tool) do
+          description tool_description
+
+          input do
+            string :input, description: "Input/question to send to the delegated agent."
+          end
+
+          define_method(:execute) do |input:|
+            forwarded_context = OmniAgent::Agent.__send__(:filter_forwarded_context, context, forward)
+            OmniAgent::Agent.__send__(:run_delegated_agent, agent_class, input, run_alias, forwarded_context)
+          end
+        end
+      end
+
+      def filter_forwarded_context(context, forward)
+        return {} unless context.is_a?(Hash)
+        return context.dup if forward == true
+        return {} if forward.nil? || forward == false
+
+        keys = Array(forward).map(&:to_sym)
+        context.select { |key, _| keys.include?(key.to_sym) }
+      end
+
+      def run_delegated_agent(agent_class, input, run_alias, forwarded_context)
+        depth = (Thread.current[:omni_agent_delegation_depth] ||= 0)
+        max_depth = OmniAgent.configuration.max_delegation_depth
+
+        if depth >= max_depth
+          raise OmniAgent::MaxDelegationDepthError,
+                "Exceeded max_delegation_depth (#{max_depth}) while delegating to #{agent_class.name}."
+        end
+
+        Thread.current[:omni_agent_delegation_depth] = depth + 1
+        begin
+          entrypoint = run_alias || :run
+          agent_class.new.public_send(entrypoint, input, context: forwarded_context).answer
+        ensure
+          Thread.current[:omni_agent_delegation_depth] = depth
+        end
+      end
+
       def normalize_callbacks(callback_type, callbacks)
         raise ArgumentError, "#{callback_type} requires at least one method name" if callbacks.empty?
 
@@ -145,7 +212,11 @@ module OmniAgent
       @default_context = context_override || {}
     end
 
-    def run(input, context: {}, prompt_method: nil)
+    def stream
+      OmniAgent::Streaming::Proxy.new(self)
+    end
+
+    def run(input, context: {}, prompt_method: nil, &stream)
       context = @default_context.merge(context || {})
       bind_context_instance_variables(context)
 
@@ -170,13 +241,14 @@ module OmniAgent
                 "Increase OmniAgent.configuration.max_tool_iterations if more tool calls are expected."
         end
 
-        response = provider.chat(messages: messages, tools: filtered_tools, **@chat_options)
+        response = provider.chat(messages: messages, tools: filtered_tools, stream: stream, **@chat_options)
 
         if response.content && !response.tool_calls?
           messages << { role: "assistant", content: response.content }
           set_after_generation_state(response: response, messages: messages, initial_messages_count: initial_messages_count)
           run_after_generation_callbacks(input: input, context: context, messages: messages, response: response)
           sync_context_from_instance_variables(context)
+          stream&.call(OmniAgent::Streaming::Event.done(response))
           return response
         end
 
@@ -196,6 +268,9 @@ module OmniAgent
 
           if tool_class
             tool_instance = tool_class.new
+            tool_instance.context = context if tool_instance.respond_to?(:context=)
+
+            stream&.call(OmniAgent::Streaming::Event.tool_call(name: tool_name, arguments: tool_args, id: tool_id))
 
             begin
               result = tool_instance.invoke(tool_args)
@@ -206,13 +281,16 @@ module OmniAgent
                 name: tool_name,
                 content: result.to_s
               }
+              stream&.call(OmniAgent::Streaming::Event.tool_result(name: tool_name, id: tool_id, content: result.to_s))
             rescue => e
+              error_content = "Error executing tool: #{e.message}"
               messages << {
                 role: "tool",
                 tool_call_id: tool_id,
                 name: tool_name,
-                content: "Error executing tool: #{e.message}"
+                content: error_content
               }
+              stream&.call(OmniAgent::Streaming::Event.tool_result(name: tool_name, id: tool_id, content: error_content, error: true))
             end
 
             should_stop_generation ||= tool_class.respond_to?(:stops_generation?) && tool_class.stops_generation?
@@ -231,6 +309,7 @@ module OmniAgent
           set_after_generation_state(response: response, messages: messages, initial_messages_count: initial_messages_count)
           run_after_generation_callbacks(input: input, context: context, messages: messages, response: response)
           sync_context_from_instance_variables(context)
+          stream&.call(OmniAgent::Streaming::Event.done(response))
           return response
         end
       end
@@ -238,12 +317,17 @@ module OmniAgent
 
     def available_tools
       tool_namespace = "#{self.class.name}::Tools".safe_constantize
-      return [] unless tool_namespace
 
-      tool_namespace.constants.filter_map do |const_name|
-        const = tool_namespace.const_get(const_name)
-        const if const.is_a?(Class) && const < OmniAgent::Tool
+      namespace_tools = if tool_namespace
+        tool_namespace.constants.filter_map do |const_name|
+          const = tool_namespace.const_get(const_name)
+          const if const.is_a?(Class) && const < OmniAgent::Tool
+        end
+      else
+        []
       end
+
+      namespace_tools + self.class.configured_delegated_tool_classes
     end
 
     private

data/lib/omni_agent/configuration.rb

@@ -1,7 +1,7 @@
 module OmniAgent
   class Configuration
     attr_accessor :default_provider, :default_model, :max_retries, :retry_base_delay, :max_tool_iterations,
-                  :eval_judge_provider, :eval_judge_model, :eval_cache_enabled, :eval_cache_path
+                  :max_delegation_depth, :eval_judge_provider, :eval_judge_model, :eval_cache_enabled, :eval_cache_path
 
     def initialize
       @default_provider = :openai
@@ -9,6 +9,7 @@ module OmniAgent
       @max_retries = 3
       @retry_base_delay = 0.5
       @max_tool_iterations = 10
+      @max_delegation_depth = 5
       @eval_judge_provider = nil
       @eval_judge_model = nil
       @eval_cache_enabled = true

data/lib/omni_agent/errors.rb

@@ -4,6 +4,7 @@ module OmniAgent
     class MissingDependencyError < Error; end
     class UnknownProviderError < Error; end
     class MaxToolIterationsError < Error; end
+    class MaxDelegationDepthError < Error; end
     class EvalAssertionError < Error; end
   end
 
@@ -11,5 +12,6 @@ module OmniAgent
   MissingDependencyError = Errors::MissingDependencyError
   UnknownProviderError = Errors::UnknownProviderError
   MaxToolIterationsError = Errors::MaxToolIterationsError
+  MaxDelegationDepthError = Errors::MaxDelegationDepthError
   EvalAssertionError = Errors::EvalAssertionError
 end

data/lib/omni_agent/providers/base.rb

@@ -9,7 +9,7 @@ module OmniAgent
         @model = model || default_model
       end
 
-      def chat(messages:, tools: [], **_options)
+      def chat(messages:, tools: [], stream: nil, **_options)
         raise NotImplementedError, "Providers must implement #chat"
       end
 

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

@@ -28,6 +28,8 @@ module OmniAgent
 
           @properties = builder.properties
           @required = builder.required_fields
+          @validators = builder.validators
+          @polymorphics = builder.polymorphics
         end
       end
 
@@ -43,7 +45,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 +66,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?
 
@@ -69,6 +160,12 @@ module OmniAgent
       end
     end
 
+    attr_accessor :context
+
+    def initialize
+      @context = {}
+    end
+
     def invoke(arguments_hash)
       filtered_kwargs = self.class.parse_arguments(arguments_hash)
       execute(**filtered_kwargs)

data/lib/omni_agent/version.rb

@@ -1,3 +1,3 @@
 module OmniAgent
-  VERSION = "0.1.7"
+  VERSION = "0.1.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omni_agent
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - ACR1209
@@ -85,9 +85,12 @@ files:
 - 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