smart_prompt 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 671745a347fa5443d42ce018a0c00870f5c1c13771060d1facea3ecf6cff41d6
-  data.tar.gz: 5a2f1177a1ed5de38daee6422586841c8358c869cd3e9fc71d4b67078a5438e1
+  metadata.gz: 74ae2371cb915bd160c90add5b0b2b771b45b9b2fbed32ce05da3140d6cde814
+  data.tar.gz: 7898daeb6a6dbf9d963b4daabf603140a14c503aa750aa9917e32a2619213c37
 SHA512:
-  metadata.gz: 9fed26cf6880bf7b9bb2e71c2e4013c66a25b9b542bc88e5727025eef57731d5024dc3a01d548ed3d76f404646835666540dc7ea056477f8abd9cc2b28bddeeb
-  data.tar.gz: 1ac2f3ed8fc1b664a623888193d82fe114ef8a8a8f43b6dd8600875132d617af624ccca6d0c6f10814759ae881e51c2351ba6f4bba3b09f89b426381da470fb7
+  metadata.gz: 6a6beb7c8c669c35f7ec3b30bfd67b5d66af9043bcd93beb82c172b7651a907ce0cb40a3835d3871eedb4984e76e6bea8ba6100aec57d50dcd3398fa8027e246
+  data.tar.gz: 81088495756cb62aace3f6154f61a5b7d55b1ec43ec9e927c48e9f78d068348e05f90e34802af584ad732ad1db0f736a00f0abae9d0a1a984c86550136875f4e

data/lib/smart_prompt/conversation.rb

@@ -33,23 +33,32 @@ module SmartPrompt
       @temperature = temperature
     end
 
+    def history_messages
+      @engine.history_messages
+    end
+
+    def add_message(msg)
+      history_messages << msg
+      @messages << msg
+    end
+
     def prompt(template_name, params = {})
       if template_name.class == Symbol
         template_name = template_name.to_s
         SmartPrompt.logger.info "Use template #{template_name}"
         raise "Template #{template_name} not found" unless @templates.key?(template_name)
         content = @templates[template_name].render(params)
-        @messages << { role: "user", content: content }
+        add_message({ role: "user", content: content })
         self
       else
-        @messages << { role: "user", content: template_name }
+        add_message({ role: "user", content: template_name })
         self
       end
     end
 
     def sys_msg(message)
       @sys_msg = message
-      @messages << { role: "system", content: message }
+      add_message({ role: "system", content: message })
       self
     end
 
@@ -61,10 +70,14 @@ module SmartPrompt
       @last_response
     end
 
-    def send_msg
+    def send_msg(params = {})
       Retriable.retriable(RETRY_OPTIONS) do
         raise ConfigurationError, "No LLM selected" if @current_llm.nil?
-        @last_response = @current_llm.send_request(@messages, @model_name, @temperature, @tools, nil)
+        if params[:with_history]
+          @last_response = @current_llm.send_request(history_messages, @model_name, @temperature, @tools, nil)
+        else
+          @last_response = @current_llm.send_request(@messages, @model_name, @temperature, @tools, nil)
+        end
         if @last_response == ""
           @last_response = @current_llm.last_response
         end
@@ -76,10 +89,14 @@ module SmartPrompt
       return "Failed to call LLM after #{MAX_RETRIES} attempts: #{e.message}"
     end
 
-    def send_msg_by_stream(&proc)
+    def send_msg_by_stream(params = {}, &proc)
       Retriable.retriable(RETRY_OPTIONS) do
         raise ConfigurationError, "No LLM selected" if @current_llm.nil?
-        @current_llm.send_request(@messages, @model_name, @temperature, @tools, proc)
+        if params[:with_history]
+          @current_llm.send_request(history_messages, @model_name, @temperature, @tools, proc)
+        else
+          @current_llm.send_request(@messages, @model_name, @temperature, @tools, proc)
+        end
         @messages = []
         @messages << { role: "system", content: @sys_msg }
       end

data/lib/smart_prompt/engine.rb

@@ -1,103 +1,130 @@
 module SmartPrompt
-    class Engine
-      attr_reader :config_file, :config, :adapters, :current_adapter, :llms, :templates
-      def initialize(config_file)
+  class Engine
+    attr_reader :config_file, :config, :adapters, :current_adapter, :llms, :templates
+
+    def initialize(config_file)
+      @config_file = config_file
+      @adapters = {}
+      @llms = {}
+      @templates = {}
+      @current_workers = {}
+      @history_messages = []
+      load_config(config_file)
+      SmartPrompt.logger.info "Started create the SmartPrompt engine."
+    end
+
+    def create_dir(filename)
+      path = File::path(filename).to_s
+      parent_dir = File::dirname(path)
+      Dir.mkdir(parent_dir, 0755) unless File.directory?(parent_dir)
+    end
+
+    def load_config(config_file)
+      begin
         @config_file = config_file
-        @adapters={}
-        @llms={}
-        @templates={}
-        load_config(config_file)
-        SmartPrompt.logger.info "Started create the SmartPrompt engine."
+        @config = YAML.load_file(config_file)
+        if @config["logger_file"]
+          create_dir(@config["logger_file"])
+          SmartPrompt.logger = Logger.new(@config["logger_file"])
+        end
+        SmartPrompt.logger.info "Loading configuration from file: #{config_file}"
+        @config["adapters"].each do |adapter_name, adapter_class|
+          adapter_class = SmartPrompt.const_get(adapter_class)
+          @adapters[adapter_name] = adapter_class
+        end
+        @config["llms"].each do |llm_name, llm_config|
+          adapter_class = @adapters[llm_config["adapter"]]
+          @llms[llm_name] = adapter_class.new(llm_config)
+        end
+        @current_llm = @config["default_llm"] if @config["default_llm"]
+        Dir.glob(File.join(@config["template_path"], "*.erb")).each do |file|
+          template_name = file.gsub(@config["template_path"] + "/", "").gsub("\.erb", "")
+          @templates[template_name] = PromptTemplate.new(file)
+        end
+        load_workers
+      rescue Psych::SyntaxError => ex
+        SmartPrompt.logger.error "YAML syntax error in config file: #{ex.message}"
+        raise ConfigurationError, "Invalid YAML syntax in config file: #{ex.message}"
+      rescue Errno::ENOENT => ex
+        SmartPrompt.logger.error "Config file not found: #{ex.message}"
+        raise ConfigurationError, "Config file not found: #{ex.message}"
+      rescue StandardError => ex
+        SmartPrompt.logger.error "Error loading configuration: #{ex.message}"
+        raise ConfigurationError, "Error loading configuration: #{ex.message}"
+      ensure
+        SmartPrompt.logger.info "Configuration loaded successfully"
       end
+    end
 
-      def create_dir(filename)
-        path = File::path(filename).to_s
-        parent_dir = File::dirname(path) 
-        Dir.mkdir(parent_dir, 0755) unless File.directory?(parent_dir)
+    def load_workers
+      Dir.glob(File.join(@config["worker_path"], "*.rb")).each do |file|
+        require(file)
       end
+    end
 
-      def load_config(config_file)
-        begin
-          @config_file = config_file
-          @config = YAML.load_file(config_file)
-          if @config['logger_file']
-            create_dir(@config['logger_file'])
-            SmartPrompt.logger = Logger.new(@config['logger_file'])
-          end
-          SmartPrompt.logger.info "Loading configuration from file: #{config_file}"
-          @config['adapters'].each do |adapter_name, adapter_class|
-            adapter_class = SmartPrompt.const_get(adapter_class)
-            @adapters[adapter_name] = adapter_class
-          end
-          @config['llms'].each do |llm_name,llm_config|
-            adapter_class = @adapters[llm_config['adapter']]
-            @llms[llm_name]=adapter_class.new(llm_config)
-          end
-          @current_llm = @config['default_llm'] if @config['default_llm']
-          Dir.glob(File.join(@config['template_path'], '*.erb')).each do |file|
-            template_name = file.gsub(@config['template_path']+"/","").gsub("\.erb","")
-            @templates[template_name] = PromptTemplate.new(file)
-          end
-          load_workers          
-        rescue Psych::SyntaxError => ex
-          SmartPrompt.logger.error "YAML syntax error in config file: #{ex.message}"
-          raise ConfigurationError, "Invalid YAML syntax in config file: #{ex.message}"
-        rescue Errno::ENOENT => ex
-          SmartPrompt.logger.error "Config file not found: #{ex.message}"
-          raise ConfigurationError, "Config file not found: #{ex.message}"
-        rescue StandardError => ex
-          SmartPrompt.logger.error "Error loading configuration: #{ex.message}"
-          raise ConfigurationError, "Error loading configuration: #{ex.message}"
-        ensure
-          SmartPrompt.logger.info "Configuration loaded successfully"          
-        end        
-      end
-
-      def load_workers
-        Dir.glob(File.join(@config['worker_path'], '*.rb')).each do |file|
-          require(file)
-        end
+    def check_worker(worker_name)
+      if SmartPrompt::Worker.workers[worker_name]
+        return true
+      else
+        SmartPrompt.logger.warn "Invalid worker: #{worker_name}"
+        return false
       end
+    end
 
-      def check_worker(worker_name)
-        if SmartPrompt::Worker.workers[worker_name]
-          return true
+    def call_worker(worker_name, params = {})
+      SmartPrompt.logger.info "Calling worker: #{worker_name} with params: #{params}"
+      worker = get_worker(worker_name)
+      begin
+        result = worker.execute(params)
+        SmartPrompt.logger.info "Worker #{worker_name} executed successfully"
+        if result.class == String
+          recive_message = {
+            "role": "assistant",
+            "content": result,
+          }
         else
-          SmartPrompt.logger.warn "Invalid worker: #{worker_name}"
-          return false
-        end
-      end
-      
-      def call_worker(worker_name, params = {})
-        SmartPrompt.logger.info "Calling worker: #{worker_name} with params: #{params}"
-        worker = get_worker(worker_name)        
-        begin
-          result = worker.execute(params)
-          SmartPrompt.logger.info "Worker #{worker_name} executed successfully"
-          result
-        rescue => e
-          SmartPrompt.logger.error "Error executing worker #{worker_name}: #{e.message}"
-          SmartPrompt.logger.debug e.backtrace.join("\n")
-          raise
+          recive_message = {
+            "role": result.dig("choices", 0, "message", "role"),
+            "content": result.dig("choices", 0, "message", "content").to_s + result.dig("choices", 0, "message", "tool_calls").to_s,
+          }
         end
+        worker.conversation.add_message(recive_message)
+        result
+      rescue => e
+        SmartPrompt.logger.error "Error executing worker #{worker_name}: #{e.message}"
+        SmartPrompt.logger.debug e.backtrace.join("\n")
+        raise
       end
+    end
 
-      def call_worker_by_stream(worker_name, params = {}, &proc)
-        SmartPrompt.logger.info "Calling worker: #{worker_name} with params: #{params}"
-        worker = get_worker(worker_name)        
-        begin
-          worker.execute_by_stream(params, &proc)
-          SmartPrompt.logger.info "Worker #{worker_name} executed(stream) successfully"          
-        rescue => e
-          SmartPrompt.logger.error "Error executing worker #{worker_name}: #{e.message}"
-          SmartPrompt.logger.debug e.backtrace.join("\n")
-          raise
-        end
+    def call_worker_by_stream(worker_name, params = {}, &proc)
+      SmartPrompt.logger.info "Calling worker: #{worker_name} with params: #{params}"
+      worker = get_worker(worker_name)
+      begin
+        worker.execute_by_stream(params, &proc)
+        SmartPrompt.logger.info "Worker #{worker_name} executed(stream) successfully"
+      rescue => e
+        SmartPrompt.logger.error "Error executing worker #{worker_name}: #{e.message}"
+        SmartPrompt.logger.debug e.backtrace.join("\n")
+        raise
       end
-    private
-      def get_worker(worker_name)
-        SmartPrompt.logger.info "Creating worker instance for: #{worker_name}"
-        Worker.new(worker_name, self)
+    end
+
+    def get_worker(worker_name)
+      SmartPrompt.logger.info "Creating worker instance for: #{worker_name}"
+      unless worker = @current_workers[worker_name]
+        worker = Worker.new(worker_name, self)
+        @current_workers[worker_name] = worker
       end
+      return worker
+    end
+
+    def history_messages
+      @history_messages
+    end
+
+    def clear_history_messages
+      @history_messages = []
     end
-end
+  end
+end

data/lib/smart_prompt/openai_adapter.rb

@@ -1,18 +1,18 @@
-require 'openai'
+require "openai"
 
 module SmartPrompt
   class OpenAIAdapter < LLMAdapter
     def initialize(config)
       super
-      api_key = @config['api_key']
-      if api_key.is_a?(String) && api_key.start_with?('ENV[') && api_key.end_with?(']')
+      api_key = @config["api_key"]
+      if api_key.is_a?(String) && api_key.start_with?("ENV[") && api_key.end_with?("]")
         api_key = eval(api_key)
       end
       begin
         @client = OpenAI::Client.new(
           access_token: api_key,
-          uri_base: @config['url'],
-          request_timeout: 240
+          uri_base: @config["url"],
+          request_timeout: 240,
         )
       rescue OpenAI::ConfigurationError => e
         SmartPrompt.logger.error "Failed to initialize OpenAI client: #{e.message}"
@@ -31,25 +31,26 @@ module SmartPrompt
       end
     end
 
-    def send_request(messages, model=nil, temperature=0.7, tools=nil, proc=nil)
+    def send_request(messages, model = nil, temperature = 0.7, tools = nil, proc = nil)
       SmartPrompt.logger.info "OpenAIAdapter: Sending request to OpenAI"
+      temperature = 0.7 if temperature == nil
       if model
         model_name = model
       else
-        model_name = @config['model']
+        model_name = @config["model"]
       end
       SmartPrompt.logger.info "OpenAIAdapter: Using model #{model_name}"
       begin
         parameters = {
           model: model_name,
           messages: messages,
-          temperature: @config['temperature'] || temperature
+          temperature: @config["temperature"] || temperature,
         }
         if proc
-          parameters[:stream]=proc
+          parameters[:stream] = proc
         end
         if tools
-          parameters[:tools]=tools
+          parameters[:tools] = tools
         end
         response = @client.chat(parameters: parameters)
       rescue OpenAI::Error => e
@@ -79,15 +80,15 @@ module SmartPrompt
       if model
         model_name = model
       else
-        model_name = @config['model']        
+        model_name = @config["model"]
       end
       SmartPrompt.logger.info "OpenAIAdapter: Using model #{model_name}"
       begin
         response = @client.embeddings(
-            parameters: {
-              model: model_name,
-              input: text.to_s
-            }
+          parameters: {
+            model: model_name,
+            input: text.to_s,
+          },
         )
       rescue => e
         SmartPrompt.logger.error "Unexpected error during Ollama request: #{e.message}"
@@ -98,4 +99,4 @@ module SmartPrompt
       return response.dig("data", 0, "embedding")
     end
   end
-end
+end

data/lib/smart_prompt/version.rb

@@ -1,3 +1,3 @@
 module SmartPrompt
-  VERSION = "0.2.2"
+  VERSION = "0.2.4"
 end

data/lib/smart_prompt/worker.rb

@@ -1,6 +1,6 @@
 module SmartPrompt
   class Worker
-    attr_reader :name, :config_file
+    attr_reader :name, :config_file, :conversation
 
     def initialize(name, engine)
       SmartPrompt.logger.info "Create worker's name is #{name}"
@@ -11,14 +11,14 @@ module SmartPrompt
     end
 
     def execute(params = {})
-      conversation = Conversation.new(@engine, params[:tools])
-      context = WorkerContext.new(conversation, params, @engine)
+      @conversation = Conversation.new(@engine, params[:tools]) unless @conversation
+      context = WorkerContext.new(@conversation, params, @engine)
       context.instance_eval(&@code)
     end
 
-    def execute_by_stream(params = {}, &proc)      
-      conversation = Conversation.new(@engine, params[:tools])
-      context = WorkerContext.new(conversation, params, @engine, proc)
+    def execute_by_stream(params = {}, &proc)
+      @conversation = Conversation.new(@engine, params[:tools])
+      context = WorkerContext.new(@conversation, params, @engine, proc)
       context.instance_eval(&@code)
     end
 
@@ -34,7 +34,7 @@ module SmartPrompt
   end
 
   class WorkerContext
-    def initialize(conversation, params, engine, proc=nil)
+    def initialize(conversation, params, engine, proc = nil)
       @conversation = conversation
       @params = params
       @engine = engine
@@ -43,11 +43,11 @@ module SmartPrompt
 
     def method_missing(method, *args, &block)
       if @conversation.respond_to?(method)
-        if method==:send_msg
-          if @proc==nil
-            @conversation.send_msg
+        if method == :send_msg
+          if @proc == nil
+            @conversation.send_msg(params)
           else
-            @conversation.send_msg_by_stream(&@proc)
+            @conversation.send_msg_by_stream(params, &@proc)
           end
         else
           @conversation.send(method, *args, &block)
@@ -79,4 +79,4 @@ module SmartPrompt
       worker.execute_by_stream(params, proc)
     end
   end
-end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: smart_prompt
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - zhuang biaowei
 bindir: exe
 cert_chain: []
-date: 2025-03-28 00:00:00.000000000 Z
+date: 2025-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yaml