activeai 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5a985f1783335da05fa3165fbe352823a431d206c2586a334eff561874e88d2
-  data.tar.gz: bce08aa0e01e59e780ad8a47fd632e10567ae7c25dd8d88b295f61344d4a044c
+  metadata.gz: 446cdb7b4d1341e1450486380b0926a68ff594b4361a330f6baa7466ac208c76
+  data.tar.gz: 5416c0e23d45fb0c7b7833b3ed8888a7339a5e51fb8bf2f34447283452e3db5b
 SHA512:
-  metadata.gz: db6b75600a2cf40c9b872c62a64316ffd36c69bd53856b3b05aed9865332450ed54c4b16690c7225ec313fb86d1634a6baade87cec4ab11464e0f9b4fb48be09
-  data.tar.gz: 383a17006039e02b64507bba0c95648bef990a17ce7f2ad676ab21fd0505f62a9eada8c5484e7a170215200a770d58e27c924e1a00be397f382d4c4364f39d59
+  metadata.gz: 0e5f825a3d3b3c2781cc353462ed74087b5c56bd5492e70dad21f3294328dce63d1e198b28e745f98e503a5483b9eb7f0d41c4a552f680200809753a6527b09e
+  data.tar.gz: b7fa0ae8250c6bacd2f5083acfbcbcf2fa58f481721e69b9ce060f5a4fac934b8d6b28b41386ce2bafa6f1cef019543e113b04929fcb7bd2e086858068a38596

data/README.md

@@ -39,6 +39,12 @@ puts result
 #=> 'tomatoes, jam'
 ```
 
+### Behavior: WriteFunctionCall
+
+#### TODO
+
+This lets you use `code-davinci-002` or `code-cushman-001` to run logic. The router uses this internally. Supply a list of example pairs that are a "description" and "code", and then you can complete another one.
+
 ### TODO: with other patterns
 
 ### TODO: auto-detected behavior pattern from config
@@ -102,7 +108,7 @@ controller.call("Pay Mom R127 for groceries")
 It's possible to instantiate an `ActiveAI::Router`, load up the examples from multiple controllers, and then have it handle many types of requests. It does this in a similar way to how the controller uses an LLM to map to action and params, but it concatenates all controller routing examples and strips out the parameter preparation step for efficiency, since the controller handles this.
 
 ```ruby
-router = ActiveAI::Router.new
+router = ActiveAI::Router.new # TODO you need to add providers now.. should be optional?
 
 # load all auto-detected routes:
 router.auto_load_routing(Rails.root.join('config','routes')) # loads all .yml files as controller examples

data/lib/activeai/behavior/llm/conversation.rb

@@ -20,7 +20,7 @@ class ActiveAI::Behavior::LLM::Conversation < ActiveAI::Behavior::LLM
         # TODO use the label key they provide in the yml file
       end,
       "Conversation:\n" + @state['conversation']
-    ].join(SEPARATOR)
+    ].join(LINE_SEPARATOR)
   end
 
   def add(speaker, message)

data/lib/activeai/behavior/llm/follow_structured_examples.rb

@@ -15,12 +15,12 @@ class ActiveAI::Behavior::LLM::FollowStructuredExamples < ActiveAI::Behavior::LL
         example.map do |key, value|
           "#{key}: #{value}"
         end.join("\n")
-      end.join(SEPARATOR)
-    ].join(SEPARATOR)
+      end.join(LINE_SEPARATOR)
+    ].join(LINE_SEPARATOR)
   end
 
   def call(input={}, extract: []) # TODO cool splat stuff?
-    prompt = base_prompt + SEPARATOR
+    prompt = base_prompt + LINE_SEPARATOR
 
     prompt += input.map do |key, value|
       "#{key}: #{value}"

data/lib/activeai/behavior/llm/write_function_call.rb

@@ -0,0 +1,40 @@
+class ActiveAI::Behavior::LLM::WriteFunctionCall < ActiveAI::Behavior::LLM
+  def initialize(llm, state)
+    super(llm)
+    @state = state
+    # TODO raise errors if not expected thingies available in the config
+  end
+
+  def base_prompt
+    (@state[:examples].map do |example|
+      "/* #{example[:description]} */\n#{example[:code]}"
+    end + [""]).join("<|endoftext|>")
+  end
+
+  def call(comment)
+    prompt = base_prompt
+    prompt += "/* #{comment} */\n"
+
+    complete_result = complete(prompt) # this still breaks sometimes by generating like 50 functions instead of stopping. think i fixed it? forgot an <|endoftext|> at the end
+
+    # puts prompt
+    # puts complete_result
+
+    completion = complete_result['choices'][0]['text']
+    completion = completion.strip.gsub("\n", "\\n") # fixes parsing errors (in JSON??)
+
+    matcher = /(.*?)\((.*)\)/m # should be made ungreedy, but then i dont see when it over-completes because it fails silently
+    matches = matcher.match(completion)
+
+    if matches.nil?
+      # binding.pry
+      raise "Unmatched router response in #{self.class}"
+    end
+
+    return {
+      text: completion.strip,
+      path: matches[1],
+      params: matches[2].presence && JSON.parse(matches[2])
+    }
+  end
+end

data/lib/activeai/behavior/llm.rb

@@ -7,7 +7,7 @@ class ActiveAI::Behavior::LLM < ActiveAI::Behavior::Base
     @llm.complete(prompt: prompt, stop: stop)
   end
 
-  SEPARATOR = "\n\n###\n\n"
+  LINE_SEPARATOR = "\n\n###\n\n"
 
   def extract_keys(completion, extract)
     matcher_string = extract.map{ |key| "#{key}:(.*)" }.join
@@ -25,5 +25,6 @@ class ActiveAI::Behavior::LLM < ActiveAI::Behavior::Base
 end
 
 require_relative "llm/conversation"
-require_relative "llm/unstructured"
 require_relative "llm/follow_structured_examples"
+require_relative "llm/unstructured"
+require_relative "llm/write_function_call"

data/lib/activeai/controller.rb

@@ -9,20 +9,37 @@ class ActiveAI::Controller
   end
 
   def self.load_routing(routes_config)
-    @llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'text-curie-001', temperature: 0.2)
-    self.routing_behavior = ActiveAI::Behavior::LLM::FollowStructuredExamples.new(@llm, routes_config)
+    @llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'code-cushman-001', temperature: 0)
+
+    examples = ActiveAI.route_examples_to_function_call_examples(routes_config['examples'])
+    self.routing_behavior = ActiveAI::Behavior::LLM::WriteFunctionCall.new(@llm, { examples: examples })
   end
 
   attr_accessor :params
 
+  def initialize(provider)
+    @provider = provider
+  end
+
   def prepare_action(request)
-    routing = self.class.routing_behavior.call({ 'Request' => request }, extract: %W[Route Params])
-    controller_name, action_name = routing['Route'].split('#')
+    # samples to parse:
+    #   plugins.slack.send_message({ \"channel\": \"#general\", \"text\": \"Hi\" })
+    #   unmatched()
+
+    function = self.class.routing_behavior.call(request)
+    *controller_path, action_name = function[:path].split(".")
+    controller_name = controller_path.join("/").presence
+
     # TODO verify it's the right controller and the action name exists and it's not a reserved / internal thing
-    return {
-      action: action_name,
-      params: JSON.parse(routing['Params']) # TODO cast as JSON earlier? e.g. in config of the behavior? 
-    }
+
+    if controller_name.present?
+      return {
+        action: action_name,
+        params: function[:params]
+      }
+    else
+      return nil
+    end
   end
 
   def call(request)

data/lib/activeai/router.rb

@@ -4,7 +4,7 @@ class ActiveAI::Router
 
   def initialize
     @routings = []
-    @llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'text-curie-001', temperature: 0.2)
+    @llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'code-cushman-001', temperature: 0)
   end
 
   def add_controller_routing(routing)
@@ -24,26 +24,42 @@ class ActiveAI::Router
   end
 
   def behavior
-    config = {
-      'instruction' => INSTRUCTION,
-      'examples' => [UNMATCHED] + @routings.map do |routing|
-        routing['examples'].reject do |example|
-          example['Route'] == 'None'
-        end.map do |example|
-          example.slice('Match', 'Route')
-        end
-      end.flatten
-    }
-
-    ActiveAI::Behavior::LLM::FollowStructuredExamples.new(@llm, config)
+    raw_examples = [UNMATCHED] + @routings.map do |routing|
+      routing['examples'].reject do |example|
+        example['Route'] == 'None'
+      end.map do |example|
+        example.slice('Match', 'Route')
+      end
+    end.flatten
+    examples = ActiveAI.route_examples_to_function_call_examples(raw_examples)
+
+    ActiveAI::Behavior::LLM::WriteFunctionCall.new(@llm, { examples: examples })
   end
 
+  # def behavior_via_structured_examples
+  #   config = {
+  #     'instruction' => INSTRUCTION,
+  #     'examples' => [UNMATCHED] + @routings.map do |routing|
+  #       routing['examples'].reject do |example|
+  #         example['Route'] == 'None'
+  #       end.map do |example|
+  #         example.slice('Match', 'Route')
+  #       end
+  #     end.flatten
+  #   }
+
+  #   ActiveAI::Behavior::LLM::FollowStructuredExamples.new(@llm, config)
+  # end
+
   def find_controller(request)
-    # should return constantized maybe?
-    routing = behavior.call({ 'Request' => request }, extract: %W[Route])
-    controller_name, action_name = routing['Route'].split('#')
+    function = behavior.call(request) # TODO maybe the behavior should return function and params as well. seems right
     
-    if controller_name == "None" || action_name.blank?
+    *controller_path, action_name = function[:path].split(".")
+    controller_name = controller_path.join("/").presence
+
+    # TODO verify it's the right controller and the action name exists and it's not a reserved / internal thing
+
+    if controller_name.blank? || action_name.blank? || action_name == 'unmatched'
       return nil
     else
       return (controller_name + "_controller").classify.constantize
@@ -53,11 +69,18 @@ class ActiveAI::Router
     end
   end
 
-  def call(request)
-    if controller = find_controller(request)
-      controller.new.call(request)
-    else
-      return nil
-    end
-  end
+  # This stopped being necessary, because we find controller and call it elsewhere:
+  # def call(request, providers=nil)
+  #   if controller = find_controller(request)
+
+  #     provider = if providers.respond_to?(:find_by)
+  #       provider_name = controller.to_s.gsub("Plugins::", "").gsub("Controller","")
+  #       providers.find_by(name: provider_name)
+  #     end
+
+  #     controller.new(provider).call(request)
+  #   else
+  #     return nil
+  #   end
+  # end
 end

data/lib/activeai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveAI
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/lib/activeai.rb

@@ -16,5 +16,17 @@ module ActiveAI
     }
   end
 
+  def self.route_examples_to_function_call_examples(examples)
+    examples.map do |example|
+      function = example['Route'].gsub('/','.').gsub('#','.')
+      function = "unmatched" if function == "None"
+      
+      {
+        description: example['Match'],
+        code: "#{function}(#{example['Params']&.strip})"
+      }
+    end
+  end
+
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeai
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - jeriko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-06 00:00:00.000000000 Z
+date: 2023-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -64,6 +64,7 @@ files:
 - lib/activeai/behavior/llm/conversation.rb
 - lib/activeai/behavior/llm/follow_structured_examples.rb
 - lib/activeai/behavior/llm/unstructured.rb
+- lib/activeai/behavior/llm/write_function_call.rb
 - lib/activeai/configuration.rb
 - lib/activeai/controller.rb
 - lib/activeai/neural_network.rb