slack-smart-bot 1.14.1 → 1.15.0

data/lib/slack/smart-bot/comm/unreact.rb

@@ -2,7 +2,7 @@ class SlackSmartBot
   # list of available emojis: https://www.webfx.com/tools/emoji-cheat-sheet/
   # unreact(:thumbsup)
   # ts: can be true, false or a specific ts
-  def unreact(emoji, ts=false)
+  def unreact(emoji, ts=false, channel: Thread.current[:dest])
     begin
       if ts.is_a?(TrueClass) or ts.is_a?(FalseClass)
         parent = ts
@@ -21,7 +21,7 @@ class SlackSmartBot
         @logger.warn 'unreact method no ts supplied'
       else
         begin
-          client.web_client.reactions_remove(channel: Thread.current[:dest], name: emoji, timestamp: ts) unless config.simulate
+          client.web_client.reactions_remove(channel: channel, name: emoji, timestamp: ts) unless config.simulate
         rescue Exception => stack
           @logger.warn stack
         end

data/lib/slack/smart-bot/comm.rb

@@ -17,3 +17,4 @@ require_relative 'comm/delete'
 require_relative 'comm/get_presence'
 require_relative 'comm/set_status'
 require_relative 'comm/update'
+require_relative 'comm/get_smartbot_team_info'

data/lib/slack/smart-bot/commands/general/add_admin.rb

@@ -13,31 +13,41 @@ class SlackSmartBot
       end
       messages = []
       admins = config.masters.dup
+      team_id_admins = config.team_id_masters.dup
+
       channels = get_channels()
       channel_found = channels.detect { |c| c.id == channel }
       if !channel_found.nil? and channel_found.creator.to_s != ''
-        creator_info = @users.select{|u| u.id == channel_found.creator or (u.key?(:enterprise_user) and u.enterprise_user.id == channel_found.creator)}[-1]
+        creator_info = find_user(channel_found.creator)
         admins << creator_info.name
+        team_id_admins << "#{creator_info.team_id}_#{creator_info.name}"
       end
       if Thread.current[:typem] == :on_bot or Thread.current[:typem] == :on_master
         admins << config.admins.dup
+        team_id_admins << config.team_id_admins.dup
       end
       if @admins_channels.key?(channel) and @admins_channels[channel].size > 0
-        admins << @admins_channels[channel]
+        team_id_admins << @admins_channels[channel]
+        #remove the team_id from the names on @admins_channels
+        admins << @admins_channels[channel].map { |a| a.split('_')[1..-1].join('_') }
       end
       admins.flatten!
       admins.uniq!
       admins.delete(nil)
-      if admins.include?(user.name)
-        admin_info = @users.select{|u| u.id == admin_user or (u.key?(:enterprise_user) and u.enterprise_user.id == admin_user)}[-1]
-        if admins.include?(admin_info.name)
+      team_id_admins.flatten!
+      team_id_admins.uniq!
+      team_id_admins.delete(nil)
+      if team_id_admins.include?("#{user.team_id}_#{user.name}")
+        admin_info = find_user(admin_user)
+        if team_id_admins.include?("#{admin_info.team_id}_#{admin_info.name}")
           messages << "This user is already an admin of this channel."
         else
           @admins_channels[channel] ||= []
-          @admins_channels[channel] << admin_info.name
+          @admins_channels[channel] << "#{admin_info.team_id}_#{admin_info.name}"
           update_admins_channels()
           messages << "The user is an admin of this channel from now on."
           admins << admin_info.name
+          team_id_admins << "#{admin_info.team_id}_#{admin_info.name}"
         end
         messages << "*Admins*: <@#{admins.join('>, <@')}>"
       else

data/lib/slack/smart-bot/commands/general/add_announcement.rb

@@ -9,18 +9,18 @@ class SlackSmartBot
         channel = Thread.current[:dest]
       end
       if File.exist?("#{config.path}/announcements/#{channel}.csv") and !@announcements.key?(channel)
-        t = CSV.table("#{config.path}/announcements/#{channel}.csv", headers: ['message_id', 'user_deleted', 'user_created', 'date', 'time', 'type', 'message'])
+        t = CSV.table("#{config.path}/announcements/#{channel}.csv", headers: ['message_id', 'user_team_id_deleted', 'user_deleted', 'user_team_id_created', 'user_created', 'date', 'time', 'type', 'message'])
         @announcements[channel] = t
         num = t[:message_id].max + 1
       elsif !@announcements.key?(channel)
         File.open("#{config.path}/announcements/#{channel}.csv","w")
-        t = CSV.table("#{config.path}/announcements/#{channel}.csv", headers: ['message_id', 'user_deleted', 'user_created', 'date', 'time', 'type', 'message'])
+        t = CSV.table("#{config.path}/announcements/#{channel}.csv", headers: ['message_id', 'user_team_id_deleted', 'user_deleted', 'user_team_id_created', 'user_created', 'date', 'time', 'type', 'message'])
         num = 1
         @announcements[channel] = t
       else
         num = @announcements[channel][:message_id].max + 1
       end
-      values = [num, '', user.name, Time.now.strftime("%Y/%m/%d"), Time.now.strftime("%H:%M"), type, message]
+      values = [num, '', '', user.team_id, user.name, Time.now.strftime("%Y/%m/%d"), Time.now.strftime("%H:%M"), type, message]
       @announcements[channel] << values
       CSV.open("#{config.path}/announcements/#{channel}.csv", "a+") do |csv|
         csv << values

data/lib/slack/smart-bot/commands/general/add_vacation.rb

@@ -8,13 +8,29 @@ class SlackSmartBot
     if type.match?(/sick\s+baby/i) or type.match?(/sick\s+child/i)
       type = 'sick child'
     end
+    team_id_user = "#{user.team_id}_#{user.name}"
+    if @vacations.key?(team_id_user) and @vacations[team_id_user][:public_holidays].to_s != ""
+      country_region = @vacations[team_id_user][:public_holidays].downcase
+    elsif config[:public_holidays].key?(:default_calendar)
+      country_region = config[:public_holidays][:default_calendar].downcase
+    else
+      country_region = ''
+    end
+
+    local_day_time = local_time(country_region)
+    if local_day_time.nil?
+      today = Date.today
+    else
+      today = local_day_time.to_date
+    end
 
     if from=='today'
-      from = Date.today.strftime("%Y/%m/%d")
+      from = today.strftime("%Y/%m/%d")
     elsif from =='tomorrow'
-      from = (Date.today+1).strftime("%Y/%m/%d")
+      from = (today+1).strftime("%Y/%m/%d")
     elsif from.match?(/next\s+week/)
-      from = Date.today + ((1 - Date.today.wday) % 7)
+      from = today + ((8 - today.wday) % 7)
+      from += 7 if from == today
       to = (from + 6).strftime("%Y/%m/%d")
       from = from.strftime("%Y/%m/%d")
     end
@@ -35,21 +51,21 @@ class SlackSmartBot
         respond "It seems like the date #{to} is not in the correct format: YYYY/MM/DD or is a wrong date."
       else
         vacations = @vacations.deep_copy
-        vacations[user.name] ||= { user_id: user.id, periods: [] }
-        if !vacations[user.name].key?(:periods)
-          vacations[user.name][:user_id] = user.id
-          vacations[user.name][:periods] = []
+        vacations[team_id_user] ||= { user_id: user.id, periods: [] }
+        if !vacations[team_id_user].key?(:periods)
+          vacations[team_id_user][:user_id] = user.id
+          vacations[team_id_user][:periods] = []
         end
 
-        if vacations[user.name].periods.empty?
+        if vacations[team_id_user].periods.empty?
           vacation_id = 1
         else
-          vacation_id = vacations[user.name].periods[-1].vacation_id + 1
+          vacation_id = vacations[team_id_user].periods[-1].vacation_id + 1
         end
-        vacations[user.name].periods << { vacation_id: vacation_id, type: type.downcase, from: from, to: to }
-        update_vacations({user.name => vacations[user.name]})
+        vacations[team_id_user].periods << { vacation_id: vacation_id, type: type.downcase, from: from, to: to }
+        update_vacations({team_id_user => vacations[team_id_user]})
         respond "Period has been added   ##{vacation_id}"
-        check_vacations(date: Date.today, user: user.name, set_status: true, only_first_day: false)
+        check_vacations(date: today, team_id: user.team_id, user: user.name, set_status: true, only_first_day: false)
       end
     end
   end

data/lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat.rb

@@ -3,33 +3,282 @@ class SlackSmartBot
     module General
       module AI
         module OpenAI
-          def open_ai_chat(message, delete_history)
-            save_stats(__method__)
+          def open_ai_chat(message, delete_history, type, model: '', tag: '', description: '', files: [])
             get_personal_settings()
-            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings, reconnect: delete_history)
-            respond message_connect if message_connect
-            user = Thread.current[:user]
-            if !@ai_open_ai[user.name].nil? and !@ai_open_ai[user.name][:client].nil?
-              @ai_gpt ||= {}
-              @ai_gpt[user.name] ||= []
-
-              if message == "" # ?? is called
-                @ai_gpt[user.name] = []
-                respond "*GPT*: Let's start a new conversation. Ask me anything."
+            user = Thread.current[:user].dup
+            user_name = user.name
+            team_id = user.team_id
+            team_id_user = Thread.current[:team_id_user]
+            if model != '' and !@open_ai_models.include?(model)
+              open_ai_models('', just_models: true) if @open_ai_models.empty?
+              model_selected = @open_ai_models.select{|m| m.include?(model)}
+              model = model_selected[0] if model_selected.size == 1
+            end
+
+            @active_chat_gpt_sessions[team_id_user] ||= {}
+            if delete_history
+              @active_chat_gpt_sessions[team_id_user][Thread.current[:dest]] = ''
+              session_name = ''
+            end
+
+            if @active_chat_gpt_sessions[team_id_user].key?(Thread.current[:thread_ts]) and Thread.current[:thread_ts]!='' #added and Thread.current[:thread_ts]!='' for testing when SIMULATE==true and not in a thread
+              session_name = @active_chat_gpt_sessions[team_id_user][Thread.current[:thread_ts]]
+            elsif @active_chat_gpt_sessions[team_id_user].key?(Thread.current[:dest])
+              session_name = @active_chat_gpt_sessions[team_id_user][Thread.current[:dest]]
+            else
+              session_name = ''
+              @active_chat_gpt_sessions[team_id_user][Thread.current[:dest]] = ''
+            end
+            if type == :start or type == :continue
+              session_name = message
+              @active_chat_gpt_sessions[team_id_user] ||= {}
+              @active_chat_gpt_sessions[team_id_user][Thread.current[:thread_ts]] = session_name
+              message = ''
+              get_openai_sessions(session_name)
+              @open_ai[team_id_user] ||= {}
+              @open_ai[team_id_user][:chat_gpt] ||= {}
+              @open_ai[team_id_user][:chat_gpt][:sessions] ||= {}
+              if !@open_ai[team_id_user][:chat_gpt][:sessions].key?(session_name)
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name] = {
+                  team_creator: team_id,
+                  user_creator: user_name,
+                  started: Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+                  last_activity: Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+                  collaborators: [],
+                  num_prompts: 0,
+                  model: model,
+                  copy_of_session: '',
+                  copy_of_team: '',
+                  copy_of_user: '',
+                  users_copying: [],
+                  public: false,
+                  shared: [],
+                  description: description,
+                  tag: tag.downcase
+                }
+              else # type == :continue or loading
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:model] = model if model != ''
+                num_prompts = @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:num_prompts]
+                respond "*ChatGPT*: I just loaded *#{session_name}*.\nThere are *#{num_prompts} prompts* in this session.\nThis was the *last prompt* from the session:\n"
+                content = @ai_gpt[team_id_user][session_name].join("\n")
+                index_last_prompt = content.rindex(/^(Me>\s.*)$/)
+                if index_last_prompt.nil?
+                  respond "No prompts found"
+                else
+                  last_prompt = content[index_last_prompt..-1].gsub(/^Me>/, '*Me>*').gsub(/^chatGPT>/i, "\n*ChatGPT>*")
+                  respond last_prompt
+                end
+              end
+              if Thread.current[:on_thread] and
+                  (Thread.current[:thread_ts] == Thread.current[:ts] or
+                    ( @open_ai[team_id_user][:chat_gpt][:sessions].key?(session_name) and
+                      @open_ai[team_id_user][:chat_gpt][:sessions][session_name].key?(:thread_ts) and
+                      @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:thread_ts].include?(Thread.current[:thread_ts]) ) )
+                react :running, Thread.current[:thread_ts]
+                @listening[team_id_user] ||= {}
+                @listening[team_id_user][Thread.current[:thread_ts]] = Time.now
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:thread_ts] ||= []
+
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:thread_ts] << Thread.current[:thread_ts]
+                @listening[:threads][Thread.current[:thread_ts]] = Thread.current[:dest]
               else
-                react :speech_balloon
-                begin
-                  @ai_gpt[user.name] = [] if delete_history
-                  @ai_gpt[user.name] << message
-                  success, res = SlackSmartBot::AI::OpenAI.send_gpt_chat(@ai_open_ai[user.name][:client], @ai_open_ai[user.name].gpt_model, @ai_gpt[user.name].join("\n"))
-                  if success
-                    @ai_gpt[user.name] << res
+                @active_chat_gpt_sessions[team_id_user][Thread.current[:dest]] = session_name
+              end
+              @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:description] = description if description != ''
+              @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:tag] = tag.downcase if tag != ''
+              open_ai_chat_use_model(model, dont_save_stats: true) if model != ''
+            elsif type == :temporary and
+              (!@chat_gpt_collaborating.key?(team_id_user) or !@chat_gpt_collaborating[team_id_user].key?(Thread.current[:thread_ts]))
+
+              @open_ai[team_id_user] ||= {}
+              @open_ai[team_id_user][:chat_gpt] ||= {}
+              @open_ai[team_id_user][:chat_gpt][:sessions] ||= {}
+
+              if Thread.current[:on_thread] and
+                (Thread.current[:thread_ts] == Thread.current[:ts] or
+                  (@open_ai[team_id_user][:chat_gpt][:sessions].key?("") and @open_ai[team_id_user][:chat_gpt][:sessions][""].key?(:thread_ts) and
+                  @open_ai[team_id_user][:chat_gpt][:sessions][""][:thread_ts].include?(Thread.current[:thread_ts]) ))
+                @listening[team_id_user] ||= {}
+                @listening[team_id_user][Thread.current[:thread_ts]] = Time.now
+                @listening[:threads][Thread.current[:thread_ts]] = Thread.current[:dest]
+                react :running if Thread.current[:thread_ts] == Thread.current[:ts]
+                @open_ai[team_id_user][:chat_gpt][:sessions][""] ||= {}
+                @open_ai[team_id_user][:chat_gpt][:sessions][""][:thread_ts] ||= []
+                @open_ai[team_id_user][:chat_gpt][:sessions][""][:thread_ts] << Thread.current[:thread_ts]
+                @active_chat_gpt_sessions[team_id_user] ||= {}
+                @active_chat_gpt_sessions[team_id_user][Thread.current[:thread_ts]] ||= ""
+              end
+            end
+
+            #for collaborators
+            if @chat_gpt_collaborating.key?(team_id_user) and @chat_gpt_collaborating[team_id_user].key?(Thread.current[:thread_ts])
+              team_creator = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:team_creator]
+              user_creator = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:user_creator]
+              session_name = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:session_name]
+              collaborator = true
+            else
+              team_creator = team_id
+              user_creator = user_name
+              collaborator = false
+            end
+            team_id_user_creator = team_creator + "_" + user_creator
+            unless type != :temporary and
+              (!@open_ai.key?(team_id_user_creator) or !@open_ai[team_id_user_creator].key?(:chat_gpt) or !@open_ai[team_id_user_creator][:chat_gpt].key?(:sessions) or
+              !@open_ai[team_id_user_creator][:chat_gpt][:sessions].key?(session_name) or
+              (@open_ai[team_id_user_creator][:chat_gpt][:sessions].key?(session_name) and !collaborator and user_creator!=user.name))
+              save_stats(__method__)
+              @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name][:last_activity] = Time.now.strftime("%Y-%m-%d %H:%M:%S") unless session_name == ''
+              @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings, reconnect: delete_history, service: :chat_gpt)
+
+              respond message_connect if message_connect
+              if !@ai_open_ai[team_id_user_creator].nil? and !@ai_open_ai[team_id_user_creator][:chat_gpt][:client].nil?
+                @ai_gpt[team_id_user_creator] ||= {}
+                @ai_gpt[team_id_user_creator][session_name] ||= []
+
+                if delete_history or !@open_ai.key?(team_id_user_creator) or !@open_ai[team_id_user_creator].key?(:chat_gpt) or !@open_ai[team_id_user_creator][:chat_gpt].key?(:sessions) or
+                  !@open_ai[team_id_user_creator][:chat_gpt][:sessions].key?(session_name) or !@open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name].key?(:model) or
+                  !@open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name].key?(:num_prompts)
+
+                  if delete_history and session_name == '' && @open_ai.key?(team_id_user_creator) && @open_ai[team_id_user_creator].key?(:chat_gpt) &&
+                    @open_ai[team_id_user_creator][:chat_gpt].key?(:sessions) && @open_ai[team_id_user_creator][:chat_gpt][:sessions].key?("") &&
+                    @open_ai[team_id_user_creator][:chat_gpt][:sessions][""].key?(:thread_ts)
+
+                    @open_ai[team_id_user_creator][:chat_gpt][:sessions][""][:thread_ts].each do |thread_ts|
+                      if thread_ts != Thread.current[:thread_ts] && @listening[:threads].key?(thread_ts)
+                        unreact :running, thread_ts, channel: @listening[:threads][thread_ts]
+                        message_chatgpt = "I'm sorry, but I'm no longer listening to this thread since you started a new temporary session."
+                        respond message_chatgpt, @listening[:threads][thread_ts], thread_ts: thread_ts
+                        @listening[team_id_user_creator].delete(thread_ts)
+                        @listening[:threads].delete(thread_ts)
+                      end
+                    end
+                  end
+
+                  @open_ai[team_id_user_creator] ||= {}
+                  @open_ai[team_id_user_creator][:chat_gpt] ||= {}
+                  @open_ai[team_id_user_creator][:chat_gpt][:sessions] ||= {}
+                  @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name] ||= {}
+                  @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name][:model] = model
+                  @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name][:num_prompts] = 0
+                end
+
+                if message == "" and session_name == '' # ?? is called
+                  @ai_gpt[team_id_user_creator][session_name] = []
+                  respond "*ChatGPT*: Let's start a new temporary conversation. Ask me anything."
+                  open_ai_chat_use_model(model, dont_save_stats: true) if model != ''
+                else
+                  react :speech_balloon
+                  begin
+                    urls_messages = []
+                    get_openai_sessions(session_name, team_id: team_creator, user_name: user_creator)
+                    @ai_gpt[team_id_user_creator][session_name] = [] if delete_history
+                    if @open_ai.key?(team_id_user_creator) and @open_ai[team_id_user_creator].key?(:chat_gpt) and @open_ai[team_id_user_creator][:chat_gpt].key?(:sessions) and
+                      @open_ai[team_id_user_creator][:chat_gpt][:sessions].key?(session_name) and @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name].key?(:model)
+                      if model == ''
+                        model = @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name][:model].to_s
+                      else
+                        @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name][:model] = model
+                      end
+                    else
+                      model = ''
+                    end
+                    model = @ai_open_ai[team_id_user_creator].chat_gpt.model if model.empty?
+                    if message == ''
+                      res = ''
+                    else
+                      if !files.nil? and files.size == 1
+                        http = NiceHttp.new(host: "https://files.slack.com", headers: { "Authorization" => "Bearer #{config.token}" })
+                        res = http.get(files[0].url_private_download)
+                        message = "#{message}\n\n#{res.data}"
+                      end
+
+                      @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name][:num_prompts] += 1
+                      urls = message.scan(/!(https?:\/\/[\S]+)/).flatten
+                      urls.uniq.each do |url|
+                        begin
+                            parsed_url = URI.parse(url)
+
+                            headers = {}
+                            authorizations = {}
+
+                            if config.key?(:authorizations)
+                              config[:authorizations].each do |key, value|
+                                if value.key?(:host)
+                                  authorizations[value[:host]] = value
+                                end
+                              end
+                            end
+
+                            if @personal_settings_hash.key?(team_id_user) and @personal_settings_hash[team_id_user].key?(:authorizations)
+                              @personal_settings_hash[team_id_user][:authorizations].each do |key, value|
+                                if value.key?(:host)
+                                  authorizations[value[:host]] = value
+                                end
+                              end
+                            end
+
+                            authorizations.each do |key, value|
+                              if key.match?(/^(https:\/\/|http:\/\/)?#{parsed_url.host.gsub('.','\.')}/)
+                                value.each do |k, v|
+                                  headers[k.to_sym] = v unless k == :host
+                                end
+                              end
+                            end
+
+                            domain = "#{parsed_url.scheme}://#{parsed_url.host}"
+                            http = NiceHttp.new(host: domain, headers: headers, log: :no)
+                            response = http.get(parsed_url.path)
+                            html_doc = Nokogiri::HTML(response.body)
+                            html_doc.search('script, style').remove
+                            text = html_doc.text.strip
+                            text.gsub!(/^\s*$/m, "")
+                            urls_messages << "> #{url}: content extracted and added to prompt\n"
+                            http.close
+                        rescue Exception => e
+                            text = "Error: #{e.message}"
+                            urls_messages << "> #{url}: #{text}\n"
+                        end
+                        message.gsub!("!#{url}", '')
+                        message += "\n #{text}\n"
+                      end
+
+                      @ai_gpt[team_id_user_creator][session_name] << "Me> #{message}"
+                      prompts = @ai_gpt[team_id_user_creator][session_name].join("\n\n")
+                      prompts.gsub!(/^Me>\s*/,'')
+                      prompts.gsub!(/^chatGPT>\s*/,'')
+                      success, res = SlackSmartBot::AI::OpenAI.send_gpt_chat(@ai_open_ai[team_id_user_creator][:chat_gpt][:client], model, prompts, @ai_open_ai[team_id_user_creator].chat_gpt)
+                      if success
+                        @ai_gpt[team_id_user_creator][session_name] << "chatGPT> #{res}"
+                      end
+                    end
+                    if session_name == ''
+                      temp_session_name = @ai_gpt[team_id_user_creator][''].first[0..35].gsub('Me> ','')
+                      respond "*ChatGPT* Temporary session: _<#{temp_session_name.gsub("\n",' ').gsub("`",' ')}...>_ model: #{model}\n#{res.to_s.strip}"
+                      if res.to_s.strip == ''
+                        respond "It seems like GPT is not responding. Please try again later or use another model, as it might be overloaded."
+                      end
+                      #to avoid logging the prompt or the response
+                      if config.encrypt
+                        Thread.current[:encrypted] ||= []
+                        Thread.current[:encrypted] << message
+                      end
+                    elsif res.to_s.strip == ''
+                      res = "\nAll prompts were removed from session." if delete_history
+                      respond "*ChatGPT* Session _<#{session_name}>_ model: #{model}#{res}"
+                      respond "It seems like GPT is not responding. Please try again later or use another model, as it might be overloaded." if message != ''
+                    else
+                      respond "*ChatGPT* Session _<#{session_name}>_ model: #{model}\n#{res.to_s.strip}"
+                    end
+                    if urls_messages.size > 0
+                      respond urls_messages.join("\n")
+                    end
+                    update_openai_sessions(session_name, team_id: team_creator, user_name: user_creator) unless session_name == ''
+                  rescue => exception
+                    respond "*ChatGPT*: Sorry, I'm having some problems. OpenAI probably is not available. Please try again later."
+                    @logger.warn exception
                   end
-                  respond "*GPT* Session: _<#{@ai_gpt[user.name].first[0..29]}...>_ (id:#{@ai_gpt[user.name].object_id}) \n#{res.strip}"
-                rescue => exception
-                  respond "*GPT*: Sorry, I'm having some problems. OpenAI probably is not available. Please try again later."
+                  unreact :speech_balloon
                 end
-                unreact :speech_balloon
               end
             end
           end

data/lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_add_collaborator.rb

@@ -0,0 +1,42 @@
+class SlackSmartBot
+  module Commands
+    module General
+      module AI
+        module OpenAI
+          def open_ai_chat_add_collaborator(cname)
+            save_stats(__method__)
+
+            user = Thread.current[:user]
+            team_id = user.team_id
+            team_id_user = Thread.current[:team_id_user]
+
+            @active_chat_gpt_sessions[team_id_user] ||= {}
+
+            if @active_chat_gpt_sessions[team_id_user].key?(Thread.current[:thread_ts])
+              session_name = @active_chat_gpt_sessions[team_id_user][Thread.current[:thread_ts]]
+            elsif @active_chat_gpt_sessions[team_id_user].key?(Thread.current[:dest])
+              session_name = @active_chat_gpt_sessions[team_id_user][Thread.current[:dest]]
+            else
+              session_name = ''
+            end
+
+            if session_name != "" and @active_chat_gpt_sessions[team_id_user].key?(Thread.current[:thread_ts])
+              collaborator = find_user(cname)
+              team_id_user_collaborator = collaborator.team_id + "_" + collaborator.name
+              unless @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:collaborators].include?(team_id_user_collaborator)
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:collaborators] << team_id_user_collaborator
+              end
+              @listening[team_id_user_collaborator] ||= {}
+              @listening[team_id_user_collaborator][Thread.current[:thread_ts]] = Time.now
+              @chat_gpt_collaborating[team_id_user_collaborator] ||= {}
+              @chat_gpt_collaborating[team_id_user_collaborator][Thread.current[:thread_ts]] ||= { team_creator: team_id, user_creator: user.name, session_name: session_name }
+              respond "Now <@#{collaborator.name}> is a collaborator of this session only when on a thread.\nIn case you don't want to send a message as a prompt, just start the message with hyphen (-)."
+            else
+              respond "You can add collaborators for the chatGPT session only when started on a thread and using a session name."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_copy_session.rb

@@ -0,0 +1,89 @@
+class SlackSmartBot
+  module Commands
+    module General
+      module AI
+        module OpenAI
+          def open_ai_chat_copy_session(team_orig, user_orig, session_name, new_session_name)
+            if user_orig == ""
+              save_stats(__method__)
+            else
+              save_stats(:open_ai_chat_copy_session_from_user)
+            end
+
+            user = Thread.current[:user].dup
+            team_id = user.team_id
+            if user_orig == ""
+              user_orig = user.name 
+              team_orig = team_id
+            end
+            team_orig = team_id if team_orig == ""
+            dest = Thread.current[:dest]
+            get_openai_sessions()
+            orig_team_id_user = team_orig + "_" + user_orig
+            team_id_user = team_id + "_" + user.name
+
+            if !@open_ai.key?(orig_team_id_user)
+              respond "*ChatGPT*: The user *#{user_orig}* doesn't exist."
+            elsif !@open_ai[orig_team_id_user][:chat_gpt][:sessions].key?(session_name)
+              respond "*ChatGPT*: The session *#{session_name}* doesn't exist."
+            elsif user_orig != user.name and
+              !@open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:public] and
+                  !@open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:shared].include?(dest)
+              respond "*ChatGPT*: The session *#{session_name}* doesn't exist or it is not shared."
+            else
+              @open_ai[team_id_user] ||= {}
+              @open_ai[team_id_user][:chat_gpt] ||= {}
+              @open_ai[team_id_user][:chat_gpt][:sessions] ||= {}  
+              session_orig = @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name]
+              open_ai_new_session = {
+                team_creator: team_id,
+                user_creator: user.name,
+                started: Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+                last_activity: Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+                collaborators: [],
+                num_prompts: session_orig[:num_prompts],
+                model: session_orig[:model],
+                shared: [],
+                copy_of_session: session_name,
+                copy_of_team: team_orig,
+                copy_of_user: user_orig,
+                users_copying: [],
+                public: false,
+                description: session_orig[:description],
+                tag: session_orig[:tag]
+              }
+              new_session_name = session_name if new_session_name == ""
+              session_names = @open_ai[team_id_user][:chat_gpt][:sessions].keys
+              if session_names.include?(new_session_name)
+                number = session_names.join("\n").scan(/^#{new_session_name}(\d+)$/).max
+                if number.nil?
+                  number = "1"
+                else
+                  number = number.flatten[-1].to_i + 1
+                end
+                new_session_name = "#{new_session_name}#{number}"
+              end
+              @open_ai[team_id_user][:chat_gpt][:sessions][new_session_name] = open_ai_new_session
+
+              if user_orig != user.name or team_id != team_orig
+                @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:users_copying] ||= []
+                @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:users_copying] << user.name
+                update_openai_sessions("", team_id: team_orig, user_name: user_orig)
+              end
+
+              get_openai_sessions(session_name, team_id: team_orig, user_name: user_orig)
+              @ai_gpt[team_id_user] ||= {}
+              @ai_gpt[team_id_user][new_session_name] = @ai_gpt[orig_team_id_user][session_name].dup
+              update_openai_sessions(new_session_name, team_id: team_id, user_name: user.name)
+              if user_orig != user.name or team_id != team_orig
+                respond "*ChatGPT*: Session #{session_name} (#{user_orig}) copied to #{new_session_name}.\nNow you can call `^chatGPT #{new_session_name}` to use it."
+              else
+                respond "*ChatGPT*: Session #{session_name} copied to #{new_session_name}.\nNow you can call `^chatGPT #{new_session_name}` to use it."
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_delete_session.rb

@@ -0,0 +1,45 @@
+class SlackSmartBot
+  module Commands
+    module General
+      module AI
+        module OpenAI
+          def open_ai_chat_delete_session(session_name)
+            save_stats(__method__)
+
+            user = Thread.current[:user].dup
+            team_id_user = Thread.current[:team_id_user]
+
+            @active_chat_gpt_sessions[team_id_user] ||= {}
+
+            #todo: add confirmation message
+            @open_ai[team_id_user] ||= {}
+            @open_ai[team_id_user][:chat_gpt] ||= {}
+            @open_ai[team_id_user][:chat_gpt][:sessions] ||= {}
+            if @open_ai[team_id_user][:chat_gpt][:sessions].key?(session_name)
+              delete_threads = []
+              @active_chat_gpt_sessions[team_id_user].each do |thread_ts, sname|
+                delete_threads << thread_ts if sname == session_name
+              end
+              delete_threads.each do |thread_ts|
+                @active_chat_gpt_sessions[team_id_user].delete(thread_ts)
+                @listening[team_id_user].delete(thread_ts) if @listening.key?(team_id_user)
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:collaborators].each do |collaborator|
+                  collaborator_name = collaborator.split("_")[1..-1].join("_")
+                  @listening[collaborator_name].delete(thread_ts) if @listening.key?(collaborator_name)
+                  @chat_gpt_collaborating[collaborator].delete(thread_ts) if @chat_gpt_collaborating.key?(collaborator)
+                end
+              end
+
+              @open_ai[team_id_user][:chat_gpt][:sessions].delete(session_name)
+
+              update_openai_sessions(session_name)
+              respond "*ChatGPT*: Session *#{session_name}* deleted."
+            else
+              respond "*ChatGPT*: You don't have a session with that name.\nCall `chatGPT list sessions` to see your saved sessions."
+            end
+          end
+        end
+      end
+    end
+  end
+end