glim_ai 0.2.0

data/lib/glim_ai_callable.rb

@@ -0,0 +1,151 @@
+
+
+
+module AICallable
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def ai_callable_as(method_name, &block)
+      method_signature_builder = MethodSignatureBuilder.new
+      method_signature_builder.instance_eval(&block)
+      ai_method_signatures << method_signature_builder.signature.merge({ name: method_name.to_s })
+    end
+
+    def ai_method_signatures
+      @ai_method_signatures ||= []
+    end
+
+    def ai_method_signatures_clean
+      return @ai_method_signatures_clean if @ai_method_signatures_clean
+      def remove_local_name(data)
+        result = data.map do |item|
+          { 
+            'name' => item[:name],
+            'description' => item[:description],
+            'parameters' => {
+              'type' => item[:parameters][:type],
+              'properties' => item[:parameters][:properties].transform_values { |property| property.reject { |k, _| k == :local_name } },
+              'required' => item[:parameters][:required]
+            }
+          }
+        rescue => e
+          putt :warning, "Issue with #{item}: #{e.message}"
+          raise e
+        end
+        return result
+      end
+      sigs = ai_method_signatures # this is an array
+      @ai_method_signatures_clean = remove_local_name(sigs)
+    end
+  
+  end # ClassMethods
+
+  def _perform_ai_call(eval_function_name, eval_function_arguments)
+    # begin
+      sigs = self.class.ai_method_signatures
+      putt(:functions, "eval_function_name = #{eval_function_name}, sigs: #{sigs}")
+
+      sig = sigs.select { |x| x[:name].to_s == eval_function_name.to_s }.first
+      props = sig[:parameters][:properties]
+      # props looks like this: {v1=>{...}, v2: {...}
+      local_function_arguments = {}
+      for ai_name in props.keys
+        v = props[ai_name]
+        # v looks like this:  {:type=>:string, :description=>"The expression, as a string, in correct ruby syntax", :local_name=>:exp}}
+        local_param_name = v[:local_name]
+        local_function_arguments[local_param_name] = eval_function_arguments[ai_name]
+      end
+      putt(:functions, "eval_function_arguments: #{eval_function_arguments}")
+      putt(:functions, "local_function_arguments: #{local_function_arguments}")
+
+      required_params = sig[:parameters][:required]
+      for required_param in required_params
+        raise "Missing required parameter: #{required_param}" unless eval_function_arguments[required_param]
+      end
+      # eval_function_result = eval_functions_object.send(eval_function_name, **local_function_arguments)
+      eval_function_result = send(eval_function_name, **local_function_arguments)
+    # rescue => e
+    #   putt :warning, "FAILED Function call to #{self}.#{eval_function_name}(#{local_function_arguments}): #{e}"
+    #   eval_function_result = e.message
+    # end
+    return eval_function_result
+  end
+
+
+  class MethodSignatureBuilder
+    def initialize
+      @signature = {
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      }
+    end
+
+    attr_reader :signature
+
+    def describe(text)
+      @signature[:description] = text
+    end
+
+#     4.2.1. Instance Data Model
+# JSON Schema interprets documents according to a data model. A JSON value interpreted according to this data model is called an "instance".
+
+# An instance has one of six primitive types, and a range of possible values depending on the type:
+
+# null:
+# A JSON "null" value
+# boolean:
+# A "true" or "false" value, from the JSON "true" or "false" value
+# object:
+# An unordered set of properties mapping a string to an instance, from the JSON "object" value
+# array:
+# An ordered list of instances, from the JSON "array" value
+# number:
+# An arbitrary-precision, base-10 decimal number value, from the JSON "number" value
+# string:
+# A string of Unicode code points, from the JSON "string" value
+
+    def number(name, description, opts = {})
+      # we want to use ai_name for everything here, but then when we invoke, 
+      # we will want to look up the local name
+      ai_name = opts[:ai_name] || name
+      @signature[:parameters][:properties][ai_name] = {
+        type: :number,
+        description: description,
+        local_name: name
+      }
+      if opts[:required]
+        raise "Required muat be boolean if set" unless opts[:required].is_a?(TrueClass) || opts[:required].is_a?(FalseClass)
+        @signature[:parameters][:required] << ai_name if opts[:required]
+      end
+    end
+
+    def string(name, description, opts = {})
+      # we want to use ai_name for everything here, but then when we invoke, 
+      # we will want to look up the local name
+      ai_name = opts[:ai_name] || name
+      @signature[:parameters][:properties][ai_name] = {
+        type: :string,
+        description: description,
+        local_name: name
+      }
+      if opts[:enum]
+        rng = opts[:enum]
+        for s in rng
+          raise "Invalid enum value: #{s}" unless s.is_a?(String)
+        end
+        @signature[:parameters][:properties][ai_name][:enum] = rng
+      end
+      if opts[:required]
+        raise "Required muat be boolean if set" unless opts[:required].is_a?(TrueClass) || opts[:required].is_a?(FalseClass)
+        @signature[:parameters][:required] << ai_name if opts[:required]
+      end
+    end
+
+  end
+end

data/lib/glim_context.rb

@@ -0,0 +1,62 @@
+require_relative 'globals'
+
+class GlimContext
+
+    attr_reader :log_name, :template_subdir
+    attr_reader :start_time
+
+    def initialize(log_name: nil, template_subdir: "templates")
+        #["test/test_glim.rb:71:in `new'",
+        if !log_name
+            @log_name = caller[0].split(':').first.split('/').last
+        else
+            @log_name = log_name
+        end
+        @log_name += Time.now.strftime('%Y-%m-%d-%H-%M-%S')
+        @template_subdir = template_subdir.must_be_a String
+        putt :log, "GlimContext template_subdir=#{@template_subdir}, log_name: #{log_name.inspect}"
+        @start_time = Time.now
+    end
+
+    def request(args)
+        args_with_context = args.merge(context: self)
+        GlimRequest.new(**args_with_context)
+    end
+
+    def request_from_template(template_name, **template_args)
+        req = GlimRequest.new(context: self)
+        req.process_template(template_name, **template_args)
+        req.context = self
+        req
+    end
+
+    # just for convenience
+    def response_from_template(template_name, **template_args)
+        template_name.must_be_a String
+        template_args.must_be_a Hash
+        # puts("response_from_spec: #{template_args.inspect}")
+        req = request_from_template(template_name, **template_args)
+        req.response
+    end
+
+    def log_base_glim 
+        ENV['GLIM_LOG_DIRECTORY']
+    end
+
+    def log_base
+        File.join(log_base_glim,log_name) 
+    end
+
+    def log_line_to_summary(line)
+        log_summary_file = File.join(log_base, "llm_log.csv")
+        seconds_since_start = Time.now - start_time
+        s = "#{seconds_since_start.round(3)}, #{line}"
+        File.open(log_summary_file, 'a') do |f|
+          f.puts s
+        end
+    end
+    
+
+end
+
+    

data/lib/glim_helpers.rb

@@ -0,0 +1,54 @@
+module GlimHelpers
+
+    # TODO: modify this so that you can also include a single file, list of files, etc
+    def include_files(path, prefix='')
+        putt :include_files, "include_files(path: #{path}, prefix: #{prefix})"
+        result = ""
+        Dir.foreach(path) do |entry|
+            next if entry.start_with?('.')
+            entry_path = File.join(path, entry)
+            relative_path = File.join(prefix, entry)
+            if File.directory?(entry_path)
+                result += include_files(entry_path, relative_path)
+            else
+                # elsif File.file?(entry_path)
+                # result +=  "\n```\n# File: #{relative_path}\n"
+                # result += File.read(entry_path)
+                # result += "\n```\n"
+                result += include_file(entry_path, relative_path)
+            end
+        end
+        result
+    end
+
+    def include_file(entry_path, relative_path = nil)
+        relative_path ||= entry_path
+        raise("File not found: #{entry_path}") if !File.file?(entry_path)
+        result = "\n<file pathname=\"#{relative_path}\">"
+        result += File.read(entry_path)
+        result + "</file>\n"
+    end
+
+
+    def prompt_output_files 
+<<-GLIM_PROMPT
+
+
+TODO 
+
+fix this for xml
+
+SYSTEM MESSAGE: ALWAYS, when asked to generate source code or other text files, use the following format:
+<file pathname="path_to_file/hello.rb">
+puts "Hello from Line 1"
+puts "hello from Line 2"
+</file>
+So, the example above shows how you would include a file called "hello.rb" that belongs in the subdirectory "path_to_file" of the current directory. 
+The file would contain two "puts" statements. 
+Use this for all text files you generate, not just source code.
+
+GLIM_PROMPT
+    end
+    
+end
+    

data/lib/glim_request.rb

@@ -0,0 +1,266 @@
+require 'must_be'
+require 'json-schema'
+require 'erb'
+
+require_relative 'globals'
+require_relative 'glim_helpers'
+
+
+require_relative 'chat_request_details'
+require_relative 'chat_response'
+
+module GenericParams
+  def generic_params(*attr_names)
+    attr_names.each do |attr_name|
+      define_method("#{attr_name}=") do |value|
+        instance_variable_set("@#{attr_name}", value)
+        request_details.update_request_hash
+      end
+    end
+  end
+end
+
+
+class GlimRequest
+
+  extend GenericParams
+
+  GENERIC_PARAMS = %i[temperature top_p max_tokens stop]
+
+  generic_params(*GENERIC_PARAMS)
+  attr_reader(*GENERIC_PARAMS)
+  
+  attr_reader :llm_name, :prompt
+
+  attr_reader :request_hash
+
+    # this is the data structure the response class will send over the network
+  # the cache key is generated from this. 
+  def initialize(**args)
+    @use_cached_response = true
+    @logged_something = false
+    args.each do |k, v| 
+      if (GENERIC_PARAMS + %i[template_name template_text context llm_name ]).include?(k)
+        instance_variable_set("@#{k}", v) 
+      else
+        raise "Unknown parameter #{k}"
+      end
+      # puts "GlimRequest.initialize: #{args_with_req.inspect}"
+    end
+    @request_hash = {}
+    request_details.llm_class_changed
+  end
+
+  def method_missing(method_name, *args, &block)
+    if request_details.respond_to?(method_name)
+      request_details.send(method_name, *args, &block)
+    else
+      raise "No method #{method_name} in #{request_details.class}."
+    end
+  end
+
+  def generic_params_hash
+    h = {}
+    GENERIC_PARAMS.each do |attr_name|
+      h[attr_name] = instance_variable_get("@#{attr_name}")
+    end
+    h
+  end
+
+  def self.openai_llms
+    %w[
+    gpt-4 gpt-4-0613 gpt-4-32k gpt-4-32k-0613 
+    gpt-3.5-turbo gpt-3.5-turbo-0613 gpt-3.5-turbo-16k gpt-3.5-turbo-16k-0613]
+  end
+
+  def self.aviary_llms
+    llama2_llms + codellama_llms
+  end
+  
+  def self.llama2_llms(size = nil)
+    sizes = [7,13,70]
+    if !size
+      return sizes.map { |n| "meta-llama/Llama-2-#{n}b-chat-hf" }
+    end
+    if sizes.include?(size)
+      return "meta-llama/Llama-2-#{size}b-chat-hf"
+    else
+      raise "Unknown llama size #{size}"
+    end
+  end
+
+  def self.codellama_llms
+    return ["codellama/CodeLlama-34b-Instruct-hf"]
+  end
+
+  def request_details
+    @request_details ||= details_class_for_llm_name.new(self) #  raise("Set llm_name first!")
+  end
+
+  def details_class_for_llm_name
+    llm_name&.start_with?('claude')  ?  AnthropicRequestDetails : ChatRequestDetails
+  end
+
+  def llm_name=(llm_name)
+    @llm_name = llm_name
+    klass = details_class_for_llm_name
+    if @request_details&.class != klass
+      @request_details = klass.new(self)
+      putt :warning, "Setting llm_name to #{llm_name} caused deletion of request_hash, parameters might get lost, TODO"
+      @request_hash = {} 
+      @request_details.llm_class_changed
+    end
+    request_details.update_request_hash
+  end
+
+  def prompt=(p)
+    @prompt = p
+    request_details.update_request_hash
+    save_log_file("prompt.txt", prompt)
+  end
+
+  def response_class
+    @request_details.response_class
+  end 
+    
+  attr_accessor :template_name, :template_text
+  attr_accessor :no_cache, :use_cached_response
+  attr_accessor :context
+
+  def log_base_this_request
+    @log_base_this_request ||= begin
+      timestamp = Time.now.strftime('%a-%H:%M:%S.%3N')
+      template_name_sanitized = (template_name || "no_template").gsub(/[^0-9A-Za-z.\-]/, '_')
+      subdir = File.join(context.log_base, "#{timestamp}-#{template_name_sanitized}")
+      FileUtils.mkdir_p(subdir) unless Dir.exist?(subdir)
+      putt :log, "Log path: #{@log_base_this_request}"
+      subdir
+    end
+    @log_base_this_request
+  end
+
+  def process_template(template_name, **template_args)
+    # TODO - think through how to handle paths
+    # basedir = File.dirname(File.expand_path($PROGRAM_NAME))
+
+    for c in caller
+      calling_file = c.split(':').first
+      break unless calling_file && calling_file.include?("/lib")
+    end
+    dir_path = File.dirname(calling_file)
+    template_path = File.join(dir_path, 'templates', "#{template_name}.erb")
+
+    unless File.exist?(template_path)
+      raise "Template #{template_name} not found: #{template_path}"
+    end
+
+    putt :config, template_path
+
+    #template_path = File.join("#{basedir}","templates","#{template_name}.erb")
+    
+    template_text = File.read(template_path)
+    template = ERB.new(template_text)
+
+    wrapper = Object.new
+    wrapper.extend(GlimHelpers) 
+    template_args.each do |key, value|
+      wrapper.define_singleton_method(key) { value }
+    end  
+    req_instance = self # this way, we can access it in the define_method below
+    wrapper.define_singleton_method(:req) { req_instance } # caution: can't use self directly here, otherwise self == wrapper
+    @prompt = template.result(wrapper.instance_eval { binding })
+    @template_name = template_name
+    @template_text = template_text
+    request_details.update_request_hash
+    save_log_file("template_text.txt", template_text)
+    save_log_file("prompt.txt", prompt)
+    return nil
+  end
+
+  # def _generic_params
+  #   h = {}
+  #   for key in GENERIC_PARAMS
+  #     h[key] = instance_variable_get("@#{key}")
+  #   end
+  #   h
+  # end
+
+  def count_tokens(s)
+    response_class._count_tokens(llm_name, s)
+  end
+
+  def llm_info
+    response_class._llm_info(llm_name)
+  end
+
+  def cost_per_prompt_token
+    llm_info[:cost_per_prompt_token]
+  end
+
+ def  cost_per_completion_token
+    llm_info[:cost_per_completion_token]
+  end
+
+  def context_length
+    llm_info[:context_length]
+  end
+
+  def prompt_token_count
+    # careful; for open_ai, this needs prepare() first and we want to look at messages[]
+    count_tokens(prompt)
+  end
+
+  def min_cost
+    return prompt_token_count * cost_per_prompt_token
+  end
+
+  def max_cost
+    # TODO this doesn't work yet. 
+    return cost_per_prompt_token * prompt_token_count + cost_per_completion_token * max_tokens
+  end
+
+  def cache_key
+    putt :cache, "Computing cache key based on:"
+    # putt :cache, JSON.pretty_generate(deep_copy_with_mods(request_hash, 88,88))
+    key = Digest::SHA1.hexdigest(request_hash.to_json)
+    putt :cache, "Cache key was: #{key}"
+    return key
+  end 
+
+  # this will create a response and, unless it's cached, send off the request to the API
+  def response
+    response = response_class.new(self)
+    return response
+  end
+
+  def to_s
+    s = "Req to #{llm_name}"
+    s += " from #{template_name}" if template_name
+    s += request_details.to_s if request_details
+  end
+  
+  def inspect
+    "#<GlimRequest: prompt_size=#{@prompt ? @prompt.size : 'nil'}, template_name=#{@template_name}>"
+  end
+
+
+  def save_log_file(section_name, content)
+    file_path = File.join(log_base_this_request, section_name)
+    putt(:log, "Saving to: #{file_path}")
+    File.write(file_path, content)
+    
+    log_dir = ENV['GLIM_LOG_DIRECTORY']
+    if !@logged_something
+      @logged_something = true
+      last_all_files = File.join(log_dir,"_last","*")
+      #puts "deleting #{last_all_files}"
+      Dir.glob(last_all_files).each do |file|
+        File.delete(file) if File.file?(file)
+      end
+    end
+    last_file = File.join(log_dir,"_last",section_name)
+    FileUtils.mkdir_p(File.dirname(last_file)) unless Dir.exist?(File.dirname(last_file))
+    File.write(last_file, content)
+  end
+
+end

data/lib/glim_response.rb

@@ -0,0 +1,155 @@
+require_relative 'globals'
+
+class GlimResponseError < StandardError
+  def initialize(raw_response, message = "Unexpected GlimResponse")
+    puts("\n---GlimResponseError---")
+    puts(JSON.pretty_generate(raw_response) || "GlimResponse was Nil!")
+    super(message)
+  end
+end
+
+# A response is always either available or a request has been sent
+class GlimResponse
+  attr_reader :req, :params
+  
+  def initialize(req)
+    @req = req
+    log_request_hash
+    @time_request_sent = Time.now
+    @cached_response = _look_for_cached_response
+    if req.use_cached_response && @cached_response
+      putt :cache, "Using cached response for key: #{req.cache_key}"
+      @raw_response = cached_response.with_indifferent_access
+      log_raw_response
+      process_response_from_api
+      log_summary_append
+    else
+      if @cached_reaponse 
+        putt :cache, "Making API call because req.use_cached_response was #{req.use_cached_response}, even though cached response was found for key: #{req.cache_key}"
+      else
+        putt :cache, "Making API call because no cached response was found for key: #{req.cache_key}"
+      end
+      @cached_response = false
+      putt :rpc, "RPC to #{req}"
+      async_send_request_to_api
+      # now the request has been send. the user's thread can do more stuff until the 
+      # user eventually looks at this response, which will block if we haven't heard back.
+    end
+  end
+
+  def log_request_hash
+    s = "# request_hash generated by #{req.class} with #{req.request_details.class}\n"
+    s += JSON.pretty_generate(req.request_hash)
+    req.save_log_file("request_hash.json", s)
+
+    
+    # template_text = File.read('lib/chat_request.erb')
+    # template = ERB.new(template_text)
+    #s = template.result_with_hash(request_hash: req.request_hash)
+    #req.save_log_file("request_hash.html",s)
+
+
+
+  end
+
+  def log_raw_response
+    req.save_log_file("raw_response.json", JSON.pretty_generate(raw_response))
+  end
+
+  def log_completion
+    req.save_log_file("completion.txt", completion)
+  end
+
+  def context
+    req.context
+  end
+  
+  # caching
+  def save_raw_response_to_cache
+    putt :cache, "Saving response to cache for key: #{req.cache_key}"
+    cache_file = File.join(CACHE_PATH, "#{req.cache_key}.json")
+    File.write(cache_file, raw_response.to_json)
+  end
+
+  def _look_for_cached_response
+    cache_file = File.join(CACHE_PATH, "#{req.cache_key}.json")
+    me = self.class.name
+    if File.exist?(cache_file)
+      putt :cache, "Cached #{me} found for key: #{req.cache_key}"
+      return (JSON.parse(File.read(cache_file)).with_indifferent_access)
+    else
+      putt :cache, "No cached #{me} found for key: #{req.cache_key}"
+      return nil
+    end
+  end
+
+  attr_reader :cached_response
+
+  def response_available?
+    @thread.status == false
+  end
+
+  def responding_llm_name
+    raise "implement in subclass!"
+  end
+
+  def total_tokens
+    prompt_tokens + completion_tokens
+  end
+
+  def total_cost
+    prompt_tokens * req.cost_per_prompt_token + completion_tokens * req.cost_per_completion_token
+  end
+
+  def log_summary_append
+    templ = req.template_name ? req.template_name+".erb" : "no_template"
+    time_spent = Time.now - @time_request_sent
+    tps = completion_tokens / time_spent
+    s = "#{responding_llm_name}, #{templ}, #{prompt_tokens}, prompt_tokens + , #{completion_tokens}, completion_tokens = $"
+    if cached_response
+      s += ",0,0,cached, , , "
+    else
+      s += ",#{total_cost}, #{time_spent.round(3)}, seconds, #{tps}, tokens/s"
+    end
+    s += ", #{req.log_base_this_request}"
+    context.log_line_to_summary(s)
+  end
+
+
+  def wait_for_response
+    return if @raw_response
+    raise "No Thread! Call run() first!" unless @thread
+    if response_available?
+      putt :rpc, "Response already received from #{req.to_s}"
+    else
+      putt :rpc, "Will now block until we have a for #{req.to_s}"
+    end
+    @raw_response ||= (@thread.value.must_be_a Hash).with_indifferent_access
+    save_raw_response_to_cache unless req.no_cache
+    log_raw_response
+    process_response_from_api
+    log_summary_append
+  end
+
+  def err(msg)
+    raise GlimResponseError.new(raw_response, msg)
+  end
+  
+  # the raw response as received from OpenAI
+  def raw_response
+    wait_for_response
+    @raw_response
+  end
+
+  def [](key)
+    wait_for_response
+    @raw_response[key]
+  end
+
+  def completion
+    wait_for_response
+    @completion
+  end
+
+end
+