autoflux 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfba17b715db371a3388379b0d894f1cd7e02e5ddec7dc9e30545b009037195e
-  data.tar.gz: 768d96e08f58eac4516c03b6fb1ae13a6c4939ffa47702fa57de3c45cff8a831
+  metadata.gz: 85b6aa4923d77e37e9e4c0323b9d7b4ea211d1c826b832f439ffef41fc2838a4
+  data.tar.gz: 1f83f0a1a66cca3f03fdd0905625406e87fb5e43f9c8a8a467d4508d1fb2a450
 SHA512:
-  metadata.gz: fe2ee26a057d023a378eee32fead552d45312724a1a59b4dcf1a6681cef889ffda78030fcafac5b98ee41ae2c4a4d3b24d859fa1682aac86595ed82e58759226
-  data.tar.gz: dd3461bdffb1f07be326962f43b3ee661e901881eaea3a71c0225bb55047c559e13a5e62743e4426751a36af3447fdcf4084cddd238f155ce4529060f619802a
+  metadata.gz: 5014bfa1497302ff5a839f2ed914ca483af355faf5c33f6f5f543e2e3a4729a09515c58e473b6ecb2e6e03dd345a7354371728475f2fbee5998d1db514b7a465
+  data.tar.gz: 95a4935d4ca50f9817412184781ce486b5273ba349be6441f5842f746b8f61543f849d5c3d23fb39375e02f265078e7596809d7599a4a6135d76c2b16725950b

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.2
   NewCops: enable
   SuggestExtensions: false
 

data/README.md

@@ -28,11 +28,9 @@ Autoflux provides a default state machine for a chat workflow.
 stateDiagram-v2
     [*] --> Start
     Start --> Command
-    Command --> Assistant
-    Assistant --> Command
-    Assistant --> Tool
-    Tool --> Assistant
+    Command --> Agent
     Command --> Stop
+    Agent --> Command
     Stop --> [*]
 ```
 
@@ -47,116 +45,38 @@ workflow = Autoflux::Workflow.new(
 workflow.run
 ```
 
-You can give a system prompt when running the workflow:
-
-```ruby
-workflow.run(system_prompt: 'Help user to solve the problem')
-```
-
-When receive "exit" from the user, the workflow transition to the stop state.
+When the `io` is `EOF`, the workflow will stop.
 
 ### Agent
 
-The agent is an adapter to the LLM model.
+The agent is a interface implements `call` method to process the command.
 
 ```ruby
-# :nodoc:
-class OpenAIAgent
-  attr_reader :client, :model
-
-  def initialize(client:, model: 'gpt-4o-mini')
-    super(tools: tools)
-    @client = client
-    @model = model
+agent = ->(prompt, **context) {
+  case prompt
+  when 'hello'
+    'Hello, how can I help you?'
+  when 'bye'
+    'Goodbye'
+  else
+    'I do not understand'
   end
-
-  def call(memory:)
-    msg = client.chat(
-      parameters: {
-        model: model,
-        messages: memory.data.map { |event| convert_message(event) },
-      }
-    ).dig('choices', 0, 'message')
-
-    convert_event(msg)
-  end
-
-  # If allow to use the tool, return tool object implements `Autoflux::_Tool` interface
-  def tools?(name) = false
-  def tool(name) = nil
-
-  # Autoflux use a generic event object to represent the message, you have to convert it to the model's format
-  def convert_message(event)
-    {
-      role: event[:role],
-      content: event[:content]
-    }.tap do |evt|
-      evt[:tool_calls] = event[:invocations]&.map { |invocation| convert_tool_call(invocation) }
-      evt[:tool_call_id] = event[:invocation_id] if event[:invocation_id]
-    end
-  end
-
-  def convert_tool_call(invocation)
-    {
-      type: :function,
-      id: invocation[:id],
-      function: {
-        name: invocation[:name],
-        arguments: invocation[:args]
-      }
-    }
-  end
-
-  def convert_event(msg) # rubocop:disable Metrics/MethodLength
-    {
-      role: msg['role'],
-      content: msg['content'],
-      invocations: msg['tool_calls']&.map do |call|
-        {
-          id: call['id'],
-          name: call.dig('function', 'name'),
-          args: call.dig('function', 'arguments')
-        }
-      end
-    }
-  end
-end
+}
 ```
 
-The memory is history which keep in the workflow. You can decide to use it or not.
-
-### Tool
-
-The tool is a function that can be used in the agent's response.
+The workflow will pass itself as context to the agent.
 
 ```ruby
-# :nodoc:
-class AddToCartTool
-  attr_reader :name, :description, :parameters
-
-  def initialize # rubocop:disable Metrics/MethodLength
-    @name = 'add_to_cart'
-    @description = 'Add the product to the cart'
-    @parameters = {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'The name of the product' },
-        quantity: { type: 'number', description: 'The quantity of the product' }
-      }
-    }
-  end
-
-  def call(workflow:, params:)
-    { success: true, content: "Added #{params[:quantity]} #{params[:name]} to the cart" }
-  end
-end
+agent = ->(prompt, workflow:, **) {
+    workflow.io.write("User: #{prompt}")
+}
 ```
 
-> You can define how to tell the agent to use the tool by adding `name` and `description` to the tool.
+Workflow never knows the how the agent works and which tool is used.
 
 ### IO
 
-The IO is an adapter to the input and output.
+The IO is an adapter to let the workflow interact with the user.
 
 ```ruby
 # :nodoc:

data/lib/autoflux/step/agent.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Autoflux
+  module Step
+    # The Agent is transfer control to the agent and wait for the next event
+    class Agent
+      attr_reader :prompt
+
+      def initialize(prompt: nil)
+        @prompt = prompt
+      end
+
+      def to_s = self.class.name || "Agent"
+
+      def call(workflow:)
+        res = workflow.agent.call(prompt, workflow: workflow)
+        workflow.io.write(res.to_s)
+        Command.new
+      end
+    end
+  end
+end

data/lib/autoflux/step/command.rb

@@ -4,19 +4,13 @@ module Autoflux
   module Step
     # The Command step is used to get the user input.
     class Command
-      EXIT_COMMAND = "exit"
-
       def to_s = self.class.name || "Command"
 
       def call(workflow:)
         input = workflow.io.read
         return Stop.new if input.nil?
-        return Stop.new if input == EXIT_COMMAND
 
-        # @type var event: Autoflux::event
-        event = { role: ROLE_USER, content: input }
-        workflow.memory.push(event)
-        Assistant.new
+        Agent.new(prompt: input)
       end
     end
   end

data/lib/autoflux/step.rb

@@ -6,7 +6,6 @@ module Autoflux
     require "autoflux/step/start"
     require "autoflux/step/stop"
     require "autoflux/step/command"
-    require "autoflux/step/assistant"
-    require "autoflux/step/tool"
+    require "autoflux/step/agent"
   end
 end

data/lib/autoflux/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Autoflux
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/autoflux/workflow.rb

@@ -18,37 +18,29 @@ module Autoflux
 
     include Enumerable
 
-    attr_reader :id, :agent, :memory, :io
+    attr_reader :id, :agent, :io
 
     # @rbs state: State
-    def initialize(agent:, io:, id: nil, step: Step::Start.new, memory: Memory.new)
+    def initialize(agent:, io:, id: nil, step: Step::Start.new)
       @id = id || Workflow.next_id
       @agent = agent
       @io = io
       @step = step
-      @memory = memory
     end
 
     def each
       return to_enum(:each) unless block_given?
 
-      yield self
-      while @step
+      loop do
+        break unless @step
+
+        yield self
         @step = step.call(workflow: self)
-        yield self if @step
       end
     end
 
     # Run the workflow.
-    #
-    # @rbs system_prompt: String?
-    def run(system_prompt: nil, &block)
-      if system_prompt
-        # @type var event: Autoflux::event
-        event = { role: ROLE_SYSTEM, content: system_prompt }
-        memory.push(event)
-      end
-
+    def run(&block)
       each(&block || ->(_workflow) {})
     end
 

data/lib/autoflux.rb

@@ -6,12 +6,6 @@ require_relative "autoflux/version"
 module Autoflux
   class Error < StandardError; end
 
-  ROLE_SYSTEM = "system"
-  ROLE_ASSISTANT = "assistant"
-  ROLE_TOOL = "tool"
-  ROLE_USER = "user"
-
-  require_relative "autoflux/memory"
   require_relative "autoflux/step"
   require_relative "autoflux/workflow"
 end

data/sig/autoflux/agent.rbs

@@ -1,8 +1,6 @@
 module Autoflux
   # Agent implements the _Agent interface.
   interface _Agent
-    def tool?: (String name) -> bool
-    def tool: (String name) -> _Tool?
-    def call: (memory: _Memory) -> event
+    def call: (String? prompt, workflow: Workflow) -> _ToS
   end
 end

data/sig/autoflux/step.rbs

@@ -5,32 +5,24 @@ module Autoflux
   end
 
   module Step
-    # The Start step is used to start the workflow.
     class Start
       include Autoflux::_Step
     end
 
-    # The Stop step is used to stop the workflow.
     class Stop
       include Autoflux::_Step
     end
 
-    # The Assistant state is used to call the agent.
-    class Assistant
+    class Agent
       include Autoflux::_Step
-      OUTPUT_ROLE_NAME: "assistant"
-    end
 
-    # The Tool state is used to call the tools provided by the agent.
-    class Tool
-      include Autoflux::_Step
-      def run: (workflow: Workflow, invocation: invocation) -> ::_ToJson
+      attr_reader prompt: String?
+
+      def initialize: (?prompt: String) -> void
     end
 
-    # The Command step is used to get the user input.
     class Command
       include Autoflux::_Step
-      EXIT_COMMAND: "exit"
     end
   end
 end

data/sig/autoflux/workflow.rbs

@@ -7,18 +7,16 @@ module Autoflux
     @agent: _Agent
     @io: _IO
     @step: _Step
-    @memory: _Memory
 
     def self.next_id: () -> String
 
     attr_reader id: String
     attr_reader agent: _Agent
-    attr_reader memory: _Memory
     attr_reader io: _IO
 
-    def initialize: (agent: _Agent, io: _IO, ?id: String?, ?step: _Step, ?memory: _Memory) -> void
+    def initialize: (agent: _Agent, io: _IO, ?id: String?, ?step: _Step) -> void
     def each: { (Workflow) -> void } -> void
-    def run: (?system_prompt: String?) ?{ (Workflow) -> void } -> void
+    def run: () ?{ (Workflow) -> void } -> void
     def stop: () -> void
     def step: () -> _Step
     def to_h: () -> { id: String, step: String }

data/sig/autoflux.rbs

@@ -1,11 +1,6 @@
 module Autoflux
   VERSION: String
 
-  ROLE_SYSTEM: eventRole & "system"
-  ROLE_USER: eventRole & "user"
-  ROLE_TOOL: eventRole & "tool"
-  ROLE_ASSISTANT: eventRole & "assistant"
-
   class Error < StandardError
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autoflux
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Aotokitsuruya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-07 00:00:00.000000000 Z
+date: 2025-01-11 00:00:00.000000000 Z
 dependencies: []
 description: A lightweight AI agent framework for Ruby
 email:
@@ -27,26 +27,21 @@ files:
 - Steepfile
 - commitlint.config.js
 - lib/autoflux.rb
-- lib/autoflux/memory.rb
 - lib/autoflux/stdio.rb
 - lib/autoflux/step.rb
-- lib/autoflux/step/assistant.rb
+- lib/autoflux/step/agent.rb
 - lib/autoflux/step/command.rb
 - lib/autoflux/step/start.rb
 - lib/autoflux/step/stop.rb
-- lib/autoflux/step/tool.rb
 - lib/autoflux/version.rb
 - lib/autoflux/workflow.rb
 - package-lock.json
 - package.json
 - sig/autoflux.rbs
 - sig/autoflux/agent.rbs
-- sig/autoflux/event.rbs
 - sig/autoflux/io.rbs
-- sig/autoflux/memory.rbs
 - sig/autoflux/stdio.rbs
 - sig/autoflux/step.rbs
-- sig/autoflux/tool.rbs
 - sig/autoflux/workflow.rbs
 homepage: https://github.com/elct9620/autoflux
 licenses:
@@ -63,7 +58,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/autoflux/memory.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Autoflux
-  # The Memory is a class to store the memory of the workflow.
-  class Memory
-    attr_reader :data, :verbose
-
-    # @rbs data: Array[Hash]
-    def initialize(data: [], verbose: false)
-      @data = data
-      @verbose = verbose
-      freeze
-    end
-
-    # Push the data to the memory.
-    #
-    # @rbs data: Hash
-    def push(event)
-      puts JSON.pretty_generate(event) if verbose
-      @data.push(event)
-    end
-
-    # Get the last data from the memory.
-    def last
-      @data.last
-    end
-  end
-end

data/lib/autoflux/step/assistant.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Autoflux
-  module Step
-    # The Assistant state is used to call the agent.
-    class Assistant
-      def to_s = self.class.name || "Assistant"
-
-      def call(workflow:)
-        event = workflow.agent.call(memory: workflow.memory)
-        workflow.memory.push(event)
-
-        # @type var invocation_event: Autoflux::invocationEvent
-        invocation_event = event
-        return Tool.new if invocation_event[:invocations]&.any?
-
-        # @type var event: Autoflux::textEvent
-        workflow.io.write(event[:content]) if event[:role] == ROLE_ASSISTANT
-
-        Command.new
-      end
-    end
-  end
-end

data/lib/autoflux/step/tool.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Autoflux
-  module Step
-    # The Tool state is used to call the tools provided by the agent.
-    class Tool
-      def to_s = self.class.name || "Tool"
-
-      def call(workflow:)
-        # @type var event: Autoflux::invocationEvent
-        event = workflow.memory.last
-        event[:invocations]&.each do |invocation|
-          # @type: var invocation: Autoflux::invocation
-          # @type: var event: Autoflux::invocationResultEvent
-          event = {
-            role: ROLE_TOOL,
-            content: run(workflow: workflow, invocation: invocation).to_json,
-            invocation_id: invocation[:id]
-          }
-          workflow.memory.push(event)
-        end
-
-        Assistant.new
-      end
-
-      protected
-
-      def run(workflow:, invocation:)
-        name = invocation[:name]
-        params = JSON.parse(invocation[:args], symbolize_names: true)
-        return { status: "error", message: "Tool not found" } unless workflow.agent.tool?(name)
-
-        workflow.agent.tool(name)&.call(workflow: workflow, params: params)
-      rescue JSON::ParserError
-        { status: "error", message: "Invalid arguments" }
-      end
-    end
-  end
-end

data/sig/autoflux/event.rbs

@@ -1,27 +0,0 @@
-module Autoflux
-  type jsonString = String
-
-  type invocation = {
-    id: String,
-    name: String,
-    args: jsonString
-  }
-
-  type eventRole = "assistant" | "system" | "user" | "tool" | String
-  type baseEvent = {
-    role: eventRole,
-    agent_id?: String,
-    raw?: Hash[untyped, untyped]
-  }
-  type textEvent = baseEvent & {
-    content: String
-  }
-  type invocationEvent = baseEvent & {
-    invocations: Array[invocation]
-  }
-  type invocationResultEvent = textEvent & {
-    invocation_id: String
-  }
-
-  type event = textEvent | invocationEvent | invocationResultEvent
-end

data/sig/autoflux/memory.rbs

@@ -1,20 +0,0 @@
-module Autoflux
-  interface _Memory
-    def data: () -> Array[event]
-    def push: (event event) -> void
-    def last: () -> event
-  end
-
-  # The Memory is a class to store the memory of the workflow.
-  class Memory
-    include _Memory
-
-    @data: Array[event]
-    @verbose: bool
-
-    attr_reader verbose: bool
-
-    # @rbs data: Array[Hash]
-    def initialize: (?data: Array[event], ?verbose: bool) -> void
-  end
-end

data/sig/autoflux/tool.rbs

@@ -1,5 +0,0 @@
-module Autoflux
-  interface _Tool
-    def call: (workflow: Workflow, params: untyped) -> untyped
-  end
-end