omni_agent 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea0324a20bc12e064b994b4fcdf7af700cd0280ba7b0609dc75724717e9fc881
-  data.tar.gz: dfda03e711340e59dfbb1cd803bc785a51bbe39d972992c6a26fb5b2d4d8761a
+  metadata.gz: 66c390e526b0bd6176f8755538304d0e0e99d9cc36627be1ee9b63119b53ce34
+  data.tar.gz: 4918452fbba6d30772abbf9d072d0c16cf363d5220a099183e9caa04d7481220
 SHA512:
-  metadata.gz: 72739c339838d0f38c172455226ff79244ab7e739920ec9e7b89f16182d220a1526886bff1f85b7b943bc6426676d5cc4dbd727f903c612df401587fc627f3f0
-  data.tar.gz: b90d265c701efaf90d5d5f5e5f9aac3b337095e998d413bf5e872e05d794a9793a44e0bd669425d30ee13eabd50ded2f0fdc2c19cadbc1ff976ec02d0e8d888f
+  metadata.gz: 522e4be90a757a9056e95cf45f5aafb1f18d7b6914e1ca667e32b3774ab70422f552e333ac2e340c4d1dab1c628350e04d494a9726b908467eb53723ae300dd6
+  data.tar.gz: c2c7939747237e554df0ac2569b84e36b164c1235f75fa876f04518cb644ad02579e18f4ee168c53ff55f32b75c8a58284ff921b217eda4b9148f67a8d5e4de7

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 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)
 
 

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
@@ -129,6 +139,23 @@ class SupervisorAgent < OmniAgent::Agent
 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,8 +78,8 @@ 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
@@ -212,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)
 
@@ -237,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
 
@@ -265,6 +270,8 @@ module OmniAgent
             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)
 
@@ -274,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?
@@ -299,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

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?
 

data/lib/omni_agent/version.rb

@@ -1,3 +1,3 @@
 module OmniAgent
-  VERSION = "0.1.8"
+  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.8
+  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