ox-ai-workers 0.7.4 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3838e126219f836dadf449f3a2f62c4ffc298df002b100e3249ac3281568858a
-  data.tar.gz: '09ae1592f862b982d74c579d9f14f4873f3a8a434f9cdb1300d524673d45ad8d'
+  metadata.gz: 9a6d42d123d2331ff4ebe6fde17c6cd64759933f64940dcf453eca6dc5efb402
+  data.tar.gz: 19bfa6c66009d2856ecb983d7375beceb40a9d1edf0cf7cd304cfa61529450e4
 SHA512:
-  metadata.gz: af412ce5edd9468958f054a7fbe7646dc5d4daa77473f31cb2f83d5cea009066005bf4f54f3e5cbe091a2dfd646e3c45bca366a64252afcb5746cef6a0f304de
-  data.tar.gz: 3ab249b4ebd3bf6961ed1e56209abded50a2111620a2dd3b46508f14f6b45f8b36e12af52abb9a8ae2ae0456a0b8f14fc649b937a83b6e2627da11dcc6821688
+  metadata.gz: 638dea1186324159ebbcacd5f3714aa302ba2e6b5a8a4883cda35feb06ae327f96a0e783ff7c007be090de99f157cf2e35b0d0287f228719c278f1dd8cf9c616
+  data.tar.gz: 0713c7d9f42db7873d70023cabafc4b7e0647e2fe59f76f0d469de530d405d67c8677a989d967bad0317891de9a609293995ab5d68ea7382f39d92aaaa739f4d

data/.cursorrules

@@ -0,0 +1,69 @@
+OxAiWorkers is a Ruby gem that implements a finite state machine (using the `state_machine` gem) to solve tasks using generative intelligence (with the `ruby-openai` gem). This approach enhances the final result by utilizing internal monologue and external tools.
+
+## Architecture Principles
+- The library is built on the finite state machine (FSM) pattern using the 'state_machine' gem
+- Integration with generative models is implemented using the 'ruby-openai' gem
+- DRY (Don't Repeat Yourself) principle is applied throughout all components
+- Modular structure with clear separation of responsibilities between classes
+- Encapsulation of states and transitions in separate classes
+- Implementation of the "Composition" pattern for flexible tool integration
+
+## Core Components
+- `Request` and `DelayedRequest` - classes for executing API requests (immediate and delayed)
+- `Iterator` - main class for iterative task execution with tools
+- `Assistant` - high-level wrappers over Iterator (Sysop, Coder, Localizer, etc.)
+- `Tool` - tools that can be used during task execution (Eval, FileSystem, Database)
+- `ToolDefinition` - module for declaring functions and methods for tools
+- `StateTools` - base class for managing states and transitions
+- `ContextualLogger` - logging system with contextual information support
+
+## Code Conventions
+- Use `snake_case` for method and variable names
+- Functions for generative models should also be in `snake_case` (inner_monologue, outer_voice, etc.)
+- All public methods must have documentation with usage examples
+- Tests are mandatory for all new functions
+- All code comments, CHANGELOG, README, and other documentation must be written in English
+- Use YARD-style documentation for all public methods
+- Maintain a unified code formatting style (Rubocop is recommended)
+- Follow the "Fail fast" principle for early error detection
+
+## Interaction Patterns
+- The system uses internal monologue (inner_monologue) for planning actions
+- External voice (outer_voice) is used for communication with the user
+- Actions (action_request) are executed through tools
+- Summary (summarize) is used to compress dialog history
+- Execution flow management through finite state machine
+- Implementation of callback mechanisms for flexible event handling
+- Isolation of error handling functions at the tool level
+
+## Integration
+- CLI interface through `oxaiworkers init` and `oxaiworkers run` commands
+- Rails support via ActiveRecord for storing delayed requests
+- Configuration through the `OxAiWorkers.configure` block
+- Multilingual support via standard I18n
+- Integration with external APIs through request client templates
+- Delayed execution mechanism via DelayedRequest
+- Support for various language models (OpenAI, Anthropic, Gemini)
+
+## Best Practices
+- Use callbacks to handle various states (on_inner_monologue, on_outer_voice)
+- Handle errors at the tool level, preventing them from interrupting the main execution flow
+- When creating new assistants, inherit from the base Assistant class
+- Use the white_list mechanism to restrict available functions
+- Separate language model requests from result processing logic
+- Practice dependency injection to improve code testability
+- Use localization mechanisms for multilingual support
+
+## Tools Architecture
+- Each tool should be a self-contained module
+- Tools are registered through the `define_function` interface
+- All tools should handle their own errors and return readable messages
+- Use parameter validation at the function definition level
+- Maintain a unified format for return values
+
+## Performance and Scaling
+- Cache API request results when possible
+- Use asynchronous processing for long operations
+- Apply backoff strategies for repeated requests
+- Break large tasks into atomic operations
+- Provide monitoring and profiling mechanisms

data/.ruby-version

@@ -1 +1 @@
-3.3.4
+3.4.1

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.7.5] - 2024-08-26
+
+- Improved handling of truncated responses in Iterator
+- Updated dependencies
+
 ## [0.7.4] - 2024-08-25
 
 - Fixed `finish_it` for `Iterator`

data/app/models/task.rb

@@ -0,0 +1,10 @@
+class Task < ApplicationRecord
+  validates :title, presence: true
+  belongs_to :user, optional: true
+
+  enum status: {
+    pending: 0,
+    in_progress: 1,
+    completed: 2
+  }
+end

data/lib/oxaiworkers/delayed_request.rb

@@ -97,12 +97,17 @@ module OxAiWorkers
           @custom_id = line['custom_id']
           # @result = line.dig("response", "body", "choices", 0, "message", "content")
           parse_choices(line.dig('response', 'body'))
-          complete_batch!
+          # Don't complete the batch if the response is truncated due to max_tokens
+          complete_batch! unless @is_truncated
         end
       elsif !batch['error_file_id'].nil?
         @errors = @client.files.content(id: batch['error_file_id'])
         fail_batch!
       end
+
+      # Truncated response is not considered complete
+      return false if @is_truncated
+
       true
     end
   end

data/lib/oxaiworkers/iterator.rb

@@ -209,6 +209,18 @@ module OxAiWorkers
     end
 
     def process_result(_transition)
+      # If the response is truncated due to max_tokens, repeat the request
+      if @worker.is_truncated && @worker.result.present?
+        # Save the partial response and continue the dialogue with AI
+        OxAiWorkers.logger.info(
+          "Truncated response detected (finish_reason: #{@worker.finish_reason}). Repeating request to get complete response.", for: self.class
+        )
+        @queue << { role: :assistant, content: @worker.result }
+        # Request continuation
+        next_iteration
+        return
+      end
+
       @result = @worker.result || @worker.errors
       if @worker.tool_calls.present?
         @queue << { role: :assistant, content: @worker.tool_calls_raw.to_s }

data/lib/oxaiworkers/module_request.rb

@@ -3,7 +3,7 @@
 module OxAiWorkers
   class ModuleRequest
     attr_accessor :result, :client, :messages, :model, :max_tokens, :custom_id, :temperature, :tools, :errors,
-                  :tool_calls_raw, :tool_calls
+                  :tool_calls_raw, :tool_calls, :is_truncated, :finish_reason
 
     def initialize_requests(model: nil, max_tokens: nil, temperature: nil)
       @max_tokens = max_tokens || OxAiWorkers.configuration.max_tokens
@@ -11,6 +11,8 @@ module OxAiWorkers
       @model = model || OxAiWorkers.configuration.model
       @temperature = temperature || OxAiWorkers.configuration.temperature
       @client = nil
+      @is_truncated = false
+      @finish_reason = nil
 
       OxAiWorkers.configuration.access_token ||= ENV['OPENAI']
       if OxAiWorkers.configuration.access_token.nil?
@@ -31,6 +33,8 @@ module OxAiWorkers
       @messages = []
       @tool_calls = nil
       @tool_calls_raw = nil
+      @is_truncated = false
+      @finish_reason = nil
     end
 
     def append(role: nil, content: nil, messages: nil)
@@ -62,6 +66,10 @@ module OxAiWorkers
       @tool_calls = []
       @result = response.dig('choices', 0, 'message', 'content')
       @tool_calls_raw = response.dig('choices', 0, 'message', 'tool_calls')
+      @finish_reason = response.dig('choices', 0, 'finish_reason')
+      @is_truncated = @finish_reason == 'length'
+
+      return @tool_calls if @tool_calls_raw.nil?
 
       @tool_calls_raw.each do |tool|
         function = tool['function']

data/lib/oxaiworkers/request.rb

@@ -19,6 +19,10 @@ module OxAiWorkers
     end
 
     def completed?
+      # Truncated response is not considered complete,
+      # so the iterator continues processing
+      return false if @is_truncated
+
       @result.present? or @errors.present? or @tool_calls.present?
     end
   end

data/lib/oxaiworkers/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ox-ai-workers
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.7.5
 platform: ruby
 authors:
 - Denis Smolev
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-27 00:00:00.000000000 Z
+date: 2025-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -124,12 +123,14 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".cursorrules"
 - ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE
 - README.md
 - Rakefile
+- app/models/task.rb
 - config/locales/en.oxaiworkers.assistant.yml
 - config/locales/en.oxaiworkers.iterator.yml
 - config/locales/en.oxaiworkers.tool.yml
@@ -173,7 +174,6 @@ metadata:
   homepage_uri: https://ai.oxteam.me
   source_code_uri: https://github.com/neonix20b/ox-ai-workers
   changelog_uri: https://github.com/neonix20b/ox-ai-workers/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -188,8 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: A powerful state machine with OpenAI generative intelligence integration
 test_files: []