ox-ai-workers 1.0.3.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40e4c40056a05355df7b66a1c7aacb17bad47f9614d36e6b74123dff5f4a2c32
-  data.tar.gz: d65bb1c38aeeb5504421fc98055c7a4a03412fd58ced9ad4e8e2d39eb1c2cb7a
+  metadata.gz: 222d468a923d3589372785cdb3d6cc17aab4328b5598565aa69f77d9623a5b61
+  data.tar.gz: b6af99dfa09c007f67affe266e6de0add9f0a2e82968a244bc06cdfe544a3f8e
 SHA512:
-  metadata.gz: 1e475007bbf4da1f6d29e290b073c91476d9ff45d5a0e12d218368de6634d6e66b39ee151163c6d19bbb024bc3147bd2126d4f1faa8a44f649c7837d459ebc05
-  data.tar.gz: 8564897582fe09d96199dfbd7c805b098057ea69a8aab51912ad483f4323786084488dd41f5ee88c48c8f056cf953b23f1e77f83002b9607ac87814bd3617659
+  metadata.gz: 82e8a31e47464a3d0d2f9cf1a37b317a5f5fa5df65f2ce997d99b596002dbc91d58685abc7bf90f4fdb011c441b21437510e67e25b8380a1e72626ee72c142a6
+  data.tar.gz: 3dbb22555ea1448c5dde835374f18bc9f4c201a7a854a1866029e43a28b3a10f4486435684ee61cef7f11839502d03dc051e8b71a19d91dcec8875b322f79ef9

data/.ruby-version

@@ -1 +1 @@
-3.4.1
+3.4.4

data/CHANGELOG.md

@@ -1,8 +1,7 @@
-## [1.0.2] - 2025-05-17
+## [1.1.0] - 2025-05-21
 
-- Added `openai_whisper` model
-- Added `openai_transcribe` model
-- Added `tool_call_id` for `Iterator`
+- Added `add_base64` and `add_url` for Models
+- Added Anthropic support
 
 ## [1.0.1] - 2025-05-13
 
@@ -65,7 +64,6 @@
 - Fixed tool calls parsing
 - Refine Russian locale for Iterator with enhanced step descriptions and planning guidance
 - Update locale for Iterator
-- Added `on_stream` for `Iterator`
 
 ## [0.7.10] - 2025-03-31
 

data/README.md

@@ -392,7 +392,7 @@ class MyTool
     
     define_function :hello_world, description: "Says hello to someone" do
       property :name, type: "string", description: "Name to greet" # Default required: true
-      property :age, type: ["integer", "null"], description: "Age of the person" # Default required: true, can be null so it's optional
+      property :age, type: "integer", description: "Age of the person", required: false
     end
   end
   
@@ -409,8 +409,6 @@ class MyTool
 end
 ```
 
-The `define_function` method accepts an optional `strict` parameter (defaults to `true`) that controls whether additional properties are allowed in the input. When `strict: true` (default), the schema will include `additionalProperties: false`, enforcing that only defined properties can be used.
-
 Tools can also implement a `context` method that returns information to be included in assistant conversations before each request, which is particularly useful when multiple assistants share a common tool to maintain shared state or history.
 
 ### Working with Files and Images
@@ -495,20 +493,6 @@ iterator = OxAiWorkers::Iterator.new(
 )
 ```
 
-### Streaming API Responses
-
-Enable streaming for real-time feedback:
-
-```ruby
-worker = OxAiWorkers::Request.new(
-  on_stream: ->(chunk) { 
-    if chunk.dig('choices', 0, 'delta', 'content')
-      print chunk.dig('choices', 0, 'delta', 'content') 
-    end
-  }
-)
-```
-
 ### Available Assistant Types
 
 OxAiWorkers provides several specialized assistant types:

data/lib/ox-ai-workers.rb

@@ -62,7 +62,7 @@ module OxAiWorkers
 
   class Configuration
     attr_accessor :max_tokens, :temperature, :wait_for_complete, :access_token_deepseek, :access_token_openai,
-                  :access_token_stability, :access_token_wolfram, :access_token_anthropic
+                  :access_token_stability, :access_token_wolfram, :access_token_anthropic, :access_token_gemini
 
     def initialize
       @max_tokens = DEFAULT_MAX_TOKEN
@@ -74,6 +74,7 @@ module OxAiWorkers
       @access_token_stability = nil
       @access_token_wolfram = nil
       @access_token_anthropic = nil
+      @access_token_gemini = nil
 
       [Array, NilClass, String, Symbol, Hash].each do |c|
         c.send(:include, OxAiWorkers::PresentCompat) unless c.method_defined?(:present?)

data/lib/oxaiworkers/assistant/module_base.rb

@@ -25,9 +25,9 @@ module OxAiWorkers
         execute
       end
 
-      def init_worker(delayed: false, model: nil, on_stream: nil)
+      def init_worker(delayed: false, model: nil)
         model ||= OxAiWorkers.default_model
-        delayed ? DelayedRequest.new(model:) : Request.new(model:, on_stream:)
+        delayed ? DelayedRequest.new(model:) : Request.new(model:)
       end
 
       def replace_context(context)

data/lib/oxaiworkers/assistant/orchestrator.rb

@@ -11,7 +11,7 @@ module OxAiWorkers
         store_locale
 
         @pipeline = Tool::Pipeline.new(
-          on_message: ->(text:) { @iterator.add_queue text, role: :system }
+          on_message: ->(text:) { @iterator.add_queue text }
         )
 
         with_locale do

data/lib/oxaiworkers/iterator.rb

@@ -18,6 +18,11 @@ module OxAiWorkers
       @locale = locale || I18n.locale
       @call_id = 0
 
+      @def_only = def_only || ITERATOR_FUNCTIONS
+      @def_except = def_except
+
+      init_white_list_with available_defs
+
       with_locale do
         define_function :inner_monologue, description: I18n.t('oxaiworkers.iterator.inner_monologue.description') do
           property :speach, type: 'string', description: I18n.t('oxaiworkers.iterator.inner_monologue.speach'),
@@ -37,8 +42,6 @@ module OxAiWorkers
       @tools = tools
       @role = role
       @context = []
-      @def_only = def_only || ITERATOR_FUNCTIONS
-      @def_except = def_except
 
       @on_inner_monologue = on_inner_monologue
       @on_outer_voice = on_outer_voice
@@ -129,14 +132,14 @@ module OxAiWorkers
       end
       @worker.append(messages: @messages)
       @tasks.each { |task| @worker.append(role: :user, content: "<task>\n#{task}\n</task>") }
-      @worker.tools = function_schemas.to_openai_format(only: available_defs)
+      @worker.tools = [function_schemas]
       return unless @tools.present?
 
       @worker.tools += @tools.map do |tool|
         if tool.respond_to?(:function_schemas)
-          tool.function_schemas.to_openai_format
+          tool.function_schemas
         else
-          tool.class.function_schemas.to_openai_format
+          tool.class.function_schemas
         end
       end.flatten
     end
@@ -180,6 +183,8 @@ module OxAiWorkers
       OxAiWorkers.logger.warn "Iterator::ServerError #{e.message}. Waiting 10 seconds..."
       sleep(10)
       external_request
+    rescue Faraday::BadRequestError => e
+      OxAiWorkers.logger.warn "Iterator::BadRequestError #{e.message}. #{@worker.messages.to_json}"
     end
 
     def tick_or_wait
@@ -228,26 +233,12 @@ module OxAiWorkers
           @call_id += 1
           # Add tool call message in the correct format
           out = tool.send(external_call[:name], **external_call[:args])
-          @queue << {
-            role: :assistant,
-            tool_calls: [{
-              id: "call_#{@call_id}",
-              type: 'function',
-              function: {
-                name: external_call[:name],
-                arguments: external_call[:args].to_json
-              }
-            }]
-          }
-          @queue << if out.present?
-                      { role: :tool,
-                        content: out,
-                        tool_call_id: "call_#{@call_id}" }
-                    else
-                      { role: :tool,
-                        content: "Tool call #{external_call[:name]} successful.",
-                        tool_call_id: "call_#{@call_id}" }
-                    end
+          @queue += @worker.model.tool_call(
+            name: external_call[:name],
+            args: external_call[:args],
+            call_id: @call_id,
+            out:
+          )
         end
         @worker.finish
         iterate! if can_iterate?
@@ -269,35 +260,22 @@ module OxAiWorkers
       @queue << { role:, content: text }
     end
 
-    def add_context(text, role: :system)
+    def add_context(text, role: :user)
       add_raw_context({ role:, content: text })
     end
 
     def add_file(pdf:, filename:, text:, role: :user)
-      content = []
-      content << { type: 'text', text: } if text.present?
-      content << {
-        type: 'file',
-        file: {
-          filename:,
-          file_data: "data:application/pdf;base64,#{Base64.strict_encode64(pdf)}"
-        }
-      }
-
+      content = @worker.model.add_base64(binary: pdf, filename:, text:, mime_type: 'application/pdf')
       add_raw_context({ role:, content: })
     end
 
     def add_image(text:, url: nil, binary: nil, role: :user, detail: 'auto', mime_type: 'image/png')
       content = []
-      content << { type: 'text', text: } if text.present?
-
-      image_url = if binary.present?
-                    "data:#{mime_type};base64,#{Base64.strict_encode64(binary)}"
-                  else
-                    url
-                  end
-
-      content << { type: 'image_url', image_url: { url: image_url, detail: } }
+      if binary.present?
+        content = @worker.model.add_base64(binary:, filename:, text:, mime_type:, detail:)
+      elsif url.present?
+        content = @worker.model.add_url(url:, text:, detail:, mime_type:)
+      end
 
       add_raw_context({ role:, content: })
     end

data/lib/oxaiworkers/models/anthropic_max.rb

@@ -5,9 +5,144 @@ module OxAiWorkers
     class AnthropicMax < LLMBase
       def initialize(uri_base: nil, api_key: nil, model: nil, max_tokens: nil, temperature: nil, frequency_penalty: nil)
         @model = model || 'claude-3-7-sonnet-latest'
-        @uri_base = uri_base || 'https://api.anthropic.com/v1/'
+        @uri_base = uri_base # || 'https://api.anthropic.com/v1/'
         @api_key = api_key || OxAiWorkers.configuration.access_token_anthropic
-        super(uri_base:, api_key: @api_key, model: @model, max_tokens:, temperature:, frequency_penalty:)
+        super(uri_base: @uri_base, api_key: @api_key, model: @model, max_tokens:, temperature:, frequency_penalty:)
+      end
+
+      def client
+        @client ||= Anthropic::Client.new(
+          access_token: @api_key,
+          uri_base: @uri_base,
+          log_errors: true
+        )
+      end
+
+      def request(parameters)
+        client.messages(parameters:)
+      end
+
+      def build_parameters(messages:, tools: [], filtered_functions: [], tool_choice: nil)
+        parameters = {
+          model: @model,
+          system: messages.select { |m| m[:role] == :system }.map { |m| m[:content] }.join("\n\n"),
+          messages: messages.reject { |m| m[:role] == :system },
+          temperature: @temperature,
+          max_tokens: @max_tokens
+        }
+        if tools.present?
+          functions = tools.map(&:to_anthropic_format).flatten
+
+          @names = functions.map { |f| f[:name] }
+
+          parameters[:tools] = functions.reject { |f| filtered_functions.include?(f[:name]) }
+
+          parameters[:tool_choice] =
+            tool_choice.nil? ? { type: 'any' } : { type: 'tool', name: tool_choice }
+        end
+        parameters
+      end
+
+      def tool_call(name:, args:, call_id:, out:)
+        [
+          {
+            role: :assistant,
+            content: [
+              {
+                type: 'tool_use',
+                id: "call_#{call_id}",
+                name:,
+                input: args
+              }
+            ]
+          },
+          {
+            role: :user,
+            content: [
+              {
+                type: 'tool_result',
+                tool_use_id: "call_#{call_id}",
+                content: out.present? ? out : "Tool call #{name} successful."
+              }
+            ]
+          }
+        ]
+      end
+
+      def add_base64(binary:, filename:, text:, mime_type:)
+        content = []
+        content << { type: 'text', text: } if text.present?
+        content << {
+                      type: mime_type.include?('image') ? 'image' : 'document',
+                      source: {
+                        type: 'base64',
+                        media_type: mime_type,
+                        data: Base64.strict_encode64(binary)
+                      }
+                    }
+        content
+      end
+
+      def add_url(url:, text:, mime_type:)
+        content = []
+        content << { type: 'text', text: } if text.present?
+        content << {
+                      type: mime_type.include?('image') ? 'image' : 'document',
+                      source: {
+                        type: 'url',
+                        url: url
+                      }
+                    }
+        content
+      end
+
+      def parse_response(response, &)
+        choices = response['content']
+        @is_truncated = (response['stop_reason'] == 'max_tokens')
+        return if choices.nil? || choices.empty?
+
+        choices.each do |choice|
+          result, tool_calls = parse_one_choice(choice)
+          yield(result, @is_truncated, tool_calls)
+        end
+      end
+
+      def parse_one_choice(choice)
+        return unless choice # Skip if there's no choice
+
+        # Initialize result variables
+        @result = nil
+        @tool_calls = []
+
+        # Process content item
+        if choice['type'] == 'tool_use'
+          # Handle tool use
+          begin
+            # Attempt to parse arguments, handle potential JSON errors
+            args = JSON.parse(choice['input'].to_json, symbolize_names: true)
+          rescue JSON::ParserError => e
+            OxAiWorkers.logger.error("Failed to parse tool call arguments: #{e.message}", for: self.class)
+            OxAiWorkers.logger.debug("Raw arguments: #{choice['input']}", for: self.class)
+          end
+
+          fname = @names.find { |n| n.end_with?(choice['name']) }
+          if fname != choice['name']
+            OxAiWorkers.logger.error("Tool call name #{choice['name']} not found. Using #{fname} instead.",
+                                     for: self.class)
+          end
+
+          tool_call = {
+            class: fname.split('__').first,
+            name: fname.split('__').last,
+            args:
+          }
+          @tool_calls << tool_call
+        elsif choice['type'] == 'text'
+          # Handle text content
+          @result = choice['text']
+        end
+
+        [@result, @tool_calls]
       end
     end
   end

data/lib/oxaiworkers/models/llm_base.rb

@@ -13,6 +13,148 @@ module OxAiWorkers
         @uri_base = uri_base
         @model = model
       end
+
+      def request(parameters)
+        client.chat(parameters:)
+      end
+
+      def client
+        @client ||= OpenAI::Client.new(
+          access_token: @api_key,
+          uri_base: @uri_base,
+          log_errors: true # Highly recommended in development, so you can see what errors OpenAI is returning. Not recommended in production because it could leak private data to your logs.
+        )
+      end
+
+      def build_parameters(messages:, tools: [], filtered_functions: [], tool_choice: nil)
+        parameters = {
+          model: @model,
+          messages:,
+          temperature: @temperature,
+          max_completion_tokens: @max_tokens,
+          frequency_penalty: @frequency_penalty
+        }
+        if tools.present?
+          functions = tools.map(&:to_openai_format).flatten
+
+          parameters[:tools] = functions.reject { |f| filtered_functions.include?(f[:name]) }
+
+          parameters[:tool_choice] =
+            tool_choice.nil? ? 'required' : { type: 'function', function: { name: tool_choice } }
+        end
+        parameters
+      end
+
+      def tool_call(name:, args:, call_id:, out:)
+        [
+          {
+            role: :assistant,
+            tool_calls: [{
+              id: "call_#{call_id}",
+              type: 'function',
+              function: {
+                name:,
+                arguments: args.to_json
+              }
+            }]
+          },
+          {
+            role: :tool,
+            content: out.present? ? out : "Tool call #{name} successful.",
+            tool_call_id: "call_#{call_id}"
+          }
+        ]
+      end
+
+      def add_base64(binary:, filename:, text:, mime_type:, detail: 'auto')
+        content = []
+        content << { type: 'text', text: } if text.present?
+        content << if mime_type.include?('image')
+                     { type: 'image_url',
+                       image_url: { 
+                                    url: "data:#{mime_type};base64,#{Base64.strict_encode64(binary)}",
+                                    detail: 
+                                  } 
+                      }
+                   else
+                     {
+                       type: 'file',
+                       file: {
+                         filename:,
+                         file_data: "data:#{mime_type};base64,#{Base64.strict_encode64(binary)}"
+                       }
+                     }
+                   end
+        content
+      end
+
+      def add_url(url:, text:, detail: 'auto')
+        content = []
+        content << { type: 'text', text: } if text.present?
+        content << { type: 'image_url', image_url: { url:, detail: } }
+        content
+      end
+
+      def parse_response(response, &)
+        choices = response['choices']
+        return if choices.nil? || choices.empty?
+
+        choices.each do |choice|
+          arr = parse_one_choice(choice)
+          yield(arr)
+        end
+      end
+
+      def parse_one_choice(choice)
+        message = choice['message']
+        return unless message # Skip if there's no message in this choice
+
+        # Accumulate raw tool calls if present
+        tool_calls_raw = message['tool_calls']
+
+        # Update result with the content if present
+        current_result = message['content']
+        @result = current_result if current_result.present?
+
+        # Update finish reason and truncation status based on the *last* choice's reason
+        current_finish_reason = choice['finish_reason']
+        @is_truncated = (current_finish_reason == 'length')
+
+        @tool_calls = _parse_tool_calls(tool_calls_raw) unless @is_truncated || tool_calls_raw.empty?
+        [@result, @is_truncated, @tool_calls]
+      end
+
+      def _parse_tool_calls(tool_calls_raw)
+        tool_calls = [] # Ensure it's clean before parsing
+        tool_calls_raw.each do |tool_call|
+          next unless tool_call['type'] == 'function' # Ensure it's a function call
+
+          function = tool_call['function']
+          next unless function && function['name'] && function['arguments']
+
+          begin
+            # Attempt to parse arguments, handle potential JSON errors
+            args = JSON.parse(function['arguments'], symbolize_names: true)
+          rescue JSON::ParserError => e
+            OxAiWorkers.logger.error("Failed to parse tool call arguments: #{e.message}", for: self.class)
+            OxAiWorkers.logger.debug("Raw arguments: #{function['arguments']}", for: self.class)
+            # Decide how to handle parsing errors, e.g., skip this call or add with empty args
+            # Skipping for now, as partial args are likely useless.
+            next
+          end
+          OxAiWorkers.logger.debug("function: #{function.inspect}", for: self.class)
+          # Accumulate parsed tool calls
+          next if function['name'].empty?
+
+          tool_calls << {
+            class: function['name'].split('__').first,
+            name: function['name'].split('__').last,
+            args:
+          }
+          # @last_call = function['name'].to_s
+        end
+        tool_calls
+      end
     end
   end
 end

data/lib/oxaiworkers/module_request.rb

@@ -3,16 +3,14 @@
 module OxAiWorkers
   class ModuleRequest
     attr_accessor :result, :client, :messages, :model, :custom_id, :tools, :errors,
-                  :tool_calls_raw, :tool_calls, :is_truncated, :finish_reason, 
-                  :on_stream_proc, :call_stack, :last_call, :stop_double_calls
+                  :tool_calls, :is_truncated,
+                  :call_stack, :last_call, :stop_double_calls
 
-    def initialize_requests(model:, on_stream: nil, call_stack: nil)
+    def initialize_requests(model:, call_stack: nil)
       @custom_id = SecureRandom.uuid
       @model = model
       @client = nil
       @is_truncated = false
-      @finish_reason = nil
-      @on_stream_proc = on_stream
       @call_stack = call_stack
       @last_call = nil
 
@@ -25,18 +23,12 @@ module OxAiWorkers
     end
 
     def cleanup
-      @client ||= OpenAI::Client.new(
-        access_token: @model.api_key,
-        uri_base: @model.uri_base,
-        log_errors: true # Highly recommended in development, so you can see what errors OpenAI is returning. Not recommended in production because it could leak private data to your logs.
-      )
+      @client ||= @model.client
       @result = nil
       @errors = nil
       @messages = []
       @tool_calls = nil
-      @tool_calls_raw = nil
       @is_truncated = false
-      @finish_reason = nil
       # @last_call = nil
     end
 
@@ -46,32 +38,23 @@ module OxAiWorkers
     end
 
     def params
-      parameters = {
-        model: @model.model,
+      filtered_functions = []
+      filtered_functions << @last_call if @stop_double_calls.include?(@last_call)
+
+      tool_choice = if @call_stack&.any?
+                      func1 = @call_stack.first
+                      @call_stack = @call_stack.drop(1)
+                      func1
+                    else
+                      nil
+                    end
+
+      @model.build_parameters(
         messages: @messages,
-        temperature: @model.temperature,
-        max_completion_tokens: @model.max_tokens,
-        frequency_penalty: @model.frequency_penalty
-      }
-      if @tools.present?
-        parameters[:tools] = @tools.reject do |f|
-          tool_name = f[:function][:name]
-          tool_name == @last_call && @stop_double_calls.include?(tool_name)
-        end
-
-        if @call_stack&.any?
-          func1 = @call_stack.first
-          @call_stack = @call_stack.drop(1)
-          parameters[:tool_choice] = { type: 'function', function: { name: func1 } }
-        else
-          parameters[:tool_choice] = 'required'
-        end
-      end
-      if @on_stream_proc.present?
-        parameters[:stream] = @on_stream_proc
-        parameters[:stream_options] = { include_usage: true }
-      end
-      parameters
+        tools: @tools,
+        filtered_functions:,
+        tool_choice:
+      )
     end
 
     def not_found_is_ok
@@ -83,75 +66,15 @@ module OxAiWorkers
     def parse_choices(response)
       # Reset instance variables before processing choices
       @result = nil
-      @tool_calls_raw = []
       @tool_calls = []
-      @finish_reason = nil
       @is_truncated = false
 
-      choices = response['choices']
-      return if choices.nil? || choices.empty?
-
-      choices.each do |choice|
-        # Parse basic info and accumulate raw tool calls
-        parse_one_choice(choice)
-      end
-
-      # Only parse tool calls if the response wasn't truncated
-      _parse_tool_calls unless @is_truncated || @tool_calls_raw.empty?
-    end
-
-    def parse_one_choice(choice)
-      message = choice['message']
-      return unless message # Skip if there's no message in this choice
-
-      # Accumulate raw tool calls if present
-      @tool_calls_raw.concat(message['tool_calls']) if message['tool_calls']
-
-      # Update result with the content if present
-      current_result = message['content']
-      @result = current_result if current_result.present?
-
-      # Update finish reason and truncation status based on the *last* choice's reason
-      current_finish_reason = choice['finish_reason']
-      if current_finish_reason.present?
-        @finish_reason = current_finish_reason
-        @is_truncated = (@finish_reason == 'length')
-      end
-    end
-
-    private
-
-    # Parses the accumulated raw tool calls into the structured @tool_calls array.
-    # This should only be called after confirming the response is not truncated.
-    def _parse_tool_calls
-      @tool_calls = [] # Ensure it's clean before parsing
-      @tool_calls_raw.each do |tool_call|
-        next unless tool_call['type'] == 'function' # Ensure it's a function call
-
-        function = tool_call['function']
-        next unless function && function['name'] && function['arguments']
-
-        begin
-          # Attempt to parse arguments, handle potential JSON errors
-          args = JSON.parse(function['arguments'], symbolize_names: true)
-        rescue JSON::ParserError => e
-          OxAiWorkers.logger.error("Failed to parse tool call arguments: #{e.message}", for: self.class)
-          OxAiWorkers.logger.debug("Raw arguments: #{function['arguments']}", for: self.class)
-          # Decide how to handle parsing errors, e.g., skip this call or add with empty args
-          # Skipping for now, as partial args are likely useless.
-          next
-        end
-        OxAiWorkers.logger.debug("function: #{function.inspect}", for: self.class)
-        # Accumulate parsed tool calls
-        next if function['name'].empty?
-
-        @tool_calls << {
-          class: function['name'].split('__').first,
-          name: function['name'].split('__').last,
-          args: args
-        }
-        @last_call = function['name'].to_s
+      @model.parse_response(response) do |result, is_truncated, tool_calls|
+        @result = result
+        @is_truncated = is_truncated
+        @tool_calls += tool_calls
       end
+      @last_call = @tool_calls.last[:name] if @tool_calls.any?
     end
   end
 end

data/lib/oxaiworkers/request.rb

@@ -10,7 +10,7 @@ module OxAiWorkers
     end
 
     def request!
-      response = @client.chat(parameters: params)
+      response = @model.request(params)
       parse_choices(response)
     end
 

data/lib/oxaiworkers/tool/pipeline.rb

@@ -17,8 +17,8 @@ module OxAiWorkers
                              required: true
           property :result, type: 'string', description: I18n.t('oxaiworkers.tool.pipeline.send_message.result'),
                             required: true
-          property :example, type: %w[string null], description: I18n.t('oxaiworkers.tool.pipeline.send_message.example'),
-                             required: true
+          property :example, type: 'string', description: I18n.t('oxaiworkers.tool.pipeline.send_message.example'),
+                             required: false
           property :to_id, type: 'string', description: I18n.t('oxaiworkers.tool.pipeline.send_message.to_id'),
                            required: true
         end

data/lib/oxaiworkers/tool/pixels.rb

@@ -19,8 +19,8 @@ module OxAiWorkers
           property :prompt, type: 'string', description: I18n.t('oxaiworkers.tool.pixels.generate_image.prompt'),
                             required: true
           if worker.sizes.length > 1
-            property :size, type: %w[string null], description: I18n.t('oxaiworkers.tool.pixels.generate_image.size'),
-                            enum: worker.sizes
+            property :size, type: 'string', description: I18n.t('oxaiworkers.tool.pixels.generate_image.size'),
+                            enum: worker.sizes, required: false
           end
           if current_dir.present?
             property :file_name, type: 'string',
@@ -28,8 +28,8 @@ module OxAiWorkers
                                  required: true
           end
           if worker.qualities.length > 1
-            property :quality, type: %w[string null], description: I18n.t('oxaiworkers.tool.pixels.generate_image.quality'),
-                               enum: worker.qualities
+            property :quality, type: 'string', description: I18n.t('oxaiworkers.tool.pixels.generate_image.quality'),
+                               enum: worker.qualities, required: false
           end
         end
 

data/lib/oxaiworkers/tool/wolfram.rb

@@ -19,8 +19,8 @@ module OxAiWorkers
           property :prompt, type: 'string', description: I18n.t('oxaiworkers.tool.wolfram_alpha.ask.prompt'),
                             required: true
           if location.nil?
-            property :location, type: %w[string null], description: I18n.t('oxaiworkers.tool.wolfram_alpha.ask.location'),
-                                required: true
+            property :location, type: 'string', description: I18n.t('oxaiworkers.tool.wolfram_alpha.ask.location'),
+                                required: false
           end
         end
 

data/lib/oxaiworkers/tool_definition.rb

@@ -109,7 +109,7 @@ module OxAiWorkers
         name = function_name(method_name)
 
         if block_given?
-          parameters = ParameterBuilder.new(parent_type: 'object', strict:).build(&)
+          parameters = ParameterBuilder.new(parent_type: 'object').build(&)
 
           if parameters[:properties].empty?
             raise ArgumentError,
@@ -118,11 +118,11 @@ module OxAiWorkers
         else
           # Create an empty parameters object with additionalProperties: false when strict is true
           parameters = { type: 'object', properties: {} }
-          parameters[:additionalProperties] = false if strict
+          # parameters[:additionalProperties] = false if strict
         end
 
         function_params = { name:, description:, parameters: }
-        function_params[:strict] = true if strict
+        function_params[:strict] = strict
 
         @schemas[method_name] = {
           type: 'function',
@@ -133,36 +133,47 @@ module OxAiWorkers
       # Converts schemas to OpenAI-compatible format
       #
       # @return [String] JSON string of schemas in OpenAI format
-      def to_openai_format(only: nil)
-        valid_schemas(only:).values
+      def to_openai_format
+        @schemas_openai ||= Marshal.load(Marshal.dump(valid_schemas.values))
+        @schemas_openai.map do |schema|
+          if schema[:function][:strict] == true
+            parameters = schema[:function][:parameters]
+            parameters[:additionalProperties] = false
+            parameters[:properties].each do |key, param|
+              param[:type] = parameters[:required].include?(key.to_s) ? param[:type] : [param[:type], 'null']
+            end
+            parameters[:required] = parameters[:properties].keys.map(&:to_s)
+          else
+            schema[:function].delete(:strict)
+          end
+          schema
+        end
       end
 
       # Returns a subset of schemas based on the provided filter.
       #
       # @param only [Array<Symbol>] An optional array of schema names to filter by.
       # @return [Hash<Symbol, Hash>] A hash of schemas with their corresponding names as keys.
-      def valid_schemas(only: nil)
-        if only.nil?
-          @schemas
-        else
-          @schemas.select { |name, _schema| only.include?(name) }
-        end
+      def valid_schemas
+        @schemas
       end
 
       # Converts schemas to Anthropic-compatible format
       #
       # @return [String] JSON string of schemas in Anthropic format
-      def to_anthropic_format(only: nil)
-        valid_schemas(only:).values.map do |schema|
-          schema[:function].transform_keys('parameters' => 'input_schema')
+      def to_anthropic_format
+        @schemas_anthropic ||= Marshal.load(Marshal.dump(valid_schemas.values))
+        @schemas_anthropic.map do |schema|
+          schema[:function].delete(:strict)
+          schema[:function].transform_keys(parameters: :input_schema)
         end
       end
 
       # Converts schemas to Google Gemini-compatible format
       #
       # @return [String] JSON string of schemas in Google Gemini format
-      def to_google_gemini_format(only: nil)
-        valid_schemas(only:).values.map { |schema| schema[:function] }
+      def to_google_gemini_format
+        valid_schemas.values.map { |schema| schema[:function] }
       end
     end
 
@@ -170,10 +181,9 @@ module OxAiWorkers
     class ParameterBuilder
       VALID_TYPES = %w[object array string number integer boolean null].freeze
 
-      def initialize(parent_type:, strict: true)
+      def initialize(parent_type:)
         @schema = parent_type == 'object' ? { type: 'object', properties: {}, required: [] } : {}
         @parent_type = parent_type
-        @strict = strict
       end
 
       # Builds the parameter schema
@@ -200,7 +210,7 @@ module OxAiWorkers
         prop = { type:, description:, enum: }.compact
 
         if block_given?
-          nested_schema = ParameterBuilder.new(parent_type: type, strict: @strict).build(&)
+          nested_schema = ParameterBuilder.new(parent_type: type).build(&)
 
           case type
           when 'object'
@@ -222,7 +232,7 @@ module OxAiWorkers
         if @parent_type == 'object'
           @schema[:properties][name] = prop
           @schema[:required] << name.to_s if required
-          @schema[:additionalProperties] = false if @strict
+          # @schema[:additionalProperties] = false if @strict
         else
           @schema = prop
         end
@@ -246,7 +256,7 @@ module OxAiWorkers
           raise ArgumentError, "Invalid name '#{name}'. Name must be a symbol" unless name.is_a?(Symbol)
         end
 
-        unless VALID_TYPES.include?(type) || type.is_a?(Array) && type.all? { |t| VALID_TYPES.include?(t) }
+        unless VALID_TYPES.include?(type)
           raise ArgumentError, "Invalid type '#{type}'. Valid types are: #{VALID_TYPES.join(', ')}"
         end
 

data/lib/oxaiworkers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OxAiWorkers
-  VERSION = '1.0.3.2'
+  VERSION = '1.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox-ai-workers
 version: !ruby/object:Gem::Version
-  version: 1.0.3.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Denis Smolev