roseflow 0.0.1 → 0.1.0

data/lib/roseflow/actions/ai/resolve_provider.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "roseflow/action"
+require "roseflow/ai/provider"
+require "roseflow/openai/config"
+
+module Roseflow
+  module Actions
+    module AI
+      class ResolveProvider
+        extend Roseflow::Action
+
+        expects :provider
+        promises :provider
+
+        executed do |context|
+          context[:provider] = resolve_provider(context[:provider])
+        end
+
+        private_class_method
+
+        def self.resolve_provider(provider)
+          case provider
+          when :openai
+            Roseflow::AI::Provider.new(name: :openai, credentials: Roseflow::OpenAI::Config.new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roseflow/ai/model.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Roseflow
+  module AI
+    class Model
+      attr_reader :name, :provider
+
+      def initialize(name:, provider:)
+        @name = name
+        @provider = provider
+        @model_ = provider.models.find(name)
+      end
+
+      def call(operation, input)
+        @model_.call(operation, input)
+      end
+    end # Model
+  end # AI
+end # Roseflow

data/lib/roseflow/ai/provider.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "roseflow/openai/provider"
+
+module Roseflow
+  module AI
+    class Provider
+      def initialize(name:, credentials:)
+        @name = name
+        @credentials = credentials
+        initialize_provider
+      end
+
+      def models
+        @models ||= provider.models
+      end
+
+      private
+
+      attr_reader :name, :credentials, :provider
+
+      def initialize_provider
+        case name
+        when :openai
+          @provider = Roseflow::OpenAI::Provider.new(credentials: credentials)
+        end
+      end
+    end # Provider
+  end # AI
+end # Roseflow

data/lib/roseflow/chat/dialogue.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "roseflow/chat/exchange"
+require "roseflow/chat/message"
+
+module Roseflow
+  module Chat
+    class Dialogue
+      attr_reader :messages
+      attr_reader :exchanges
+      attr_reader :personality
+
+      def initialize(personality: nil)
+        @messages = []
+        @exchanges = []
+        initialize_with_personality(personality) if personality
+      end
+
+      def model
+        @model ||= provider.models.chattable.first
+      end
+
+      def provider
+        @provider ||= OpenAI::Provider.new(Roseflow::OpenAI::Config.new)
+      end
+
+      def recall(messages)
+        @messages = messages
+        parse_exchanges
+      end
+
+      # This method takes a string input as input, which is a message to send to the LLM model.
+      # If the model is chattable, it sends the messages to the model and returns a response.
+      def say(input, **options)
+        if model.chattable?
+          message = create_user_message(input)
+          @messages.push(message)
+
+          model_response = provider.chat(model: model, messages: @messages, **options)
+
+          if model_response && model_response.success?
+            exchange = create_exchange(message, model_response.choices.first.message)
+            @exchanges.push(exchange)
+            @messages.push(exchange.response)
+            exchange.response
+          else
+            raise "Did not receive a response from the model"
+          end
+        else
+          raise "Model is not chattable"
+        end
+      end
+
+      private
+
+      def initialize_with_personality(personality)
+        @personality = personality
+        @messages << SystemMessage.new(role: "system", content: personality.description)
+      end
+
+      def create_user_message(input)
+        UserMessage.new(role: "user", content: input)
+      end
+
+      def create_exchange(prompt, response)
+        Exchange.new(prompt: prompt, response: response)
+      end
+
+      def parse_exchanges
+        user_assistant_messages.each_cons(2) do |prompt, response|
+          @exchanges << Exchange.new(prompt: prompt, response: response)
+        end
+      end
+
+      def user_assistant_messages
+        @messages.reject { |message| message.role == "system" }
+      end
+    end
+  end
+end

data/lib/roseflow/chat/exchange.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "roseflow/chat/message"
+
+module Roseflow
+  module Chat
+    class Exchange < Dry::Struct
+      attribute :prompt, UserMessage
+      attribute :response, ModelMessage
+    end
+  end
+end

data/lib/roseflow/chat/message.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+require "roseflow/types"
+
+module Roseflow
+  module Chat
+    class Message < Dry::Struct
+      attribute :role, Types::String
+      attribute :content, Types::String
+      attribute? :name, Types::String
+      attribute? :token_count, Types::Integer
+
+      def user?
+        role == "user"
+      end
+
+      def system?
+        role == "system"
+      end
+
+      def model?
+        %w(system assistant).include?(role)
+      end
+    end
+
+    class ModelMessage < Message
+      attribute :role, Types::String.constrained(included_in: %w(system assistant))
+    end
+
+    class UserMessage < Message
+      attribute :role, Types::String.constrained(included_in: %w(user))
+    end
+
+    class SystemMessage < Message
+      attribute :role, Types::String.constrained(included_in: %w(system))
+    end
+  end
+end

data/lib/roseflow/chat/personality.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Roseflow
+  module Chat
+    class Personality < Dry::Struct
+      attribute :name, Types::Strict::String
+      attribute :description, Types::Strict::String
+    end
+  end
+end

data/lib/roseflow/embeddings/embedding.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Roseflow
+  module Embeddings
+    EmbeddingModelNotSpecifiedError = Class.new(StandardError)
+    
+    class Embedding
+      attr_reader :length, :vector
+      attr_writer :input
+
+      def initialize(**kwargs)
+        @length = kwargs.fetch(:length, 1024)
+        @input = kwargs.fetch(:input, nil)
+        @model = kwargs.fetch(:model, nil)
+        @vector = kwargs.fetch(:vector, nil)
+      end
+
+      def call
+        raise ArgumentError, "An input must be provided" unless @input
+        raise EmbeddingModelNotSpecifiedError, "An embedding model must be specified" unless @model
+        response = @model.provider.create_embedding(model: @model, input: @input)
+        response.embedding
+      end
+    end # Embedding
+  end # Embeddings
+end # Roseflow

data/lib/roseflow/finite_machine.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require "ulid"
+require "finite_machine"
+
+## FIXME:
+## Monkey patching FiniteMachine::GenericDSL for Ruby 3.2 support.
+## See: https://github.com/piotrmurach/finite_machine/pull/74
+
+module FiniteMachine
+  # A class responsible for observing state changes
+  class Observer < GenericDSL
+    include Safety
+
+    # Clean up callback queue
+    #
+    # @api private
+    def cleanup_callback_queue(_id)
+      if callback_queue.alive?
+        callback_queue.shutdown
+      end
+    rescue MessageQueueDeadError
+    end
+
+    # The current state machine
+    attr_reader :machine
+
+    # The hooks to trigger around the transition lifecycle.
+    attr_reader :hooks
+
+    # Initialize an Observer
+    #
+    # @param [StateMachine] machine
+    #   reference to the current machine
+    #
+    # @api public
+    def initialize(machine)
+      @id = ULID.generate
+      @machine = machine
+      @hooks = Hooks.new
+
+      @machine.subscribe(self)
+      ObjectSpace.define_finalizer(@id, method(:cleanup_callback_queue))
+    end
+
+    def callback_queue
+      @callback_queue ||= MessageQueue.new
+    end
+
+    # Evaluate in current context
+    #
+    # @api private
+    def call(&block)
+      instance_eval(&block)
+    end
+
+    # Register callback for a given hook type
+    #
+    # @param [HookEvent] hook_type
+    # @param [Symbol] state_or_event_name
+    # @param [Proc] callback
+    #
+    # @example
+    #   observer.on HookEvent::Enter, :green
+    #
+    # @api public
+    def on(hook_type, state_or_event_name = nil, async = nil, &callback)
+      sync_exclusive do
+        if state_or_event_name.nil?
+          state_or_event_name = HookEvent.any_state_or_event(hook_type)
+        end
+        async = false if async.nil?
+        ensure_valid_callback_name!(hook_type, state_or_event_name)
+        callback.extend(Async) if async == :async
+        hooks.register(hook_type, state_or_event_name, callback)
+      end
+    end
+
+    # Unregister callback for a given event
+    #
+    # @api public
+    def off(hook_type, name = ANY_STATE, &callback)
+      sync_exclusive do
+        hooks.unregister hook_type, name, callback
+      end
+    end
+
+    module Once; end
+
+    module Async; end
+
+    def on_enter(*args, &callback)
+      on HookEvent::Enter, *args, &callback
+    end
+
+    def on_transition(*args, &callback)
+      on HookEvent::Transition, *args, &callback
+    end
+
+    def on_exit(*args, &callback)
+      on HookEvent::Exit, *args, &callback
+    end
+
+    def once_on_enter(*args, &callback)
+      on HookEvent::Enter, *args, &callback.extend(Once)
+    end
+
+    def once_on_transition(*args, &callback)
+      on HookEvent::Transition, *args, &callback.extend(Once)
+    end
+
+    def once_on_exit(*args, &callback)
+      on HookEvent::Exit, *args, &callback.extend(Once)
+    end
+
+    def on_before(*args, &callback)
+      on HookEvent::Before, *args, &callback
+    end
+
+    def on_after(*args, &callback)
+      on HookEvent::After, *args, &callback
+    end
+
+    def once_on_before(*args, &callback)
+      on HookEvent::Before, *args, &callback.extend(Once)
+    end
+
+    def once_on_after(*args, &callback)
+      on HookEvent::After, *args, &callback.extend(Once)
+    end
+
+    # Execute each of the hooks in order with supplied data
+    #
+    # @param [HookEvent] event
+    #   the hook event
+    #
+    # @param [Array[Object]] data
+    #
+    # @return [nil]
+    #
+    # @api public
+    def emit(event, *data)
+      sync_exclusive do
+        [event.type].each do |hook_type|
+          any_state_or_event = HookEvent.any_state_or_event(hook_type)
+          [any_state_or_event, event.name].each do |event_name|
+            hooks[hook_type][event_name].each do |hook|
+              handle_callback(hook, event, *data)
+              off(hook_type, event_name, &hook) if hook.is_a?(Once)
+            end
+          end
+        end
+      end
+    end
+
+    # Cancel the current event
+    #
+    # This should be called inside a on_before or on_exit callbacks
+    # to prevent event transition.
+    #
+    # @param [String] msg
+    #   the message used for failure
+    #
+    # @api public
+    def cancel_event(msg = nil)
+      raise CallbackError.new(msg)
+    end
+
+    private
+
+    # Handle callback and decide if run synchronously or asynchronously
+    #
+    # @param [Proc] :hook
+    #   The hook to evaluate
+    #
+    # @param [HookEvent] :event
+    #   The event for which the hook is called
+    #
+    # @param [Array[Object]] :data
+    #
+    # @api private
+    def handle_callback(hook, event, *data)
+      to = machine.events_map.move_to(event.event_name, event.from, *data)
+      trans_event = TransitionEvent.new(event.event_name, event.from, to)
+      callable = create_callable(hook)
+
+      if hook.is_a?(Async)
+        defer(callable, trans_event, *data)
+      else
+        callable.call(trans_event, *data)
+      end
+    end
+
+    # Defer callback execution
+    #
+    # @api private
+    def defer(callable, trans_event, *data)
+      async_call = AsyncCall.new(machine, callable, trans_event, *data)
+      callback_queue.start unless callback_queue.running?
+      callback_queue << async_call
+    end
+
+    # Create callable instance
+    #
+    # @api private
+    def create_callable(hook)
+      callback = proc do |trans_event, *data|
+        machine.instance_exec(trans_event, *data, &hook)
+      end
+      Callable.new(callback)
+    end
+
+    # Callback names including all states and events
+    #
+    # @return [Array[Symbol]]
+    #   valid callback names
+    #
+    # @api private
+    def callback_names
+      machine.states + machine.events + [ANY_EVENT, ANY_STATE]
+    end
+
+    # Forward the message to observer
+    #
+    # @param [String] method_name
+    #
+    # @param [Array] args
+    #
+    # @return [self]
+    #
+    # @api private
+    def method_missing(method_name, *args, &block)
+      _, event_name, callback_name = *method_name.to_s.match(/^(\w*?on_\w+?)_(\w+)$/)
+      if callback_name && callback_names.include?(callback_name.to_sym)
+        public_send(event_name, :"#{callback_name}", *args, &block)
+      else
+        super
+      end
+    end
+
+    # Test if a message can be handled by observer
+    #
+    # @param [String] method_name
+    #
+    # @param [Boolean] include_private
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def respond_to_missing?(method_name, include_private = false)
+      *_, callback_name = *method_name.to_s.match(/^(\w*?on_\w+?)_(\w+)$/)
+      callback_name && callback_names.include?(:"#{callback_name}")
+    end
+  end # Observer
+
+  class StateMachine
+    def initialize(*args, &block)
+      options = args.last.is_a?(::Hash) ? args.pop : {}
+      @initial_state = DEFAULT_STATE
+      @auto_methods = options.fetch(:auto_methods, true)
+      @subscribers = Subscribers.new
+      @observer = Observer.new(self)
+      @events_map = EventsMap.new
+      @env = Env.new(self, [])
+      @dsl = DSL.new(self, options)
+      @name = options.fetch(:name) { ULID.generate }
+
+      env.target = args.pop unless args.empty?
+      env.aliases << options[:alias_target] if options[:alias_target]
+      dsl.call(&block) if block
+      trigger_init
+    end
+
+    def transition!(event_name, *data, &block)
+      from_state = current
+      to_state = events_map.move_to(event_name, from_state, *data)
+
+      block.call(from_state, to_state) if block
+
+      if log_transitions
+        Logger.report_transition(@name, event_name, from_state, to_state, *data)
+      end
+
+      try_trigger(event_name) { transition_to!(to_state) }
+    end
+  end # StateMachine
+
+  module Logger
+    def report_transition(machine_name, event_name, from, to, *args)
+      message = ["Transition: @machine=#{machine_name} @event=#{event_name} "]
+      unless args.empty?
+        message << "@with=[#{args.join(",")}] "
+      end
+      message << "#{from} -> #{to}"
+      info(message.join)
+    end
+  end # Logger
+end # FiniteMachine

data/lib/roseflow/interaction/with_http_api.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "roseflow/interaction"
+
+module Roseflow
+  module Interaction
+    module WithHttpApi
+    end # WithHttpApi
+  end # Interaction
+end # Roseflow

data/lib/roseflow/interaction.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "light-service"
+
+module Roseflow
+  module Interaction
+    extend LightService::Organizer
+
+    def self.extended(base_class)
+      base_class.extend LightService::Organizer::ClassMethods
+      base_class.extend LightService::Organizer::Macros
+    end
+  end
+end

data/lib/roseflow/interaction_context.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "light-service/context"
+require "hashie/extensions/method_access"
+
+module Roseflow
+  class InteractionContext < LightService::Context
+    include Hashie::Extensions::MethodAccess
+  end
+end

data/lib/roseflow/interactions/ai/initialize_llm.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "roseflow/interaction"
+require "roseflow/actions/ai/resolve_model"
+require "roseflow/actions/ai/resolve_provider"
+
+module Roseflow
+  module Interactions
+    module AI
+      class InitializeLlm
+        extend Roseflow::Interaction
+
+        def self.call(context)
+          with(context).reduce(actions)
+        end
+
+        def self.actions
+          [
+            Actions::AI::ResolveProvider,
+            Actions::AI::ResolveModel
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/roseflow/primitives/vector.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "dry-types"
+
+module Types
+  include Dry.Types()
+  Number = Types::Float | Types::Integer
+end
+
+module Roseflow
+  module Primitives
+    class Vector < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :values, Types::Array.of(Types::Number)
+      attribute :dimensions, Types::Integer
+    end # Vector
+  end # Primitives
+end # Roseflow

data/lib/roseflow/prompt.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "phlex"
+
+module Roseflow
+  class Prompt < Phlex::SGML
+    private
+
+    def plain_raw(content)
+      unsafe_raw(content)
+    end
+
+    def condensed(string)
+      string.gsub(/\s+/, " ").strip
+    end
+  end
+end

data/lib/roseflow/text/completion.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Roseflow
+  module Text
+    class Completion
+      def initialize(input)
+        @input = input
+      end
+
+      # Creates a new completion for the given input.
+      def call(model:, prompt:, **options)
+        provider.completions(model: model, prompt: @input, **options).choices
+      end
+    end
+  end
+end