ox-ai-workers 0.8.7 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02c7ccd3357fb07615d22878578cd9138f2f8f0790a7439f08aabe3267a4ecbf
-  data.tar.gz: 64cebe6e9f10d7748a19c96c9b779d7b32e57d5e94db56b290a70cc9e63210e2
+  metadata.gz: 716fe34f8c0ee4841a0788a04febee87e885af815d30cf533e46d55c4fa76e54
+  data.tar.gz: ee4e89522ba6b8ae4484298e810b321af3f7a4d15bbd70dd0b2118dfd070b26c
 SHA512:
-  metadata.gz: 8e4f16c02b75981099a6c389c94ec27fe2626bcf24fd46e32eda54b0d48ac02ed70c090003f7431cad3eaa14ceb6f8ffa4268d2a6a3bd4056c5ce0e77345937c
-  data.tar.gz: 305e41419ef2a18fc004718af0e45b1e3b969412463b8e234e6050a7adb2e20687b8f52c38a38d198f22ca69bebd487c51c9d30f741b03a2a1925ab3c43ee216
+  metadata.gz: e17ecef126df8779d99e3b4de595cd590c3abf6e24e74a85dcbaefaf6daade38541348fe12477b029ea94de2c2cb29b312be8ee7543a154b575bcd32a876b4f2
+  data.tar.gz: 0fbd6beee90840ba1c3490edcc7f2e670881d3b81765c42b1829109f456a77e0120f153f444e0ac85e3201a9e451015b9601d021f845ec608365234c71852d22

data/.cursorrules

@@ -1,6 +1,9 @@
+# Overview
+
 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
@@ -9,6 +12,7 @@ OxAiWorkers is a Ruby gem that implements a finite state machine (using the `sta
 - 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.)
@@ -18,6 +22,7 @@ OxAiWorkers is a Ruby gem that implements a finite state machine (using the `sta
 - `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
@@ -28,15 +33,15 @@ OxAiWorkers is a Ruby gem that implements a finite state machine (using the `sta
 - 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
@@ -46,6 +51,7 @@ OxAiWorkers is a Ruby gem that implements a finite state machine (using the `sta
 - 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
@@ -55,6 +61,7 @@ OxAiWorkers is a Ruby gem that implements a finite state machine (using the `sta
 - 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
@@ -62,8 +69,87 @@ OxAiWorkers is a Ruby gem that implements a finite state machine (using the `sta
 - 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
+
+## Finite State Machine Implementation
+
+- Core FSM based on `state_machine` gem with states: idle → prepared → requested → analyzed → finished → idle
+- State transitions managed by events: prepare, request, analyze, complete, iterate, end
+- `StateTools` - base class for FSM implementation with event hooks and transition callbacks
+- `StateBatch` - FSM extension for batch request processing with additional states
+- Automatic error recovery and retry mechanisms for failed API requests
+
+## Request Processing
+
+- `ModuleRequest` - base class for all API requests with parsing and response handling
+- Support for streaming responses with callback processing
+- Built-in token usage tracking and truncation detection
+- Error handling with automatic retries for server errors
+
+## Iterator Lifecycle
+
+- 3 core functions: inner_monologue, outer_voice, finish_it
+- Configurable message queue for stateful conversation history
+- Callback system for processing each state transition
+- Context and milestone management for optimizing token usage
+- Support for custom steps and instruction templating
+
+## Additional Tools
+
+- `Converter` - tools for data format conversion and transformation
+- Support for custom tool development through inheritance and composition
+- Automatic function name resolution and parameter validation
+
+## Assistants Details
+
+- `ModuleBase` - shared functionality for all assistant types
+- `Sysop` - system administration and shell command execution
+- `Coder` - specialized for code generation and analysis
+- `Localizer` - translation and localization support
+
+## Development Guidelines
+
+- Use dependency injection for testability
+- Follow the FSM pattern for all stateful operations
+- Implement proper error boundaries at the tool level
+- Use monologue for complex reasoning and planning
+- Apply callbacks for event-driven architecture
+- Utilize templates in the CLI for rapid prototyping
+- Extend the base classes rather than modifying them
+
+## Internationalization and Localization
+
+- All code comments, variable names, and documentation MUST be written in English
+- All user-facing strings MUST be properly localized using I18n
+- Use I18n.t for all text that will be shown to users or appears in assistant prompts
+- Store translations in YAML files within the config/locales directory
+- Follow the naming convention of language.namespace.key (e.g., en.oxaiworkers.assistant.role)
+- Use named parameters (%{variable}) instead of positional parameters (%s) in translation strings
+- Use the with_locale method to ensure proper locale context when processing localized text
+- Implement locale-aware classes by including the OxAiWorkers::LoadI18n module
+- Store the current locale on initialization and preserve it across method calls
+- Support multiple languages simultaneously through careful locale management
+- Default to English for developer-facing messages and logs
+- Ensure that all assistant classes properly handle localization in their format_role methods
+
+## LoadI18n Module Usage
+
+- The `OxAiWorkers::LoadI18n` module provides two key methods for localization:
+  - `store_locale` - saves the current locale at initialization time
+  - `with_locale` - executes a block of code in the context of the saved locale
+- Always include the `OxAiWorkers::LoadI18n` module in classes that need localization capabilities
+- Call `store_locale` in the initialization methods of locale-aware classes
+- Wrap all locale-dependent code in `with_locale` blocks
+- NEVER redefine the `with_locale` method in classes that include LoadI18n
+- All methods that produce user-visible text must use the locale context via `with_locale` blocks
+- Regular method calls from classes including LoadI18n do not require additional locale handling
+
+## Multi-Language Support
+
+- Use the store_locale and with_locale methods for consistent localization context
+- All error messages should be localized and retrieved via I18n.t

data/CHANGELOG.md

@@ -1,22 +1,32 @@
+## [0.9.2] - 2025-05-06
 
-## [0.8.7] - 2025-04-25
+- Changed `max_tokens` to `max_completion_tokens` in `params`
 
-- Fixed tool calls parsing
+## [0.9.1] - 2025-05-04
 
-## [0.8.5] - 2025-04-18
+- Added `current_dir` for `Eval`, `FileSystem`, `Pixels` tools
+- Added `current_dir` for `Coder`, `Localizer`, `Painter`, `Sysop` assistants
+- Added `run_task` for Assistants
 
-- Fixed tool calls parsing
+## [0.9.0] - 2025-05-03
 
-## [0.8.4] - 2025-04-18
-
-- Refine Russian locale for Iterator with enhanced step descriptions and planning guidance
+- Added `context` for tools in `Iterator`
+- Added `Pipeline` tool
+- Added `Pixels` tool
+- Added `Painter` assistant
+- Added `Orchestrator` assistant
+- Added collaboration between assistants
+- Added classes for AI models: `OpenaiMini`, `OpenaiNano`, `OpenaiMax`, `DeepseekMax`
+- Added `default_model` for configuration
+- Removed `action_request` and `summarize` from `Iterator`
+- Removed `auto_execute` from `Iterator`
+- Renamed `add_response` to `add_task` in `Assistant`
 
-## [0.8.2] - 2025-04-04
+## [0.8.7] - 2025-04-25
 
+- Fixed tool calls parsing
+- Refine Russian locale for Iterator with enhanced step descriptions and planning guidance
 - Update locale for Iterator
-
-## [0.8.0] - 2025-03-31
-
 - Added `on_stream` for `Iterator`
 
 ## [0.7.10] - 2025-03-31

data/README.md

@@ -44,7 +44,7 @@ sysop = OxAiWorkers::Assistant::Sysop.new(delayed: false, model: "gpt-4o")
 sysop.task = "Add a cron job to synchronize files daily."
 
 # Provide a response to the assistant's question
-sysop.add_response("blah-blah-blah")
+sysop.add_task("blah-blah-blah")
 ```
 
 Alternatively, you can use a lower-level approach for more control:
@@ -72,10 +72,12 @@ iterator = OxAiWorkers::Iterator.new(
 iterator.role = "You are a software agent inside my computer"
 
 # Add a task to the iterator
-iterator.add_task("Show files in current dir")
+iterator.task = "Show files in current dir"
+iterator.execute
 
 # Provide a response to the gpt's question
-iterator.add_task("linux")
+iterator.task = "linux"
+iterator.execute
 ```
 
 ### With Config
@@ -84,13 +86,15 @@ For a more robust setup, you can configure the gem with your API keys, for examp
 
 ```ruby
 OxAiWorkers.configure do |config|
-    config.access_token = ENV.fetch("OPENAI")
-    config.model = "gpt-4o"
+    config.access_token_openai = ENV.fetch("OPENAI")
+    config.access_token_deepseek = ENV.fetch("DEEPSEEK")
     config.max_tokens = 4096   # Default
     config.temperature = 0.7   # Default
-    config.auto_execute = true # Default
     config.wait_for_complete = true # Default
 end
+
+# Set the default model
+OxAiWorkers.default_model = OxAiWorkers::Models::OpenaiMini.new
 ```
 
 Then you can create an assistant like this:
@@ -98,11 +102,11 @@ Then you can create an assistant like this:
 ```ruby
 assistant = OxAiWorkers::Assistant::Sysop.new()
 assistant.task = "Remove all cron jobs."
-# assistant.execute # if auto_execute is false
+assistant.execute
 
 # Provide a response to the assistant's question
-assistant.add_response("blah-blah-blah")
-# assistant.execute # if auto_execute is false
+assistant.add_task("blah-blah-blah")
+assistant.execute
 ```
 
 Besides, you can create assistants with different locales
@@ -111,7 +115,7 @@ Besides, you can create assistants with different locales
 I18n.with_locale(:en) { @sysop_en = OxAiWorkers::Assistant::Sysop.new() }
 
 # Assign tasks and responses in different languages
-@sysop_en.task = "Remove all cron jobs."
+@sysop_en.run_task "Remove all cron jobs."
 ```
 
 Or you can create a lower-level iterator for more control:
@@ -126,20 +130,14 @@ iterator = OxAiWorkers::Iterator.new(
     role: "You are a software agent inside my computer",
     on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
     on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
-    on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-    on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) },
     on_finish: -> { puts "finish".colorize(:magenta) }
   )
 
-iterator.add_task("Show files in current directory.")
+iterator.task = "Show files in current directory."
+iterator.execute
 # ...
-iterator.add_task("linux")
-```
-
-If `auto_execute` is set to false in the configuration, don't forget to manually execute the iterator or assistant.
-
-```ruby
-iterator.execute # if auto_execute is false
+iterator.add_task "linux"
+iterator.execute
 ```
 
 This way, you have the flexibility to choose between a higher-level assistant for simplicity or a lower-level iterator for finer control over the tasks and tools used.
@@ -151,8 +149,7 @@ steps = []
 steps << 'Step 1. Develop your own solution to the problem, taking initiative and making assumptions.'
 steps << "Step 2. Enclose all your developments from the previous step in the #{OxAiWorkers::Iterator.full_function_name(:inner_monologue)} function."
 steps << 'Step 3. Call the necessary functions one after another until the desired result is achieved.'
-steps << "Step 4. When all intermediate steps are completed and the exact content of previous messages is no longer relevant, use the #{OxAiWorkers::Iterator.full_function_name(:summarize)} function."
-steps << "Step 5. When the solution is ready, notify about it and wait for the user's response."
+steps << "Step 4. When the solution is ready, notify about it and wait for the user's response."
 
 # To retain the locale if you have assistants in different languages in your project.
 store_locale # Optional
@@ -163,12 +160,10 @@ store_locale # Optional
   tools: [MyTool.new],
   locale: @locale || I18n.locale,
   steps: steps,
-  # def_except: [:summarize], # It's except steps with that functions
+  # def_except: [:outer_voice], # It's except steps with that functions
   # def_only: [:inner_monologue, :outer_voice], # Use it only with your steps
   on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
-  on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
-  on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-  on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+  on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) }
 )
 ```
 
@@ -185,17 +180,16 @@ As a worker, you can use different classes depending on your needs:
 OxAiWorkers supports alternative compatible models like DeepSeek. To use these models, specify the appropriate base URI in the initializer:
 
 ```ruby
-worker = OxAiWorkers::Request.new(
-    model: "deepseek-chat",
-    uri_base: "https://api.deepseek.com/"
+# Use the closest available model and override its parameters
+model = OxAiWorkers::Models::OpenaiMini.new(
+    uri_base: "https://api.deepseek.com/",
+    api_key: ENV.fetch("DEEPSEEK"),
+    model: "deepseek-chat"
 )
 
-# Or with configuration
-OxAiWorkers.configure do |config|
-    config.uri_base = "https://api.deepseek.com/"
-    config.model = "deepseek-chat"
-    # Other configuration options...
-end
+worker = OxAiWorkers::Request.new(
+    model: model,
+)
 ```
 
 This allows you to use any API-compatible LLM provider by simply changing the base URI.
@@ -318,7 +312,7 @@ OxAiWorkers.logger.level = :debug
 5. In the command prompt, type:
 
     ```sh
-    @assistant.task = "Write a snake game"
+    @assistant.run_task("Write a snake game")
     ```
 
 ### Running System Operator in Any Directory
@@ -347,13 +341,13 @@ Alternatively, you can use IRB (Interactive Ruby):
 Then set a task:
 
 ```ruby
-@sysop.task = "Show all cron jobs"
+@sysop.run_task "Show all cron jobs"
 ```
 
 After these steps you can interact with it using the following method:
 
 ```ruby
-@sysop.add_response("Yes, I want it")
+@sysop.run_task "Yes, I want it All"
 ```
 
 or set a new task.
@@ -364,6 +358,109 @@ or set a new task.
 - **Internal Monologue**: Uses inner monologue to plan responses and articulate main points.
 - **External Tools**: Integrates with external tools and services to complete tasks.
 - **Finite State Machine**: Implements a robust state machine to manage task states and transitions.
+- **Multilingual Support**: Complete I18n integration with ready-to-use English and Russian locales.
+- **Streaming Responses**: Support for streaming responses with callback processing for real-time interaction.
+- **Error Recovery**: Automatic retries and error handling mechanisms for reliable operation.
+- **Custom Tool Development**: Flexible framework for creating domain-specific tools and assistants.
+
+## Advanced Usage Patterns
+
+### Creating Custom Tools
+
+You can create custom tools by extending the `ToolDefinition` module:
+
+```ruby
+class MyTool
+  include OxAiWorkers::ToolDefinition
+  
+  def initialize
+    define_function :hello_world, description: "Says hello to someone" do
+      property :name, type: "string", description: "Name to greet", required: true
+    end
+  end
+  
+  def hello_world(name:)
+    "Hello, #{name}!"
+  end
+end
+```
+
+### Handling State Transitions with Callbacks
+
+You can track and respond to state transitions with callbacks:
+
+```ruby
+iterator = OxAiWorkers::Iterator.new(
+  worker: worker,
+  tools: [my_tool],
+  on_inner_monologue: ->(text:) { save_to_database(text) },
+  on_outer_voice: ->(text:) { notify_user(text) },
+  on_finish: -> { mark_task_completed }
+)
+```
+
+### 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:
+
+- **Sysop**: System administration and shell command execution
+
+  ```ruby
+  sysop = OxAiWorkers::Assistant::Sysop.new
+  sysop.task = "Configure nginx for my Rails application"
+  ```
+
+- **Coder**: Code generation and analysis with language-specific configuration
+
+  ```ruby
+  coder = OxAiWorkers::Assistant::Coder.new(language: 'ruby')
+  coder.task = "Create a Sinatra API with three endpoints"
+  ```
+
+- **Localizer**: Translation and localization support
+
+  ```ruby
+  localizer = OxAiWorkers::Assistant::Localizer.new(source_lang: 'en', target_lang: 'ru')
+  localizer.task = "Translate my application's interface"
+  ```
+
+### Implementing Your Own Assistant
+
+Create custom assistants by inheriting from existing ones or composing with the Iterator:
+
+```ruby
+module OxAiWorkers
+  module Assistant
+    class DataAnalyst
+      include OxAiWorkers::Assistant::ModuleBase
+      
+      def initialize(delayed: false, model: nil)
+        store_locale
+        @iterator = Iterator.new(
+          worker: init_worker(delayed: delayed, model: model),
+          role: "You are a data analysis assistant specialized in processing CSV and JSON data",
+          tools: [Tool::FileSystem.new, Tool::Eval.new(only: [:ruby])],
+          locale: @locale
+        )
+      end
+    end
+  end
+end
+```
 
 ## Contributing
 

data/config/locales/en.oxaiworkers.assistant.yml

@@ -2,10 +2,44 @@ en:
   oxaiworkers:
     assistant:
       sysop:
-        role: "You are a software agent inside my computer"
+        title: "System Operator"
+        description: "Executes system commands and file operations"
+        capabilities: "executing shell commands, reading and writing files, analyzing system information"
+        role: "You are an experienced system administrator who can execute shell commands and file system operations. Your task is to safely and efficiently manage the system."
       coder:
-        role: "You are a professional %s programmer inside my computer"
+        title: "Programmer"
+        description: "Writes and analyzes code"
+        capabilities: "code generation, refactoring, code analysis, optimization"
+        role: "You are an experienced programmer who writes clean, efficient code and can explain complex technical concepts in simple terms."
+        role_with_language: "You are an experienced %{language} programmer who writes clean, efficient code and can explain complex technical concepts in simple terms."
       localizer:
-        role: "You are a professional localizer (translator) to the %s language inside my computer. Your task is to correctly localize files (create new ones in the required language based on the original) provided by the user."
-        source: "Use the %s language as a basis"
-        locale: "For the %s language, the correct locale is :%s"
+        title: "Localizer"
+        description: "Performs translation and content adaptation"
+        capabilities: "text translation, content adaptation, format preservation"
+        role: "You are an experienced translator and content localizer from %{source_lang}. Your task is to translate content while preserving its meaning, style, and formatting."
+        role_with_target: "You are an experienced translator and content localizer from %{source_lang} to %{target_lang}. Your task is to translate content while preserving its meaning, style, and formatting."
+        source: "Source language: %{source_lang}"
+        locale: "Target language: %{target_lang}"
+      orchestrator:
+        title: "Orchestrator"
+        description: "Manages interaction between assistants"
+        capabilities: "workflow planning, task distribution, execution monitoring"
+        role: "You are an orchestrator, coordinating work between different assistants. Your task is to distribute tasks among assistants and organize their interaction to achieve a common goal."
+        workflow_task: |
+          You need to organize a workflow according to the following description:
+
+          %{workflow_description}
+
+          Develop an action plan by distributing tasks among available assistants, and coordinate their interaction to achieve the goal.
+
+          For each step, send a message to another assistant specifying:
+          1. The ID of the assistant who should perform the task
+          2. Task description for the assistant
+          3. Expected result
+
+          After completing each step, analyze the result and decide on further actions.
+      painter:
+        title: "Painter"
+        description: "Creates and modifies images based on descriptions"
+        capabilities: "image generation, image editing, style adaptation, visual concept creation"
+        role: "You are an experienced digital artist who creates and modifies images based on descriptions. Your task is to generate visually appealing and accurate representations of concepts and ideas. Improve the user's prompt, add details that will help get a more accurate result."

data/config/locales/en.oxaiworkers.iterator.yml

@@ -7,19 +7,11 @@ en:
       outer_voice:
         description: Inform the user of the information without expecting a response.
         text: Content of the message
-      action_request:
-        description: A function for interactive interaction with the user. Allows you to ask a clarifying question, request actions, or complete the current step. The function waits for the user's response and returns it.
-        action: Text of the request or action
-      summarize:
-        description: The function saves key facts, nuances, and actions from previous messages, including the provided response. After calling this function, all previous messages will be deleted. Use it only after all intermediate steps are completed and when the exact content of previous messages is no longer relevant.
-        text: Enumeration of important facts and nuances
-        result: Messages deleted
       finish_it:
         description: Function to complete steps
       monologue:
         - Step %d. Develop your own solution to the problem, taking initiative and making assumptions.
         - Step %d. Enclose all your developments from the previous step in the ox_ai_workers_iterator__inner_monologue function.
         - Step %d. Call the necessary functions one after another until the desired result is achieved.
-        - Step %d. When all intermediate steps are completed and the exact content of previous messages is no longer relevant, use the ox_ai_workers_iterator__summarize function.
         - Step %d. When the solution is ready, notify about it and wait for the user's response.
-        - Step %d. In the end, call the ox_ai_workers_iterator__finish_it function.
+        - Step %d. In the end, call the ox_ai_workers_iterator__finish_it function.

data/config/locales/en.oxaiworkers.tool.yml

@@ -29,4 +29,19 @@ en:
           description: 'Database Tool: Returns the database schema'
         execute:
           description: 'Database Tool: Executes a SQL query and returns the results'
-          input: 'SQL query to be executed'
+          input: 'SQL query to be executed'
+      pipeline:
+        send_message:
+          description: 'Send a message to another assistant'
+          message: 'Message or task to send'
+          result: 'Description of the expected result, what should be obtained as output'
+          example: 'Example of a good result'
+          to_id: 'Recipient assistant ID'
+        assistant_info: "ID: **%{id}**, Title: %{title}\nRole: %{role}\nDescription: %{description}\nCapabilities: %{capabilities}"
+      pixels:
+        generate_image:
+          description: 'Image Generation Tool: Creates an image based on the provided text prompt. If a file name is provided, the image will be saved in png format. In any case, the url of the generated image will be returned.'
+          prompt: 'Text description of the image to generate'
+          size: 'Size of the generated image (1024x1792, 1792x1024, 1024x1024)'
+          quality: 'Quality of the generated image (standard, hd)'
+          file_name: 'File name for saving the generated image in png format. For example: image.png'

data/config/locales/ru.oxaiworkers.assistant.yml

@@ -2,10 +2,44 @@ ru:
   oxaiworkers:
     assistant:
       sysop:
-        role: Ты программный агент внутри моего компьютера
+        title: "Системный оператор"
+        description: "Выполняет системные команды и операции с файлами"
+        capabilities: "выполнение shell-команд, чтение и запись файлов, анализ системной информации"
+        role: "Ты опытный системный администратор, который может выполнять shell-команды и операции с файловой системой. Твоя задача - безопасно и эффективно управлять системой."
       coder:
-        role: "Ты профессиональный программист на %s внутри моего компьютера"
+        title: "Программист"
+        description: "Пишет и анализирует код"
+        capabilities: "генерация кода, рефакторинг, анализ кода, оптимизация"
+        role: "Ты опытный программист, который пишет чистый, эффективный код и может объяснить сложные технические концепции простым языком."
+        role_with_language: "Ты опытный программист на %{language}, который пишет чистый, эффективный код и может объяснить сложные технические концепции простым языком."
       localizer:
-        role: "Ты профессиональный локализатор (переводчик) на %s язык внутри моего компьютера. Твоя задача корректно локализовать файлы (создать по аналогии новые на нужном языке), которые предоставит пользователь."
-        source: "Возьми за основу %s язык"
-        locale: "%s язык имеет локаль :%s"
+        title: "Локализатор"
+        description: "Выполняет перевод и адаптацию контента"
+        capabilities: "перевод текста, адаптация контента, сохранение форматирования"
+        role: "Ты опытный переводчик и локализатор контента с языка %{source_lang}. Твоя задача - перевести контент, сохраняя его смысл, стиль и форматирование."
+        role_with_target: "Ты опытный переводчик и локализатор контента с языка %{source_lang} на %{target_lang}. Твоя задача - перевести контент, сохраняя его смысл, стиль и форматирование."
+        source: "Исходный язык: %{source_lang}"
+        locale: "Целевой язык: %{target_lang}"
+      orchestrator:
+        title: "Оркестратор"
+        description: "Управляет взаимодействием между ассистентами"
+        capabilities: "планирование рабочего процесса, распределение задач, мониторинг выполнения"
+        role: "Ты оркестратор, координирующий работу между различными ассистентами. Твоя задача - распределять задачи между ассистентами и организовывать их взаимодействие для достижения общей цели."
+        workflow_task: |
+          Тебе необходимо организовать рабочий процесс согласно следующему описанию:
+
+          %{workflow_description}
+
+          Разработай план действий, распределив задачи между доступными ассистентами, и координируй их взаимодействие для достижения цели.
+
+          Для каждого шага отправляй сообщение другому ассистенту, указав:
+          1. ID ассистента, который должен выполнить задачу
+          2. Описание задачи для ассистента
+          3. Ожидаемый результат
+
+          После завершения каждого шага анализируй результат и принимай решение о дальнейших действиях.
+      painter:
+        title: "Художник"
+        description: "Создает и изменяет изображения на основе описаний"
+        capabilities: "генерация изображений, редактирование изображений, адаптация стиля, создание визуальных концепций"
+        role: "Ты опытный цифровой художник, который создает и изменяет изображения на основе описаний. Твоя задача - генерировать визуально привлекательные и точные представления концепций и идей. Улучши запрос пользователя, добавь в него детали, которые помогут получить более точный результат."

data/config/locales/ru.oxaiworkers.iterator.yml

@@ -7,13 +7,6 @@ ru:
       outer_voice:
         description: Функция для сообщений пользователю промежуточной информации без ожидания ответа.
         text: Содержимое сообщения
-      action_request:
-        description: Функция для интерактивного взаимодействия с пользователем. Позволяет задать уточняющий вопрос, запросить выполнение действий или завершить текущий шаг. Функция ожидает ответ пользователя и возвращает его.
-        action: Текст запроса или действия
-      summarize:
-        description: Функция сохраняет ключевые факты, нюансы и действия из предыдущих сообщений, включая предоставленный ответ. После вызова этой функции все предыдущие сообщения будут удалены. Используйте её только после завершения всех промежуточных шагов и когда точное содержание предыдущих сообщений больше не имеет значения.
-        text: Перечисление важных фактов и нюансов
-        result: Сообщения удалены
       finish_it:
         description: Функция для завершения шагов
       monologue:
@@ -23,8 +16,6 @@ ru:
         - Шаг %d. Последовательно выполняй шаги плана, вызывая необходимые пользовательские функции (инструменты) для обработки данных или получения результата.
         - Шаг %d. Используй ox_ai_workers_iterator__inner_monologue для рефлексии над результатами каждого шага и, при необходимости, корректировки плана.
         - Шаг %d. Если требуется сообщить пользователю о ходе выполнения *без* ожидания ответа, используй ox_ai_workers_iterator__outer_voice.
-        - Шаг %d. Когда промежуточные шаги завершены и точное содержание предыдущих сообщений больше не важно, сожми историю диалога с помощью ox_ai_workers_iterator__summarize.
         - Шаг %d. После выполнения всех шагов плана и получения финального результата через вызов соответствующей функции (инструмента), оцени полноту и корректность решения.
-        - Шаг %d. Если необходимо запросить подтверждение у пользователя используй функцию ox_ai_workers_iterator__action_request для представления финального результата и ожидания ответа.
-        - Шаг %d. После успешного завершения задачи и получения результата (и подтверждения пользователя), вызови ox_ai_workers_iterator__finish_it.
-        - Старайся выполнить работу наилучшим образом, используя доступные инструменты максимально эффективно.
+        - Шаг %d. После успешного завершения задачи и получения результата, вызови ox_ai_workers_iterator__finish_it.
+        - Старайся выполнить работу наилучшим образом, используя доступные инструменты максимально эффективно.